Commutators and Conjugates
Difficulty: 4/5 I suggest
that you first learn how to solve a Rubik’s cube blindfolded before you start
reading about commutators and conjugates, or at least you are familiar with
the difference between orientation and permutation. If you don’t know the difference between
orientation and permutation, you should read the introduction to the 3x3x3 Blindfolded Solution before
going any further. Using
commutators and conjugates is my favorite way to solve a Rubik’s cube. They allow you to solve the cube
intuitively. Anyone can just memorize
an algorithm and use algorithms to solve a Rubik’s cube. But you never actually “figured out” how to
solve a Rubik’s cube… until now. I want to
be clear that you cannot solve a Rubik’s cube using only commutators and
conjugates. Well, actually, you can,
but there is no reason to do so.
Commutators and conjugates are generally used when the cube is almost
solved, with only a few pieces out of place on the cube. Commutators
can do a couple of things, that I will list here: 1.
It
swaps the positions of three stickers (or groups of stickers) on a Rubik’s
cube and does nothing else. 2.
It
swaps the orientation of two pieces on a Rubik’s cube and does nothing else. 3.
It
swaps the positions of two sets of two stickers (or groups of stickers) on a
Rubik’s cube and does nothing else. Of the
three cases that can happen above, the first case is ideal. This is what most commutators do. The second case is useful, and there are
some commutators that do this. The
third case is usually not very useful.
It is very rare that you will find a situation that you can use the
third case. Notice
that I did not say that a commutator swaps the position of any three pieces…
I said stickers. Which means you can
use commutators to change not only permutation, but also orientation of any
three pieces, or groups of pieces on the cube. Your “piece” can be defined as a corner, it
could be an edge, it could be a corner and an edge, or it could be an edge
and two corners. The only limitation
of a piece is that the piece must be connected. For example, if you wanted one of your
pieces to be the TFL (top front left) corner and the TF edge, that is fine,
because the TFL corner and TF edge are connected to each other. If you wanted your piece to be the TFL
corner and the TR edge, that cannot work, because they are not connected
together. For now, I
will explain the simplest (and probably most common and useful) type of
commutators used. These commutators
swap the positions of any three stickers from any three corners on a Rubik’s
cube, and do nothing else. There are a
couple of conditions that must be satisfied before you can perform this type
of commutator. These conditions are: 1.
Of
the three corners that need to be swapped, one of them must be in the top
layer, and two of them must be in the bottom layer. (Try to position the cube without actually
turning any sides to satisfy this condition.) 2.
Of
the two corners in the bottom layer, exactly one of them must be oriented
correctly relative to the bottom face, and the other must be oriented
incorrectly relative to the bottom face.
A corner is correctly oriented relative to the bottom face if either
the sticker on the bottom face (from that corner) matches with the sticker in
the center on the bottom face, OR matches with the sticker in the center on
the top face. Here’s an example: Let’s say that you have the face with the
green center sticker on top (and therefore, face with the blue center sticker
will be on bottom). If you have a
corner in the bottom layer that has a blue sticker or a green sticker on the
bottom face, then that sticker is oriented correctly, otherwise, it is
oriented incorrectly. 3.
The
corner in the top layer must belong in the position of the corner in the
bottom layer where the correctly oriented piece is located, and the corner in
the top layer must be oriented incorrectly relative to the top face. If these
three conditions are not met, then you cannot perform the commutator
directly. If you cannot perform the
commutator directly, then you must first perform a conjugate. A conjugate is basically just a ‘setup
move’ that is used before the commutator is performed. We won’t worry about conjugates yet. Alright,
so now you know what commutators do, and the conditions that are necessary to
perform them. The only thing you need
to know is how to actually perform them.
Commutators are always of the form: X Y X’Y’, where X is an algorithm,
Y is an algorithm, X’ is the inverse of the X, and Y’ is the inverse of
Y. Before we go any further, you need
to understand what inverses are. The
inverse of an algorithm is another algorithm that will ‘undo’ exactly what
you just did. For example, if you do
the algorithm: R T, the inverse of that algorithm would be: T’ R’, because
that is the algorithm that would get the cube back to its original
state. The way to find an inverse is
this: Write the algorithm backwards,
and put a prime symbol (‘) after each letter.
Example: To write the inverse
of the algorithm: T R B2 T’ L R’, you would need to first write the algorithm
backwards, which would be: R’ L T’ B2 R T, and then put a prime after every
symbol, which would be: R L’ T B2 R’ T’.
This is the inverse for the original algorithm. Notice that if you put a prime symbol after
another prime symbol, they cancel each other out. Also notice that if your algorithm contains
a 180degreeturn (in this example, B2), you can ignore putting a prime
symbol after that because rotating something 180 degrees clockwise has the
same final affect as rotating it 180 degrees counterclockwise. Now that
you know what inverses are, the only thing you need to do is learn how to
define what is algorithm X, and what is algorithm Y. Once you define X and Y, X’ and Y’ will
also be defined based on what X and Y are.
I will first explain how to define algorithm, X. Algorithm
X is whatever algorithm is needed in order to put the corner in the top layer
to the position of the correctly oriented corner in the bottom layer. There are however, two complications. The first complication is that X must put
the corner in the top layer to the bottom layer, and the corner in the top
layer must have correct orientation (and permutation) when you put it
there. The second complication is that
the algorithm absolutely cannot affect the entire bottom layer, except for
the corner in the bottom layer that is correctly oriented. That probably all sounds very confusing
right now, but I will have an example of this shortly. Algorithm
Y is whatever algorithm is needed in order to put the incorrectly oriented corner
in the bottom layer to the position of the corner in the bottom layer that
algorithm X affected. There is only
complication, and I shouldn’t even call it a complication because it actually
just makes things easier. The
complication is that you can only turn the bottom layer. This means that Y will never be more than
one turn long. Once you
perform X and Y, the cube may look rather scrambled, but you are actually
much closer than you think you are to solving the cube. Recall that the form of a commutator is: X
Y X’ Y’. Once you perform X and Y,
even though the cube may look scrambled, you will know exactly what to do
because, since you know what X and Y are, you will therefore know what X’ and
Y’ are. Here is
the simplest example I can give you of a situation where you can perform a
commutator. As you
should notice, all three conditions are satisfied in order to directly
perform a commutator. 1) It contains
one corner in the top layer and two in the bottom layer. 2) Of the two corners in the bottom layer,
one is oriented correctly relative to the bottom face (the one with the
yellow sticker on the bottom), and the other one is oriented incorrectly
relative to the bottom face (the one with the blue sticker on the bottom).
And 3) The corner in the top layer belongs where the correctly oriented
corner is located in the bottom layer, and the corner in the top layer is
oriented incorrectly relative to the top face. This probably all sounds pretty complicated,
but if you closely study the cube, and look for what I just mentioned, you
will realize that all three conditions are satisfied. Alright,
LET’S DO THIS. Let’s perform the
commutator. The first thing you need
to do is algorithm X, which is whatever algorithm is needed in order to put
the corner in the top layer to its correct position in the bottom layer (and
remember, you can’t effect the bottom layer at all, except for the location
where the corner in the top layer belongs).
Can you see what the algorithm is? The
algorithm X in this case is: R T R’.
Here is a picture below to show what this did. There are
a lot of things you need to notice here so I will explain what exactly
happened. First of all, you should
notice that the corner that was previously in the top layer is now in the
bottom layer, in its correct location.
You should also notice that nothing was affected in the bottom layer,
except for the position where you placed the corner that was previously in
the top layer. Another odd observation
you probably have is that the top layer looks rather scrambled. As it turns out, you can scramble the top
layer and middle layer as much as you want.
As long as you keep track of what is going on in the bottom layer, the
commutator will work. Since you
performed X, the next step is Y.
Algorithm Y is whatever algorithm is needed in order to put the
incorrectly oriented corner in the bottom layer to the only position in the
bottom layer that was affected during algorithm X. This should not be too hard to see what the
algorithm is. It is simply one turn of
the cube. In this case, Y = D. (D means rotate bottom layer 90 degrees
clockwise.) Here is the result: The cube
probably does look rather scrambled right now, but this is the beauty of
commutators. Right now, your part of
thinking is over. You already figured
out what X and Y are, so the only thing left to perform is X’ and Y’, which
are already defined, since X and Y are defined. Now simply
perform X’, which is: (R T R’)’, which is: R T’ R’. Performing this will give you this result: From this
point, I think anyone could figure out what to do next, but according to the
commutator, we are not finished yet.
We still need to do Y’, which is (D)’, which is: D’. Simple as
that. This is how all commutators
basically work. You need to get a
certain piece(s) to the bottom layer (which would be X), then swap that
piece(s) with another piece(s) that need to be swapped (which would be Y),
then do the inverse of both of them (which would be X’ Y’) to solve the
commutator. Some
commutators, however, are not as easy to recognize. If the three conditions of a commutator are
not satisfied, then you cannot perform the commutator directly, and must
first use a conjugate, which I will discuss now. A conjugate
is whatever algorithm is needed in order to put the cube in a state that the
three conditions for a commutator are satisfied. Usually, a conjugate only consists of one
move, maybe two. It is very rare that
you will have to use a conjugate that consists of more than two moves. If you use a conjugate, you must do the
commutator (after doing the conjugate), and then after doing the commutator,
you must do the inverse of the conjugate.
I will denote a conjugate with the letter, Z. Any
commutator using a conjugate will be of the form: Z X Y X’ Y’ Z’ Where (Z)
is the conjugate, (X Y X’ Y’) is the commutator, and (Z’) is the inverse of
the conjugate. Here’s a
simple example of a conjugate: Any experienced
cuber should recognize this pattern (which you should be an experienced cuber
if you are reading this). A very
common algorithm can be done to solve this cube right now, but I will instead
show you how to solve the cube in this particular case using a commutator and
a conjugate rather than an algorithm. If you
study the cube, you should come to the conclusion that it is impossible to
position the cube so that a commutator can be directly performed, because not
all three conditions are satisfied.
This means that a conjugate must be used. Here is the conjugate in this case: The
conjugate in this case is: L2. The
reason for this is that now all three conditions are satisfied. I’m not going to list all three conditions
again and explain why they are true in this case. You should be able to figure out why all
three conditions are satisfied. You
might be asking yourself, how did I know that the conjugate would be L2 in
this case? And the answer is: You just have to practice at it, and eventually
you will come to the point where you can recognize what the conjugate will
be. There is no set method to
determine what the conjugate will be. Alright,
now that I performed the conjugate, (Z), the next step is to perform the
commutator. As you know, the first
thing I need to perform is X, which is to get the corner in the top layer to
its solved state in the bottom layer.
X in this case is: R T R’. The cube will now look like this: You should
now notice that the corner that was in the top layer is now in the solved
state in the bottom layer, and that position was the only position affected
in the bottom layer. Next, perform
Y. Remember, to perform Y, you need to
get the other unsolved corner in the bottom layer to the position in the
bottom layer that was just affected.
In this case, Y is: D2. Alright. At this point, you’ve performed Z, X, and
Y. This is what I love about
commutators. If you look at the cube
above, it looks pretty scrambled, but you already know exactly what to do. Since you already did Z X Y, the only thing
left to perform is X’ Y’ Z’. Next I
perform X’: Now Y’… And
finally, Z’. As you can
see, adding a conjugate to a commutator doesn’t really make the commutator any
harder to do… once you figure out what the conjugate is. Deciding what is the conjugate is the hard
part of the conjugate. If you can do
that, performing the rest of the commutator is not that hard to do. A single
commutator can switch any three pieces on the cube. Let’s say you have four pieces on the cube
out of place. What can you do? The answer is simple. Just perform two separate commutators. For the first commutator, only worry about
placing one piece in the correct location.
After the first commutator, you will have one less piece out of place;
therefore you will only have to worry about three pieces out of place. Use one more commutator to solve the
remaining three pieces, and the cube will be solved. If you
have five pieces out of place, you can obviously not solve it with one
commutator. You will probably need to
use three commutators, although in some cases, if you are clever, you might
be able to get away with using only two commutators. That takes a lot of practice though. Now that
you know the first type of commutator out there, I will now explain the
second type. The second type of
commutator changes the orientation of any two pieces on the cube, while preserving
permutation. I personally think this
type of commutator is easier to understand than the first type. There are only two conditions that need to
be satisfied in order to perform this commutator without a conjugate, and
those conditions are: 1.
There
need to be two pieces on the cube with correct permutation and incorrect
orientation. 2.
Both
of those pieces need to be in the bottom layer. If both
pieces are not in the bottom layer, you will obviously have to perform a
conjugate. A conjugate for this type
of commutator will never need to be more than one move. That makes things simpler. Let’s say
you have a cube that looks like this: If you can
solve a Rubik’s cube blindfolded, this situation should look pretty familiar,
and you already know the algorithm to solve the cube from this point, but
instead I will be showing you how to solve it using a commutator. The general rule for a commutator is that
you want to get a piece located correctly in the bottom layer (X), completely
ignoring how scrambled the top two layers get, then replace that piece in the
bottom layer with something else that needs to be solved (Y), and then undo
the first algorithm (X’), and then undo the second algorithm (Y’). In this example, we’ll start with the
yellow/blue/red corner. Our goal is to
get it positioned correctly in the bottom layer, by only affecting that one
piece in the bottom layer. After doing
that, your cube should look something like this: The algorithm
X in this case is: F’ T F R T R’.
Notice that the only piece affected in the bottom layer was the one
corner that I wanted to be affected.
Everything else is in the same location as before. Now that you did X, the next thing to do is
Y, which would get the other scrambled piece to the location of the piece
that you just solved. In this
case, Y is: D. Once again, since you
already performed X and Y, you should realize by now that X’ and Y’ are
therefore already defined, and your part of thinking for this commutator is
over. Next
perform X’, which is: (F’ T F R T R’)’, which is R T’ R’ F’ T’ F. If you perform this, you get: Next
perform Y’, which is: D’. I don’t
think commutators of this type are nearly as hard to perform as the first
type. However, the first type is much
more useful, and requires far fewer moves than the second type. The hard part about the second type of
commutators, however is recognizing what X will be. X typically consists of about 6 or 7 moves for
the second type of commutator, and typically only 3 or 4 moves for the first
type of commutator. 
