Commutators and Conjugates

Difficulty: 4/5

 

I suggest that you first learn how to solve a Rubiks 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 dont 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 Rubiks cube. They allow you to solve the cube intuitively. Anyone can just memorize an algorithm and use algorithms to solve a Rubiks cube. But you never actually figured out how to solve a Rubiks cube until now.

 

I want to be clear that you cannot solve a Rubiks 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 Rubiks cube and does nothing else.

2.       It swaps the orientation of two pieces on a Rubiks cube and does nothing else.

3.       It swaps the positions of two sets of two stickers (or groups of stickers) on a Rubiks 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 Rubiks 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. Heres an example: Lets 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 wont 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 XY, 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 180-degree-turn (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 shouldnt 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.

 

easycomm(1).jpg

 

 

easycomm(2).jpg

 

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, LETS DO THIS. Lets 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 cant 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.

 

easycommX.jpg

 

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:

 

easycommY.jpg

 

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:

 

easycommXprime.jpg

 

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.

 

solved3bottom.jpg

 

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.

 

Heres a simple example of a conjugate:

 

easyconj(1).jpg

 

 

easyconj(2).jpg

 

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:

 

easyconjZ.jpg

 

The conjugate in this case is: L2. The reason for this is that now all three conditions are satisfied. Im 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:

 

easyconjX.jpg

 

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.

 

easyconjY.jpg

 

Alright. At this point, youve 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:

 

easyconjXprime.jpg

 

Now Y

 

easyconjYprime.jpg

 

And finally, Z.

 

easyconjZprime.jpg

 

As you can see, adding a conjugate to a commutator doesnt 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. Lets 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.

 

Lets say you have a cube that looks like this:

 

cornerorientalgo2.jpg

 

If you can solve a Rubiks 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, well 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:

 

comorienX.jpg

 

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.

 

comorienY.jpg

 

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:

 

easycommXprime.jpg

 

Next perform Y, which is: D.

 

solved3bottom.jpg

 

I dont 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.

 

 

 

 

Home