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



## Christopher Mowla (Jun 7, 2010)

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



*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!_
*
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!


----------



## joey (Jun 7, 2010)

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

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


----------



## Christopher Mowla (Jun 7, 2010)

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 (Jun 7, 2010)

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


----------



## Christopher Mowla (Jun 7, 2010)

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?


----------



## Robert-Y (Jun 7, 2010)

4Chan said:


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



How come?


----------



## 4Chan (Jun 8, 2010)

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 (Jun 8, 2010)

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?


----------



## 4Chan (Jun 8, 2010)

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


----------



## JeffDelucia (Jun 8, 2010)

Is this faster than the edgeswap+tperm?


----------



## Christopher Mowla (Jun 8, 2010)

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


----------



## Stefan (Jun 8, 2010)

cmowla said:


> Actually a direct approach, meaning, swapping two corners in one algorithm piece is *IMPOSSIBLE*.





cmowla said:


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


----------



## Christopher Mowla (Jun 8, 2010)

StefanPochmann said:


> How do you think you know?


Oops, I obviously have not seen this.


----------



## TMOY (Jun 9, 2010)

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 (Jun 9, 2010)

Robert-Y said:


> 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 (Jun 9, 2010)

cmowla said:


> StefanPochmann said:
> 
> 
> > How do you think you know?
> ...



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.


----------



## aegius1r (Jun 9, 2010)

TMOY said:


> 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 (Jun 9, 2010)

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


----------



## Christopher Mowla (Jun 30, 2010)

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.


----------



## irontwig (Jul 1, 2010)

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?


----------



## Mike Hughey (Jul 1, 2010)

Without even memorizing it, I can do this one as fast as my current T perm / PLL parity fix approach. I suspect it would be faster if I practiced it a bit.

Now I need to decide whether or not I should bother to learn it. It is interesting what it does on a 5x5x5, but it would take a bit of reworking for me to be able to use it there.

In any event, I'm still surprised the algorithms for this are as long as they are. I was always convinced that there would be some 12 or 14 move algorithm to swap two corners on even cubes, and we were all just missing it. (I didn't have any reason to be convinced; it was just a silly gut feeling.)


----------



## Christopher Mowla (Jul 1, 2010)

irontwig said:


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



Well, I believe you have an understanding about two-corner swaps, but just to clear things up, view the info in this spoiler.


Spoiler



It appears that we are only swapping two corners, but we also cause PLL parity as well as supercube center distortion. For example, the 19f algorithm I have just shown rotates the right center 180 and the bottom center 90 degrees clockwise.

No matter what algorithm or combination of algorithms you use to swap two corners, PLL parity must be induced (either opposite or adjacent edge swap) as well as rotating at least one center 90 degrees.

The reason for one center turned 90 degrees is due to the odd permutation in the 3X3X3 layers (e.g. any two-corner swap and two edge swap PLL will rotate a supercube center 90 degrees).

The reason for the PLL parity is because on a 3X3X3, it is not possible to swap just two corners (obviously), but if we swap two edges piece by piece on a 4X4X4, then it's possible (hence leaving what appears to be only two corners swapped). Although the fewest move algorithms for PLL parity distort supercube centers, longer ones definitely can preserve them.


However, to answer your question regarding my claims and then later algorithms, the type of OLL parity algorithm I was using before (at the beginning of the thread) didn't affect the center where the dedge flip was. Consequently, 3X3X3 restoration was required for algorithms using a combo of the single slice OLL parity + the wide turn inverse double-parity version (adding an extra r2 in the later portion of it).

The OLL parity algorithm I used this time to find the algorithms just presented affect the center which was on the same face as the flipped dedge. That was the difference. Wide turn versions of double parity algorithms which affect the same center as the dedge and corners also involved, only appear to affect the two corners and dedge.
Take for example, reThinking the Cube's reParity™:
r U2 l' U2 x' r' U2 l U2 r' U2 l U2 l' U2 y' 2m2 y' 
Now imagine flipping back just the front dedge. Only two corners will appear to be swapped.
But the double parity I used in the derivation (post 1 in this thread) was:
r2 B2 U2 l' (r2) U2 r U2 r' U2 B2 r' B2 l B2 r2
As you can see, the back two dedges in E are visibly swapped. If I add U2 to that,
r2 B2 U2 l' (r2) U2 r U2 r' U2 B2 r' B2 l B2 r2 U2
then it really appears 4 dedges are swapped along with two corners. So, if I were to flip back the single dedge now, we are in desperate need of 3X3X3 restoration.

See the difference?




Mike Hughey said:


> Without even memorizing it, I can do this one as fast as my current T perm / PLL parity fix approach. I suspect it would be faster if I practiced it a bit.


Wow, that's great! I memorized it and it seems it is okay in the beginning but finishes really fast (but that's my opinion).



Mike Hughey said:


> Now I need to decide whether or not I should bother to learn it. It is interesting what it does on a 5x5x5, but it would take a bit of reworking for me to be able to use it there.


Yeah, I didn't really intend for people to use it on the 5X5X5. I was merely just showing that this algorithm does PLL parity to all size cubes (not just to even cubes). This should be an obvious result, as I did create it from a custom double parity algorithm I made.



Mike Hughey said:


> In any event, I'm still surprised the algorithms for this are as long as they are. I was always convinced that there would be some 12 or 14 move algorithm to swap two corners on even cubes, and we were all just missing it. (I didn't have any reason to be convinced; it was just a silly gut feeling.)


If you go to this link, and go to "Parity PLL.doc", you will see there exists a 15 move algorithm for the diagonal corner swap case:
Rw2 f2 U2 Fw2 U' Rw2 U2 Fw2 U Fw2 R2 U2 F2 Rw2 U

I am not positive, but I think it might have been found by Clement's 4X4X4 solver (since he said he found it). I am not sure why Clement didn't provide a case for two adjacent swapped corners, though.

Just in case you are wondering, yes I have an algorithm for the diagonal case, but the minimum I can get is 21f (as of right now), and that is with a set-up move:
r2 x' R U2 R' U2 3r U2 r2 x' U2 r2 U2 r2 U2 L' x U2 R U2 R' U2 R' r2

Know that these are not the only algorithms I have found (or could find), but I am not sure if there exists algorithms *of this form* which swap two corners in fewer half turn moves.

EDIT:
(See the portion where I responded to irontwig)*.
*


----------



## Christopher Mowla (Jul 11, 2010)

After some thinking, I decided to try to come up with better algorithms for the diagonal corner swap case. In the process, I also found a good (maybe even better) adjacent corner swap algorithm.

My idea was to reduce the amount of cube rotations needed to perform the algorithm. For example, have all 180 degree face turns be strictly U2.

Although the following diagonal swap algorithm does not fit this category, I believe it might be fast, as it only requires two internal cube rotations.

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


Here is a 22f diagonal case which does not require any cube rotations at all: all 180 degree face turns are U2.
_Note: The two bolded moves can be inverted to achieve the same task. Just to let you all know, should that one change make this algorithm more speedsovleable._

Rw2 R U2 R U2 R' U2 *Rw* U2 Rw2 U2 Rw2 U2 *Rw* L U2 R' U2 R U2 L' Rw2 (22f)
What's interesting about both of these diagonal cases is that they do not have an obvious conjugate to make them an orientation preservation diagonal swap. This was previously asked by Joey:


joey said:


> Can you make one which keeps the orientation of the corners.
> 
> Other than the obvious L (your alg) L', conjugate.




Now, here is 22f adjacent corner swap which has no internal cube rotations (all 180 degree face turns are U2). It does require set-up cube rotations, though.
_Note: The two bolded moves can be inverted to achieve the same task. Just to let you all know, should that one change make this algorithm more speedsolveable._

z' x
Rw2 R' U2 *Rw* U2 Rw2 U2 Rw2 U2 *Rw* L U2 R' U2 R U2 R L' U2 R U2 Rw2 (22f)
x' z 
Finally, here is a 2-corner diagonal swap algorithm which contains moves outside of the set <U2,F2,B2,D2,l,r>, similar to that of cmowlaparity.

IT IS LONG, but it is at least fun to execute at least once. I suspected by experience that 2-corner swap algorithms of this form with the following move set do not yield ideal algorithms for speedsolving. Of course, this is all just my current understanding and may change later.
z Rw2 U R U' F2 L' U2 Rw2 x U2 Rw2 U2 Rw2 U2 x' U2 L U R' U' L' U2 R U2 L F2 Rw2 z' (25f)

I have one comment on the algorithms using all U2s. Yes, they are longer than other algorithms, but more moves are required to make algorithms like this (*all* U2s). Even if one or two of the 180 degree face turns were B2 or F2, etc., the algorithm could easily be less turns (even possibly optimal for the conventional move set). As you can observe, there for the adjacent corner swap, it was 3 turns more than the minimum I could get for algorithms of this form; and for the diagonal corner swap, only one more turn than I could get.

Expanding on this, the comments I gave about inverting the two bolded moves in these two algorithms is caused by the very technique which I use to force the algorithm to only contain U2s. Modifying that one portion of the algorithm generates an identical algorithm with those two moves inverted. That's why I know that those two moves in each 22f algorithm can be inverted and achieve the same task (it wasn't guess work, but two separate calculations).

I have uploaded a video on YouTube which shows these algorithms (not the last one) as well as my original 19f adjacent corner swap which I presented earlier in this thread (for those interested).


Please let me know what you all think about these algorithms!


----------



## Christopher Mowla (Jul 13, 2010)

*Clement's Diagonal Corner Swap Analyzed*

Hey everyone,

I have analyzed Clement's Diagonal Corner Swap Algorithm which is 15h/27q:
Rw2 f2 U2 Fw2 U' Rw2 U2 Fw2 U Fw2 R2 U2 F2 Rw2 U

and I have figured out how this algorithm works and engineered a 16h/27q algorithm that is much more human comprehensible (probably faster too).
Rw2 F2 U2 y Rw2 U' Rw2 U D Lw2' U' Lw2' y' r2 U2 F2 Rw2 U


How did I do it? *Please study my algorithm before reading*. I want you all to at least try to think critically before viewing the solution.



Spoiler



After A LOT of arithmetic and expansion, I broke this algorithm into 5 pieces. It was difficult to do this since many of the moves in this outline were not within the original algorithm itself, but this IS the outline for this computer-generated algorithm:

Rw2 F2 U2 r2   __________________________Preliminary
r2   ___________________________________ Extra turn to induce PLL Parity
U2 Fw2 U2 Fw2 U' Rw2 U2 Fw2 U Fw2 Rw2   ___Base 
r2 U2 F2 Rw2 __________________________Reverse of Preliminary
U   ____________________________________Finishing turn to make pure

If you don't believe that the second r2 is the move which induces PLL parity, go ahead and delete it! What we have is an N-Perm which depends on wide turns!
Rw2 F2 U2 r2
(where the r2 used to be)
U2 Fw2 U2 Fw2 U' Rw2 U2 Fw2 U Fw2 Rw2
r2 U2 F2 Rw2
U
(None of this was guess work).


Now, analyzing the real base of Clement's algorithm (the algorithm piece in my outline), it does two 2-cycles of 4 blocks in the same half of the cube.
U2 Fw2 U2 Fw2 U' Rw2 U2 Fw2 U Fw2 Rw2


By my outline, once you have this 2 2-cycle of 4 1X2X2 blocks, then the extra move which induces PLL parity is executed about the inner-layer slice parallel and adjacent to the blocks.
U2 Fw2 U2 Fw2 U' Rw2 U2 Fw2 U Fw2 Rw2
r2

But it does not matter if this move is added at the beginning or end of the base. Trying to match Clement's algorithm (and its effect on the cube) perfectly, the extra turn must come before the base.


After that is added, then the set-up moves are added. Lastly, the U turn to put the corners into position.

--The reason this algorithm was so difficult to see was because many of its moves are not present due to move cancellations!
DONE.
-------------------------------------------------------------------

Now for my algorithm, I used the same set-up moves and incorporated the extra turn to induce PLL parity (I knew about this extra turn before I analyzed Clement's algorithm obviously, as I did invent my own family of corner-swap algorithms).

The base for my algorithm is not complicated at all and is shorter in moves than Clement's solver's:
y z' Uw2 L' Uw2 L R Uw2 R' Uw2 z y'



It is based on the simple algorithm for swapping two centers on a 4X4X4:
Lw' U2 Lw Rw U2 Rw'



Here is the full outline of my algorithm:
Rw2 F2 U2 r2   ________________________Preliminary moves found from Clement’s algorithm.
r2   ____________  _____________________ Extra turn to induce PLL Parity 
y z' Uw2 L' Uw2 L R Uw2 R' Uw2 z y'   _______Base
r2 U2 F2 Rw2   _________________________Reverse of preliminary.
U   __________________________________Finishing turn to make pure

And I just did some speed optimization techniques that many know already to transform it into what I presented it as.




The mystery behind this algorithm is revealed!

By Christopher Mowla 

July 13, 2010.

Edit: (Off Topic)
The PLL parity 2 2-cycle algorithm: Rw2 Fw2 U2 r2 U2 Fw2 Rw2 (by Stefan Pochmann) does not need the F turns to be wide. That is, 
Rw2 F2 U2 r2 U2 F2 Rw2 is sufficient for both even and odd cubes. This should be obvious because of the set-up moves which I used to make my algorithm in this post. In fact, this algorithm is nothing more than the r2 move to induce PLL parity, enclosed by the same set-up moves as Clement's diagonal swap corner algorithm.


----------



## Christopher Mowla (Jul 20, 2010)

Here is a 17f adjacent corner swap:
z r2 U2 R' U2 R' U2 R x U2 Rw2 U2 B2 L U2 L' U2 Rw2 U2 z' y'

I used Cube Explorer for the most part, but that doesn't mean this algorithm is optimal in half turn moves for the given move set.


----------



## Forte (Jul 20, 2010)

cmowla said:


> Here is a 17f adjacent corner swap:
> z r2 U2 R' U2 R' U2 R x U2 Rw2 U2 B2 L U2 L' U2 Rw2 U2 z' y'
> 
> I used Cube Explorer for the most part, but that doesn't mean this algorithm is optimal in half turn moves for the given move set.



y didnt u find this by hand?!?!?!


----------



## Christopher Mowla (Jul 20, 2010)

Why didn't I? It's based on a different type of odd permutation algorithm for which I am not familiar with how to make by hand.


----------



## ryo (Feb 10, 2011)

If someone is interested I have this one : 
R2 D Rw2 U2' B2 r2 B2 U2' Lw2 R U' Lw U2 Rw' U Rw U2
(start with right thumb on top, U2' -> double trigger left hand, B2 -> double trigger right hand)


----------



## ben1996123 (Feb 10, 2011)

cmowla said:


> Here is a 17f adjacent corner swap:
> z r2 U2 R' U2 R' U2 R x U2 Rw2 U2 B2 L U2 L' U2 Rw2 U2 z' y'
> 
> I used Cube Explorer for the most part, but that doesn't mean this algorithm is optimal in half turn moves for the given move set.



How did you use cube explorer to get a 4x4 alg?


----------



## Christopher Mowla (Feb 10, 2011)

*Derivations of 17 btm Corner Swap Algorithms*



ben1996123 said:


> How did you use cube explorer to get a 4x4 alg?


 
I think the best way to explain it to you is to just give you a derivation for that algorithm. It's definitely not direct, but, as you will soon see, Cube Explorer did do most of the work.

z r2 U2 R' U2 R' U2 R x U2 Rw2 U2 B2 L U2 L' U2 Rw2 U2 x' z' (17 btm)​ 

*Derivation*


Spoiler



I am not sure if older versions of cube explorer yield identical solutions, so I need to mention that I am using version 5.00.

1) Start out with the 4-cycle double-parity case:
r U2 r l' U2 r2 U2 r' U2 r U2 r' U2 r' U2 l U2 r'

(I got this algorithm from Thom Barlow's (Kirjava's) ELL page.)

2) Convert all inner-layer slices to outer-layers (to match the 3x3x3)
R U2 R L' U2 R2 U2 R' U2 R U2 R' U2 R' U2 L U2 R' (18 f)

3) Type (or copy and paste) this into cube explorer, apply to a solved 3x3x3 cube, and hit the "add and solve" button. Then click the green arrow until you get the following 15f solution:
F2 R F2 R F2 R' U2 R2 U2 F2 L' U2 L U2 R2 (15 f)

*Cube Explorer's work is done.* From here, it is all up to us to make this into what we want.

4) By experimentation, we can find out to convert both *double* turns of R into wide turns.

So that you have a set-up like this:

F2 R F2 R F2 R' U2 Rw2 U2 F2 L' U2 L U2 Rw2, where

a) the cube isn't totally scrambled
b) the inner layers are affected, but the net result is a "half turn" away from being "solved", as opposed to if we tried to convert an even number of the quarter turns to wide too.

For example, the following are very bad because they don't give us much to work with AND, it is making this algorithm more on the inner-layer odd parity algorithm's side (by really affecting the wings).

F2 R F2 R F2 R' U2 R2 U2 F2 Lw' U2 Lw U2 R2
or
F2 R F2 Rw F2 Rw' U2 R2 U2 F2 Lw' U2 Lw U2 R2
or
F2 R F2 Rw F2 Rw' U2 R2 U2 F2 L' U2 L U2 Rw2
...etc.

5) Although it might seem to be a mess, what we have
http://alg.garron.us/?alg=F2_R_F2_R_F2_R-_U2_Rw2_U2_F2_L-_U2_L_U2_Rw2_U2&cube=4x4x4&notation=WCA F2 R F2 R F2 R' U2 Rw2 U2 F2 L' U2 L U2 Rw2
will work out just fine.

Adding the algorithm piece, U2 r2, 


Spoiler



This is based off of r2 U2 r2 U2 r2, which is can be related to
r2 U2 r2 Uw2 r2 u2, because r2 U2 r2 Uw2 r2 u2 = r2 U2 r2 U2 r2 + r2 u2 r2 u2)

The reason I say, "based off of" is because r2 U2 r2 U2 r2 affects opposite 1x2 center blocks and hence leaves the cube with PLL parity (our goal).



So we have
F2 R F2 R F2 R' U2 Rw2 U2 F2 L' U2 L U2 Rw2 + U2 r2
=
F2 R F2 R F2 R' U2 Rw2 U2 F2 L' U2 L U2 Rw2 U2 r2

This swaps two corners and two 1x2 center blocks (it also turns another center 90 degrees due to swapping two corners: that is related to regular PLLs).

From here, we can just add one set-up move to swap the same-color centers with each other:

r2
F2 R F2 R F2 R' U2 Rw2 U2 F2 L' U2 L U2 Rw2 U2 r2
r2

= r2 F2 R F2 R F2 R' U2 Rw2 U2 F2 L' U2 L U2 Rw2 U2 (17 btm)

6) Now for optimization (which is totally up to the individual, but this is how I made it into the algorithm I presented),

a) Rotating about y2 and taking the mirror image of that,
r2 B2 R' B2 R' B2 R U2 Rw2 U2 B2 L U2 L' U2 Rw2 U2

b) Adding an x cube rotation (for faster execution)
x' r2 U2 R' U2 R' U2 R x U2 Rw2 U2 B2 L U2 L' U2 Rw2 U2

c) More cube rotation "conjugates" to move the two swapped corners in the top-front,
z x
x' r2 U2 R' U2 R' U2 R x U2 Rw2 U2 B2 L U2 L' U2 Rw2 U2
x' z'

= z r2 U2 R' U2 R' U2 R x U2 Rw2 U2 B2 L U2 L' U2 Rw2 U2 x' z'

DONE



Also,
Here is a 17 btm diagonal corner swap algorithm I made last night when I saw this thread was bumped. It really took little effort, (but I guess my understanding is improving as time goes on).

r2 B2 R' U2 Rw2 U2 B2 R' B2 r2 U2 Rw2 B2 U2 R' U2 Rw2 (17 btm)​ 
*Derivation*


Spoiler



For a relatively decent set-up I had to create a set-up to swap two diagonal edge pieces on a 4x4x4 cube for Cube Explorer. It turned out to be the inverse of the algorithm on rachmaninovian's fantastic web-page:

"r2 B2 U2 r' U2 r2 B2 r' U2 r2 U2 B2 r' B2 [pure, modified from an alg found with Clement Gallet's solver]"

(So this algorithm can be created by both solvers independently).

Making the following adjustment (for the same reasons as the 17 btm adjacent corner swap alg),
Rw2 B2 U2 R' U2 R2 B2 R' U2 Rw2 U2 B2 R' B2

Adding two half turns,
Rw2 B2 U2 R' U2 R2 B2 R' U2 Rw2 U2 B2 R' B2 r2 U2

Shift
R2 B2 R' U2 Rw2 U2 B2 R' B2 r2 U2
Rw2 B2 U2 R' U2

Add one set-up move to swap same-color 1x2 center blocks with each other (and it luckily moves both corners into the U-layer for us)
Rw2
R2 B2 R' U2 Rw2 U2 B2 R' B2 r2 U2
Rw2 B2 U2 R' U2
Rw2

= r2 B2 R' U2 Rw2 U2 B2 R' B2 r2 U2 Rw2 B2 U2 R' U2 Rw2 (17 btm)
DONE



*Other Notes*
After all of this time, I have not been able to achieve algorithms less than 17 btm for these two cases (with this type of algorithm, of course). Hence, I believe these could in fact be optimal for this move set.

I plan on taking some time to make derivation videos for my 19-22 btm algorithms I presented earlier in this thread, as I did make those without any help from a solver. I will provide very convincing evidence that 19 btm IS optimal for that algorithm type.


----------



## reThinking the Cube (Feb 13, 2011)

Swaps 2 diagonal corners, UFL<->UBR, (BD) in Speffz notation.

reCornerX(BD)™ = U2 Rw2 U2 R U2 F2 R2 F2 R' F2 U2 Rw2 U2 R' F2 r2 (16 btm)


----------



## riffz (Feb 13, 2011)

reThinking the Cube said:


> *reCornerX(BD)™ = ...*


 
You can't be serious...


----------



## reThinking the Cube (Feb 15, 2011)

* NEW Diagonal Corner Swap for 4x4x4 (UFL<->UBR, (BD) Speffz)

reCornerX(BD)™= (U2 Rw2 U2 R U2)x(U2 R2 U2 R' U2)x'(U2 Rw2 U2 (Lw' r)U2) r2 *

Inspired from cmowla's ingenious idea of imbedding (r2 U2 r2 U2 r2) into the main alg, with piggybacked Rw turns - to simultaneously 

achieve edge PLL and r-slice center swaps alongside the corner permutation. TMALSS - Cube Explorer helped me find some *fertile* 

N-perm candidates, but I still had to do a considerable amount of experimentation to get that result. Please take the time to compare the 

alg above, to the other diagonal corner swappers that I have listed below:


fbCornerX(BD) = R Rw2 F2 L U L' B D L D' B2 U B r2 U2 F2 Rw2 R' U2 (Frédérick Badie)
cgCornerX(BD) = Rw2 f2 U2 Fw2 D Rw2 U2 Fw2 U' Fw2 L2 U2 B2 Lw2 U (Clément Gallet)
mfCornerX(BD) = Rw2 f2 U2 Fw2 U' Rw2 U2 Fw2 U Fw2 R2 U2 F2 Rw2 U (Michael Fung var.CG14)
rtcCornerX(BD) = x' Uw2 r2 F2 Rw2 F' Uw2 F2 Rw2 F Rw2 U2 F2 R2 Uw2 F (reThinker var.MF14)
cm1CornerX(BD) = y' Rw2 F2 U2 y Rw2 U' Rw2 U D Lw2' U' Lw2' y' r2 U2 F2 Rw2 U (Christopher Mowla1)
cm2CornerX(BD) = r2 B2 R' U2 Rw2 U2 B2 R' B2 r2 U2 Rw2 B2 U2 R' U2 Rw2 (Christopher Mowla2)


----------



## ryo (Feb 15, 2011)

ryo said:


> If someone is interested I have this one :
> R2 D Rw2 U2' B2 r2 B2 U2' Lw2 R U' Lw U2 Rw' U Rw U2
> (start with right thumb on top, U2' -> double trigger left hand, B2 -> double trigger right hand)


 
Sorry, I made a notation mistake, the correct one is :
R2 D Rw2 U2' B2 r2 B2 U2' Lw2 R U' (Lw r') U2 (Rw' l) U (Rw l') U2


----------



## Christopher Mowla (May 25, 2011)

*Derivation Video is Finally Here!*

As promised, I have made a derivation video which gives the general procedures I do to make the 2-corner swap algorithms in this thread (besides the most recent 17 btm ones, which I have already shown how to do using a 3x3x3 solver).

The video is not short, but I cover all of the necessary information to become a master! Note that ANYONE can pick up on how to do this even if he/she doesn't know how to make OLL Parity algorithms by hand because I just show how to manipulate them to make the 2-corner swap algorithms. (Of course, it always can help if you can!)


----------



## Christopher Mowla (Aug 21, 2012)

In the video above, I said that it wasn't possible to create a 2-corner swap algorithm from Frédérick Badie's algorithm:

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

A few days ago, I found it IS possible.


Spoiler



This is my newest decomposition of Frédérick Badie's algorithm.

r' U2 l F2 l' F2 r2 U2 r U2 r' U2 F2 r2 F2
=
r' U2 l F2 l' F2 r U2
U2 r U2 r'
r2 U2 (r') U2 r2 
r2 F2 r2 F2
(View what each line of moves does separately to see how this algorithm works).

I'm considering this to be even better than the decomposition at the end of my methods thread in this post.
REASON: My previous decomposition:
r' U2 l F2 l' F2 r2 U2 r U2 r' U2 F2 r2 F2
=
r' U2 l F2 l' F2 r U2
U2 r2
r' U2 (r) U2 r
r2 U2 F2 r2 F2 U2 r2
r2 U2

is false because, if you execute the algorithm in SiGN on the 4x4x4 supercube, the R center is rotated 90 degrees anti-clockwise (in the direction of R', not in the direction of R...so the true extra quarter turn must be the move r'). 
My new decomposition supports this.

In addition, if we insert r2 at the point where the extra quarter turn is in this representation, we get a double parity.

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


Therefore, following the "formula" I presented in the video to make a 2-corner swap alg. (the process is almost exactly the same), we do:


Spoiler



[1]We:
a) Write the inverse (in single slice turns)
b) Write the second algorithm in wide turns
c) Put Rw2 next to the extra quarter turn (wide turn version)
d) Add 3x3x3 moves to have just two corners (besides the effects on the centers of the supercube) exchanged.

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

Rw' U2 Lw F2 Lw' F2 Rw U2
U2 Rw U2 Rw'
Rw2 U2 (Rw') Rw2 U2 Rw2 
Rw2 F2 Rw2 F2

U2 F2 U2 


[2] Delete the inner layer turns from the entire algorithm after the quarter turn (in the first half) and before the quarter turn (in the second half)

F2 r2 F2 r2
r2 U2 r U2 
U2 U2
U2 F2 F2 U2

R' U2 L F2 L' F2 R U2
U2 R U2 R'
R2 U2 (Rw') Rw2 U2 Rw2
Rw2 F2 Rw2 F2

U2 F2 U2 

[3] Cancel moves:
F2 r2 F2 U2 r U2 R' U2 L F2 L' F2 R2 U2 R U2 Rw U2 F2 Rw2 F2 U2 F2 U2 (24)

Although it was a lucky guess, 

[4] If we take the move R' and move it to the end (it was just a guess), then we have a 22 move oriented diagonal case.
F2 r2 F2 U2 r U2 U2 L F2 L' F2 R2 U2 R U2 Rw U2 F2 Rw2 F2 U2 F2 U2 R'
=
F2 r2 F2 U2 r L F2 L' F2 R2 U2 R U2 Rw U2 F2 Rw2 F2 U2 F2 U2 R' (22)


Algorithm Structure


Spoiler: Structure



If we just move F2 to the end of the algorithm (shift),
r2 F2 U2 r L F2 L' F2 R2 U2 R U2 Rw U2 F2 Rw2 F2 U2 F2 U2 R' F2

...and then rewrite as:
r2 F2 U2
r
L F2 L' F2 R2 U2 R U2 R
r U2 F2 r2 
R2 F2 U2 F2 U2 R' F2

We can visualize this as just being an algorithm where we insert moves inside of the PLL Parity algorithm r2 F2 U2 r2 U2 F2 r2.
Diagonal corner swap
=
r2 F2 U2
r
(3x3x3 moves here)
r U2 F2 r2
(3x3x3 moves here)


This algorithm is definitely not optimal, but it appears to have a new structure.


----------



## Godmil (Aug 21, 2012)

Well done.


----------



## Nils (Aug 22, 2012)

Hhmm maybe i will use one of those ... not sure tough.


----------

