# Intuitive 3-Style as a Beginner Blind Method



## dudefaceguy (Apr 27, 2020)

I recently learned 3-style as my first blind method. I did it completely intuitively, without memorizing any algorithms. This is an explanation of what I did, and a collection of the resources that I used. I hope that it will be helpful to others who want to learn 3-style intuitively for fun.



Spoiler: Preliminary Notes



This is not speed-optimal. A competitive speedsolver will learn all of the 3-Style commutators as memorized algorithms; if your goal is speed, then you should do this. But if you just want to have fun and experiment with 3-Style, you can generate commutators on the fly during the solve. Many top blind solvers advise against this, but that is because their goal is speed. If you just want to be able to solve a cube blindfolded, there is nothing wrong with using intuitive commutators and making it up as you go along.

It’s completely viable to learn 3-style as you fist blind method – I know because I did it. I got my first success about 2 days after starting to learn, with of time of 13 minutes.
I currently average around 4 minutes for blind solving; my PB is 2:54. This is about average for a beginner blindsolver.

I learned 3-style intuitively because I’m an intuitive solver; I generally don’t use memorized algorithms in my solves, and I only know 2-4 memorized algorithms (most of which are just commutators in disguise). This guide is designed for intuitive solvers like myself who don't like to learn algorithms.

This by no means an authoritative or definitive guide – it’s just some resources that I’ve found or figured out. The main point is that you don’t have to be fast to have fun, and that it’s quite easy to learn 3-style as your first blind method.



*Learning the Basics*

The basic concept of blindfolded solving is to choose one piece (your buffer), memorize its solved location, then memorize the solved location of the piece in that spot, and so on, which will eventually lead you to memorizing a cycle of piece swaps which will put every piece in the right place. You then execute the swaps using commutators, solving 2 pieces at a time. Commutators only move 3 pieces at a time, so this leaves all the other pieces in the same spot for when you get to them later on in the solve. Since there are 20 solvable pieces on a 3x3, you have to memorize about 20 pieces of information. Many good resources already exist for these concepts, so here is a collection of links.



Spoiler: Wiki articles explaining the basics









BLD Memorization - Speedsolving.com Wiki







www.speedsolving.com









Speffz - Speedsolving.com Wiki







www.speedsolving.com








Here are some video tutorials for these basic concepts. Ignore the parts that explain execution, since we will execute the solve using 3-style instead:



Spoiler: Basic Blindsolving Tutorials















There are a lot of great 3-style tutorials on YouTube. I suggest these:



Spoiler: 3-Style Tutorials



















Finally, here are some resources explaining commutators:

https://www.ryanheise.com/cube/commutators.html


Spoiler: Commutator Resources



https://www.ryanheise.com/cube/commutators.html

















Once you know the basics of blindsolving and 3-style, try some sighted solves just to practice commutator structure (more on that below) and to make sure that you can do everything correctly. Then start experimenting with memorization and blindfolded solving. I started by writing down the memo letter pairs on paper, then holding the cube under the table and executing the solve while reading the written memo. You may be surprised how soon you will be able to execute a full solve blindfolded.

*First Commutators*

You may have heard that 3-Style requires learning 800 algorithms, but this is only true if you want to be super-duper fast. All you really need to learn is 1 interchange and 4 insertions each for edges and corners, making 8 types of commutators in all. I suggest starting with the same interchange layer for edges and corners, since the commutators will then have a similar structure. I will use UF/UFR as buffers in my examples – C/C in the Speffz lettering scheme.

I started with these 8 commutator types, which all use U as the buffer/interchange layer for both corners and edges, and C/C as the edge and corner buffers. You should use the commutators you know best – these are just examples.

Edges:

*Insertion Type**Stickers**Example*D-Layer, Side StickerG K O S[M D M’, U]D-Layer, Bottom StickerU V W X[M D2 M’, U]E-layer, Outer StickerF H P N[U’, R E R’]E-Layer, Inner StickerJ L R T[U’, R E2 R’]
Corners:

*Insertion Type**Stickers**Example*Same ColumnK P[R’ D R, U]Adjacent ColumnG T[R’ D’ R, U]Opposite ColumnH S[R’ D2 R, U]Opposite FaceU V W X[R2 D’ R2 D R2, U]

The only type of insertion that is not trivially obvious is the opposite-sticker corner insertion – learning it will save you many ugly conjugates, and therefore increase accuracy. These are 12-move commutators, which sounds long, but the insertion is very simple and fast to perform, with the added bonus that it’s the same forwards and backwards.

I used the following rules when learning these initial commutators:

Always interchange using the layer of your buffer sticker.
Always interchange with your buffer.
Never conjugate your buffer.
This made it very easy for me to construct the commutators, since they all have the same structure. Using these 3 rules, you can solve any case using conjugates that are no more than 2 moves (the only exception is the corner case FA or QA for a U-face buffer, for which I recommend a 1-move conjugate that moves the buffer out of the interchange layer). When performing a conjugate involving two pieces, I will conjugate the interchange piece first and the insertion piece second if possible – doing the conjugates in a predefined order makes it easier to remember and reverse them. If the first letter of a pair is in the interchange layer, then insert the second letter to the buffer; if the second letter is in the interchange layer, then insert the first letter to the second letter.

Once you have mastered these initial 8 commutator types, the next step is to learn a second interchange layer. I started by using only D-layer interchange commutators for edges and corners, then learned M interchange and 4-move commutators for edges, and am now learning R interchanges for corners. If you learn both U and M layer edge commutators, almost all cases will be either a pure commutator or a 1-move conjugate. After you are familiar with 2 interchange layers like this, you will start to see interchanges on other layers.

There are also many commutator lists from top cubers that you can use to get ideas, especially if you're having trouble with a hard case. I like to use Jack Cai's list: https://docs.google.com/spreadsheet...azoFNHJ0GidKrUm8NC0OzNcRdk/edit#gid=522554293
Here's another post with a whole lot of other lists: https://www.speedsolving.com/threads/a-collection-of-bld-algorithms-lists.65238/

*Rotations, Buffer Choice, Orientation, and Audio Memo*

_Rotations_

You may wish to rotate the cube before performing the commutator – this is perfectly fine, and can increase execution accuracy. If you want to be a world-class speed solver, try to eliminate rotations, but otherwise just chill out and don’t worry about it. If you never conjugate your buffer, it will be very easy to find your way back from a rotation – just put the buffer back in the right place. This prevents mistakes and increases accuracy, so I prefer rotations to conjugates if possible (top speed solvers prefer conjugates to rotations because they are faster). I prefer to do my conjugates first, then rotate, then perform the commutator, then undo the rotation, then undo the conjugate. This way I remember each step separately and I always know the order in which I will perform them, which decreases execution errors for me.

_Buffer choice_

Top blind solvers recommend using the UF edge and UFR corner (C and C in Speffz) as buffers, because they generate speed-optimal commutators. I agree with them. I started with DF/DFR and am currently experimenting with UF/UFR. The comms feel better, there are a whole lot of excellent resources for UF/UFR buffers, and it’s actually a lot of fun to switch buffers.

But since speed is not our main goal as intuitive solvers, don’t worry too much about your buffer. Use whatever buffer you are most comfortable with. However, the edge and corner buffers should be adjacent so that parity will be easier to solve (more on this below). You can always change your buffer later – transitioning is pretty easy, since we’re making up the commutators as we go along.

There are some advantages to using D-layer buffers, especially as a beginner. Having my buffers on the D face enabled me to do my insertions, and more importantly my conjugates, on the top of the cube. Having an easy conjugate is very important for intuitive solving, so that you don't mess up when undoing the conjugate. It’s up to you to choose what you think is best; my examples use C/C as buffers, and can be mirrored to your buffer of choice.

_Orientation_

Pick whatever orientation you want – but once you learn an orientation, it will be difficult to change. I use blue top/red front, which is what Jack Cai and Noah Arthurs also use, by pure coincidence. Using a popular orientation will make it easier to watch example solve videos. Blue top/red front is not really popular outside of blindfolded solving; most people use white or yellow top. I chose my orientation way before I started blind solving, because I thought it made it easier to do edge orientation in ZZ and Roux methods, and to spot the pieces that go into first and second block in Roux.

_Audio Memorization and Blindsolving Accuracy_

Top blindfolded solvers use images to memorize corners and audio (i.e. nonsense syllables) to memorize edges. This is very fast, but not always accurate – if you look at competition results for top blindsolvers, you will see lots of DNFs. This is because WCA regulations take the best of 3 attempts – it doesn’t matter if you have 2 DNFs, so competitive solvers will prioritize speed over accuracy.

If you’re not trying to set records, it’s okay to find a different system that works for you. I solve for fun, so accuracy is more important than speed for me. I started out using images for both corners and edges, since it took a really long time for me to memorize and execute. Once I got down to about 7 minutes, I transitioned to memorizing edges first and executing corners first, using images for edges and audio for corners – this method stores most of the information as images and just a small amount as an audio loop. Using this technique, I was able to decrease my times significantly without affecting my accuracy. It also made blind solving more fun, as I didn’t spend as much time puzzling over difficult letter pairs.

If you really care about accuracy, you may want to try multi-blind: memorizing and solving several cubes at once while blindfolded. This event prioritizes accuracy over speed. You can use most of the same techniques for multi-blind that you use for 3-blind; just memorize your piece types in the same order that you will execute them, and use images in a memory palace for all of your memorization. Just like 3-blind, it’s not as impossible as it looks.

*Parity*

A blind solve may end up with odd parity: two corners and two edges that must be swapped to complete the solve. If you have an odd number of letters in your memo, then you have odd parity. These last two corners and two edges cannot be solved directly with a commutator, since a commutator cycles 3 pieces. Most blind solvers will simply use a set of algorithms to solve parity at the end of the solve, but as intuitive solvers, this is not to our taste. Here's my video explaining how to solve parity with a pair commutator plus a quarter turn:






Below are some techniques to deal with parity intuitively: the first 3 solve it with a single quarter-turn, the 4th uses a pair commutator (explained in the video above), and the 5th is a semi-intuitive technique that uses Niklas and Sune.

Turning any face of the cube one quarter turn will convert between odd and even parity, so you can just detect the parity state of the cube and then “cheat” by doing a quarter-turn before you start your memo (obviously this is not competition legal). I used this cheat when I first started blindsolving, just to practice basic techniques without having to worry about parity. You can quickly detect parity by tracing the unsolved corners; don’t memorize stickers, just trace the permutation. Subtracting the number of cycles from the number of misplaced corners will give you the parity state: an odd number means odd parity and an even number means even parity. For example, 8 misplaced corners in one cycle is odd parity (8-1=7) and 6 misplaced corners in 2 cycles is even parity (6-2=4). Don’t count unsolved corners that are permuted correctly but misoriented. Detecting parity like this takes me about 10 seconds.
You can use a competition legal version of the above technique by memorizing the D layer (or the U layer if your buffers are in D) displaced by a quarter turn, then doing a D or D’ before starting your execution. Just rotate the cube by 90 degrees whenever you have a D layer target in your memo, to simulate the cube state after your D or D’ move.
Alternatively, you can swap the entire D layer by a quarter turn in your memo, then do a D or D’ as your last move. For example, if your next target is W, go to V instead; if it’s the edge sticker S, go to O instead, etc. Then continue on normally to the next target, only swapping if the target is in the D layer. When your execution is complete, the D face will be off by a quarter-turn, and you can finish the solve with D or D’.
The methods above are a fun challenge, but can get tedious and annoying after a while. Now, I use a pair commutator at the end of the solve to fix parity. If you swap 2 edges and 2 corners in your memo, making 2 adjacent unsolved pairs on the same face, doing a U or U' solves one of the pairs and leaves 3 pairs unsolved. You can then solve all 3 pairs with a pair commutator.
For example, here is a D-A-B corner commutator, but with wide D moves for the insertions and an extra U’ move at the end which fixes parity: [R:L Dw2 L’, U’] U’
And an alternative commutator, doing the parity conversion as the first move: U [R: U’, L Dw2 L’]
You can substitute U2 for the Dw2 moves, which makes slightly less intuitive algorithms like: R L U2 R' U' R U2 L' U R' U'
You can also use Niklas and Sune to solve odd parity cases. Doing a Niklas and then a Sune from the opposite side will swap two corners and two edges, solving the last 4 odd-parity targets. You can cancel 3 moves in between to make a more efficient 11-move algorithm: (L’ U R U’ L) U2 (R’ U R U2 R’)
These last two parity solutions require the same setup: swap stickers B and C (or K and O if your buffer is U/V on the D face) in corner and edge memo. This is actually easy to do, and you don't even have to know whether you have parity before you start your memo. The simplest way to do this is to add the letter B to the end of your memo if you have an odd number of letters. This will result in two adjacent unsolved pairs, which you can solve using method 4 or 5 above.

You can swap these pieces more efficiently by using a technique called “weak swap,” described by Graham Siggins here:






The basic idea behind weak swap is simple: when memorizing your first piece type (edges, in the video above), if you come to your buffer C before the B sticker, you solve the buffer to B instead of C, as if you have parity. If you do in fact have parity, you will save an algorithm. If you don’t have parity, you undo the swap by adding a letter B to the end of the edge memo (which does not actually add an extra letter compared to not doing weak swap). If you have parity, also swap C and B when memorizing the other piece type, which sets up to the cases described above without requiring a conjugate. You can use weak swap whether you memorize edges or corners first.

That’s it. I’ll continue to post more in this thread as I progress with intuitive 3-style, and I hope that other intuitive solvers will do the same. Happy cubing!


----------



## WarriorCatCuber (Apr 27, 2020)

What do you think is better? Something like Eka/Orozco or intuitive 3-style?


----------



## dudefaceguy (Apr 27, 2020)

I've never tried Eka or Orozco so I can't really say. I just learned 3-Style and I've never tried any other blind method. Intuitive 3-style is easy to learn and easy to transition to full 3-style, so I don't see any real downsides to it. If you don't like intuitive solving and prefer memorizing algorithms or using the same alg for the entire solve, then a different method might serve you better.

Edit: Here is a video from Jake Klassen explaining why he thinks you should just dive into intuitive 3-style and skip intermediate blind methods.


----------



## dudefaceguy (Apr 28, 2020)

Transitioning from DF/DFR buffer to UF/UFR buffer has been interesting. It's been about 3 or 4 days, and my times are basically the same as they were beforehand. My accuracy is down a bit, but that should come back in a few more days.

The most surprising thing about switching buffers was that I immediately started to see different types of commutators. When I was using DF/DFR as buffers, I only used D or M as edge interchanges, and only interchanged with my buffer -- these comms were familiar to me, so I stuck with what I knew. But as soon as I moved to UF/UFR as my buffer, I started seeing different interchanges in different layers. This was surprising because I thought I would have to consciously try to look out for new interchanges -- but just the process of switching buffers broke my old habits and made these new possibilities jump out for me.

My time and accuracy has been affected, but I think the effect is due to my experimenting with entirely new interchanges and insertions, rather than from converting my existing familiar commutators to a new buffer. I'm more concerned with learning and having fun than I am with getting faster, so I've embraced these new commutator possibilities and challenges.

The hardest part of switching buffers has been changing my lettering scheme. When my buffer was DF/DFR, both of those pieces used the letter K -- which meant that I would never see K in any of my memo. So, I used K as an alternate lettering option for Q. Now that I have switched my buffer, I will have to use K as K, which causes some hiccups during my memo, and messes with the spatial associations that I've made. Now that my buffers are at UF/UFR, I will never use the letter C, so I've switched C to be an alternate for Q, instead of K. It's not much of a problem, but it's taken a bit more effort to get used to it than I anticipated.

Now that I'm using C/C as my buffer, I can take advantage of commutator sheets from top cubers to learn even more new ideas. It seems that the solutions I am using are mostly the same as those I find on these alg sheets, but it's really a matter of preference. Many of the commutators that the top cubers use are move-inefficient, using long conjugates to stick to fast movesets. I prefer to construct move-efficient commutators, even if I do rotations or slower movesets like B/D moves instead of R/U moves. But, I really enjoy solving each commutator as a puzzle, and much of the fun comes from inventing an efficient solution. Even if I can see a conjugate to a more "friendly" moveset, I just can't resist the puzzle of doing a commutator in the most efficient way possible.

For example, I could solve MV or VM by conjugating it into an M-layer interchange with a D move -- this would be a very easy and familiar move set. But I could also do a pure commutator with an S-layer interchange. Since I switched buffers, I've been finding these more efficient solutions. I know that it will hurt my times to construct and execute a new comm that I've never done before, but it's so much fun that I just don't care that it's slower.


----------



## Keroma12 (Apr 28, 2020)

dudefaceguy said:


> The hardest part of switching buffers has been changing my lettering scheme. When my buffer was DF/DFR, both of those pieces used the letter K -- which meant that I would never see K in any of my memo. So, I used K as an alternate lettering option for Q. Now that I have switched my buffer, I will have to use K as K, which causes some hiccups during my memo, and messes with the spatial associations that I've made. Now that my buffers are at UF/UFR, I will never use the letter C, so I've switched C to be an alternate for Q, instead of K. It's not much of a problem, but it's taken a bit more effort to get used to it than I anticipated.



I'd recommend using other sounds or consonant clusters instead of C or Q, such as sh, st, ch. It's works really well for audio, and can also work well for images if you want consistency.
Personally, my system is entirely phonetic. For example, for Ksh I use 'caution' (or 'cushion').


----------



## dudefaceguy (Apr 28, 2020)

Keroma12 said:


> I'd recommend using other sounds or consonant clusters instead of C or Q, such as sh, st, ch. It's works really well for audio, and can also work well for images if you want consistency.
> Personally, my system is entirely phonetic. For example, for Ksh I use 'caution' (or 'cushion').


I do something similar for these sounds -- good to know that you do it as well. I started using it in audio, and it's crept into my images as well. I use ch for C and sh for H.

It's interesting that your image system is entirely phonetic. I can see how that would be very fast. I still spend a lot of time getting stumped with letter pairs, so maybe I will look into this. I go by the written letters, which can sometimes make it difficult to think of a word. For example, GH was difficult for me because I usually try to think of a word that has the letter pair as the first and last letters -- but I couldn't think of one, so I used "ghost." Using a phonetic system, I would use a hard G and a SH sound, so it would be... gosh, or gush or girlish -- probably gush. I think that's better than ghost. Thank you for the tip!

I also get really mixed up between certain consonants when doing audio edges -- for example, I might mix up LD with LB or LV. I don't know if there's a way to fix this besides practice.


----------



## Keroma12 (Apr 28, 2020)

dudefaceguy said:


> I also get really mixed up between certain consonants when doing audio edges -- for example, I might mix up LD with LB or LV. I don't know if there's a way to fix this besides practice.



I found using real words, even for audio, is helpful. Like Lid or Lad, Lob or Lab, Live or Love. Even if Lad can still sound like Lab, I find it much less likely that I'll confuse them. Even though I'm not picturing the word or anything, it just seems that the sound of a real word is harder to mis-recall in audio than a random sound. And if you can do this without adding extra syllables, then I don't see much of a downside.

PS I use ghost for GO, goth for GH (I use th when H is second).


----------



## dudefaceguy (Apr 28, 2020)

Keroma12 said:


> I found using real words, even for audio, is helpful. Like Lid or Lad, Lob or Lab, Live or Love. Even if Lad can still sound like Lab, I find it much less likely that I'll confuse them. Even though I'm not picturing the word or anything, it just seems that the sound of a real word is harder to mis-recall in audio than a random sound. And if you can do this without adding extra syllables, then I don't see much of a downside.
> 
> PS I use ghost for GO, goth for GH (I use th when H is second).


Thanks, I'll try that in my next solve. Maybe I will finally be able to do audio edges.


----------



## dudefaceguy (May 5, 2020)

Here's an execution video so you can see exactly how slow I am:


----------



## mitja (May 6, 2020)

Hi,
i believe your description is really nice. It covers most of the problems I am dealing with and I feel very much the same like you.

However, I would not use your term intuitive 3-style so literally. Ther is no black/white difference between intuitive 3-style/full 3-style. I believe everybody is doing something in between. Of course, the better you get, more algs you produce faster and faster, but saying that people can do all 818 algs just like learning 57 OLL algs or similar. Maybe when you rehearse through years , but it is more important to think how our brains work.

I believe every 3-style solver learns some basic solutions of the main alg groups as you also described them and the rest is just an interpolation of those. Just like when you get older in life you don't learn so many new concepts but interpolation of the stuff you already learned through years.

I believe that understanding of how commutator works( and all conjugate derivates also) is the key that gives us the ability to do all 818 without using the "cheat sheet".
I also don't know all 818 of them but, after one and a half month, I can produce them all. Is it intuitive? I don't think so. I just understand the concept, that's why it feels intuitive and like you said, it feels good.
And, by rehearsing I can produce them faster and faster on the end I will feel like I have learned them all.
If I compare it with PLL algs. I learned all of them first, but I understanded only few of them, maybe now even most of them, but not all. Like i know exactly why A perm is how it is, because I understand the commutator in it. I don't understand the concept of V perm( never tried), but I can easily do it.
That's why it would be so much harder to learn all ZBLL LL algs, they are longer and not so understandable like 3-style.

When you talk about parity, I also came to the conclusion, that I can just treat every edge trace the same way, parity or not and do this weak swap. I do not do MBLD yet, so I can just memorise corners first and know it I have parity, but it is much easier the way you or Graham S. describe it.

Anyway keep up the good work


----------



## dudefaceguy (May 6, 2020)

mitja said:


> However, I would not use your term intuitive 3-style so literally. Ther is no black/white difference between intuitive 3-style/full 3-style. I believe everybody is doing something in between.


You are absolutely right - it's a spectrum. Even as a beginner, I have many of the comms basically memorized - WF/WP/WH/WN edge comms are always very quick to recall for example.

The main point I wanted to make is that 3 style is perfectly viable as a beginner blind method, and it’s a lot of fun. I couldn’t find any resources for learning 3 style as a beginner blind method, or for learning it in a casual and relaxed way - in most guides, the goal is usually to achieve world-class speed.



mitja said:


> That's why it would be so much harder to learn all ZBLL LL algs, they are longer and not so understandable like 3-style.



Antoine Cantin has a video about this exact thing - I’ve never tried ZBLL of course, but the point makes sense to me.

Did you transition from OP or learn 3 style as a first blind method?


----------



## mitja (May 6, 2020)

I learned M2/ op y perm first, then advanced M2


----------



## newtonlkh (Jun 6, 2020)

Your description make it so much easier to understand than those "cyclic shift" "per special" "column cases"!!!
This is gold to me


dudefaceguy said:


> Edges:
> 
> *Type**Stickers**Example*D-Layer, Side StickerG K O S[M D M’, U]D-Layer, Bottom StickerU V W X[M D2 M’, U]E-layer, Outer StickerF H P N[U’, R E R’]E-Layer, Inner StickerJ L R T[U’, R E2 R’]
> Corners:
> ...


----------



## dudefaceguy (Jun 6, 2020)

newtonlkh said:


> Your description make it so much easier to understand than those "cyclic shift" "per special" "column cases"!!!
> This is gold to me


Thanks, that's great to hear! I've never actually learned "cyclic shifts" or "per specials" by those names. I picked up that 5-move insertion from Noah Arthurs's tutorial, and everything else is just conjugated 8-movers for me. A lot of top cubers will do longer conjugates to an 8-mover for the opposite-sticker cases, but I like that simple 5-move insertion because it reduces conjugates, and therefore increases accuracy.

I know I could probably get a lot more move-efficient by learning some more techniques from Beyer-Hardwick like the ones you describe; perhaps I should look into it more. Being move-efficient is important for me since my TPS is so low. I also just love the challenge of trying to come up with a move-optimal solution.

Are you also learning 3-style as your first blind method? What buffers are you using?


----------



## newtonlkh (Jun 7, 2020)

dudefaceguy said:


> Are you also learning 3-style as your first blind method? What buffers are you using?



Yes, still don't want to cramp the OP algs into my brain. I use C and buffer and I am only trying corners at the moment. A bit confused how to deal with corner twist cases?

Also,



dudefaceguy said:


> Once you have mastered these initial 8 commutator types, the next step is to learn a second interchange layer. I started by using only D-layer interchange commutators for edges and corners, then learned M interchange and 4-move commutators for edges, and am now learning R interchanges for corners. If you learn both U and M layer edge commutators, almost all cases will be either a pure commutator or a 1-move conjugate. After you are familiar with 2 interchange layers like this, you will start to see interchanges on other layers.



what are 4-move commutators? I read that from your other post as well, but the commutators I've learnt so far are those with 8 moves, or the 12 moves one i learnt yesterday from this post. what do 4-move commutators do?


----------



## Dylan Swarts (Jun 7, 2020)

An example of a 4 mover is [M', U2] or M' U2 M U2 in normal notation. There are only 4 movers for edges. I'm afraid I can't elaborate more, dudefaceguy should be able to shed more light on the subject.


----------



## dudefaceguy (Jun 8, 2020)

newtonlkh said:


> Yes, still don't want to cramp the OP algs into my brain. I use C and buffer and I am only trying corners at the moment. A bit confused how to deal with corner twist cases?
> 
> Also,
> 
> ...





Dylan Swarts said:


> An example of a 4 mover is [M', U2] or M' U2 M U2 in normal notation. There are only 4 movers for edges. I'm afraid I can't elaborate more, dudefaceguy should be able to shed more light on the subject.


Anything that has the form ABA'B' is a commutator, so we use a lot of 4 move commutators without thinking of them as such. Sexy Move is an example: R U R' U'. This affects 7 pieces - both edges and corners - so it's not terribly useful in the situations where we typically use commutators. But I use it to swap diagonal corners when solving corners, and I think about it as a conjugated commutator in that context since only the corners matter.

I also use 4-move commutators on big cube centers, for example r u2 r' u2. This form is also used to cycle 3x3 centers at the end of Roux, for example M' E2 M E2.

But in the context of blind solving, the only 4 move commutator you will do is the type Dylan described: U2 M U2 M'. They cycle 3 edges in the M slice, and are also used in Roux step 4c. The way I think of them is that the piece that needs to move farthest does the first U2 move. If you have the commutator C A U, then A has the farthest to go since U is not adjacent to it. So, that 4 move commutator is U2 M' U2 M. I got that rule of thumb from Jack Cai's tutorial.

To do a 4 move edge commutator, you need all 3 edges in the same slice (M, E, or S) and they all must be correctly oriented facing opposite centers. C W U works but C W K would result in a flipped edge of you tried to do a 4 mover.

Edit: You don't need to learn 4 movers - you can do those cases with an 8 move commutator as well. They are just super fast and easy, so it makes sense to learn them. But when I was just starting out I also used 8 movers for all of my edges. And, there are no 4 move commutators for corners.

Also, congratulations on learning 3 style as your first blind method - I'm happy to see more people try this! I once tried to do a blind solve in OP style using just the Eve algorithm, which swaps A/M for corners and A/D for edges. I got through corners solving one at a time, but it was kind of agonizing and it took me forever so I quit there.


----------



## dudefaceguy (Jun 10, 2020)

I recorded a video explaining how to solve odd parity scrambles intuitively using a pair commutator and weak swap. Here it is, with my "script" below.

Edit: I just realized that I messed up the memo in the last corner example, haha. Should be AP IQ EB, not AO IQ EB. It doesn't really matter since that was just an example of an inefficient memo, and I executed the different, more efficient memo. But it's still a little embarrassing.








Spoiler: Lots of text



How can you solve parity in blindfolded 3-style if you're an intuitive solver who doesn't like to memorize algorithms? I'll explain my favorite way to solve parity quickly, then go through the steps in detail, then talk about some alternatives and some optimizations to make it more efficient. This video is for beginner intuitive 3-style solvers who already know the basics of 3-style blind solving, but need a way to solve parity. If you are a complete beginner, there is a link in the description to my beginner's guide to intuitive 3-style.

First, the short version. You know you have parity when you have an odd number of letters in your memo. This is a problem because you need 2 letters for a commutator. So, we'll just add the letter B to the end of our corner memo and our edge memo to make an even number of letters. Executing that memo will make the cube look like this, with 2 unsolved edges and 2 unsolved corners. Since the unsolved pieces are next to each other in matched pairs, we can then do a pair commutator to make the cube look like this, with the U layer displaced by a quarter turn. And of course, we then solve the cube with a U'.

Okay, now the long version. Saying that a scramble "has parity" means that it has odd parity, which means that we need to swap pieces an odd number of times to solve the cube. This is why odd parity scrambles have an odd number of letters in their memo. Since commutators always do an even number of swaps, commutators can only directly solve even parity scrambles. Every quarter-turn of any face on the cube will convert the cube between even and odd parity. That's easy to see here on this cube. It has 2 unsolved edges and 2 unsolved corners. But if we do a U', you can see that the cube now has 3 unsolved edges and 3 unsolved corners. 2 unsolved pieces means odd parity, since we can solve them with 1 swap: buffer to B. And after a U', these 3 unsolved pieces can be solved with 2 swaps: buffer to D to A. So, solving an odd parity scramble just requires us to add an extra quarter turn our solve. This is a problem in blind solving because we can't do any moves until we're blindfolded, and we don't know whether we have parity until we are halfway through our memo. So, let's look at what we can do to solve an odd parity scramble intuitively.

Try this short scramble: R U R'. Since the scramble has an odd number of quarter turns, it has odd parity. Our corner memo is EI P, and we're back to our buffer with everything else solved. Since we have an odd number of letters in our memo, we have odd parity, so we'll add the letter B to make the memo EI PB. Similarly, our edge memo is JA D, and we'e back to our buffer, so we add the letter B to make it JA DB. Let's execute corners: EI, and now P is our buffer so we add B for PB. Now corners are solved with C and B switched. On to edges. JA, and D is our buffer so we add B for DB. Now the cube looks just like we wanted, with 2 pairs unsolved.

Now I'm going to explain the pair commutator in a way that's easy to see and understand intuitively, and then I'll talk about some ways to optimize it. So, if we do a U' we can see that we've converted from odd to even parity, and we have 3 unsolved pieces of each type in 3 matched pairs. We can solve all 6 pieces at the same time with a pair commutator, which is the same as the corner commutator DA, but with wide D moves during the insertions. First we conjugate the A pair out of the U layer with a B move, then begin the commutator by inserting A into C using a wide D move. Interchange with a U', undo insertion, undo interchange. Undo the conjugate, and the cube is solved. Now, that is a fine way to do it, but I like to add two optimizations to make it a lot easier, which looks like this [do the alg again]. First, instead of converting to even parity and then doing to commutator, I like to do the commutator first and then convert to even parity. This makes the insertion use L moves instead of F moves, which is easier and faster. The second optimization is that I replace the wide D moves with U moves. This makes it even easier, but less intuitive because some of the L and R moves are swapped. Here's the final algorithm I use: conjugate with an R move, then insert with L U2 R'. Since we're using U2 instead of wide D, we have to begin the insertion with an L move and finish it with an R move. Interchange with U'. Undo insertion with R U2 L', and undo interchange with U. Then undo the conjugate with an R' and solve the cube with a U'. Of course, if that's too unintuitive, you can just do a regular old pair commutator with wide D moves.

Now, you can also optimize the memo. If you find out that you have parity at the end of your corner memo, you can swap the C and B edges during your edge memo, rather than doing it at the end, which can save a commutator. Graham Siggins and Kevin Matthews also invented a method called weak swap, which enables you to swap the C and B stickers efficiently on your first set of pieces, before you know whether or not you have parity. Graham's video, which I will link in the description, uses this on edges first, but it also works when memorizing corners first. I'll give a quick demonstration of weak swap for corners. Watch Graham's video for a more thorough explanation.

The basic concept of weak swap is to assume that you do have parity when you get a cycle break. So, if you run into your buffer before the UBR piece is solved, then solve your buffer to UBR and use the UBR piece as your new buffer piece, since it will be solved to your buffer location at UFR. The buffer location stays the same, you just solve a different piece to that location. If you have odd parity, this will save you an algorithm, and if you have even parity this will just function as a cycle break and will not add an extra algorithm. Weak swap only works if you run into your buffer before the UBR piece: if you run into the UBR piece before your buffer, like we did in the previous example, then you just have to solve UBR normally and add B to the end of the corner memo if you have parity.

I'll demonstrate. Try the scramble R U' R' U2. In this scramble, we start with our buffer twisted in place. Let's say we use the less efficient method and start a new cycle randomly at A: our memo would be AP IQ E. Since it's odd parity, we would add B and have 3 commutators: AP IQ EB.

But we can save one whole commutator if we solve our buffer to UBR first. This makes the memo NR KD. Since we have already swapped B and C, an even number of letters now means that we have odd parity. Now, when we do edge memo, we can solve the C sticker to the B position as well. Our memo is JB AD, and we have saved a commutator here as well. This is a little bit more complex than just adding B to the end of the memo, but it can potentially save 2 whole commutators, which makes a big difference for speed and accuracy.

Here's the whole solve using the more efficient parity method and the optimized pair commutator. So, now you can solve parity in a blind solve using a pair commutator instead of learning a whole set of parity algorithms.


----------



## newtonlkh (Jun 11, 2020)

It's so kind of you to go through those lengths to explain it to us!

And to use short "scrambles" to demonstrate is great! I will use this to practice concepts I feel unsure!


----------



## Dylan Swarts (Jun 11, 2020)

Watched the whole thing! I realized what your method was soon before you started explaining it, I personally would not have thought of that, very cool man. It's really great to see how you intuitively do comms too, keep up the great work!


----------



## newtonlkh (Jun 25, 2020)

Any suggestions for R face interchanges? 

I think i am starting to get better with corners with U interchanges, but sometimes the conjugates are quite ugly and I tend to make mistakes when undoing. So I am trying to learn R face interchange, and I found that to be so difficult! I am still practicing sighted, so if I change the buffer to RUF temporarily it would be better (of course, then I could also turn the cube to make R face U). But that is completely useless for actual BLD, so I try keep using UFR, but than I am stuck so bad.

Thanks!! 

Tapatalk を使用して私の MHA-L29 から送信


----------



## dudefaceguy (Jun 25, 2020)

newtonlkh said:


> Any suggestions for R face interchanges?
> 
> I think i am starting to get better with corners with U interchanges, but sometimes the conjugates are quite ugly and I tend to make mistakes when undoing. So I am trying to learn R face interchange, and I found that to be so difficult! I am still practicing sighted, so if I change the buffer to RUF temporarily it would be better (of course, then I could also turn the cube to make R face U). But that is completely useless for actual BLD, so I try keep using UFR, but than I am stuck so bad.
> 
> ...


First of all, congratulations on sticking with it and progressing! If you are having trouble reversing long conjugates, I'd suggest trying to shorten your conjugates before learning R interchanges. Your conjugates shouldn't need to be longer than 2 moves. If you're stuck on a long conjugate, try looking at some commutator spreadsheets. I like Jack Cai's: https://docs.google.com/spreadsheet...azoFNHJ0GidKrUm8NC0OzNcRdk/edit#gid=522554293

JPerm also has a very user-friendly sheet: https://docs.google.com/spreadsheets/d/1rCpr-RVZVHq4S3ctRvuCfl37uy8A27okymzt5yqMPvk/edit

These commutator lists are great for getting new ideas about how to construct commutators. Some of the top cubers do tend to use long conjugates though. JPerm also categorizes the comms based on how he thinks about them, which is different than how I do it. You might like his method better than mine.

R interchanges really are very difficult -- I am just starting to use them in solves, and I always feel like I am messing them up. Ultimately, you don't need to learn R interchanges (or any other interchange) at all. JPerm uses only D and U interchanges for corners, for example. It may be easier to do D interchanges, solving your C buffer to the first sticker in the letter pair.

In terms of using RUF as a temporary "practice buffer," I think you mean that you would still use a U interchange, but your buffer sticker would be M, right? I never thought of that, but it could be a useful training technique. The goal is to eventually be able to recognize interchanges when the stickers are on the side, rather than the face, of the interchange layer. You could also practice this by using "side sticker" D-layer interchanges. For example, you can do the letter pair PH with a D2 interchange, inserting the buffer to P.

My advice is to keep working on your U interchanges until they are very good, and try adding D interchanges instead of R. Remember that any time you spend practicing R interchanges will take time away from practicing U interchanges. You want to have one really solid set of comms before you start branching out.

But hey, I'm no expert -- I just made this guide because there was literally no information about intuitive 3 style as a beginner blind method. So, you are one of the first explorers as well. Now that I've thought about this more, I think I will start practicing those "side sticker" D-layer interchanges. That seems like an easier transition than R-layer interchanges.


----------



## newtonlkh (Jun 25, 2020)

Here is the same cube state, looking from different perspectives

A: it looks like a B move will set up sticker 2 to U face, for interchange
B: it looks like a 12 move commutator is required, because sticker 3 is on D face
C: it looks like piece 3 is trapped between piece 1 and 2, and a complicated conjugate is required
D: it looks like a R face interchange is favorable. 

The same case look so different from different perspectives!















Tapatalk を使用して私の MHA-L29 から送信


----------



## dudefaceguy (Jun 26, 2020)

newtonlkh said:


> Here is the same cube state, looking from different perspectives
> 
> A: it looks like a B move will set up sticker 2 to U face, for interchange
> B: it looks like a 12 move commutator is required, because sticker 3 is on D face
> ...


This is great, a prefect illustration of why 3 style will never get boring for me.

Your example B is actually a good candidate for an R interchange as well - conjugate with a D.

For your example C, I would conjugate with R. This is similar to the one case in which I always conjugate the buffer to the D layer and interchange the other two pieces.

In your example D, an R interchange is not possible as an 8 move pure comm - you can do a 12 mover with the 5 move insert though. Or conjugate to an 8 move U interchange with B' L'. Hmm, now I really want to see what the top cubers do for IQ.... Looks like Jack and Dylan both use a 3 move conjugate for this one. You could also do R' L' which is an interesting conjugate, and cancels with the first move of the comm for a U layer interchange. So many possibilities!


----------



## dudefaceguy (Aug 19, 2020)

johnnick said:


> I think I'll start using this, as I've had a hard time switching to full 3style (I use M2/OP as of now). I also like how intuitive and free it is as well as the parity at the end of the solve.


Excellent, another convert haha! I think you would like the Jake Klassen video I posted earlier in the thread: https://www.speedsolving.com/threads/intuitive-3-style-as-a-beginner-blind-method.77200/post-1366049

Towards the end, he talks about how he recommends figuring out 3-style yourself intuitively, instead of looking at it as a monumental and exacting project to memorize the best algs immediately and systematically. He also talks about your goals for learning 3-style: basically he says you should only do it for fun, or to be truly world-class. M2/OP is sufficient for everything else.

I do it for fun, and I think this is the most fun way to learn 3-style (I know that other people love memorizing algs systematically -- just not me). I'm glad to see that I'm not the only one!

A practice technique that really helped me was trying the same scramble again if I made a mistake. Keep at it until you get it right, trying to isolate and diagnose the problem that caused the mistake. Good luck, and let me know how it goes!


----------

