Reduction parity

The term "parity" can be used to describe a number of situations that occur during a 4x4x4 solve which cannot manifest during a 3x3x3 (standard size Rubik's cube) solve. In fact, there has been debate about what situations are considered to be a parity case, but there is one situation of which any cuber who uses the term "parity" for the 4x4x4 identifies as parity: the single dedge flip.

The most popular 2-cycle (a swap of two pieces) besides the single dedge flip case is the following. This 2-cycle of wings is as common during a K4 Method solve as the single dedge flip is, but it should never arise during a solve using the Reduction Method because two dedges are not paired up. However, many who solve the 5x5x5 Rubik's cube using some variant of the Reduction Method will come across this case; and thus several (but not all) of the algorithms listed on this page which solve this case directly can be used for completing the tredge-tripling stage of a 5x5x5 Reduction solve.

An equally well-known form of reduction parity (this term will be defined formally soon) besides the single dedge flip is switching two opposite dedges in the same face.

This parity situation can be transformed into 21 other last layer forms of what is commonly called PLL parity by performing a 3x3x3 PLL and adjusting the upper face (AUF) as needed. That is, there is a total of 22 PLL parity cases. (See the PLL Parity section for details.) The remaining PLL parity cases which involve the fewest number of pieces (besides the most popular case above) are the following.

Despite that one can technically solve all 22 PLL parity cases by executing an algorithm meant to solve any one of them (to any face) and then finish solving the 4x4x4 as if it was a 3x3x3, special algorithms have been developed for every case. This allows one to use fewer moves to solve any given case and gives one more options.

Combining some form of PLL parity and a single dedge flip creates one of the many cases of what's commonly called double parity. For example, performing a swap of dedges to a fully solved 4x4x4 and then flipping the front dedge resulting from that swap gives us the following.

Since the double parity case above and the single dedge flip case both have a single dedge flipped, and since OLL algorithms do not necessarily aim to permute (move) the pieces that they correctly orient in any particular fashion, any 4x4x4 algorithm which solves:

a case containing an odd number of flipped dedges (which will be called "single parity" on this page)

or

a case which additionally has an odd permutation of dedges and an even permutation of corners (or vice versa) (which will be called "double parity" on this page)

is called an OLL parity algorithm.

It is common convention among the speedcubing community to use algorithms which contain wide (double layer) turns to solve OLL parity instead of single inner layer slices. The notation used in Chris Hardwick's Rubik's Revenge Solution signifies a wide right turn as (Rr), for example. In old WCA notation (the notation used on this page), (Rr) is expressed as Rw. (The "w" is short for "wide".) In fact, the most popular speedcubing single parity algorithms perform additional swaps besides flipping a single dedge due to the use of wide turns.

Such an algorithm is called a non-pure algorithm when compared to algorithms which just flip a single dedge, which are often called pure flips. However, the term pure is more formally associated with an algorithm being supercube safe--algorithms which do not permute (move) any centers in the supercube version of a given order.

Most of the algorithms on this page affect some centers of the 4x4x4 supercube: not all algorithms affect the supercube centers in the same manner.

Algorithms followed by a "//Safe" are supercube safe.

There are many types of parity cases which can occur during a 4x4x4 solve, but the cases which result from attempting to reduce a fully scrambled 4x4x4 into a pseudo 3x3x3 state (this means an even nxnxn cube in which all of its composite edges are complete and all of its centers are complete and are in the correct center orientation, in general). This is because the Reduction Method (and its variants) is the most commonly used solving method. Naturally, these type of parity cases are called reduction parity.

Reduction parity occurs when you try to reduce the puzzle so it can be solved by a constrained set of moves, putting it into some subset of the positions. However, you can often reach a position which seems like it is in your subset, but which is actually not, and to solve the puzzle you have to briefly go outside your constrained set of moves to bring the puzzle back into the subset you want. Typically the number of positions you can encounter is some small multiple of the number of positions you expect. The obvious example is PLL parity in 4x4x4: all the centers and edges are properly paired, so you expect to be able to finish the puzzle with only outer layer turns, but this isn't quite possible. OLL parity falls under this definition too (so the reduced 4x4x4 has four times as many positions as you would expect).[1]

There is a 50/50 chance that PLL parity will be present (assuming that one is doing a solve using reduction).

Independently, there is a 50/50 chance to get a single dedge flip. Therefore there is a 1/2×1/2 = (chance of PLL parity)×(chance of single parity) = a 1/4 chance of getting all possibilities, separately.

That is, for the reduction method (and its variants),

PLL parity occurs by itself 25% of the time,

single parity occurs 25% of the time,

double parity occurs 25% of the time, and

there is no reduction parity 25% of the time.

This page will keep strong focus on reduction parity (OLL parity and PLL parity) cases, but it will also include a limited number of other parity situations which are also common in other solving methods, as well as cases which share some characteristics with reduction parity algorithms.

The key characteristics of 4x4x4 reduction parity algorithms are:

They preserve the colors of the centers. (Note that most reduction parity algorithms do not technically preserve the centers themselves, because if they are applied to a fully solved 4x4x4 supercube, one can see that same color centers are swapped with each other.)

They do not break up (and therefore do not pair up) any dedges. (They preserve the coupling of the dedges, but they may move entire dedges.)

Additionally (with no exceptions),

All OLL parity algorithms contain an odd number of inner slice quarter turns. (They are called odd parity algorithms.)

All PLL parity algorithms contain an even number of inner slice quarter turns. (They are called even parity algorithms.)

Other parity cases

Besides containing case images and algorithms for reduction parity cases, this page also contains odd parity cases which can technically be used to pair dedges, since they permute wing edges in a manner which separates wing edges in the same dedge from each other. Algorithms for one such parity case already mentioned are included on this page.

Websites such as bigcubes.com present algorithms with an even number of inner slice quarter turns for the dedge-pairing stage of the Reduction Method.

Also included on this page are other last layer 2-cycle cases:

and 4-cycle cases which are contained within two dedges .

There is actually a total of 110 last layer 4-cycles, but since 4-cycles in two dedges are the only ones encountered using the most popular 4x4x4 solving methods, they are the only ones shown on this page. However, this PDF includes all 110 cases and relatively short algorithms to solve each one directly.

Algorithms for the Cage Method, as well as algorithms for theoretical purposes and general 4x4x4 exploration are present as well.

Some short/easy parity fixes

Since all OLL parity algorithms contain an odd number of inner slice quarter turns, one can technically fix any 4x4x4 wing edge odd parity case by executing a single slice quarter turn and then resolve the cube using an even number of inner slice quarter turns. Here's one video tutorial that illustrates the typical process.

Similar to doing an inner slice quarter turn like r to technically fix the single dedge flip parity, an inner slice half turn such as r2 is technically all that is needed to fix PLL parity. In fact, only two inner slice quarter turns + 3x3x3 turns is all that is needed to create/solve PLL parity on the 4x4x4. One can split up r2 as r r or as r' r' and insert 3x3x3 moves to obtain the pure form of PLL parity. Below is an example algorithm found in December of 2013.

Should one wish to induce an odd permutation in the wing edges of the 4x4x4 with a short algorithm without having to restore the cube as much as applying an inner slice quarter turn requires, below are fairly short (and simple) algorithms one can use.

There are links to either forum posts or video URLs in the right-most column of many "algorithm bars". These links are intended to either show one of the (if not the) first place the algorithm (or a simple conjugation, transformation, and/or a directly related version of it) was first published, and/or show one of the (if not the) earliest date of publish. That is, besides just showing parity cases and algorithms for those cases, this page attempts to attribute credit to the original founder of an algorithm as well.

(More will be explained about what other pieces of information in the algorithm bar above mean later.)

Since this algorithm contains move repetition, it can be written more compactly as f2 (r E2)2 r f2.

Clearly this algorithm does not preserve the pairing of dedges, but it does preserve the colors of the centers; and it contains 7 inner slice quarter turns, an odd number.

We can break up this algorithm as (f f r E E r E E r f f) to count 4 f's and 3 r's. At the same time, we can count a total of 11block quarter turn moves (BQTM). We can count that this algorithm has 7 block half turn moves (BHTM) without breaking it up.

In addition to the fact that all parity cases on this page are each represented by a case image,

The number of moves an algorithm contains in these two big cube move metrics is written next to them in the form of the ordered pair, (BQTM, BHTM). (We can clearly see this in the above algorithm bar.)

Algorithms with fewer BHTM are listed first in each category.

Algorithms with fewer BQTM are listed before other algorithms which have the same number of BHTM as they.

Although this algorithm affects the same number of pieces as the (11,7) move algorithm above on the 4x4x4, it also "works"/does the same for the nxnxn cube. The (11,7) above discolors centers on, say, the 5x5x5 cube.

Many of the algorithms on this page need to be "adjusted" to work for the nxnxn Rubik's cube.

Some algorithms may only be translatable to higher order even cubes (6x6x6, and larger).

All algorithms can be applied to the 6x6x6 if instead of turning the outer 2 layers, turn the outer 3 layers; instead of turning 1 inner layer slice, turn 2 inner layer slices.

Finally, one of the simplest OLL parity (more specifically, a double parity) algorithms (found in December of 2017) to remember also consists of a short repeated sequence:

This was deduced from the same idea that Floyd Newberry came up with for using a short repeated sequence to directly solve a 2-cycle. Below are two single dedge flip (2-cycle) algorithms illustrating the idea.

Additional notes about the algorithms

Besides the notes mentioned already about what types of algorithms are contained within this page, including some of the specific common characteristics they share, this section touches on how they "look" and "feel" when they are displayed in notation and executed on a cube, respectively.

Notation and animations

All algorithms on this page are written in old WCA notation, where lowercase letters represent inner slice turns, uppercase letters and xyz have the same meaning as standard 3x3x3 notation, and a move like Rw, for example, means to turn both the face and inner slice parallel and adjacent to it simultaneously in the same direction. (Using the same example, Rw = (Rr).)

Click the move length ordered pairs of the form, (number of block quarter turns, number of block half turns) (which are to the right of the algorithm in the algorithm bar), to see the algorithm animated in SiGN notation at alg.cubing.net.

Move sets

Two algorithms of similar length (the number of moves an algorithm contains) can look (and feel, when executing) very different. This is especially common if two algorithms are in a different move set (consist only of certain types of turns).

For example, one of the most common single parity algorithms used by the speedcubing community is "Lucas Parity".

Notice that it only contains the (and inverses of the) moves Rw, U2, x and Lw.

Interesting Note:

On January 24, 2010, speedsolving.com forum member reThinking the Cube showed that Lucas Garron's "Lucas Parity" (published in mid 2008) is equivalent to Stefan Pochmann's "New Dedge Flip" from his webpage (published in or before early 2007).

An alternate algorithm of the same move length in BHTM (but contains 5 fewer BQTM) is the following.

Y (short for "Yes"), if all of an algorithm's inner slice turns can be substituted with their corresponding wide turns to still preserve F3L (or if an algorithm does not contain any inner layer slices)

or

N (short for "No"), if their inner slices cannot be substituted with wide turns and still preserve F3L.

Note that with many algorithms, it's not "all or nothing". A few of the slice turns can be wide to still just flip a single dedge, for example. For convenience, an algorithm is written with the maximum number of wide turns, should that version of it still preserve as much as the version of it without any wide turns.

For example, the second 15 BHTM algorithm mentioned above could be expressed later on this page with the following algorithm bar, since all of its inner slice turns can be made wide (hence the "Y" instead of an "N") and its first and last moves can be wide and still solve the pure dedge flip case (hence why the algorithm begins and ends with Rw2 instead of r2).

For illustration of how algorithm bars are going to be labelled, let us temporarily name it "Old Standard Alg" and called the author "anonymous". (Algorithm names will be explained next.)

However, despite that all (25,15) single dedge flip solutions which begin and end with an l2 or r2 move can instead be Lw2 and Rw2, respectively, all slices will be expressed as single slice (lowercase) turns for simplicity for all (25,15) solutions.

Names/labels

Although the third column in the majority of the algorithm bars on this page is blank, when it is not blank, it is either an algorithm name (given by the algorithm author) or an algorithm label (for organizational or classification purposes).

represent consecutive ordered version algorithms which are different versions (transformations) of each other

OR

prove things like "there are actually fewer distinct paths than it appears for an algorithm in this move set and of this length" and also to show that "one algorithm is just another in disguise".

Algorithms that have been named "5x5x5 Alg" are significantly longer algorithms than their related 4x4x4 algorithm counterparts, but they are algorithms which follow a lot of constraints and manage to work on the 4x4x4 and the 5x5x5.

PLL Parity

This section shows all 22 possible PLL parity cases. In addition, algorithms for the two cases when two dedges are unoriented (and corners are solved) and the three cases when all four last layer dedges are unoriented (and the corners are solved) are also included.

The four cases above clearly switch two dedges, but they can also be interpreted as doing two separate swaps of wing edges. Recalling that the term "2-cycle" is interchangeable with the common term "swap", these cases perform 2 2-cycles of wing edges. (They are called "2 2-cycles" for short.)

There are actually 58 of these cases in the last layer, in general. However, the other 54 will only be encountered during a K4 Method solve. This PDF includes all 58 cases and short algorithms to solve each one.

Pure Flips (Single Parity)

All algorithms in this "pure flips" section are single parity algorithms.

One dedge flip

Shortest half turn move algorithms

It turns out that the shortest algorithms in the half turn move metric (in both the single slice turn metric and the block turn metric) have a length of 15.

There are exactly 288 algorithms (with a length of 15 half turns) which flip the upper front dedge and affect the top or front centers of the 4x4x4 supercube.

They all happen to be 25 BQTM as well; and they all happen to be single slice turn-based algorithms (algorithms which predominately consist of single slice turns).

All 288 (25,15) algorithms can be obtained by running the 3x3x3 Classic Setup through a 3x3x3 solver like Cube Explorer and choosing all outputted 15f algorithms which are confined to the move set <U2,F2,D2,B2,L,R>.

Simply convert the turns of the L and R faces into their corresponding inner slice turns and select the resulting algorithms which flip a single dedge on the 4x4x4.

These 288 (25,15) algorithms have been divided into 36 clusters. There are exactly 8 algorithms in each cluster.

Every cluster essentially represents a single unique algorithm path, as move transformations (from cube rotations, mirrors, and inverses) can be done to any algorithm in a given cluster to obtain the 7 other algorithms in its cluster. To avoid human error, a custom program was written to perform these move transformations to the first algorithm listed in each cluster and to label the remaining 7 algorithms in its cluster as the transformation they are of the first algorithm.

Even further, several of these clusters are categorized as being in the same group number. This is because, although transformations are strictly restricted to being in the 36 clusters, some of these clusters of algorithms are directly related to each other by either conjugation and/or by cyclic shifting (a special type of conjugation).

Take for example the first algorithm in the first cluster under Group 1 of non-symmetrical algorithms, r' U2 l F2 l' F2 r2 U2 r U2 r' U2 F2 r2 F2.

Rotating about y2 gives B2 l2 U2 l U2 l' U2 B2 l2 B2 l' U2 r B2 r', which is the third algorithm in the first cluster under Group 3 of non-symmetrical algorithms.

This is why Group 3 is called "Group 3: Cyclic Shift of Group 1", for example.

Even further, all unique non-symmetrical algorithms are directly related to each other by transformations (resulting from inserting cube rotations in between moves of the algorithms). The same holds true for all unique symmetrical algorithms.

This implies that, despite that there are 288 15 half turn move algorithms which solve the upper front dedge pure flip case, there are actually only two fundamentally unique (25,15) algorithm paths: the symmetrical approach and the non-symmetrical approach.

An algorithm is called symmetrical if its first and last moves are inverses of each other (or if it can be rewritten as such, should its first and/or last move cancel with the second and/or second to last move in the algorithm, respectively). Symmetrical algorithms are conjugates.

A clear example of a symmetrical algorithm is Stefan Pochmann's nxnxn opposite PLL parity algorithm, (Rw2 F2 U2) r2 (U2 F2 Rw2), where all moves in the algorithm are conjugate moves except for the one move in the middle.

Although symmetrical algorithms are technically conjugates of non-symmetrical algorithms, non-symmetrical algorithms are algorithms which are solely the result of a composition of one or more separate algorithm pieces, which all together accomplish the desired task. (No "conjugate assistance" is used.)

In practice, human creation of symmetrical algorithms requires more trial and error of different paths in both creation of the base (the base is defined as the move sequence B in A B A') and final setup moves, whereas the creation of non-symmetrical algorithms requires having knowledge of forming different pieces individually and knowing how to combine them.

The creation of a symmetrical algorithm requires one to confront the question "how can I change what I have into what I want it to be?" (video example), whereas the creation of a non-symmetrical algorithm requires one to confront the question "I have already achieved a portion of the task, but what is the missing piece?" (written example).

Shortest single slice quarter turn algorithms

The current upperbound in the single slice quarter turn metric for the single dedge flip is 23. This section contains over 100 algorithms with this quantity of moves.

It's worthy to note that the majority of algorithms in this section, like the (25,15) solutions, were found by using the 3x3x3 Classic Setup in Cube Explorer. For this particular set, a search up through depth 18 was performed.

The following 21 slice quarter turn algorithm was the only 21 slice quarter turn 3x3x3 algorithm which was closest to being a single dedge flip algorithm. Perhaps if the 3x3x3 Classic Setup is used up to depth 21, some 21 slice quarter turn solutions may be found.

However, unlike all of the 23 single slice quarter turn algorithms presented in this section (which can be applied to all big cube sizes), these two algorithms only work on the 4x4x4.

Like the (25,15) solutions, these solutions have been grouped next to their transformations. To save space, we label each group's algorithm as v1,v2,v3, and so forth.

However, unlike the (25,15) solutions, this is by no means the complete set of all possible unique (let alone all inverse, mirror, and rotation transformations of the unique solutions) 23 single slice quarter turn solutions. (There were 36 "unique" (25,15) solutions from which all 288 algorithms were derived from.) Perhaps in the future we will have efficient optimal solvers in the single slice quarter turn metric which we can use to do a brute force search.