New Two-Corner Swap Algorithm Technique for Big Even Cubes (PLL Parity)

Christopher Mowla

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.
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.

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!

Step 6
Carryout the move cancellations (e.g. U2 U2 is nothing at all):
= 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

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:

joey

Member
Can you make one which keeps the orientation of the corners.

Other than the obvious L (your alg) L', conjugate.

Christopher Mowla

Yes (with a powerful technique which I will present in the near future), however, I cannot see it being 21f, though. As you will see in the derivation, this type of technique depends on the effect of non-pure (speed) forms of double parity algorithms.

4Chan

I'm glad that since I use ZBLL, I never have to do corner parity on even cubes.

Christopher Mowla

The way I solve, I never get them either. I created this method just to get a piece of mind that there is another technique to swap two corners besides what has been known. Interesting though, huh?

4Chan

It's just like how you never get corner parity after you do COLL, it solves the corners.
The only parity I get is the double edge swap, and I can usually tell when I have this before doing the algorithm.

Robert-Y

Member
Wait... but you can still get it can't you? Sometimes, you might skip OLL after ZBF2L and then you might get the adjacent or opposite corner swap for your PLL, right?

Last edited:

4Chan

Ahhh! That's right, that's really rare, so I hadn't thought of that situation.

Christopher Mowla

If you are asking me, I am no authority on speed. I have timed myself on this algorithm and I get 13.4 seconds (slow, I know). It's fast enough to me considering what it does (but I am not really a speedsolver either). If there is a specific pure edge flip algorithm which you wish me to derive an algorithm like this from, I can. Of course, I am sure you can decide what's best for you based on what finger tricks you know, how you solve, etc. I just thought you guys would be interested/excited about a new way to do something. At most, those who think this is a much slower route will appreciate the usual way to handle two-corner swaps. If anyone ever wondered, "Is there a direct way to solve this", this is as direct as it can get (now move count of the algorithm I have presented is an entirely different matter).

Last edited:

Stefan

Member
Actually a direct approach, meaning, swapping two corners in one algorithm piece is IMPOSSIBLE.
If anyone ever wondered, "Is there a direct way to solve this", this is as direct as it can get
How do you think you know?

TMOY

Member
The corner parity alg I use for BLD:

Fw2 Rw2 U' Lw2 U Rw2 U' Lw2 U Fw2 U' x' U L' U' l' U L U' l2 D' L D l' D' L' D x

As close to supercube-safe as it can get (I'm solving corners at the beginning): it swaps only the Ulf and Ulb centers in addition to the ULF and ULB corners. The first 11 moves (before the x') swap two 1*2*2 blocks and the last 15 correct the wings.

Forte

Member
Wait... but you can still get it can't you? Sometimes, you might skip OLL after ZBF2L and then you might get the adjacent or opposite corner swap for your PLL, right?
lol then he does a T PERM ZBLL

Stefan

Member
How do you think you know?
Oops, I obviously have not seen this.
More importantly than just being wrong, you keep making strong (but wrong) impossibility assertions as if you had proof for them. Really dislike that. Hoped you learned that lesson earlier, when you claimed stuff like 22 btm isn't possible, only to prove yourself wrong soon after.

Last edited:

aegius1r

Member
The corner parity alg I use for BLD:

Fw2 Rw2 U' Lw2 U Rw2 U' Lw2 U Fw2 U' x' U L' U' l' U L U' l2 D' L D l' D' L' D x

As close to supercube-safe as it can get (I'm solving corners at the beginning): it swaps only the Ulf and Ulb centers in addition to the ULF and ULB corners. The first 11 moves (before the x') swap two 1*2*2 blocks and the last 15 correct the wings.
How about change the first moves to

r U r' U' r' F r2 U' r' U' r U r' F' (14F) ?

It's just like a T-perm, and I believe it can be performed faster.

TMOY

Member
Not by me. I really don't like this T-perm.

Christopher Mowla

For those who have been interested in this thread,

I just derived a 19f algorithm that preserves the orientation of two adjacently swapped corners. What's neat about this algorithm is that it does not require 3X3X3 restoration at the end. Note, however, that these type of algorithms need not be less moves than the algorithms from the method in this thread: this two-corner swap algorithm was derived from a custom-made double parity algorithm which had a different effect on a supercube than the double parity used to derive the 21f algorithm. In addition, it happened to have many move cancellations. Speedsolvable or not, here is the algorithm:

(In SiGN notation)
z'
r2 x U2 R' U2 x' U2 R' U2 R U2 L' x U2 r2 U2 r2 U2 r2 x' U2 r2
z U

It's interesting what it does to a 5X5X5.

Last edited:

irontwig

Member
So am I right in saying that you said that there's no alg for swapping two corners and then you presented a series of turns to do just that?