# Rubik's 4x4x4 Cube - Is there a "pair of moves" view of parity algorithms?

When figuring out Rubik's cubes, there are a number of intuitive approaches that help and are (at least for me) satisfying as an approach. One of the most powerful ideas especially towards the end of a solve is the idea of a pair of moves (I'm not sure I've seen this articulated, but I can't imagine that it hasn't been). Certainly, this idea is enough to solve the 3x3x3.

For example, suppose we have this position where two corners are rotated:

We can do a largely intuitive set of moves to force the top right to be rotated without impacting the rest of the top layer, but allowing the bottom three layers to be messed up. Call this set of moves 'Rot1'. (there's presumably many ways, but here's one: R'B'RBR'B'R - focus only on the near corner, and you'll see why this works). This gets us here:

The top-right is now correct, but the cost is that the bottom three layers are messed up.

Now we simply rotate the top to get the other rotated corner piece into place (U'):

And then we do the opposite of 'rot1'. This is the second pair of moves, and it unmesses the bottom half, while simulateously unrotating the top corner. If you hadn't done the U' above, it would simply get you back to where you started. But since you did, it essentially fixes the pair of rotated corners:

This is the heart of the parity issue. In a 3x3x3 cube, you can always find pairs of moves like this to solve it. It's why a single corner rotated isn't solvable. This applies to three corners out of place, or two edges rotated, etc.

However, for a 4x4x4 cube, you can imagine the middle layers stuck together so that it acts like a 3x3x3. But then it is possible to get parity issues and solve them. See here.

There are algorithms for solving these, but I'd like to understand it in a "pair of moves" kinda way. I get that it has to involve the four middle squares which can swap about. But I can't see what the equivalent of a 'rot1' is to solve this case.

The mathematical term for your 'pair of moves' concept is commutation, and more specifically, a commutator is a sequence $$ABA^{-1}B^{-1}$$, where $$A$$ and $$B$$ are two move sequences, In your example $$A$$ is the corner twist sequence an $$B$$ is a top layer turn.

Note that in such a commutator sequence every move that occurs in $$A$$ or $$B$$ will be undone later in $$A^{-1}$$ or $$B^{-1}$$.

Unfortunately it is not possible to fix that edge pair flip parity using a commutator, or even a sequence of commutators. The reason is that you need to swap a single pair of (edge) pieces, and that is a permutation that has odd parity (see my site or wikipedia). The only moves that perform an odd parity permutation on the edge pieces are inner slice quarter turns. You will need to do an odd number of such inner slice turns to get an odd edge permutation, whereas commutators can only do an even number of them.

The OLL parity fix you quote indeed uses 9 inner slice quarter turns, an odd number.

It is possible to do a single inner slice, say r, and then use various commutators to fix the centres and then the remaining 5-cycle of edges.

Personally I can never quite remember the fix for this parity problem, so I tend to use r U2 r U2 r U2 r U2 r. This leaves the centres intact but involves an odd number of inner slice turns, so that just leaves the 6 affected edges that need to be solved, and that can now be done with commutators that do 3-cycles of edges.

Note that some 4x4x4 PLL parity problems involve swapping two edge pairs. This is an even permutation (two swaps) so this can be fixed with one or more commutators. The simplest 4x4x4 PLL parity case swaps opposite edgepairs in a layer. I had always though it was actually a commutator, but see now that the one given on the site you link is not. One way to do this as a commutator is as follows:

First consider the following commutator on a 3x3x3 which flips two edges in the M middle layer.

(F U' R F' U) M2 (U' F R' U F') M2

On a 4x4x4 this sequence flips two edge pairs, and each such flip is essentially a swap of two edge pieces. Now we just need a setup sequence to get it to swap the pieces we want. For example:

B2 r2 [flip] r2 B2

This gives the swap (UFr BUr)(UFl BUl). You can also use a slightly different setup:

B' R D r2 [flip] r2 D' R' B

Then you get the swap (UFr UBl)(UFl UBr). Similarly you can use set ups R2 D or R B' to get two ways to swap the UF and UR edge pairs instead.

The use of such a set up (and its inverse at the end) is in mathematical terms called conjugation. It may not seem like it, but a conjugation of a commutator is still a commutator. This is because you could do/undo the setup in between like this:

$$C(ABA^{-1}B^{-1})C^{-1} = (CAC^{-1})(CBC^{-1})(CAC^{-1})^{-1}(CBC^{-1})^{-1}$$

• Thanks. Yeah, I was just using the OLL as an example. I was talking about the general class of parity problems. So your simple fix for an edge swap makes sense to me. Is there a similar things for a corner swap? Commented Apr 12 at 15:14
• Can you explain the PLL commutation briefly? What are the swaps? Commented Apr 12 at 15:27
• @DrXorile To perform a corner swap I would do a 3x3x3 T-perm or similar PLL sequence to fix the corners, which converts the problem to a simpler PLL parity case. Note however that the T-perm itself, or any 3x3x3 move sequence that does a corner swap cannot be done with commutators, and that still applies to the 4x4x4 too. Commented Apr 12 at 15:54
• @DrXorile The simplest 4x4x4 PLL parity case swaps opposite edgepairs in a layer. I had always though it was actually a commutator, but see now that the one given on the site you link is not. I'll try to think up a commutator version for it soon. Commented Apr 12 at 16:00