# An efficient 4x4x4 parity algorithm, intuitively.

The 4x4x4 cube is more complicated to solve than the 3x3x3 due to having a parity problem. If you have never solved a 4x4x4 before, I encourage you to go away and try solving it yourself, then come back to this article later.

The parity I refer to is as follows (speedcubers call this OLL parity): After solving the centres of the cube, look at the 24 edge pieces. If they form an odd permutation, then I say we have a parity problem we need to fix. The reason this is non-trivial is that most/all of the easy to create algorithms that preserve the centres of the cube perform an even permutation of these 24 edges. Odd permutations are possible (in conjunction with performing simultaneously an odd permutation of the indistinguishable centre squares).

I will aim for the following: An odd permutation of the 24 edge pieces, with three of the four layers solved, and all the edge pairs on the last layer preserved. This is for compatibility with common approaches to solving the 4x4x4 – usually only after solving three layers and pairing the edges is it fast to recognise the existence of a parity problem.

Since we have to perform an odd permutation, let’s do that first and perform the move l. (I won’t define the notation but will link to alg.cubing.net so you can see the moves visually).

Our goal now is to solve as much of the cube from this state as possible using even permutations. Instead of thinking of needing to perform a quarter turn of half a cube, it will be more productive to think of us as needing to perform a 4-cycle of 1x2x3 blocks to completely solve the cube.

Now a 4-cycle of these blocks is not happening, but a 3-cycle of these blocks is easy to construct. It is well-known and easy to construct 3-cycles as simple commutators (here’s an example). We can also create block 3-cycles from similar simple processes. For example, here is a 3-cycle of 1x2x3 blocks:

This doesn’t quite permute the three 1x2x3 blocks we’d want (we want to permute three all on the left side of the cube). We can get around that by conjugating by F r. So now we’re at

Let’s look at where we are. Our biggest problems are that we have to solve the two centres on the F and D faces, and re-pair the UF and DF edges.

We will look at the centres first. The usual way to solve centres in this type of position is the simple 4-mover r U2 r’ U2. But look, that move also swaps the edge pairing of exactly two edges! So we look to see if some version of this algorithm in the right direction and right orientation can solve our two problems, and it turns our that we can with [D2, l]. So altogether we now have

l [F2 r: [r’ 3Dw2 r, U2]] [D2, l]

which solves our problem, giving us a parity fix algorithm.

When the cancelling moves are cancelled, it is 15 moves long.

I will not discuss questions of optimising this algorithm for speed.

If one does look online for speed algorithms, then one will quickly come across something like the following (also 15 moves long)

Now that we’ve done our analysis, we can see the same structure in that algorithm, just in a different order. We see setup moves, the block 3-cycle, the 4-move centres solving and a single turn inserted to ensure odd parity.

## One thought on “An efficient 4x4x4 parity algorithm, intuitively.”

1. Christopher Mowla on said:

Have you seen this intuitive approach to fixing parity? (https://www.youtube.com/watch?v=gIyHFUyf5SI) Also, I derived r2 B2 U2 l U2 r’ U2 r U2 F2 r F2 l’ B2 r2 in this video series (https://www.youtube.com/watch?v=-W88afo5evE&list=PLCB1E32A6B432F0D8). In addition, I created a new category of parity algorithms (https://www.youtube.com/watch?v=JOiyd3PbXZg&list=PL271745B9E036A65E). Lastly, I recently uploaded this playlist on creating 2-gen parity algorithms (https://www.youtube.com/watch?v=Igb2zrmXV3M&list=PLo3YvnW-NFSrcq_E7bvy_RxOM16laESP9). If you haven’t seen my wikipage (which contains all kinds of parity algorithms, even the one you derived in this blog), see (https://www.speedsolving.com/wiki/index.php/4x4x4_parity_algorithms).

But of all of the parity algorithms I found, the shortest (in block quarter turns) is https://alg.cubing.net/?puzzle=4x4x4&type=alg&alg=r-_3u-_2U-_l-_2R-_u-_2R-_u_3l_2R-_u_l-_u-_2R-_u_l_e-_r.