Conjugates and commutators for twisty puzzles -- so what?

Solution 1:

Introduction

I once felt the way you currently do about the hype of commutators and conjugates on the cube, but once I "got my hands dirty" with playing around with a virtual cube simulator such as Cube Twister (or, nowadays, you can just use the online applet, alg.cubing.net), I realized that, just like anything else in math, this topic too can be simplified and generalized in the human mind to create a tool chest for tackling all types of "cube problems" and even "cube theory" topics.  

I can probably understand that you don't decompose Rubik's cube algorithms everyday, but I note that, with one negligible modification to all three of the algorithms you listed, all can be written as single commutators. (The alternate ending move is added in parenthesis.)

Algorithm 1: R U R' U R U2 R' U2 (U2) = [R U R2, R U2 R2]

Algorithm 2: L U' R' U L' U' R U2 (U') = L U' R' U L' U' R U = [L, U' R' U]

Algorithm 3: F2 U L R' F2 R L' U F2 U2 (U2)

= F2 U L R' F2 R L' U F2
= (F2) U L R' F2 R L' U (F2)
= (F2 U) L R' F2 R L' U2 (U' F2)
= (F2 U) M' x' F2 M x  U2 (U' F2)
= (F2 U) M' U2 M U2 (U' F2)
= (F2 U) [M', U2] (U' F2)
= [[F2 U: M'], [F2 U: U2]]
= [F2 U M' U' F2, F2 U U2 U' F2]

= [F2 U M' U' F2, F2 U2 F2]

Piece-Isolating Commutators (The Easiest-to-Understand Commutators)

Extrapolating on your comments in your question, I suspect that when you saw me write "Algorithm 1" as a commutator, it reinforced your notion that the commutator structure does not guarantee understand-ability, but note that commutators which consist only of R and U turns/are in the move set < R,U > are generally not any more understandable than other algorithms in < R,U > which are not commutators.

Therefore the commutator decomposition that I listed for "Algorithm 1" (which was found independently by several people) certainly does not make sense of it. In fact, if you apply a few moves to a solved cube (with zero knowledge of commutators) to simply try to find a move sequence which only affects pieces in a single layer, that is probably one of the first sequences you would find.

On the other hand, there are alternate move sequences in a less restrict move set which can be expressed as a very understandable piece-isolating commutator (or conjugated piece-isolating commutator).

Algorithm 2 As a Piece-Isolating Commutator

You can view "Algorithm 2" is a piece-isolating commutator as follows.

1. Invert the move sequence: U' R' U L U' R U L'.
2. Execute only the first three moves on a solved cube. U' R' U
3. There is a corner piece "isolated" in the left slice. Do a turn of the left face to put an alternate (solved) corner piece in that corner slot. U' R' U L
4. Undo the first three moves. U' R' U L (U' R' U)'
5. Undo that turn of the left face that you did. U' R' U L (U' R' U)' (L)'
6. Simplify and take the inverse to achieve "Algorithm 2".

To get a better grasp of what piece-isolating commutators are more generally (although this is the main idea in a nutshell), I recommend you to watch this video and this video.

A Video Exploiting "Algorithm 2"

In the process of writing this response (which took several hours), I also invested time in producing this YouTube video wherein I introduce "Algorithm 2".

Below is the video description.

This video introduces the most basic commutator (8 move Niklas piece-isolating commutator) which affects only three pieces on a Rubik's cube, explains why it works, and demonstrates how to solely use it to solve the 3x3x3 Rubik's cube and other Rubik's cube type puzzles.

Different from previous YouTube tutorials on commutators and conjugates, the way commutators are presented in this video is how I first learned (taught myself) about commutators.

One (general) algorithm. No notation. No prerequisite Rubik's cube knowledge required.

Lengthy, but very thorough, detailed, and well-explained.

Algorithm 3 As a Piece-Isolating Commutator

Once you have a piece-isolating commutator that exchanges a certain number of pieces, you may conjugate it to be any move sequence which affects the same number (and the same number of every type) of piece(s) it affects.

For example, the four move commutator in "Algorithm 3" can be rewritten in the form of a piece-isolating commutator (shown below). In this case, two edges are isolated in the top face (the fixed center can be ignored).  

(U M' U') (U2) (U M' U')' (U2)' 

At this point, we can conjugate this piece-isolating commutator with the move U' to get M' U2 M U2 = [M', U2] (after simplification). 

Then we conjugate it with the setup moves (which we already know from Algorithm 3's equivalent).

F2 U U' (setup moves)

(U M' U') (U2) (U M' U')' (U2)' (Piece-isolating commutator)

U U' F2 (undo setup moves)

[Link]

Efficiently Using Conjugates to Make Useful/Short Sequences from Piece-Isolating Commutators - 4x4x4 Parity Algorithm Example

Furthermore, if we want to create move sequences from "base algorithms" which we create from piece-isolating commutators which are as short as they possibly can be, we perform a cyclic shift of that base algorithm to see if it creates a more favorable setup so that we can use fewer setup moves to get what we want.  

Since you mentioned twisty puzzles, in general, I, being pretty good at creating short 4x4x4 parity algorithms by hand (see my YouTube channel for derivation videos and my main thread for written derivations), take note of the following move sequences for the single dedge flip parity case/position on a 4x4x4 Rubik's cube.

The Base Algorithm

1) Start with the piece-isolating commutator

(2u 2l' 2u')

(2R)

(2u 2l' 2u')'

(2R)'

[Link] (This isolates the pieces in this 1x2x2 block slot).  

2) Conjugate it with two moves.

2b 2l2 (setup moves)

2u 2l' 2u' 2R 2u 2l 2u' 2R' (piece-isolating commutator)

2l2 2b' (undo setup moves)

[Link]  

3) Apply a quarter turn.

2b 2l2 (setup moves)
2u 2l' 2u' 2R 2u 2l 2u' 2R' (piece-isolating commutator)
2l2 2b' (undo setup moves)
2R (quarter turn)

[Link]

Route 1: Conjugating the Base Algorithm

The minimum number of moves to conjugate this base algorithm into a single dedge flip is 5. Below is one choice of such setup moves. (The symbol "x2" represents turning the entire cube towards/away from you twice. It does not count as a move.)

x2 2L B R D' B //outer setup moves
2b 2l2 (setup moves)
2u 2l' 2u' 2R 2u 2l 2u' 2R' (piece-isolating commutator)
2l2 2b' (undo setup moves)
2R (quarter turn)
(x2 2L B R D' B)' //undo out setup moves

[Link]

That IS the absolute minimum number of outer setup moves that you can possibly do. This gives us a 24 block quarter turn move algorithm. However, what if I told you that we could get a 19 block quarter turn move algorithm from the base algorithm if we first perform a cyclic shift (cyclically rotate the moves in the base algorithm)? Let's try it out.  

Route 2: Shifting the Base Algorithm

1) Removing all comments from the base algorithm and writing it on one line, we have 

2b 2l2 2u 2l' 2u' 2R 2u 2l 2u' 2R' 2l2 2b' 2R.  

2) Cutting and pasting the bold 9 moves above and pasting them after the last move (cyclically shifting 9 block quarter turn moves in the clockwise direction), we get the shifted base  

2u' 2R' 2l2 2b' 2R 2b 2l2 2u 2l' 2u' 2R 2u 2l  

3) If we conjugate this base algorithm, we can conjugate it with three moves, of which there is a move cancellation between the third and fourth moves. (The letter z denotes rotating the entire cube clockwise to the right and doesn't count as a move.)

(z d' m D) //undo outer setup moves
2u' 2R' 2l2 2b' 2R 2b 2l2 2u 2l' 2u' 2R 2u 2l //shifted base
(z d' m D)' //undo outer setup moves

[Link]

Algorithm 1 As a Piece-Isolating Commutator

Finally, I conclude with discussing a piece-isolating commutator to generate the same position which "Algorithm 1" (the unmodified, R U R' U R U2 R' U2) does. This is more involved than the examples shown in the two videos I linked to, but I thought it was worth mentioning. Note that "Algorithm 1" affects two piece types, and thus, if we want to construct a single piece-isolating commutator to create the same position, we need to isolate multiple pieces.

1) For simplicity, I constructed a move sequence wherein I isolate pieces in the left slice, one at a time.  

U' M2 U //isolate middle edge piece

U' R' U R U' R' U //isolate pure twisted corner 1

U R U' R' U R U' //isolate pure twisted corner 2

[Link] (Note that a pure 3 corner twist requires TWO twisted corners to be isolated in the same slice adjacent to each other, and thus we had to break that down into two steps!) Remember, look at the LEFT slice only!  

2) Removing comments, writing on a single line, and using L' as our Y in [X,Y], we have a move sequence which cycles three edges (without flipping them) and twists three corners in the same direction as "Algorithm 1".  

[U' M2 U U' R' U R U' R' U U R U' R' U R U', L']  

3) Conjugate with a few moves to get the same exact position generated by "Algorithm 1  

(y z' F D' F')
[U' M2 U U' R' U R U' R' U U R U' R' U R U', L']
(y z' F D' F')'

  [Link]

Thinking Outside of the Box:

Solving the Entire nxnxn Cube with a Single Commutator.

Commutators have been known to only affect a few pieces on the Rubik's cube, but what most people don't know of (or are even aware of the possibility of) is the fact that ANY even permutation position of the nxnxn cube can be expressed with a single commutator move sequence. That is, we can solve the entire puzzle with a single commutator. This is definitely beyond what you asked for, but I thought it was appropriate to include a mention of this in my post to inform you that we do not need to apply multiple commutators or conjugated commutators to solve the nxnxn cube. One application of a single commutator (plus a few quarter turn slices to make the parity of all piece orbits even) is sufficient!  

Abstractly, I claim that for any even permutation scramble S which is in the nxnxn cube commutator subgroup, there exists at least one solution in the form [X,Y] such that [X,Y]' = S.  

Below are example solves I did in the past for three different cube sizes to illustrate what I mean.  

Example 2x2x2 solve||Example 3x3x3 Solve||Example 4x4x4 solve.

Thinking Outside of the Box:

Solving the Entire nxnxn Cube with a Single Conjugate

Conjugates are generally known to change which pieces a base algorithm, such as a commutator, affects. This way, if thought through, we can get away with having very few base algorithms to adjust to solve the entire cube. What most people don't know is that we can actually solve a subset of positions of the nxnxn cube solely by conjugating any of its generating move sequences.  

Abstractly, I claim that for a subset of all possible scrambles S on the nxnxn cube, there exists at least one sequence A such that A S A' = S'

Below is an example 3x3x3 solve by Inversion by Conjugation that I did in the past.  

D' B F' D' L2 B' R D L2 U L U L' R F2 U2 F2 U' //S


B R2 B' D2 B2 D2 R U' L' B' D' R U F R' F U2 L' U2 //A

D' B F' D' L2 B' R D L2 U L U L' R F2 U2 F2 U' //S

(B R2 B' D2 B2 D2 R U' L' B' D' R U F R' F U2 L' U2)'//A'

[Link]  

The conditions in which a move sequence S can be inverted by conjugation are known by some, and it is possible to count the number of positions which can be inverted by conjugation.

Conclusion

I hope that my post has answered your questions and has also informed you about going beyond the traditional group theory topics associated with the Rubik's cube! The content in this post is only the tip of the iceberg. I apologize for probably going too far in detail, but I wanted to try to give you an idea of what's out there (even if such content is not widely known).

Solution 2:

My two cents:

Conjugates are useful because they let you take an 'operator' that does one thing, and adapt it to do a different but related thing. Example: Suppose you have an operator that, say, twists two corner cubies on opposite corners of a face. You can use this to twist two adjacent corner cubies by conjugation: (a) quarter-turn a face to turn the two adjacent cubies into opposite cubies; (b) apply the opposite twist operator; (c) un-quarter-turn.

Commutators are useful precisely for building operators. I picture this as follows: Think of some face-turn sequence as 'an arrow' from the current cube state to some other state, and its inverse as 'an arrow' in the reverse direction. A conjugate of the sequence is simply 'an arrow' in a somewhat different direction. Now a commutator is simply a sequence followed by a conjugate of its inverse. The result is to take an arrow in one direction, followed by a back-arrow 'at an angle', which leaves a residual arrow representing the net change. If you plan ahead, you can make the residual arrow quite short, i.e leave only a few things changed.

I happen to have read Hofstadter's article in Scientific American ['Metamagical Themas'] on Rubik's Cube back in the 80's. I was struck by his example of a 'monoflip': Consider a sequence of turns that leaves the top layer unchanged except for a single flipped edge cubie; the rest of the cube may be scrambled as you wish. It is easy to turn this into an operator to flip two edge cubies: Simply commute the 'monoflip' with a turn of the top face! It is possible to apply this insight to create as many operators as needed to solve the Cube.

Solution 3:

In the days when I used to play with the Rubik Cube, I used conjugates a lot, because they reduce the number of sequences that you need to remember.

Suppose, for example, you know a sequence of moves $R$ that perform a $3$-cycle on three specific edge cubies $E_1,E_2,E_3$, perhaps the three surrounding a corner.

Then, if you want to do a $3$-cycle on any other set of $3$ edge cubies $E_4,E_5,E_6$, you first perform a sequence $X$ that moves $E_4 \to E_1$, $E_5 \to E_2$, $E_6 \to E_3$. Then you do $R$. Then you do $X^{-1}$ to move the three you wanted move back to their original positions - but cycled in the way you want. So, you have carried out the conjugate $XRX^{-1}$.

Of course, you have to work out $X$ on the fly, and remember it while you are doing $R$, but I found with practice that I could manage that. And you won't break any speed records using these techniques, but they do enable you to solve the cube while minimizing the amount of memorizing required.

I found commutators also useful, but that was more for specific sequences $R$.