# Intro to Commutators & Conjugates

#### dougreed

##### Member
Barring some freak occurance, there are generally three ways the cubing community has found to come up with algorithms for a Rubik's Cube.

1. Using a computer solver
2. Using commutators and conjugates
3. Using intuition

The first two offer the most promising results when the cube is very restricted; e.g. when all but the last layer or a few other pieces are solved. The latter option offers the most promising results when the cube is not very restricted; e.g. when the majority of the cube is unsolved, and the unsolved portions can be used as buffer areas to do something useful.

It is my intent to offer some insight as to how to create simple algorithms for puzzles 2x2x2-5x5x5, Megaminx, Dogic, and other similar twisty puzzles, using commutators and conjugates. I'll already assume that whatever puzzle you're trying this out on you can solve. Otherwise, if you do not have a solved puzzle to begin with, it will be difficult to judge exactly what each algorithm is doing. However, the approach is generic, so if you understand it on a 3x3x3 it should be easy to apply the same approach to other twisty puzzles.

My intent here isn't really to educate anyone on group theory, but it is interesting nonetheless and if you're interested in it at all I suggest you purchase Adventures in Group Theory, which can be found on Amazon, Half.com, or Ebay. For the rest of this guide I'll be using terms with respect to the Rubik's Cube only, but you should still know that there is some fundamental math behind it all.

==What is a Commutator?==

To the puzzle solver, a commutator is a generic approach to building a useful algorithm. The commutator fundamentally is built on two moves, A and B, which can represent any two algorithms. When we refer to the commutator [A,B], we are actually referring to the algorithm built by catenating A, B, A-inverse, and B-inverse. The resulting algorithm therefore can be expressed as [A,B]=A B A' B'.

For most of our purposes, A will be some familiar or simple algorithm (sometimes as few as 3 moves) and B will be some other one-face turn, e.g. U or U2 or U'.

It is probably not readily apparent how extremely useful this is. We can see from the beginning though that some simple cases result in interesting algorithms. For instance, if we let A=R' D' R and B=U, then the commutator [A,B] = [(R' D' R), U] = (R' D' R) U (R' D R) U'. If this algorithm is applied to a solved 3x3x3 Rubik's Cube, it is easy to see that this algorithm affects corners only and is a 3-cycle that does not preserve orientation, at least by our conventional definition.

We actually could have predicted the end result of the above commutator by looking at how A and B are related. If you notice, A does a lot to change the state of the cube, but all we are really interested are the pieces A changes that intersect with the pieces that B changes. Since B changes only the permutation of the U layer, we are only interested in how A changes the U layer, since when A is undone (A') anything that B does *not* change will be undone, since the motion of these pieces is completely disjoint.

Let us label the UFR, UBR, and FRD corners X, Y, and Z, respectively. When we apply move A, corner Z replaces corner X. When we apply move B, corner Y replaces corner Z. After A', corner X replaces corner Y. Finally, after B', corner Z replaces corner X (again). Since we are only discussing the cyclic movement of 3 corners, and none of the 3 corners are in their original positions after [A,B], this is said to be a 3-cycle.

This probably isn't completely clear yet. Before you continue, try the same commutator again. And again. If everything went well, you should be back to the original position. It may help to take some colored electrical tape (or if you have a blank cube, use that) to differentiate the corners. What is important is that you understand specifically how the algorithm is affecting the corners.

Try these commutators, all of the form [A,B], which work similarly. Before applying the algorithm, it will probably benefit you to try to guess which pieces will be affected and how. The latter ones are kind of tricky to predict.

1. A = R' D' R
B = U2
[so the result is (R' D' R) U2 (R' D R) U2]

2. A = M D M'
B = U

3. A = M D2 M'
B = U

4. A = (R U R' U') * 3 [this is a well known F2L alg]
B = D

5. A = L E' L'
B = U

6. A = r' D' r
B = U

7. A = M
B = E

8. A = M
B = E2

==What is a Conjugate?==

Well now that you (hopefully) get the hang of simple commutators, it's time to discuss conjugates. Luckily, conjugates are much easier to understand than commutators. The "conjugate of G by H", written sometimes as G^H, is essentially the catenation of G^H = H G H'.

By now you should understand the previous example of the commutator [(R' D' R), U]. What if we let this be our G and let the turn B be our H? Then, G^H = B [(R' D' R), U] B'. Go ahead and try it out. This isn't very useful, since the same thing could be accomplished with a slightly modified commutator, rather than using the conjugate.

Now, try this. On your solved cube, apply [(R' D' R), U]^(L D). Expanded into normal notation we get L D (R' D' R) U (R' D R) U' D' L'. Clearly this is of more use to us, as now we have an algorithm that 3-cycles corners in the U layer without affecting their orientation. This algorithm was actually fairly easy to arrive at.

The easiest way to arrive at this algorithm is to apply the commutator [(R' D' R), U]. Note how the U layer color, in my case yellow, is on the R face of the FRD corner. With this in mind, if I want my 3-cycle to leave corner orientation in tact, I know that whatever piece from the U layer I put into the FRD corner, the color that faces to the right *must* be my U layer color. Otherwise, the orientation will not be left in tact.

Try these conjugates of the form G^H, also. As before, try your best to figure out what they will do before you apply them.

1. G = [(R' D' R), U]
H = L'

2. G = [(M D' M'), U2]
H = S

==Practical Applications==

Many algorithms we use can be expressed as a combination of commutators.

For instance, the popular Sune algorithm, R U R' U R U2 R', can be expressed as [R,U][U2,R].
The popular PLL corner 3-cycle, (R' F R') B2 (R F' R') B2 R2 can be expressed as [R F R', B2]^[R2].
The popular PLL edge algorithm, M2 U M2 U2 M2 U M2 can be expressed as [M2, U][U', M2].

Also interesting to note is how easy it is to build 3-cycles of the form [A,B][B2,A] = A B A' B A B2 A'. For instance, [A,B][B2,A] with A=(R' D' R) and B=U yields nice results. So does A=(M D' M) and B=U. So does A=(L E L') and B=U.

With these cases in mind, it is actually very easy to combine these 3-cycles with set-up moves (conjugates) to change the orientation of pieces. For instance, where X is the 3-cycle of edges UF->UB->UL, X^(S') yields nice results. The result, S' X S, is a 3-cycle of edges that affects the edge orientation in a highly controlled manner.

==This is the End==

I'm sure there will be a lot of questions, but I hope this guide will be of use to some of you. If anything isn't clear, please ask!

-Doug

Last edited by a moderator:

#### genwin

##### Member
as a beginner, are commutators essential to learn if solving a 3x3?? i've read that you need to learn this on higher order cubes or 3x3 BLD.. i still don't understand the sune algorithm as a combination of commutators...

#### Harry

##### Member
Woooooowwwwww, thanks, I will learn those things..... Thanks MR!! I will print it out too!!!!!!

Btw, is perms also commutators?

Could you explain it to me?

So, this commutattors can be used in BLD as well?

Last edited:

#### italrubik

##### Member
Can I use those commutators to solve pyraminx crystal?

#### antoineccantin

##### Member
Barring some freak occurance, there are generally three ways the cubing community has found to come up with algorithms for a Rubik's Cube.

1. Using a computer solver
2. Using commutators and conjugates
3. Using intuition
4. Doing random moves and taking note of what it does.