#### Christopher Mowla

##### Premium Member

Everyone who solves big cubes via the 3X3X3 reduction method is familiar with two-corner swap parity cases. As we all know, this is usually done in two steps:

1) Executing some PLL (or some 2-corner and 2-edge swap odd parity algorithm)

2) Executing the two opposite edge swap.

In a nutshell, we swap two corners and two edges followed by swapping back the two edges. The end result is consequently only two swapped corners.

Is there a "direct" method? Actually a direct approach, meaning, swapping two corners in one algorithm piece is IMPOSSIBLE. However, for those who were wondering on if there is another approach, the answer is yes. In my opinion, it is more big cube direct than the usual (practiced) approach (and the algorithms generated from them can be translated to a 5X5X5 or other odd cubes to do a "T-Perm" about the central edge pieces), but its move count is higher (which I cannot help).

What is this new approach? Swapping 4 edges and two corners in one algorithm and then performing a brief 3X3X3 algorithm two correct the four edges swapped. This is exactly what the algorithm below does. Like the common approach, it is composed of two pieces. The first 16 half turn moves of the following algorithm swap four edges and two corners, while the last 5 half turn moves correct the 4 edges swapped from the first portion.

Rw2 x' U2 L' U2 R U2 x U2 R U2 R' U2 Rw2 L U2 x' U2 Rw2 U2 y' R2 U2 R2 U2 y x (21f)

Many 21f algorithms can be formed with a new technique I am going to present by deriving the algorithm above. (I am not 100% positive 21f is the lowest with this approach, though.)

Here is the derivation for those interested.

Spoiler

Before I begin the actual derivation, I will explain two items that you need to be aware of.

1) Converting the first and last moves on symmetrical pure OLL parity algorithms does not affect it being pure.

Example: Take the most well-known pure edge flip algorithm: r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2

Converting the first and last half turn moves to wide turns yields the same result:

Rw2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 Rw2

2) Adding in either:

l2 next to the first r or r'

or

r2 next to the first l or l'

which is

Example:

Pure edge flip

r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2

Pure double parity

r2 B2 U2 l (r2) U2 r' U2 r U2 F2 r F2 l' B2 r2

GOAL: We wish to find an algorithm which swaps two (adjacent) corners as well as

The HOW: As you probably have guessed, we are going to use OLL parity algorithms of a certain type: one which can be converted to

Basically what we are going to do is perform an edge flip parity algorithm TWICE. But why even use an OLL parity algorithm in the first place? Observe the effect the non-pure (speed form) OLL parity algorithm has on the two top-front corners: Rw2 B2 U2 Lw U2 Rw' U2 Rw U2 F2 Rw F2 Lw' B2 Rw2. It swaps them.

Keeping that in mind, in order to even hope to end up with these two corners to remain switched as well as have no edge flip when it's all said and done, we need to perform another algorithm right after it which flips the single edge back, induces PLL parity, and does not touch the corners.

The end result will be what we want: two swapped corners and 4 swapped (2 2-cycles) of edges swapped.

It turns out that if we perform the wide turn version of the

The impure double parity algorithm will do two 2-cycles of edges and swap the two corners. The pure edge flip part will just make sure that there will not be any flipped edges at the end.

To provide us with very good results as far as speed and length goes, we will use the following pure edge flip algorithm:

r2 B2 U2 l' U2 r U2 r' U2 B2 r' B2 l B2 r2

As described previously about the modified version of an algorithm of this form, its corresponding

r2 B2 U2 l' (r2) U2 r U2 r' U2 B2 r' B2 l B2 r2

1) Write out the pure edge flip form of this algorithm so that the portion of the algorithm which we inserted the extra r2 in is to the left. This is no problem for us because the algorithm is already in that order.

2) Write out the inverse of this pure edge flip, convert all slice turns to wide, and insert the r2 (which also should be made wide as well): this is the impure double parity.

3) Also note that we are going to use wide turns for the beginning preliminary and ending moves Rw2 for both pieces.

Rw2 B2 U2 l' U2 r U2 r' U2 B2 r' B2 l B2 Rw2

Rw2 B2 Lw' B2 Rw B2 U2 Rw U2 Rw' U2 (Rw2) Lw U2 B2 Rw2

Rw2 B2 U2 l' U2 r U2 r' U2 B2 r' B2 l

As you can see, the bold moves above automatically cancel as well as the inner slice of the L-turns adjacent to them.

=Rw2 B2 U2 l' U2 r U2 r' U2 B2 r' B2

L' B2 Rw2 B2 U2 Rw2 U2 Rw2' U2 (Rw2) Lw2 U2 B2 Rw2

Now we need to do two things:

1) Delete all slice turns of the first piece (which was formally the pure edge flip) (the lower case letters) which are to the RIGHT of the location where the extra Rw2 move was added (think symmetrically as if we have reflected the double parity modification on to the pure edge flip).

2) Convert all wide turns to face turns which are to the LEFT of the Rw2

=>

Rw2 B2 U2 U2 U2 U2 B2 B2

L' B2 R B2 U2 R U2 R' U2 Rw2 L U2 B2 Rw2

L' B2 R B2 U2 R U2 R' U2 Rw2 L U2 B2 Rw2

writing on one line:

=Rw2 B2 L' B2 R B2 U2 R U2 R' U2 Rw2 L U2 B2 Rw2

The algorithm to swap two corners and two 2-cycles of edges has been accomplished. Now just add the following 3X3X3 moves to the end:

Rw2 B2 L' B2 R B2 U2 R U2 R' U2 Rw2 L U2 B2 Rw2

B2 U2 B2 U2 B2

Adding cube rotations for easier execution:

Rw2 x' U2 L' U2 R U2 x U2 R U2 R' U2 Rw2 L U2 x' U2 Rw2 U2 y' R2 U2 R2 U2 y x

DONE

If we add R' as a preliminary move, we can have the diagonal corner swap:

R'

Rw2 x' U2 L' U2 R U2 x U2 R U2 R' U2 Rw2 L U2 x' U2 Rw2 U2 y' R2 U2 R2 U2 y x

R

As long as you have a pure edge flip algorithm which can be converted to a

1) Executing some PLL (or some 2-corner and 2-edge swap odd parity algorithm)

2) Executing the two opposite edge swap.

In a nutshell, we swap two corners and two edges followed by swapping back the two edges. The end result is consequently only two swapped corners.

Is there a "direct" method? Actually a direct approach, meaning, swapping two corners in one algorithm piece is IMPOSSIBLE. However, for those who were wondering on if there is another approach, the answer is yes. In my opinion, it is more big cube direct than the usual (practiced) approach (and the algorithms generated from them can be translated to a 5X5X5 or other odd cubes to do a "T-Perm" about the central edge pieces), but its move count is higher (which I cannot help).

What is this new approach? Swapping 4 edges and two corners in one algorithm and then performing a brief 3X3X3 algorithm two correct the four edges swapped. This is exactly what the algorithm below does. Like the common approach, it is composed of two pieces. The first 16 half turn moves of the following algorithm swap four edges and two corners, while the last 5 half turn moves correct the 4 edges swapped from the first portion.

Rw2 x' U2 L' U2 R U2 x U2 R U2 R' U2 Rw2 L U2 x' U2 Rw2 U2 y' R2 U2 R2 U2 y x (21f)

Many 21f algorithms can be formed with a new technique I am going to present by deriving the algorithm above. (I am not 100% positive 21f is the lowest with this approach, though.)

Here is the derivation for those interested.

**Prerequisite Knowledge**

Before I begin the actual derivation, I will explain two items that you need to be aware of.

1) Converting the first and last moves on symmetrical pure OLL parity algorithms does not affect it being pure.

Example: Take the most well-known pure edge flip algorithm: r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2

Converting the first and last half turn moves to wide turns yields the same result:

Rw2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 Rw2

*Reason: The outer-layer turns do not affect the area of concentration which the core of the algorithm acts upon.*

*More importantly, they are set-up moves. Sometimes internal wide turns (in place of single slice turns) besides set-up moves do not affect a pure edge flip, but those instances are rare, in general.*

2) Adding in either:

l2 next to the first r or r'

or

r2 next to the first l or l'

which is

__next to an outer layer face turn__(in algorithms of this form) converts a pure edge flip to a pure double parity.

*The reason it is next to an outer-face turn is not necessarily a prerequisite for all algorithms, however.*

Example:

Pure edge flip

r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2

Pure double parity

r2 B2 U2 l (r2) U2 r' U2 r U2 F2 r F2 l' B2 r2

*Reason: In a nutshell, it is a one-time setup move to convert a 2-cycle into a 4-cycle before the outer preliminary moves are added to the entire base. Also, it is important that it is a half turn being added in, thus still keeping the overall permutation of the algorithm odd (which is the needed structure for OLL parity algorithms, which we are now utilizing for a two-edge swap PLL parity algorithm)...yeah.*

**The Derivation**

**Step 1**

__The Thought Process__.

GOAL: We wish to find an algorithm which swaps two (adjacent) corners as well as

*four*edges. In technical terms, we need an algorithm which induces an odd permutation to the outer 3X3X3 layer orbit as well as induce PLL parity in the inner-orbit (s) of the big even cube.

The HOW: As you probably have guessed, we are going to use OLL parity algorithms of a certain type: one which can be converted to

**pure**double parity algorithms by the insertion of one move (non-pure ones can be formed by reversing a single l or r move in OLL parity algorithms which are not of this form, and even this does not apply to all algorithms). The reason we are doing so because we will combine both the double parity form and pure edge flip form together into one algorithm. Since these two algorithms are nearly identical, and the *intruder* is on the end of one of them, we will have a lot of move cancellations.

Basically what we are going to do is perform an edge flip parity algorithm TWICE. But why even use an OLL parity algorithm in the first place? Observe the effect the non-pure (speed form) OLL parity algorithm has on the two top-front corners: Rw2 B2 U2 Lw U2 Rw' U2 Rw U2 F2 Rw F2 Lw' B2 Rw2. It swaps them.

Keeping that in mind, in order to even hope to end up with these two corners to remain switched as well as have no edge flip when it's all said and done, we need to perform another algorithm right after it which flips the single edge back, induces PLL parity, and does not touch the corners.

The end result will be what we want: two swapped corners and 4 swapped (2 2-cycles) of edges swapped.

**Step 2**

It turns out that if we perform the wide turn version of the

*double parity*modification of the OLL parity algorithm and execute a pure OLL (pure edge flip) algorithm, the move count will be lower as far as solving back the two 2-cycles of edges at the end.

*Reason, observe what formation the impure double parity permutes the 4 edges: it is a formation which can be done in the fewest moves possible for formations made with these type of algorithms (if all 4 edges were in M, then M2 U2 M2 U2 would be optimal, but I cannot form an algorithm whose end result does this--which is the least amount of moves possible itself) .*

The impure double parity algorithm will do two 2-cycles of edges and swap the two corners. The pure edge flip part will just make sure that there will not be any flipped edges at the end.

To provide us with very good results as far as speed and length goes, we will use the following pure edge flip algorithm:

r2 B2 U2 l' U2 r U2 r' U2 B2 r' B2 l B2 r2

As described previously about the modified version of an algorithm of this form, its corresponding

**pure**double parity is:

r2 B2 U2 l' (r2) U2 r U2 r' U2 B2 r' B2 l B2 r2

**Step 3: The Arithmetic Begins**

1) Write out the pure edge flip form of this algorithm so that the portion of the algorithm which we inserted the extra r2 in is to the left. This is no problem for us because the algorithm is already in that order.

2) Write out the inverse of this pure edge flip, convert all slice turns to wide, and insert the r2 (which also should be made wide as well): this is the impure double parity.

3) Also note that we are going to use wide turns for the beginning preliminary and ending moves Rw2 for both pieces.

Rw2 B2 U2 l' U2 r U2 r' U2 B2 r' B2 l B2 Rw2

Rw2 B2 Lw' B2 Rw B2 U2 Rw U2 Rw' U2 (Rw2) Lw U2 B2 Rw2

**Step 4**

Rw2 B2 U2 l' U2 r U2 r' U2 B2 r' B2 l

**B2 Rw2**

**Rw2 B2**Lw' B2 Rw B2 U2 Rw U2 Rw' U2 (Rw2) Lw U2 B2 Rw2

As you can see, the bold moves above automatically cancel as well as the inner slice of the L-turns adjacent to them.

=Rw2 B2 U2 l' U2 r U2 r' U2 B2 r' B2

L' B2 Rw2 B2 U2 Rw2 U2 Rw2' U2 (Rw2) Lw2 U2 B2 Rw2

**Step 5**

Now we need to do two things:

1) Delete all slice turns of the first piece (which was formally the pure edge flip) (the lower case letters) which are to the RIGHT of the location where the extra Rw2 move was added (think symmetrically as if we have reflected the double parity modification on to the pure edge flip).

2) Convert all wide turns to face turns which are to the LEFT of the Rw2

=>

Rw2 B2 U2 U2 U2 U2 B2 B2

L' B2 R B2 U2 R U2 R' U2 Rw2 L U2 B2 Rw2

*As you will notice by comparing this algorithm with the previous, no changes have been made to the end result!*

**Carryout the move cancellations (e.g. U2 U2 is nothing at all):**

Step 6

Step 6

**=**Rw2 B2

L' B2 R B2 U2 R U2 R' U2 Rw2 L U2 B2 Rw2

writing on one line:

=Rw2 B2 L' B2 R B2 U2 R U2 R' U2 Rw2 L U2 B2 Rw2

Step 7

Step 7

The algorithm to swap two corners and two 2-cycles of edges has been accomplished. Now just add the following 3X3X3 moves to the end:

Rw2 B2 L' B2 R B2 U2 R U2 R' U2 Rw2 L U2 B2 Rw2

B2 U2 B2 U2 B2

**Step 8**

Adding cube rotations for easier execution:

Rw2 x' U2 L' U2 R U2 x U2 R U2 R' U2 Rw2 L U2 x' U2 Rw2 U2 y' R2 U2 R2 U2 y x

DONE

**Step 8b**

If we add R' as a preliminary move, we can have the diagonal corner swap:

R'

Rw2 x' U2 L' U2 R U2 x U2 R U2 R' U2 Rw2 L U2 x' U2 Rw2 U2 y' R2 U2 R2 U2 y x

R

**Conclusion**

As long as you have a pure edge flip algorithm which can be converted to a

**pure**double parity by one adjustment (preferably near the beginning or end to promote the maximum move cancellations), you can form any pure two-corner swap algorithm you wish (different parity algorithms you use will produce different two-corner swap algorithms). Notice that knowledge of how pure edge flip and double parity algorithms actually work is not required to utilize them. Good luck on deriving your own!

Last edited: Jul 4, 2010