# Methods for Forming 2-Cycle Odd Parity Algorithms for Big Cubes



## Christopher Mowla (Aug 2, 2010)

The title is a little general, but it should be, as I have a lot to share about forming several types of 2-cycle inner-layer odd permutation algorithms.

To begin, why not start with the "Pure Edge Flip" (my favorite, obviously).

I would first like to show you how to derive common OLL parity algorithms by hand. To do this, I have taken the time to make tutorial videos for three popular algorithms. Each of the three algorithm's derivations are two videos long.

_Note: I recommend you to watch the derivation on the Standard Algorithm first before you watch the other videos._

*The Standard Algorithm*
r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2

Derivation
Part I
Part II

*Lucasparity*
r U2 r U2 r' U2 r U2 l' U2 l x U2 r' U2 x' r' U2 r'

Derivation
Part I
Part II

*Another algorithm which consists of all U2 face turns*
r U2 r U2 r' U2 r U2 l' U2 r U2 r' U2 l r2 U2 r'

Derivation
Part I
Part II

Please watch the videos before reading this spoiler:


Spoiler



Notice that all three algorithms are derived from the same commutator. Each algorithm is very related in structure. Only a few minor internal adjustments differentiates Lucasparity and the other algorithm from the standard algorithm.



In addition, I have chosen to release...
​*God's Algorithm?*

For my main method for pure edge flip algorithms, I have made a video on the best/briefest algorithm I have ever found in block quarter turns (BQTM) that works for all cube sizes (Very few low move count algorithms work for all cube sizes).

The Holy Grail

_From now on, I will abbreviate BQTM with just q, and BHTM with h._ 
(Also note that BHTM is commonly called btm. So h = BHTM = btm).

On the 4X4X4: 19q/18h
z d' m D l' u' 2R' u l u' l'2 b' 2R' b r' R' 2U y' m' u x2 z' 

On the 5X5X5: 19q/18h
z d' 3m D 3l' u' 2R' u 3l u' 3l'2 b' 2R' b r' R' 2-3u y' 3m' u x2 z' 

On the inner-orbit of the 6X6X6: 20q/19h
z 3d' 4m D 3l' 3u' 3R' 3u 3l 3u' 3l'2 2R' 3b' 3R' 3b 3r' R' 2-3u y' 4m' 3u x2 z'

On the outer-orbit of the 6X6X6: 19q/19h
z 3d' 4m D 3l' 3u' 2R' 3u 3l 3u' 3l'2 3R' 3b' 2R' 3b 3r' R' 2-3u y' 4m' 3u x2 z' 
=
z 3d' 4m D 3l' 3u' 2R' 3u 3l 3u' 4l 3l 3b' 2R' 3b 3r' R' 2-3u y' 4m' 3u x2 z' 

On the inner-orbit of the 7X7X7: 20q/19h
 3d' 5m D 4l' 3u' 3R' 3u 4l 3u' 4l'2 2R' 3b' 3R' 3b 3r' R' 2-4u y' 5m' 3u x2 z'

On the outer-orbit of the 7X7X7: 19q/19h
z 3d' 5m D 4l' 3u' 2R' 3u 4l 3u' 4l'2 3R' 3b' 2R' 3b 3r' R' 2-4u y' 5m' 3u x2 z'
=
z 3d' 5m D 4l' 3u' 2R' 3u 4l 3u' 5l 4l 3b' 2R' 3b 3r' R' 2-4u y' 5m' 3u x2 z'

I point out in the latter portion in the video that its average between quarter and half turns is also less than all other algorithms which currently exist.

Here is a link to the following formula in Wolfram|Alpha (the simplified formula shown near the end of the video)

\( \frac{\left\lfloor \frac{n}{2} \right\rfloor }{2-2^{\left\lfloor \frac{n}{2} \right\rfloor }}+19.5 \)

Just substitute an integer greater than or equal to 4 for n to obtain the average for a cube of size _n._​

*Formula Derivation*


Spoiler



In order to explain it, I will explain the original form of the formula:
[FONT=&quot]




[/FONT]​ 


[FONT=&quot]*The First Portion*[/FONT]
\( 18.5\left( 1 \right) \)​This represents the case when any big cube size has a 2-wing edge swap between every orbit in the same composite edge. For example, any even cube size reduced to a 4x4x4 form, and any odd cube size reduced to a 5x5x5 form.



This case is 19q/18h thus the average is 18.5.​ 


*The Second Portion*
\( 19.0\left( \left\lfloor \frac{n-2}{2} \right\rfloor -1 \right) \)
This represents the number of cases where there are consecutive orbits which have odd parity in the same composite edge, starting from the corner and working its way inward, but excluding when all orbits are involved (previous case).








These cases are all 19q/19h thus the average is 19.0.​ 



*The Third Portion*





This represents all other cases:




 



, etc.

These cases are all (proportionally) 20q/19h thus the average is 19.5.​ 
It is the total number of cases of odd parity in the orbits of a big cube, 

 ,minus the occurrences of the first two cases.​ 




Next, we divide everything by the total number of possible cases for odd parity in all inner-layer orbits (that same series) to get the overall average.​ 
Now, I am going to explain the series.


Spoiler



Let the total number of inner-layer orbits of wing edges in a big cube \( n\ge 4 \) be \( N=\left\lfloor \frac{n-2}{2} \right\rfloor \)

Then, the total number of cases of odd parity between the orbits is the sum of the combinations of the number of orbits involved:

\( \left( \begin{matrix}
N \\
N \\
\end{matrix} \right)+\left( \begin{matrix}
N \\
N-1 \\
\end{matrix} \right)+\left( \begin{matrix}
N \\
N-2 \\
\end{matrix} \right)+\cdot \cdot \cdot +\left( \begin{matrix}
N \\
N-\left( N-1 \right) \\
\end{matrix} \right) \)

\( =\left( \begin{matrix}
N \\
N \\
\end{matrix} \right)+\left( \begin{matrix}
N \\
N-1 \\
\end{matrix} \right)+\left( \begin{matrix}
N \\
N-2 \\
\end{matrix} \right)+\cdot \cdot \cdot +\left( \begin{matrix}
N \\
1 \\
\end{matrix} \right) \)

\( =\sum\limits_{k=0}^{N-1}{\left( \begin{matrix}
N \\
N-k \\
\end{matrix} \right)} \) \( =\sum\limits_{k=0}^{\left\lfloor \frac{n-2}{2} \right\rfloor -1}{\left( \begin{matrix}
\left\lfloor \frac{n-2}{2} \right\rfloor \\
\left\lfloor \frac{n-2}{2} \right\rfloor -k \\
\end{matrix} \right)} \)

For example, the 10X10X10 has 4 inner-layer orbits.

\( \left( \begin{matrix}
N \\
N \\
\end{matrix} \right) \) or \( \left( \begin{matrix}
4\\
4 \\
\end{matrix} \right) \) represents the case



because we have 4 orbits taking all 4 at once.


\( \left( \begin{matrix}
N \\
N-1 \\
\end{matrix} \right) \) or \( \left( \begin{matrix}
4\\
3\\
\end{matrix} \right) \) represents the cases:






 , etc.
because we have 4 orbits taking 3 at once.



\( \left( \begin{matrix}
N \\
N-2 \\
\end{matrix} \right) \) or \( \left( \begin{matrix}
4 \\
2 \\
\end{matrix} \right) \) represents the cases:






,etc.
because we have 4 orbits taking 2 at once.

and finally,


\( \left( \begin{matrix}
N \\
N-3 \\
\end{matrix} \right)=\left( \begin{matrix}
N \\
N-\left( N-1 \right) \\
\end{matrix} \right)=\left( \begin{matrix}
4 \\
4-\left( 4-1 \right) \\
\end{matrix} \right)=\left( \begin{matrix}
4 \\
1 \\
\end{matrix} \right) \) represents the cases






,etc.
because we have 4 orbits, taking only one at a time.​



​ 
Now, note that this series can majorly simplify:



​ 

*PROOF*


Spoiler










So our formula simplifies to:





As you can see, there are many more cases for an average of 19.5 than for 18.5 and 19.0.​ 
But, the overall average still is less than 19.5.

Based on the fact that even and odd cubes have the same number of orbits (e.g. both the 6X6X6 and 7X7X7 have two inner-layer orbits), the floor function can be omitted and we can take the limit as the cube size gets large.

\( \underset{n\to \infty }{\mathop{\lim }}\,\frac{\frac{n}{2}}{2-2^{\frac{n}{2}}}+19.5=19.5 \)​ 
This means, no matter how large _n_ gets, the average will come arbitrarily close to, but it never reaches 19.50. (This is apparent already without calculus, but I thought a "second opinion" would further verify this statement.)

My 23q/16h "cmowlaparity" obviously has an average of 19.5, but the Holy Grail beats it slightly.
x' r2 U2 l' U2 r U2 l x U2 x' U r U' F2 U r' U r2 x


----------



## salamee (Aug 3, 2010)

Thanks for making those, now I finally understand how the Parity Algorithm works. It always bothered me to apply it blindly but not to know what it actually does.


----------



## Christopher Mowla (Aug 3, 2010)

*Techniques for Symmetrical 2-Cycle and DP Algorithms in the Conventional Move Set*



salamee said:


> Thanks for making those, now I finally understand how the Parity Algorithm works. It always bothered me to apply it blindly but not to know what it actually does.



You're very welcome. This thread will be all about that. In addition, later I will begin my proposal about why I believe the "HOLY GRAIL" is optimal. For right now, I will introduce the methods one post at a time.

Now to everyone_:

Before I even begin, I want to note that I refer to the term "symmetrical" as an adjective to describe the algorithms derived in this post. In the future, I will go into more detail about this and that of what I like to call non-symmetrical algorithms. For right now, I believe there is enough material in this post._

Now, I trust that before reading this, you have watched all three of my derivation tutorials on pure edge flip algorithms. However, you still may be able to catch on if you have not.

Here are 3 tools you will need to have in order to construct *any *fast (and relatively brief) pure symmetrical 2-cycle odd parity algorithm that currently exists. You can also derive some of your own that you can be proud of.

__________________________________
1) The commutator U2 l U2 r' U2 r U2 l'.
In commutator notation, [U2, l U2 r']. This algorithm is useful because it swaps 3 1X3 blocks (for big cube sizes in general, 3 1X(N-1) blocks) within M and it's optimal for the move set <U2, F2, D2, B2, l, l', l2, r, r', r2>.

2) Knowing how to apply set-up moves to put all 3 1X(N-1) blocks in the same slice (left or right).
_As seen in all 3 videos, different set-up moves will create different algorithms for an interior-looking J-perm.

_ 3) Knowing how to apply set-up moves to finish off the pure algorithm.
_As seen in all 3 videos, different outer set-up moves_ _can make a difference in how fast an algorithm can be._
__________________________________

Here are my derivations for other types of parity cases.

_For the following two algorithms, I recommend you watch the first and third tutorial videos first (lusasparity derivation is not necessary to watch)._

An algorithm with all U2 rotations for the case:




r' U2 r' U2 (r' l) U2 r' U2 r U2 l' U2 r2 (14)
or speed-form:
Rw' U2 Rw' U2 x' U2 Rw' U2 Rw U2 Lw' U2 Rw2 (12)
(For odd cubes, include the M slice in the first and last half turn moves.)


Spoiler



1) Start with the commutator:
U2 l U2 r' U2 r U2 l'

2) Add set-up moves to move all 3 1X(N-1) blocks into the same (right) slice.
U2
r'
U2 l U2 r' U2 r U2 l'
r
U2

3) Add the quarter turn (it's really trivial)
U2
r'
U2 l U2 r' U2 r U2 l'
r
U2
r

4) Add one set-up move to position the two oppositely swapped edges on the opposite side of the cube from one of the center blocks:

U2
U2
r'
U2 l U2 r' U2 r U2 l'
r
U2
r
U2

5) Finish off with an obvious set-up move:
r'
U2
U2
r'
U2 l U2 r' U2 r U2 l'
r
U2
r
U2
r

In condensed notation:
(r' U2)
(U2 r')
[U2, l U2 r']
(r U2)
r
(U2 r)

=r2 U2 l U2 r' U2 r U2 (l' r) U2 r U2 r 

6) Inverse
r' U2 r' U2 (r' l) U2 r' U2 r U2 l' U2 r2




An algorithm with all U2 rotations for the case:




r U2 r' U2 r' U2 l U2 r' U2 r U2 (l' r) U2 r2 U2 r' (18)


Spoiler



1) Start with the commutator:
U2 l U2 r' U2 r U2 l'

2) Add set-up moves to move all 3 1X(N-1) blocks into the same (right) slice.
U2
r'
U2 l U2 r' U2 r U2 l'
r
U2

3) Add the quarter turn (it's really trivial)
U2
r'
U2 l U2 r' U2 r U2 l'
r
U2
r

4) Add set-up moves to have two 1X(N-1) blocks in the following manner:
U2
r'
U2
r'
U2 l U2 r' U2 r U2 l'
r
U2
r
r
U2

5) Apply the last set-up move to make a pure algorithm:
r
U2
r'
U2
r'
U2 l U2 r' U2 r U2 l'
r
U2
r
r
U2
r'

In condensed notation,
(r U2 r')
(U2 r')
[U2, l U2 r']
(r U2)
r
(r U2 r')

=r U2 r' U2 r' U2 l U2 r' U2 r U2 (l' r) U2 r2 U2 r'


__________________________________
*Finding Algorithms By Hand Fast and Easy: Shifting*

Once you have:
1) A commutator which swaps only three 1X(N-1) blocks within M,
2) Added set-up moves to that commutator in order to bring all three blocks into the same slice, and
3) Applied the quarter turn to put two of them into their solved positions and pull one out, leaving two individual edge cubies and two 1X(N-2) center blocks unsolved,

Then what you have is what I call a base for conventional symmetrical algorithms: an interior-looking J-Perm.

In the three tutorial videos, I added different set-up moves to different bases to obtain the standard pure edge flip algorithm, lucasparity, and another algorithm with all U2 face rotations. In general, a very easy technique can be used (but the most powerful technique there is) to create complicated (but brief algorithms). The technique is what I call shifting (but it may be thought of as rotating).

Shifting is adding a set-up move to an algorithm which is the inverse of the algorithm's first move.

For example, one shift of the base for the algorithm last derived is:
U2
U2
r'
U2 l U2 r' U2 r U2 l'
r
U2
r
U2
=
r'
U2 l U2 r' U2 r U2 l'
r
U2
r U2

Which has the same effect if we move the U2 to the end.

This gives us the ability to keep the same number of moves in a base to transform it into another (and probably more complicated to understand at face value) base which is closer to what we need to construct a particular algorithm. The algorithms resulting from one or more shifts of a base (without adding exterior set-up moves which cancel with either the first or last moves in the base) is what I like to call a shifted base.

*How Do Shifts Work?*


Spoiler



Using the previous example, staring with:
U2
r'
U2 l U2 r' U2 r U2 l'
r
U2
r
If you say in your head, "Boy, I wish I could separate the two 1X2 center blocks from each other without adding moves to the algorithm", shifting is your sanctuary because a shift of the first move will do just that. This should not be surprising because a shift is just a very particular set-up move.

Another important note is that, if the move being shifted is not in contact with any of the other pieces which are currently unsolved, then it has no effect on the cube: it only changes the algorithm structure.

For example, taking the previous algorithm and shifting until the l move is the first one:
l U2 r' U2 r U2 l'
r
U2
r
U2 r' U2

If we now shift the l move, there is no effect on the cube.
U2 r' U2 r U2 l'
r
U2
r
U2 r' U2 l

If we did in fact wish to use that cube state, *we would have a choice* on whether we prefer the l move to be where it is or move to the right of the last U2: either way, that algorithm accomplishes the same task.



Spoiler



For those who have computed algorithms with 3X3X3 solvers, doesn't this one fact eliminate a whole bunch of possible algorithms for parity cases?





Pretty neat, uh? Now I will give some examples putting this powerful technique to work.
__________________________________
Here is the derivation of the standard algorithm for the opp wing edge swap case, using this technique.

_Note: I HIGHLY recommend you watch my derivation videos on the standard algorithm and Lucasparity before attempting to follow this, because I start from Lucasparity's base._





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


Spoiler



1) Starting with Lucasparity's base (from the my derivation video):
F2
l'
U2
U2 l U2 r' U2 r U2 l'
U2
l
F2
r'
=F2 U2 r' U2 r U2 l' U2 l F2 r'

2) Shifting the first 4 (half turn) moves,
r U2 l' U2 l F2 r'
F2 U2 r' U2

3) Adding a set-up move:
r
r U2 l' U2 l F2 r'
F2 U2 r' U2
r'
=r2 U2 l' U2 l F2 r' F2 U2 r' U2 r'

4) Taking the inverse:
r U2 r U2 F2 r F2 l' U2 l U2 r2



Algorithm with all U2s for opposite wing edge swap (revisited?):
_I recommend you watch the my video on the pure edge flip algorithm that consists of all U2 face rotations._




r U2 r U2 (l' r) U2 r U2 r' U2 l U2 r2 (14)
or speed form:
Rw U2 Rw U2 x U2 Rw U2 Rw' U2 Lw U2 Rw2 (12)
On odd cubes, include the M slice in the first and last half turn moves.


Spoiler



1) Start with the commutator U2 l U2 r' U2 r U2 l'
(In commutator notation, [U2, l U2 r'])

2) In order to create an algorithm with all U2s, we need to first move down the two 1X(N-1) blocks in r so that a U2 set-up move can be used to bring the third block into slice r.
r'
U2 l U2 r' U2 r U2 l'
r

3) Apply U2 as a set-up move, indeed we can bring the third block above the other two into slice r.
U2
r'
U2 l U2 r' U2 r U2 l'
r
U2

4) Now we apply a quarter turn to put back two of the 3 currently unsolved 1X(N-1) blocks as well as pulling out the currently solved one. This gives us a net result of two edge cubes and two 1X(N-1) blocks unsolved (which is exactly what we need for 2-cycle odd permutation algorithms).

U2
r'
U2 l U2 r' U2 r U2 l'
r
U2
r

5) Now we write on one line:
U2 r' U2 l U2 r' U2 r U2 l' r U2 r

6) Shift the first 6 (half turn) moves (meaning, "move" the first six moves from the beginning of the algorithm to the end):
U2 r U2 l' r U2 r
U2 r' U2 l U2 r' 

7) Apply the last set-up move:
r
U2 r U2 l' r U2 r
U2 r' U2 l U2 r' 
r'
=r U2 r U2 l' r U2 r U2 r' U2 l U2 r2

*Observation:*
This algorithm resembles the other algorithm I derived in this post:
r' U2 r' U2 (r' l) U2 r' U2 r U2 l' U2 r2
doesn't it?
This is probably just a coincidence. 

Building from this, recall the diagonal edge swap case was almost identical to the opposite edge swap. Hence for the opposite edge swap algorithm derived in this spoiler, the corresponding diagonal algorithm is:
r' U2 r U2 r U2 l' U2 r U2 r' U2 (l r') U2 r2 U2 r 
(Just inverting all slice turns in the previous diagonal edge swap algorithm).




*Double-Parity Algorithms*

In my 2-Corner Swap PLL Parity Thread, I mentioned that inserting a r2 next to a l or vice versa can convert pure edge flip algorithms to double-parities. I believe we now have enough tools to see why this is.



Spoiler



1) Taking the standard pure edge flip algorithm:
r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2

2) Removing set-up moves:
U2 l U2 r' U2 r U2 F2 r F2 l'

3) Shifting once:
l U2 r' U2 r U2 F2 r F2 l' 
U2

4) If we add in r2 now, this leaves just two 1X4 blocks (in general, 1XN blocks) unsolved in r.
l U2 r' U2 r U2 F2 r F2 l'
U2
r2

5) Now if we add set-up moves, we have a pure double-parity:
l2 B2
l U2 r' U2 r U2 F2 r F2 l'
U2 r2
B2 l2

Don't like it in F? No problem. Let's just remove the set-up moves and shift twice more (with this r2 in the algorithm) to get a better set-up:
r' U2 r U2 F2 r F2 l'
U2 r2
l U2 

6) Now we can add set-up moves to make it a pure algorithm:
r2
B2
r' U2 r U2 F2 r F2 l'
U2 r2
l U2 
B2
r2

In summary: If you add a r2 (or l2, depending on the set-up) to a non-pure opposite wing edge swap shifted base of the form:
l U2 r' U2 r U2 F2 r F2 l' 
U2

, where the two oppositely swapped edges and the two centers are in the same slice, then the least amount of pieces are affected when the extra half turn is applied to induce PLL parity. From there, you are free to either add set-up moves or shift and then add set-up moves. Multiple algorithms can be created from the same base shifted several times.



As you can see, all of the most-common fast symmetrical algorithms can be derived using the same commutator. Not only that, but you can easily make them yourself with pure arithmetic and logic.

If anyone has any questions, don't be shy to ask. I am willing to help.


----------



## riffz (Aug 4, 2010)

I just watched the derivation for the standard alg. Your visual aids were really helpful. Thanks.


----------



## cmhardw (Aug 12, 2010)

Wow Chris! Thank you so much for this write-up! I have only watched the derivation of the "standard" algorithm, both parts, and it is amazing to have an idea of how this works. I will want to go through the second part a few times to make sure I fully understand your application of setup turns, but this is amazing! I can't wait to go through the rest of the videos for the other parity algs!

Chris


----------



## Christopher Mowla (Aug 12, 2010)

riffz said:


> I just watched the derivation for the standard alg. Your visual aids were really helpful. Thanks.


You're welcome. I was hoping those illustrations made sense for everyone.

 


cmhardw said:


> Wow Chris! Thank you so much for this write-up! I have only watched the derivation of the "standard" algorithm, both parts, and it is amazing to have an idea of how this works. I will want to go through the second part a few times to make sure I fully understand your application of setup turns, but this is amazing! I can't wait to go through the rest of the videos for the other parity algs!
> 
> Chris


I am honored to hear this from you! I will derive other algorithms soon as well. I have the derivations, but I need the time to write them out clearly for everyone to understand as well as make some more videos. I will also introduce the method which I formed "The Holy Grail" from.


----------



## Christopher Mowla (Aug 19, 2010)

*cmowlaparity Derivation and K4 2-Cycle Algorithms*

[FONT=&quot]An[/FONT]other method for 2-Cycle Parity Algorithms is based on a commutator for which not all of its moves are in the conventional move set. Below is a link to a video deriving this commutator as well as deriving "cmowlaparity" pure edge flip algorithm. As mentioned with the derivation videos before, it is a good idea to first watch the derivation of the standard pure edge flip algorithm before watching this one. (The link for this is in the first post of this thread).

cmowlaparity
x' Rw2 U2 Lw' U2 r U2 Rw U2 x' U r U' F2 U r' U Rw2 x (Even Cubes)
x' Rw2 U2 (Lw' M') U2 r U2 Rw U2 x' U r U' F2 U r' U Rw2 x (Odd Cubes)

And, of course, if the remaining single slice turns are converted to wide, we have the result of speed forms of OLL parity algorithms:
x' Rw2 U2 Lw' U2 Rw U2 Rw U2 x' U Rw U' F2 U Rw' U Rw2 x  (Even Cubes)
x' Rw2 U2 (Lw' M') U2 Rw U2 Rw U2 x' U Rw U' F2 U Rw' U Rw2 x  (Odd Cubes)

Derivation
Part 1
Part 2

For convenience, I also provide a typed derivation for it as well.


Spoiler



[1] Start with the commutator to swap 3 1X(N-1) blocks in M.
B2 U' r' U B2 U' r U
_To see how I came up with this commutator, please take time to watch the derivation video).

_[2] Now, as with conventional algorithms, we need to get all 3 1X(N-1) blocks into the same slice so that we can apply a quarter turn to put back two of those blocks (solve back half of the slice). This will leave us with only two 1X(N-2) center blocks swapped as well as swap two individual edge cubies.

Here, we add the set-up move l'.
l'
B2 U' r' U B2 U' r U
l
_This will move the 1X(N-1) slot currently affected in the back left portion of the cube to the top left of the cube._

[3] Now, all we need to do is do a set-up move U2 to bring the third 1X(N-1) block affected into the r slice (on top of the other two).
U2 l'
B2 U' r' U B2 U' r U
l U2

[4] Next, we add in the quarter turn to create the interior J-Perm.
U2 l'
B2 U' r' U B2 U' r U
l U2
r'

[5] As with the standard algorithm derivation, our goal is to get a set-up similar to U2 l U2 r' U2 r U2 F2 r F2 l'. Before we do anything, let's write what we have on one line:
U2 l' B2 U' r' U B2 U' r U l U2 r'

Now we move the last three (half turn) moves to the front of the algorithm (a backwards shift of 3h):
l U2 r'
U2 l' B2 U' r' U B2 U' r U
_(I explain why shifts work in the derivation video_,_ for those who are uneasy with this step.)_

This gives us essentially the same set-up as the main portion for the standard algorithm without us having to add any moves to what we had originally.

[6] Add the set-up moves r2 U2 to what we have to make a pure algorithm:
r2 U2
l U2 r'
U2 l' B2 U' r' U B2 U' r U
U2 r2
=r2 U2 l U2 r' U2 l' B2 U' r' U B2 U' r U U2 r2
=r2 U2 l U2 r' U2 l' B2 U' r' U B2 U' r U' r2 (see back bottom edge)

[7] Rotating about y2,
l2 U2 r U2 l' U2 r' F2 U' l' U F2 U' l U' l2

[8] Taking the mirror,
r2 U2 l' U2 r U2 l F2 U r U' F2 U r' U r2

[9] Adding in a preliminary x cube rotation,
x' r2 U2 l' U2 r U2 l F2 U r U' F2 U r' U r2 x

[10] Converting maximum moves to wide without affecting its purity, (done by experimentation)
x' Rw2 U2 Lw' U2 r U2 Lw F2 U r U' F2 U r' U Rw2 x

[11] Adding in an interior x cube rotation for easier execution,
x' Rw2 U2 Lw' U2 r U2 Lw *x* U2 *x'* U r U' F2 U r' U Rw2 x

[12] Converting (Lw x) to Rw,
x' Rw2 U2 Lw' U2 r U2 Rw U2 x' U r U' F2 U r' U Rw2 x

DONE

_Note: For odd cubes, either the second or third wide turn must include the M slice. For example, on the 5X5X5, this algorithm could either be:
_x' Rw2 U2 (Lw' M') U2 r U2 Rw U2 x' U r U' F2 U r' U Rw2 x
or
x' Rw2 U2 Lw' U2 r U2 (Rw M') U2 x' U r U' F2 U r' U Rw2 x



K4 Method 2-Cycle Parity Algorithms

I am going to now derive K4 2-cycle parity algorithms based off of cmowlaparity. These cases involve a swap of wing edges in adjacent composite edges, as opposed to opposite edges as seen with common algorithms I derived in my previous post. These algorithms are a direct solution to these particular parities, as opposed to adding set-up moves to an opposite wing edge swap algorithm such as l' U2 l' U2 F2 l' F2 r U2 r' U2 l'2. In addition, based on my search, the algorithms I will derive for these cases are optimal in half turn moves.


_For all three of these cases, I build directly off of cmowlaparity's base. So please watch the derivation video or read and understand steps 1-5 of the written derivation previously provided in this post._

*Note: *In order to use these algorithms on odd cubes, the M slice needs to be included with either of the wide turns (but not both).

*Case 1*:




l'2 U Lw U2 r' U2 Rw' U2 x U' r' U x' U2 x U' (l' r) l' (21q/15h)
*Derivation*


Spoiler



[1] Start with cmowlaparity's base:
l U2 r'
U2 l' B2 U' r' U B2 U' r U

[2] Move the last move to the front of the algorithm (shift backwards once),
U 
l U2 r'
U2 l' B2 U' r' U B2 U' r

[3] Add the set-up move l'2 to swap the two 1X(N-2) center blocks of the front face with each other. At the same time, the UFl wing edge will be placed in the DBl slot which is currently affected.
l'2
U l U2 r' U2 l' B2 U' r' U B2 U' r
l'2

[4] By experimentation, some moves can be converted to wide turns and not affecting the purity of the algorithm.
l'2
U Lw U2 r' U2 Lw' B2 U' r' U B2 U' r
l'2

[5] Now, adding in an internal cube rotation for easier execution,
l'2 U Lw U2 r' U2 Lw' x' U2 x U' r' U B2 U' r l'2

[6] Merging the (Lw' x') to Rw',
=l'2 U Lw U2 r' U2 Rw' U2 x U' r' U B2 U' r l'2

[7] Adding in another internal cube rotation,
l'2 U Lw U2 r' U2 Rw' U2 x U' r' U x' U2 x U' r l'2

[8] And this can be rewritten as:
l'2 U Lw U2 r' U2 Rw' U2 x U' r' U x' U2 x U' (l' r) l'

DONE.



*Case 2*:




l'2 U' Lw U2 r' U2 Rw' U2 x U r' U' x' U2 x U (l' r) l' (21q/15h)
_Note: The set-up move l'2 can be made wide turns for this case._
*
Derivation*


Spoiler



Because B2 U' r' U B2 U' r U and B2 U r' U' B2 U r U' are both commutators which swap three 1X(N-1) blocks on a cube of size N, then it can be justified that if we invert just the individual U turns in case 1's algorithm, we will have the algorithm for case 2!

To verify why this is, we can reconstruct cmowlaparity's base with the commutator B2 U r' U' B2 U r U' instead of B2 U' r' U B2 U' r U. However, I will not cover that because it is just repetition.



*Case 3:*




l' r' U Lw U2 r' U2 Rw' U2 x U' r' U x' U2 x U' (r' l) r' (21q/16h)

*Derivation*


Spoiler



Building off of the algorithm for case 1, if we just omit the outer set-up moves l'2, then we have again:
U Lw U2 r' U2 Rw' U2 x U' r' U x' U2 x U' r

Instead of swapping the two 1X(N-2) center blocks in the front face with the set-up move l'2, we can instead swap the two center blocks in the top face, doing the set-up moves l' r':

l' r'
U Lw U2 r' U2 Rw' U2 x U' r' U x' U2 x U' r
r l

This can be rewritten as:
l' r' U Lw U2 r' U2 Rw' U2 x U' r' U x' U2 x U' (l r') r'

DONE

NOTE:
The reflection for this case is needed to handle a "4th" case:




r l U' Rw' U2 l U2 Lw U2 x U l U' x' U2 x U (r' l) l (21q/16h)



Hence, all three K4 2-cycle parity cases can be tackled with essentially the same algorithm. In addition, they are all optimal in half turn moves.

_I can tackle all three in less quarter turns using my main method for 2-cycle symmetrical algorithms. I will present this method in my next information post. From that method will come a derivation for the "Holy Grail"._


*2-Cycle and 3-Cycle Algorithms*

Since algorithms for all 3 cases mentioned were derived from essentially the same algorithm, why don't we see if there is any other types of algorithms we can generate from what we have. By doing some minor adjustments, the results are astounding!

Now, there are a lot more cases than the ones I am going to list here, but I will give them case numbers anyway.

* Case 1:*




F2 U Lw2 U2 l' U2 r U2 l' F2 U r U' F2 U r' U Lw2 U' F2 (29q/20h)
*Derivation*


Spoiler



[1] If we start with the single slice version of cmowlaparity,
x' r2 U2 l' U2 r U2 *l* x U2 x' U r U' F2 U r' U r2 x

[2] We invert the l move (in bold)
x' r2 U2 l' U2 r U2 l' x U2 x' U r U' F2 U r' U r2 x

[3] Add the set-up moves:

x' D2 F
x' r2 U2 l' U2 r U2 l' x U2 x' U r U' F2 U r' U r2 x
F' D2 x

[4] Optimizing
=
x2
B2 D
r2 U2 l' U2 r U2 l' x U2 x' U r U' F2 U r' U r2
D' B2
x2

=
F2 U
x2
r2 U2 l' U2 r U2 l' x U2 x' U r U' F2 U r' U r2
x2
U' F2

The first and last r2 moves can be converted to wide in cmowlaparity, and it is still pure. It turns out that the same is true here, even with the adjustments we made to make what we have so far.

F2 U
x2
Rw2 U2 l' U2 r U2 l' x U2 x' U r U' F2 U r' U Rw2
x2
U' F2

Thus we can get rid of the x2 cube rotations
Since (x2 Rw2)=Lw2

F2 U
Lw2 U2 l' U2 r U2 l' x U2 x' U r U' F2 U r' U Lw2
U' F2

Writing on one line,
F2 U Lw2 U2 l' U2 r U2 l' x U2 x' U r U' F2 U r' U Lw2 U' F2

The x cube rotation can be taken out if we like:
F2 U Lw2 U2 l' U2 r U2 l' F2 U r U' F2 U r' U Lw2 U' F2 (29q/20h)

DONE


The minimum number of half turns to do the 3-cycle alone is 10h, and the minimum number of half turns to do the 2-cycle alone is 16h. Hence, this algorithm does both simultaneously in 6h less than if optimal algorithms were used to do each separately.

* Case 2:*




b2 D' l'2 U l U2 r' U2 l B2 U' r' U B2 U' r l'2 D b2 (27q/19h)
*Derivation*


Spoiler



[1] If we invert the same l move in the single slice version of the algorithm for "case 1" of the 2-cycle K4 algorithms (before we converted any moves to wide turns), we have:
l'2
U l U2 r' U2 *l* B2 U' r' U B2 U' r
l'2

[2] Now, adding the set-up moves:
b2 D'
l'2 U l U2 r' U2 l B2 U' r' U B2 U' r l'2
D b2

[3] Writing on one line,
b2 D' l'2 U l U2 r' U2 l B2 U' r' U B2 U' r l'2 D b2

DONE
_You can optimize it anyway you like. I have no particular suggestions._



*Case 3:*




f2 D l2 U' l U2 r' U2 l B2 U r' U' B2 U r l2 D' f2 (27q/19h)
*Derivation*


Spoiler



[1] If we now apply the same idea to "case 2" of the 2-cycle algorithms, that is, inverting the same l move, we have:
l2 U' l U2 r' U2 l B2 U r' U' B2 U r l2


[2] Add the set-up moves:
f2 D
l2 U' l U2 r' U2 l B2 U r' U' B2 U r l2
D' f2

[3] Writing one one line,
f2 D l2 U' l U2 r' U2 l B2 U r' U' B2 U r l2 D' f2

DONE
_You can optimize it anyway you like. I have no particular suggestions._


----------



## reThinking the Cube (Aug 19, 2010)

Very, very, nice work. Processing..........


----------



## Kirjava (Aug 19, 2010)

This is amazing.


----------



## bamilan (Aug 19, 2010)

wow


----------



## Christopher Mowla (Feb 5, 2011)

*Derivation of the "Holy Grail of Edge Flip Algorithms" (and Much More)*

After many hours of work, I finally made a video series which gives a very thorough explanation of how I found the algorithm (shown in my first post in this thread) and all of the details about it that one could ask for (except on my conjecture why it could be God's Algorithm for this specific case).

Due to the thorough explanation, as well as me trying to introduce this new wide-turn based parity algorithm method, the total video time is stretches to approximately 1 hour and 38 minutes. *BUT*, note that one needs only to watch Part I and Part II to see the derivation of the Holy Grail (HG) algorithm for the 4x4x4 and 5x5x5 cubes. (See the short description under the link for each of the videos as well as the video descriptions on YouTube for more information on what's in each video).

Here is the video series.

*Beginner*
Part I (22:15)
This video covers "basic" information necessary to fully understand Part II. In addition, the commutator used in the HG algorithm is thoroughly developed, instead of beginning the derivation with the commutator.
​ *Intermediate*
Part II (31:21)
This video concludes the derivation for the HG algorithm for the 4x4x4 and 5x5x5 cubes.

Part III (17:57)
This video touches on how to translate the HG algorithm to higher order cubes (6x6x6 and greater), gives a "general formula" for the algorithm, and other details.



*Advanced*
Part IV (26:51)
This video is VERY theoretical in nature, as I explain the theory behind why the translation to larger cubes worked (i.e., interior set-up move insertion theory).
This is a must see for puzzle theorists, as it is definitely a major advancement in algorithm creation, and, obviously, it is the final step to us fully understanding why every move in the HG algorithm works.​ 
NOTE:
For those who choose not to watch Part I, (I do recommend watching it, though, so that you can get into my head and get a good foundation), take note that I use SiGN notation. If you don't know SiGN notation already, don't worry. I explain from time to time throughout the video series about why moves are represented as they are with SiGN. More importantly, I have made a video on SiGN notation you can watch here: SiGN Notation.

Now, the SiGN notation I use differs slightly from what is currently integrated in Lucas Garron's resource, alg.garron.us. There are only two differences (according to my knowledge):

1) For wide turns on the 4x4x4, I have 2(u,d,f,b,l,r) instead of (u,d,f,b,l,r). _I chose to do this because it is more consistent with the general structure of the notation._

2) Although these moves are rarely used in the video series, the way to define the M, E and S slice turns (and block turns of them), is different as well. Michael Gottlieb (qqwref), one of the independent inventors of SiGN notation, and I agreed on this version of SiGN because it defines the M, E and S slices in such a way to not depend on the cube size.
​ *The Method of 
Wide Turn-Based 2-Cycle Odd Parity Algorithms*​
_Please make sure you have watched at least Part I and Part II of the derivation before reading what’s below (Part III and Part IV are not necessary to watch to understand the rest of the content in this post)._
*Edge Flip Algorithms which Do Not Use the Technique of Shifting*​ (Minimum: 22q)​


Spoiler



In Part II, I mention 22q and 23q algorithms without really showing them. Here are a few algorithms of this length which were indirectly described in that video:



Note 1: To apply the following algorithms to higher order even and odd cubes, all of the moves are basically the same (no move insertions like in the Holy Grail Algorithm): keep the same proportion of the outer block turns and apply the algorithm to the proper inner slice.
Note 2: I will leave the derivations to you all. These algorithms have the same general structure as common speedsolving parity algorithms. _I will provide their outlines, however._
*My favorite 23q*
On even cubes:
*Rw* U L F' U l' Dw Uw *Rw2* Dw' l' Dw *Rw2* Dw' l Uw' U' F L' U' *Rw'*
=
Rw U L F' U 
(l')
Uw Dw
Rw2 Dw' l' Dw Rw2 Dw' l Dw
Dw' Uw'
U' F L' U' Rw'

For odd cubes, just include the central slice for all of the bold moves above. That is,
3r U L F' U 2L' 2d 2u 3r2 2d' 2L' 2d 3r2 2d' 2L 2u' U' F L' U' 3r'

Notes about the algorithm


Like the HG algorithm, this algorithm makes a cross about the front center face (on a supercube).
It uses the commutator Rw2 Dw' l' Dw Rw2 Dw' l Dw to make the "slidden j-perm" and the set-up moves Rw U L F' U to make an edge flip from that "slidden j-perm".
*My favorite 22q*

On even cubes:
y *Lw'* *Uw2* x' D' U' l' Uw Dw *Rw2* Dw' l' Dw *Rw2* Dw' l U *d'* Rw2 Bw z2
=
r' d2 F' B'
x'
(l')
Uw Dw
Rw2 Dw' l' Dw Rw2 Dw' l Dw
Dw' Uw'
x
B F d2 r

For odd cubes, just include the central slice for all of the bold moves above. That is
y 3l' 3u2 x' D' U' 2L' 2u 2d 3r2 2d' 2L' 2d 3r2 2d' 2L U 2-3d' 2r2 2b z2

Note
Also, @Cride5, looking at the algorithm above, take note of the last portion (where the move cancellation occurred (shown in brackets below).
y Lw' Uw2 x' D' U' l' Uw Dw Rw2 Dw' l' Dw Rw2 Dw' l [U d'] Rw2 Bw z2
This algorithm demonstrates ATM (Axial Turn Metric), from your thread.

Notes about the algorithm


This algorithm swaps all same-color center pieces within the top face in a different fashion than standard speedsolving algorithms.
It uses the same commutator as the previous algorithm, but it uses the set-up moves Lw' Uw2 x' D' U' to make the "slidden j-perm" an edge flip algorithm. Hence, the move cancellation from 23q to 22q.
*A Neat 23q*
_Take note of the portion in brackets.

_On Odd cubes:
z x *3r* *3u2* x' *4u* U y' 2R' 2u 2d *3l'2* 2u' 2R' 2u *3l'2* 2u' 2R [*4u'* *3u'* U'] x' *3u2* 2r' z

=
2D 2L'2 4b B
y2 x'
(2L')
2d 2u
3r2 2d' 2L' 2d 3r2 2d' 2L 2d
2d' 2u'
x y2
B' 4b' 2L'2 2D'

For even cubes, the bold moves above contain one less layer on the inside than its odd cube counter-part (e.g. 7x7x7 vs 6x6x6, 5x5x5 vs 4x4x4, etc.).

For example, on the 4x4x4: (watch the applet execute the bracketed portion!)
z x 2r 2u2 x' 3u U y' 2R' 2u 2d 2l'2 2u' 2R' 2u 2l'2 2u' 2R [3u' 2u' U'] x' 2u2 2r' z

As far as I have been able to find, no algorithms of this form, that is:

Outer set-up moves to make an edge flip
set-up moves to move all blocks into either the r slice or l slice
commutator
Inverse of set-up moves to move all blocks into either the r slice or l slice
(quarter turn)
Inverse of outer set-up moves to make an edge flip

are less than 22q for any size cubes.


 *Optimal Edge Flip Algorithms that Discolor the Centers *
(They can be used in the Cage Method)​


Spoiler



*Optimal Algorithm in Quarter Turns* (15q)

An algorithm that only permutes 2(n-2) center pieces (many others are much more messy).

Even Cubes:
*2r'* 2L' *2u* 2r' *2u'* 2L *2u* y *2l* 2d 2R' 2d' *2l'* y' 2r *2u'* *2r*
Odd cubes:
3r' 2L' 3u 2r' 3u' 2L 3u y 3l 2d 2R' 2d' 3l' y' 2r 3u' 3r

*Derivation*


Spoiler



[1] The base on the 4x4x4:
(2R')
2d' 2l' y'
2r 2u' 2L' 2u 2r' 2u' 2L 2u
y 2l 2d

Translating to the 5x5x5 by converting some turns to triple layer turns,
(2R')
2d' 3l' y'
2r 3u' 2L' 3u 2r' 3u' 2L 3u
y 3l 2d

[2] Shift:
2L' 3u 2r' 3u' 2L 3u
y 3l 2d
(2R') 2d' 3l' y' 2r 3u' 

[3] Add one set-up move:
3r'
2L' 3u 2r' 3u' 2L 3u
y 3l 2d
(2R') 2d' 3l' y' 2r 3u'
3r


 
*Optimal Algorithms in Half Turns* (12h)
Brief History
According to my knowledge, no one has ever been able to achieve an algorithm to do this which was less than 13h. So, this is a breakthrough for HALF turns!

These algorithms are single slice-based, although they can have all turns except inner-layer slices converted to wide to achieve a similar form to the 15q algorithm presented previously:

*My favorite 12h Algorithm:*
On Even Cubes:
x' 2r2 3d 2R U' L'2 U 2R' 3d 2R U2 F2 2r2 x y2

On Odd Cubes:
x' 2r2 4d 2R U' L'2 U 2R' 4d 2R U2 F2 3r2 x y2

*Derivation*


Spoiler



[1] Start off with a commutator to cycle three wings:
U' F2 U 2B U' F2 U 2B'

[2]Add one set-up move to bring all wings into the 2R slice:
U'
U' F2 U 2B U' F2 U 2B'
U
[3] Add quarter turn
U'
U' F2 U 2B U' F2 U 2B'
U
(2R)
[4] Shift:
U 2B U' F2 U 2B'
U
(2R)
U' U' F2 
[5] Add one set-up move:
2R2
U 2B U' F2 U 2B'
U
(2R)
U' U' F2 
2R2
[6] Merging the U' U' as U2, converting the outer-most set-up move to wide (for easier execution), and inserting y cube rotations,
2r2
U y'
2R U' L'2 U 2R'
U y' (2R)
U2 F2
3r2 
[7] Merge the two U y' as 4d,
2r2
4d
2R U' L'2 U 2R'
4d (2R)
U2 F2
3r2
[8] Finally, adding cube rotations:
x'
2r2
4d
2R U' L'2 U 2R'
4d (2R)
U2 F2
3r2
x y2


 
Note that we can make a 12h double parity algorithm by inverting the quarter turn.
On Even Cubes:
x' 2r2 3d 2R U' L'2 U 2R' 3d *2R'* U2 F2 2r2 x y2
On Odd Cubes:
x' 2r2 4d 2R U' L'2 U 2R' 4d *2R'* U2 F2 3r2 x y2
_If you don't know why we can do this, see the end of my second post in this thread on "Double Parity"._


 
*Optimal Edge Flip Algorithms that Discolor the Centers & Scramble the Outer Layers*​ (Not useful for anything except cube theory).
​​


Spoiler



*Possible Optimal Algorithm for the 2-cycle Single Edge Flip (not double-parity): 15q/11h*
We can simply remove the U2 from the previous algorithm (the non-doubleparity version) to achieve this, because the U2 move does not help do anything but restore the outer-layers of the cube.

On Even Cubes:
x' 2r2 3d 2R U' L'2 U 2R' 3d 2R F2 2r2 x y2

On Odd Cubes:
x' 2r2 4d 2R U' L'2 U 2R' 4d 2R F2 3r2 x y2

_We can achieve a 15q/11h doubleparity by inverting the extra quarter turn, as we did before._

*Possible Optimal Algorithm for the Single Edge Flip 4-cycle (Double-Parity): 13q/11h*
(Performed the same on both odd and even cubes)

2L' B' 2U B' D2 B 2U' B' 2L D2 2L' 

*Derivation*


Spoiler



[1] Start out with the commutator:
B 2U B' D2 B 2U' B' D2
[2] Add set-up moves to bring all pieces into the 2L slice:
B2
B 2U B' D2 B 2U' B' D2
B2
[3] Add a quarter turn:
B2
B 2U B' D2 B 2U' B' D2
B2
(2L')
[4] Shift backwards:
B2
(2L')
B2
B 2U B' D2 B 2U' B' D2
[5] Add the following piece to make a non-symmetrical double-parity algorithm
B2
(2L')
B2
B 2U B' D2 B 2U' B' D2
D2 2L D2 2L' 
[6] Cancel moves:
B2 (2L') B' 2U B' D2 B 2U' B' 2L D2 2L' 
[7] Delete the first half turn move, as we don't need it for inner-layer manipulation:
2L' B' 2U B' D2 B 2U' B' 2L D2 2L' 





*A 21q Algorithm Which Permutes the Centers like Common Algorithms *​ *(Even Cubes Only)*​


Spoiler



If we take the 15q algorithm we had before:
2r' 2L' 2u 2r' 2u' 2L 2u y 2l 2d 2R' 2d' 2l' y' 2r 2u' 2r
and add set-up moves to it, we have it:

2b' R' 2U
2r' 2L' 2u 2r' 2u' 2L 2u y 2l 2d 2R' 2d' 2l' y' 2r 2u' 2r
2U' R 2b
=
2b' R' 2U 2r' *2L'* 2u 2r' 2u' *2L* 2u y 2l 2d *2R'* 2d' 2l' y' 2r 2u' 2r 2U' R 2b

To translate to other even cube sizes besides the 4x4x4, keep all of the moves which are not bold the same proportion. The bold moves indicate which orbits need to be affected.

For example, on the inner orbit of the 6x6x6,
3b' R' 2-3u 3r' 2L' 3u 3r' 3u' 2L 3u y 3l 3d 2R' 3d' 3l' y' 3r 3u' 3r 2-3u' R 3b

Here is a “3-gen”/4-gen algorithm which does not touch the front-bottom-left (n/2)x(n/2)x(n/2) block:

2b' R' 2U 2r' *2R'* 2u 2b' 2u' *2R* 2u 2r 2b *2R'* 2b' 2r' 2b 2u' 2r 2U' R 2b

Comparing it to the previous 21q, they are nearly the same, but this path allows using less slices.

Just as with translating the other algorithm to higher order even cubes, the bold moves are the orbit which needs to be affected, while the rest of the moves are kept proportional.

For example, on the outer-orbit of the 6x6x6,
3b' R' 2-3u 3r' *2R'* 3u 3b' 3u' *2R* 3u 3r 3b *2R'* 3b' 3r' 3b 3u' 3r 2-3u' R 3b

*Derivation*


Spoiler



(I am going to use WCA notation).

Start with the commutator:
Bw Uw' r' Uw Bw' Uw' r Uw

Add set-up moves and quarter turn,
Uw' Lw'
Bw Uw' r' Uw Bw' Uw' r Uw
Lw Uw
r'

Shift:
r' Uw Bw' Uw' r Uw
Lw Uw
r'
Uw' Lw'
Bw Uw'

Add one set-up move to make 15q center discoloring algorithm,
Rw'
r' Uw Bw' Uw' r Uw
Lw Uw
r'
Uw' Lw'
Bw Uw'
Rw

Add set-up moves to not discolor the centers,
Bw' R' u
Rw'
r' Uw Bw' Uw' r Uw
Lw Uw
r'
Uw' Lw'
Bw Uw'
Rw
u' R Bw
=
Bw' R' u Rw'
r' Uw Bw' Uw' r Uw Lw Uw r' Uw' Lw' Bw Uw'
Rw u' R Bw

Since this algorithm only applies to even cubes completely, we can make a "3-gen"/5-gen in <B, R, U>,
=
Bw' R' u Rw'
r' Uw Bw' Uw' r Uw (Rw x') Uw r' Uw' (Rw' x) Bw Uw'
Rw u' R Bw

=
Bw' R' u Rw'
r' Uw Bw' Uw' r Uw Rw Bw r' Bw' Rw' Bw Uw'
Rw u' R Bw
=
Bw' R' u Rw' r' Uw Bw' Uw' r Uw Rw Bw r' Bw' Rw' Bw Uw' Rw u' R Bw
(All we need to do is to covert to SiGN notation to achieve the algorithm we wished to derive).





By: Christopher Mowla
Date: February 5, 2011.


----------



## Kirjava (Feb 8, 2011)

cmowla said:


> l'2 U Lw U2 r' U2 Rw' U2 x U' r' U x' U2 x U' (l' r) l'


 
I think this is faster; l2 U Lw U2 r' U2 Rw' U2 F r' F' U2 F r F2 l2

Also, do you have an alternatives for l' r' U Lw U2 r' U2 Rw' U2 x U' r' U x' U2 x U' (r' l) r' ? 

That alg is hard to tweak for speed, the rest are fine.

I got into learning 4x4x4 algs recently. Let me know if you find any adjacent 4cycles, too.


----------



## Christopher Mowla (Feb 18, 2011)

*Adjacent Double Parity Algorithms*

I know this is off topic from the main focus of this thread (2-cycles), but...


Kirjava said:


> Let me know if you find any adjacent 4cycles, too.


I am aware that I am stating the obvious for some, but just to get everyone on the same page, I will mention something before I present my algorithms.


Spoiler



Usually, if we have a double parity in two adjacent composite edges, we can just conjugate a double parity algorithm for two opposite composite edges to handle the adjacent case (simple enough, right?).

For example, Kirjava's algorithm of choice for opposite composite edge double parity is:
 r2 B2 r' U2 r' U2 B2 r' B2 r B2 r' B2 r2 B2 (15 btm)
(This algorithm can be found on his ELL Page).

To affect two adjacent edges, we merely need to memorize the opposite algorithm and then conjugate it (add setup moves) to make the left or right composite edge affected along with the front or back composite edge. For example,
R B
r2 B2 r' U2 r' U2 B2 r' B2 r B2 r' B2 r2 B2
B' R'
= R B r2 B2 r' U2 r' U2 B2 r' B2 r B2 r' B2 r2 B R' (18 btm)


 *My Algorithms*


Spoiler



What I have done is actually made algorithms which do the same task without conjugating an opposite edge double parity algorithm. With the approach that I took, it appears that 19 btm seems to be the minimum so far for the 4x4x4, 5x5x5, and special cases of big cube sizes in general for algorithms (for most cases, it's 20 btm).

I am NOT saying that this is the optimal algorithm OF THIS TYPE for btm (i.e., not doing a R B move conjugate to an opposite edge algorithm), but it might be.

Interestingly enough though, the move count for these unified algorithms and the regular combos seems to be nearly equivalent (and again, based off of the approach that I took).

I have found two different (but very related) algorithms. One of them is 19-20 btm, and the other is 20 btm for all size cubes. In addition, I have found a 14-17 btm algorithm that discolors centers (just to satisfy my curiosity and maybe yours).*

Algorithms which do not discolor the centers*
*[1]* 27q/20 btm Algorithm for all Big Cube Sizes:r2 F L F U2 l F2 D2 r D2 l' F r' F U2 F' r L' F' r2

If we make the r2 turns wide, then I believe this algorithm might be lower in qtm than any other algorithm and/or algorithm combo that currently exists. Its ftm count is equivalent to the combo presented in the first spoiler (which could be optimal too, being 25 ftm).

*[2]* 26-27q/19-20 btm Algorithm for all Big Cube Sizes, in general.
= r2 F' R' F' U2 l F2 D2 r D2 l' F' r' F' U2 F Rw F r2 (19 btm)

To successfully transfer this algorithm to all big cube sizes in general, the algorithm must be recognized as:
r2 F' R' F' U2 l F2 D2 r D2 l' F' r' F' U2 F (R [r]) F r2
, where [r] represents all of the inner-layer right slices (it does not include the central slice on odd cubes) which need to be affected and R represents just moving the outer-most right face. 

For example, on the inner orbit of wings for the 7x7x7, (click the link if you don't know SiGN Notation)
3R2 F' R' F' U2 3L F2 D2 3R D2 3L' F' 3R' F' U2 F (R 3R) F 3R2

Hence it is 19 btm for very few of the \( 2^{\left\lfloor \frac{n-2}{2} \right\rfloor }-1 \) amount of possible cases for a cube of size _n_. (Click HERE to substitute a number for _n_\( \ge 4 \) to see the total amount of possible cases for a cube of size _n_\( \ge 4 \)).

Due to the fact that both of these algorithms are basically "cousins", they have the same beginning in their derivations. I will therefore combine them into one spoiler and separate them when it comes time to.

*Derivation*


Spoiler



1) Start with the commutator:
F r' F' U2 F r F' U2

2) Add the following piece to have just two wings and two 1x(n-2) blocks swapped:
As seen with the derivations of most of the 2-cycle algorithms in this thread, we add setup moves to bring all 1x1x(n-1) blocks into the right slice. In addition, we add a quarter turn to solve back two of the 4 wing edge pieces and half of the centers.
F2 l'
 F r' F' U2 F r F' U2
 l F2 
 (r)


3) Writing on one line,
= F2 l' F r' F' U2 F r F' U2 l F2 r

4) Add a piece to involve two more wings, but keep the same amount of centers (2) involved:
F2 l' F r' F' U2 F r F' U2 l F2 r
 r' D2 r D2

5) Add another piece (Don't worry, there will actually be a lot of move cancellations).
F2 l' F r' F' U2 F r F' U2 l F2 r
 r' D2 r D2
 l' F2 l F2

= F2 l' F r' F' U2 F r F' U2 l F2 r r' D2 r D2 l' F2 l F2

6) Shift, (this shouldn't be new to anyone who has kept up with this thread)
F' U2 l F2 r r' D2 r D2 l' F2 l F2
 F2 l' F r' F' U2 F r 

*Now this is where we can take two routes: one to the 19-20 btm algorithm or just the 20 btm algorithm.

For the 19-20 btm algorithm,


Spoiler



7) Add the setup move R' so that, when it's inverted at the end of the algorithm, it can merge with the r move there. In addition, this move will also begin to place the affected edges into their final positions.

R'
 F' U2 l F2 r r' D2 r D2 l' F2 l F2 F2 l' F r' F' U2 F r 
 R

8) Add the remaining setup moves to make visually pure:
r2 F'
 R'
 F' U2 l F2 r r' D2 r D2 l' F2 l F2 F2 l' F r' F' U2 F r 
 R
 F r2

9) Cancel/merge moves
= r2 F' R' F' U2 l F2 D2 r D2 l' F' r' F' U2 F Rw F r2 (19 btm)

*To apply to all size cubes, take note of the form presented previously in this post.



For the 20 btm algorithm,


Spoiler



7) Invert the F quarter turn moves (we in effect use the commutator F' r' F U2 F' r F U2 instead of F r' F' U2 F r F' U2). _ I used this trick before in this thread when I was deriving all of my K4 adjacent 2-cycle algorithms._
F U2 l F2 r r' D2 r D2 l' F2 l F2
 F2 l' F' r' F U2 F' r 

8) Add the set-up moves to complete:
r2 F L
 F U2 l F2 r r' D2 r D2 l' F2 l F2
 F2 l' F' r' F U2 F' r 
 L' F' r2

9) Cancel moves to get:
r2 F L F U2 l F2 D2 r D2 l' F r' F U2 F' r L' F' r2 (20 btm)
_This algorithm is applied exactly like this to all big cubes._






*Non-Visually Pure (Causes Center Discoloration)*
Rw F' Rw' F' U2 F r F' U2 r F Rw r' F Rw' (17,15 on big cubes. 16,14 on the 4x4x4 and 5x5x5) 
On the 7x7x7,
3r F' 3r' F' U2 F 3R F' U2 3R F 3r 3R' F 3r'

* Derivation*


Spoiler



Do steps 1-3 of the derivation for the visually pure algorithms above to start with::
 F2 l' F r' F' U2 F r F' U2 l F2 r

4) Add the piece:
F2 l' F r' F' U2 F r F' U2 l F2 r
 r' F2 r F2

5) Shift, (again, this should be nothing new to those who have been keeping up with this thread).
F' U2 F r F' U2 l F2 r
 r' F2 r F2
 F2 l' F r'

6) Add the following 3 setup moves
Lw D' Lw'
 F' U2 F r F' U2 l F2 r
 r' F2 r F2
 F2 l' F r' 
 Lw D Lw'

7) Cancel moves to have:
 Lw D' Lw' F' U2 F r F' U2 r F r' Lw D Lw'

8) Merge the (r' Lw) as R x'
Lw D' Lw' F' U2 F r F' U2 r F R x' D Lw' (14 btm)

To apply it to all size cubes, we need to use 4x4x4 wide turn equivalences for the first and last two wide turns, and we should keep Rw r', instead of canceling them to R for the 4x4x4 and 5x5x5.
Rw F' Rw' F' U2 F r F' U2 r F Rw r' F Rw'



In addition, here is a 13 btm non-center preserving adjacent double parity algorithm which is faster.
r2 U Rw' U R U r' U' R' U' Rw U' r2 = [r2 U Rw' U R U: r']​


----------



## Christopher Mowla (Apr 12, 2011)

*The Holy Grail of Edge Flip Algorithm's Base By Cube Explorer 5.00*

I have just found a 3x3x3 set-up for Cube Explorer to produce the "Holy Grail" base for the 4x4x4 cube.

If you have watched Part II of my HG Alg Derivation series, you would see that the "Holy Grail" algorithm has the following structure.

_In WCA Notation_

Dw' M D Set-up
Lw' Uw' r' Uw Lw Uw' Lw2 Bw' r' Bw (Lw' r) Lw' Uw Base
D' M' Dw Reverse of Set-up

Here is a screenshot of Cube Explorer


Spoiler










The 3x3x3 set-up for Cube Explorer shown in the image above is F' U' B' U F2 U' F L' B' L F' B U F'.

As you can see, clicking the green arrow, the optimal solution is
U' F2 B' L' B L F2 U F' U' B U F (15q, 13 htm)

To translate it properly to the 4x4x4, the moves are converted as follows:
Uw' Fw2 b' Lw' b Lw Fw2 Uw Fw' Uw' b Uw Fw

Rotate about y,
Uw' Lw2 r' Bw' r Bw Lw2 Uw Lw' Uw' r Uw Lw

Inverse
Lw' Uw' r' Uw Lw Uw' Lw2 Bw' r' Bw r Lw2 Uw

= Lw' Uw' r' Uw Lw Uw' Lw2 Bw' r' Bw (Lw' r) Lw' Uw *


*What Does This Prove?*
This doesn't necessarily prove that the HG Algorithm is God's Algorithm for the visually pure edge flip case, but it does put up quite a case.

Maybe some people can play around with this base set-up and generate algorithms from it using another solver to see if more move cancellations can be achieved with the outer set-up moves Dw' M D.

*A More "Perfect Set-up"*


Spoiler



If you see the effect the base Lw' Uw' r' Uw Lw Uw' Lw2 Bw' r' Bw (Lw' r) Lw' Uw has on the bottom x-center piece, note that it takes 3 set-up moves to make a visually pure algorithm. If that x-center piece was in a different location, perhaps only two set-up moves are required to make a visually pure algorithm.

As I have told cuBerBruce when I showed him, I cannot recollect how I found the set-up for this case (a mixture of Cube Explorer, my algorithm creation method, trial and error, and basic "unscrambling" skills), but it is:

L' U' R' U' R U L' U' L U R' U' L' U L2 R

When translated to the 4x4x4 correctly (and I couldn't get this to translate to any other cube size...except for higher order bandaged even cubes), it is the following:
Lw' u' Rw' u' Rw u Lw' u' Lw u Rw' u' Lw' u Lw2 Rw

Merging the last two wider turns as a x cube rotation and shifting that x cube rotation backwards (moving to the front of the algorithm,

x Lw' u' Rw' u' Rw u Lw' u' Lw u Rw' u' Lw' u Lw'

Now we have a set-up we can conjugate with two instead of three moves:
Dw' M 
Lw' x u' Rw' u' Rw u Lw' u' Lw u Rw' u' Lw' u Lw'
M' Dw

Unlike the HG Algorithm, this visually pure single edge flip algorithm has no move cancellations and remains 19q.

cuBerBruce was kind enough to run Tomas Rokicki's 3x3x3 solver and generate other 15q bases like this one (using that algorithm as the set-up). Not all of them translated to the 4x4x4, but here are two that did:

F-D-F+U-D-R-U+R+D+F-D+F+L-U+L+
=>
Fw'
M
Fw' Dw' Fw u' Dw' Rw' u Rw Dw Fw' Dw Fw Lw' u Lw
M'
Fw

and

R-L-B+R+U-D-R-U+R+D+R-B-R+U+L+
=>
Fw'
M
Rw' Lw' Bw Rw u' Dw' Rw' u Rw Dw Rw' Bw' Rw u Lw
M'
Fw

Both are 19q like the Holy Grail Algorithm, but I could not translate them to other big cube sizes.


*My Point*
Even though the Holy Grail Base set-up requires one additional set-up move than the "more perfect" set-up, it is not any more moves.

cuBerBruce's work shows that 15q solutions are indeed optimal for "the more perfect set-up", and Cube Explorer gives us a 14q algorithm for the Holy Grail Base set-up, which happens to be the Holy Grail Base itself.

Discussion anyone?


EDIT:
cuBerBruce was kind enough to run Tomas Rokicki's solver for the HG base setup. From the results, we have a third algorithm:
Rw Bw' r' Lw Dw' r Dw Lw' Bw Rw' Lw' Uw' r Uw Lw

I said "third" but I actually forgot to show how the setup for Cube Explorer translates to the 4x4x4. First of all, it is better to execute if we rotate it about the y axis to: L' U' R' U L2 U' L B' R' B L' R U L'
=> Lw' Uw' r' Uw Lw2 Uw' Lw Bw' r' Bw Lw' r Uw Lw'.


----------



## Christopher Mowla (Jun 3, 2011)

*Adjacent Double Parity Algorithms (Revisited)*

Although I have already posted it in the "A Collection of Algorithms" thread, I thought I would post it here too, accompanied by a full derivation. I made a special effort to post this derivation because, as you will see, I took an entirely different approach than the previous to create the base (and a 2-gen one too!).

z' Rw' U' Rw' l' U L'
U (r U2)3 r2 U
L U' l Rw U Rw z

= [z' Rw' U' Rw' l' U L': U (r U2)3 r2 U] (25q, 21 btm)
Although this algorithm is 21 btm (3 more btm than the current minimum combo of 18 btm), it has a very low quarter turn move count being 25q (which I think is the current minimum for all combos). In addition, it is significantly easier to execute than my previous algorithms.*

Derivation*


Spoiler



Just as I had to create a base for the previous adjacent double parity algorithms in the first adjacent double parity algorithms post, the bases had the following two characteristics:

1) There were only 4 wing edges misplaced
2) There were only 2 1x(n-2) center blocks unsolved (on a supercube).

i.e.,
F U2 l F2 r r' D2 r D2 l' F2 l F2
F2 l' F' r' F U2 F' r 

We are going to do a similar set up for this algorithm, but with a completely different approach.

[1] Just as we always start out parity algorithms, we start with a commutator. This time, it's a very brief one: r U2 r' U2
 
Unlike with 2-cycle algorithms, where our ultimate goal is to make a 3 1x1x(n-1) block swapper, for example: U2 l U2 r' U2 r U2 l', we are going to be dealing with 1x1xn blocks.

[2] Just as we added set up moves to the commutators for cycling 3 1x1x(n-1) blocks ^ to bring all three into the same slice (whether l or r) so that we can do a quarter turn, we are going to do the same thing here. There will only be two 1x1xn blocks (in our case, 1x1x4 blocks, since we are using the 4x4x4) we will focus on.

In order to put back the most pieces with a quarter turn (as well as inducing an odd permutation), we to solve back the 1x1x4 block in the front right portion of the cube. With r U2 r' U2, that block is currently only a complete 1x1x3 block. However,

If we add a U2 conjugate, then we will make that one a complete 1x1x4 block.
(According to the color scheme of the cube applet, this 1x1x4 block will be all white on its front side.)

*U2*
r U2 r' U2
*U2*

[3] Next, we now prepare to do a quarter turn. Looking at the 1x1x4 block we completed in step [2], if we imagine pushing it away from us with a move r, then the entire top right 1x1x4 slot will be solved back. However, we SHOULD NOT do that right now. First, it would be smart if we first paste another block to be connected to this 1x1x4 block prior to doing the quarter turn r. The incomplete 1x1x4 block in the top left 1x1x4 slot will be our choice because notice its colors: green and yellow. Now look back at the complete 1x1x4 block we have formed. By doing r, we will solve it back completely. At the same time, if the 1x1x3 portion of the 1x1x4 block in the top left 1x1x4 slot is place UNDER our complete 1x1x4 block prior to adding the quarter turn, then we solve back more than half of slice r.

So how do we get this down to the bottom in the fewest number of moves?
We could very well do l2 D2

U2
r U2 r' U2
U2
*l2 D2*

but let's instead do r2 U2

U2
r U2 r' U2
U2
*r2 U2*

[4] Now we can add the quarter turn, r.

(It's really hard to see the original formation of slice r before the set up moves r2 U2 were applied, but we have already seen that the logical quarter turn to do is r instead of r'. But no worries, because, if you ever make the quarter turn go in the opposite direction as it's supposed to, you can simply reverse it.)

U2
r U2 r' U2
U2
r2 U2
*r*

[5] Now undo r2 U2 with U2 r2
U2
r U2 r' U2
U2
r2 U2
r
*U2 r2*

Because we were careful, the only two center blocks unsolved are the ones seen discolored. In addition, we have 4 wing edges now out of place.

[6] With a little trial and error, it is best if we have the U face rotated +90 degrees. In order to do this, instead of applying a set up move U', we can just:

a) Split the first move (U2) into U U
*U U*
r U2 r' U2
U2
r2 U2
r
U2 r2

b) Shift one of them to the end of the algorithm.
U
r U2 r' U2
U2
r2 U2
r
U2 r2
*U*

[7] Let's simplify this base.
= U r U2 r U2 r U2 r2 U

[8] From here, we just add in ALOT of set up moves to position the dedges and centers.

a) First we add L' to get the completed dedge off of the top face, which has one of the two unsolved 1x2 center blocks because, if we here to do a slice turn through slice U right now, it would break up that dedge (not to mention break of the center block, which we DO NOT want to do!)
*L'*
U r U2 r U2 r U2 r2 U
*L*

b) Secondly, we add U to get the unsolved 1x2 center block in the top on the opposite side of the cube as the other one (which is in the back face).
*U* L'
U r U2 r U2 r U2 r2 U
L *U*'

c) Thirdly, we add in l'. Sadly, I can only say that it was by painstaking work which helped me to see that this move was needed. (You can see soon why it helps).
*l'* U L'
U r U2 r U2 r U2 r2 U
L U' *l*

d) Fourthly, we add in Rw' to pair up the second dedge.
*Rw'* l' U L'
U r U2 r U2 r U2 r2 U
L U' l *Rw*

e) Next, we add in U' to get the second paired dedge out of the M layer so that we can swap same color 1x2 center blocks with each other without breaking it up again. We choose U' over U because we are trying to form an adjacent double parity algorithm. What could be better than just to place it adjacently next to the other paired dedge?
*U'* Rw' l' U L'
U r U2 r U2 r U2 r2 U
L U' l Rw *U*

f) Second to last, we add in the obvious move, Rw', to swap same-color 1x2 center blocks with each other.
*Rw'* U' Rw' l' U L'
U r U2 r U2 r U2 r2 U
L U' l Rw U *Rw*

g) Lastly, the adjacent dedge swap ended up in slice L. Hence, let's do z' to move it in U.

=> [*z'* Rw' U' Rw' l' U L' :U r U2 r U2 r U2 r2 U]

(Note: The Rw' turns need not be wide turns, but they don't hurt anything either.)

DONE


With a similar method, I have made adjacent 4-cycles for the other cases:

*Case 1*




Lw' U2 M'2 U' x r' U2 r' U2 r2 U2 r' U2 x' U M'2 U2 Lw

= [Lw' U2 M'2 U' x: r' U2 r' U2 r2 U2 r' U2] (25q, 16 btm)

*Case 2*




Lw' U2 M'2 U x' l' U2 l' U2 l2 U2 l' U2 x U' M'2 U2 Lw

= [Lw' U2 M'2 U x': l' U2 l' U2 l2 U2 l' U2] (25q, 16 btm)

_Just take their inverses to get the other two cases.
Also, if anyone wants a derivation for those, let me know. But again, I did use the same general method as the derivation in this post.


_EDIT:
Speaking of this method and 4-cycles,

Here is a derivation of the famous beginner parity fix: r U2 r U2 r U2 r U2 r

*Derivation*


Spoiler



[1] We can easily make a 4-cycle that discolors 4 1x(n-2) center blocks by:
a) Doing set up moves to bring one 1xn block onto the slice where the quarter turn will be executed.
b) Do the quarter turn
c) Reverse the set up moves.

Lw F2 (r) F2 Lw'

_Note that the turns of L do not need to be wide, but it helps us visualize._

The advantage to doing Lw F2 first is to have one of the 4 1x2 center blocks to not be discolored (the white 1x2 center block in the top is affected as well, for those who don't have a supercube handy).

[2] However, the white 1x2 center block in the back face on the right side belongs in the top right, as well as the pieces connected to it in the back bottom of slice r. Hence, we are tempted to do r' as to restore it

Lw F2 r F2 Lw' r'

This is indeed a commutator: [Lw F2, r]

[3] Since it's a commutator, we know the number of inner layer quarter turns is now even again, and we will have to resume our usual routine of set up moves + quarter turn + reverse of set up.

Studying our commutator, notice that slice r is in "desperate need" of being moved away from us with move r, since the entire front half of slice r is connected.

Before we do this, however, take note of the 1x1x4 block in the top left 1x1x4 block slot. It is primarily yellow. We can put back a lot of pieces if we first do some set up moves to put that 1x1x4 block in the back of what is currently slice r so that, when we do the move r, it is brought to the bottom.

Hence, we add Lw' B2

Lw F2 r F2 Lw' r' 
Lw' B2

[4] Do the quarter turn, r and reverse the set up,

Lw F2 r F2 Lw' r' 
Lw' B2 r B2 Lw
we have it!

[5] Modifying the algorithm now, on the 4x4x4, we can add x cube rotations to make all face turns U2.

Lw x U2 r U2 Lw' r' x'
Lw' x' U2 r U2 Lw x

Grouping wide turns with x cube rotations,

(Lw x) U2 r U2 (Lw' x') r'
(Lw' x') U2 r U2 (Lw x)

=
Rw U2 r U2 Rw' r'
Rw' U2 r U2 Rw

Taking out the outer layer turns of R, (IMPORTANT NOTE: We can do this because the moves that are wide were originally set up moves. As I have said earlier, they were never required, but it helps us visualize).
=
r U2 r U2 r' r'
r' U2 r U2 r

= r U2 r U2 r U2 r U2 r
DONE

So one of the closest "cousins" to the famous r U2 r U2 r U2 r U2 r is shockingly:

Lw F2 D2 r D2 F2 Lw' r'
Lw' U2 r U2 Lw

Looking at this algorithm in a few steps,
Lw F2 D2 r D2 F2 Lw'

Is the same first step as the other algorithm, just we added in an extra set up move D2 to bring the green center block into slice r as well.

The r' is the completion of the commutator [Lw F2 D2, r]

and the last portion is set up moves + quarter turn
Lw F2 D2 r D2 F2 Lw' r'
Lw' U2 r U2 Lw

=>
(Lw x) U2 F2 r F2 U2 (Lw' x)' r'
Lw' U2 r U2 Lw

=
Rw U2 F2 r F2 U2 Rw' r'
Lw' U2 r U2 Lw

Omitting the wide turns (because they were just set up moves involving the inner layers only),
= r U2 F2 r F2 U2 r' r' l' U2 r U2 l
= r U2 F2 r F2 U2 r2 l U2 r' U2 l'

This algorithm is a 4-cycle (obviously) and it only affects two centers just like the previous algorithm. The front (green) face is now discolored because we involved it in the quarter turn with D2.

Anyway, from this, we have a much more convenient algorithm to make a common visually pure 4-cycle case:
Rw U2
r U2 F2 r F2 U2 r2 l' U2 r U2 l (16)
U2 Rw'

It's definitely not optimal, but I just wanted to show you a slight modification of the original alg with justification.


----------



## Christopher Mowla (Jun 9, 2011)

Kirjava said:


> Also, do you have an alternatives for l' r' U Lw U2 r' U2 Rw' U2 x U' r' U x' U2 x U' (r' l) r' ?
> 
> That alg is hard to tweak for speed, the rest are fine.
> 
> I got into learning 4x4x4 algs recently. Let me know if you find any adjacent 4cycles, too.


x' r' U R U r' U' R' U' B2 r' B2 l U2 l' U2 r2 x (21, 16)

At the cost of one extra quarter turn and half turn, this can be optimized to:
x' r' U R U r' U' R' U' *(Rw' l)* U2 r' U2 *Rw* U2 l' U2 r2 x (22, 17)
_(To apply on odd cubes, include the central slice with the two bold moves.)_

Here's another algorithm for that case. It's longer, but it might be just as fast on the 4x4x4.
x' r' U R U r' U' R' U' (l r') U2 r' U2 r U2 l' U2 r2 x (23, 19)

and, even though you didn't ask for it, but here is an alg for another case, just modifying the first one:
Rw' U R U r' U' R' U' x' U2 r' U2 r U2 l' U2 l Rw x (21, 17)
_This alg is two btm longer than the optimal (15), but its q moves are the same and is 2 qtm (plain quarter turn moves) less than the 15 btm I have previously posted in this thread.

_Here's another algorithm for that case:
Rw' U R U r' U' R' U' (Rw' l) U2 r' U2 r U2 l' U2 Rw2(22, 17)


----------



## Christopher Mowla (Jun 11, 2011)

*Adjacent Double Parity (Revisited #2) AND Another 23q Visual Pure Dedge Flip Alg*



cmowla said:


> ...it has a very low quarter turn move count being 25q (which I think is the current minimum for all combos)...


I have lowered it to 24q.






Here's the algorithm on the 4x4x4, (24q, 20 btm)​ x' *l* U' R U' r U R' U r' F' r' U2 r D2 r D2 r' U2 F *M'* x​ 
To apply it to all size cubes in general, take note of the two moves in bold font.
l = all inner-layer slices to the left of the r slice(s) which you use to affect a particular orbit(s).
M' = 
all inner-layer slices to the left of the r slice(s) which you use to affect a particular orbit(s). 
+
the r slice(s) used to affect a particular orbit(s).

For example, on the inner orbit of the 6x6x6 (in SiGN Notation),
x' *2-3l* U' R U' 3R U R' U 3R' F' 3R' U2 3R D2 3R D2 3R' U2 F *2-4l'* x

*Derivation*


Spoiler



Instead of starting with r U2 r U2 r' = [r U2: r], if we break the U2s into two pieces, then we have a much better chance of creating an adjacent parity algorithm in fewer moves (maybe fewer quarter turns, half turns, or both, depending on what the odd permutation is). How do we do this? We need to place an outer-layer slice move between them.

Hence,
[1] Let's start out instead with: r U' R U' r U R' U r' = [r U' R U': r].

[2] If you execute this on a 4x4x4 supercube, the 1x2 center block on the right side of the top face is one of the 4 1x2 center blocks unsolved. If we now add F', then we complete a 1x1x3 block.
r U' R U' r U R' U r'
F'

[3] Add r' U2 r to restore the top center and pair up one of the 3 unpaired dedges.
r U' R U' r U R' U r'
F'
r' U2 r

[4] Add D2 r D2 r' to restore the last two centers and pair up the last two unpaired dedges.
r U' R U' r U R' U r'
F'
r' U2 r
D2 r D2 r'

[5] Add U2 F to restore the cube as much as possible.
r U' R U' r U R' U r'
F'
r' U2 r
D2 r D2 r'
U2 F

[6] Now, if we conjugate with the move L', then we can get a 25q adjacent double parity. However, to squeeze out an extra quarter turn, it would be ideal if we could somehow merge the conjugate with the r (the first turn of the algorithm). To start out, let's convert r to a wide turn. Note that we must invert the extra R with R'.
Rw U' R U' r U R' U r'
F'
r' U2 r
D2 r D2 r'
U2 F
R'

[7] Now we conjugate with L', and both the first two moves and last two will merge as one move each.
L'
Rw U' R U' r U R' U r'
F'
r' U2 r
D2 r D2 r'
U2 F
R'
L

[8] Optimizing,
a) Merging the moves and writing the algorithm on one line,
l x U' R U' r U R' U r' F' r' U2 r D2 r D2 r' U2 F M' x'
b) Conjugating with x2,
l x' U' R U' r U R' U r' F' r' U2 r D2 r D2 r' U2 F M' x
c) We can interchange the first two letters to have the exact form of the algorithm to be derived.
x' *l* U' R U' r U R' U r' F' r' U2 r D2 r D2 r' U2 F *M'* x

DONE



*Another 23q Visually Pure Single Dedge Flip algorithm.*
Rw2 F2 r' U2 r U2 F r U' R U' r U R' U r' F Rw2 (23, 18)

*Derivation*


Spoiler



From the same start (steps 1-3) as the previous algorithm,

[1-3] We have:
r U' R U' r U R' U r'
F'
r' U2 r

[4] Restore the cube's outer layers by adding U2 F.
r U' R U' r U R' U r'
F'
r' U2 r
U2 F

[5] Shift,
r' U2 r
U2 F
r U' R U' r U R' U r'
F'

[6] Conjugate with Rw2 F2
Rw2 F2
r' U2 r
U2 F
r U' R U' r U R' U r'
F'
F2 Rw2

[7] And F' F2 = F
=> Rw2 F2 r' U2 r U2 F r U' R U' r U R' U r' F Rw2

DONE


This algorithm is an interesting find because I could never before create a 23q single slice turn based algorithm other than using the commutator F' r' F U2 F' r F U2

Lastly, note that I used a similar start to make the algorithms in my previous post. That is, using the idea of splitting U2s into two pieces by inserting R slices between them.


----------



## Christopher Mowla (Sep 12, 2011)

*15 btm 2-cycle for the 4x4x4!*

I was shocked today that 16 btm isn't the optimal move count for one of the K4LL 2-cycle cases! However, the algorithm only can be translated to even cubes, and based on where the interior conjugate must be added, it's 17 btm on all other even cube sizes. It's definitely not transferable to odd cubes (just try to convert the algorithm pieces to the 5x5x5 in steps 1-3 in the derivation and you'll see why). Hence, this algorithm is only 15 btm on the 4x4x4 and works on larger even cubes but at a higher move count.

*History*
I highly doubt an algorithm of this length (in btm) has been achieved before for this case. As I have mentioned already, I was shocked myself. I didn't know my wide turn method could actually beat conventional methods in btm for a case like this!

Anyway, here's the algorithm translation for the 4x4x4.
z' Fw' l' Uw2 r Uw' r' Uw2 Bw2 Uw' r' Uw Bw2 Uw l Fw z (19q, 15 btm)
= [z' Fw' l' Uw': [Bw2 Uw': [Uw Bw2 Uw': [r, Uw'] ] r' ] ]

*Derivation*


Spoiler



1) Start with the commutator

r Uw' r' Uw

2) Conjugate to bring most affected pieces into slice r.

Uw Bw2 Uw' 
r Uw' r' Uw 
Uw Bw2 Uw'

3) Do the quarter turn r'.

Uw Bw2 Uw' 
r Uw' r' Uw 
Uw Bw2 Uw' 
(r')

4) Shift the first two half turns

Uw' 
r Uw' r' Uw 
Uw Bw2 Uw' 
r' 
Uw Bw2

5) Conjugate

z' Fw' l' Uw'
Uw' 
r Uw' r' Uw 
Uw Bw2 Uw' 
r' 
Uw Bw2 
Uw l Fw z

6) Merge quarter turns to half turns

z' Fw' l' 
Uw2
r Uw' r' 
Uw2 
Bw2 Uw' 
r' 
Uw Bw2 
Uw l Fw z
= z' Fw' l' Uw2 r Uw' r' Uw2 Bw2 Uw' r' Uw Bw2 Uw l Fw z
= [z' Fw' l' Uw': Uw' r Uw' r' Uw2 Bw2 Uw' r' Uw Bw2]

By the derivation, the algorithm can also be written as:
z' Fw' l' Uw'
Bw2 Uw'
Uw Bw2 Uw' 
r Uw' r' Uw 
Uw Bw2 Uw' 
r'
Uw Bw2
Uw l Fw z
=[z' Fw' l' Uw': [Bw2 Uw': [Uw Bw2 Uw': [r, Uw'] ] r' ] ]


*Translating to the 6x6x6 and All Other Even Cubes *(20q, 17 btm)


Spoiler



1) Rewrite in SiGN notation, and convert double layer turns to triple layer turns.

z' 3f' 2L' 3u2 2R 3u' 2R' 3u2 3b2 3u' 2R' 3u 3b2 3u 2L 3f z

2) Split the first 3u2 turn to 3u 3u.

z' 3f' 2L' 3u2 2R 3u' 2R' 3u 3u 3b2 3u' 2R' 3u 3b2 3u 2L 3f z

3) Rewrite as

z' 3f' 2L' 3u2 2R 

3u' 2R' 3u 

3u 3b2 3u' 2R' 3u 3b2 3u 2L 3f z 

4) It's easier to see what we need to do if we take the inverse.

 z' 3f' 2L' 3u' 3b2 3u' 2R 3u 3b2 3u'

3u' 2R 3u 

2R' 3u2 2L 3f z 
 
5) If you execute the first piece on a solved 6x6x6 and then slowly just do 3u' 2R 3u (using the link above), you'll see why we have an oblique in the wrong place. The interior conjugate is 3R.

z' 3f' 2L' 3u' 3b2 3u' 2R 3u 3b2 3u'
3R 
3u' 2R 3u
3R' 
2R' 3u2 2L 3f z

6) So we can take the inverse of this to beg the original form for the 4x4x4

z' 3f' 2L' 3u2 2R
3R
3u' 2R' 3u
3R'
3u 3b2 3u' 2R' 3u 3b2 3u 2L 3f z

7) Note that 2R and 3R represent all inner layer slices on the right side of an nxnxn cube and merge to 2-3r (hence we cancel a move for all cases).

 z' 3f' 2L' 3u2 *2-3r* 3u' 2R' 3u (3R') 3u 3b2 3u' 2R' 3u 3b2 3u 2L 3f z

*General formula for even cubes. *
The algorithm above is a good representation. Just note that the bold move indicates moving all inner right slices and the parenthesized move means moving all inner layer right slices down which contain wings that DO NOT need to be affected.

Oh, and the entire outline of this algorithm on the 6x6x6 (and all even cubes >= the 6x6x6) is:

z' 3f' 2L' 3u' 
3b2 3u'
3u 3b2
3u' 2R 
3R
3u' 2R' 3u 
3R'
3u 3b2 3u'
2R' 
3u 3b2
3u 2L 3f z
= [z' 3f' 2L' 3u' : [3b2 3u': [3u 3b2 3u': 2R [3R: 3u' 2R' 3u ] ] (2R') ] ]

More compactly,
= [z' 3f' 2L' 3u' 3b2 3u': [3u 3b2 3u': 2R [3R: 3u' 2R' 3u ] ] (2R') ]
(The 3R conjugate represents all slices containing wings that DO NOT need to be affected).

As you can see, the interior conjugate in this algorithm, unlike the "Holy Grail" Alg, is not around the quarter turn. Rather, it is nested into the original commutator. (Hence the commutator is _no longer present_ for the general algorithm.)


----------



## mrCage (Sep 12, 2011)

Why not just use R B - [l' U2]2 F2 l' F2 r u2 r' U2 l2 - B' R' for case 3. Utilizing the "holy grail of 2-cycle" ...

Per

Cmowla, could you summarise all parity/double parity algorithms you have discovered/derived for 4x4x4 ... in standard notation with no x, y or z? Diagrams would be most welcome.

Links to Garron's or Randelshofer's applet would be supercool.

Thanks for all your work 

Per


----------



## Christopher Mowla (Sep 12, 2011)

mrCage said:


> Why not just use R B - [l' U2]2 F2 l' F2 r u2 r' U2 l2 - B' R' for case 3.


Yeah, that does work well for btm. In this thread, I was just trying to get less q moves for cases, and the algorithms which are 16 btm that I added are 2q less than that combo. The reason I posted this one is because it has even less btm than even that good combo you mentioned.



mrCage said:


> Cmowla, could you summarise all parity/double parity algorithms you have discovered/derived for 4x4x4 ... in standard notation with no x, y or z? Diagrams would be most welcome.
> 
> Links to Garron's or Randelshofer's applet would be supercool.
> 
> ...


You're welcome! I can do that! Now, did you just mean the algorithms that I considered significant enough to represent all others in their respective categories (for example, best move count in any of the 4 metrics, move set, etc.), or all algorithms I have posted everywhere on speedsolving? Also, did you want me to give other algorithms not posted on speedsolving? Do you want me to put the derivations for each or just the algorithm? When you say, "standard notation," do you mean WCA? If so, and you do want translations to cube sizes >= the 6x6x6, with the randomness of some of the algorithms, wouldn't it be better to use SiGN? However, if you meant for me to use WCA for all algorithm translations regardless, I can do that.


----------



## mrCage (Sep 13, 2011)

Hmmm. If you link to applets then the notation is given. As to what algs i only care about btm optimised. Any 2-cycle or double parity (when reduction method is followed).
If no applets then i prefer Rw, r,l, Lw etc. Otherwise it's up to you ... 

Per


----------



## Christopher Mowla (Oct 3, 2011)

*The Optimal Algorithm for Case 3 on Even Cubes Found?*

I'm still going to post all algorithms in one post, but for this post, I am going to show two more 15 btm algorithms for "case 3".


This first one is a much cleaner alg than the second I'll present.
 Fw2 Lw' Uw r' Uw' Lw Uw Lw' Dw' r' Dw Lw r Uw' Fw2 (17q, 15 btm)


Spoiler



*Derivation*


Spoiler



1) Commutator r Uw' Lw' Uw r' Uw' Lw Uw

2) Conjugate and quarter turn
Dw Lw
r Uw' Lw' Uw r' Uw' Lw Uw
Lw' Dw'
r' 

3) Shift
Lw' Uw r' Uw' Lw Uw
Lw' Dw'
r' 
Dw Lw
r Uw'

4) Conjugate once more
Fw2
Lw' Uw r' Uw' Lw Uw
Lw' Dw'
r' 
Dw Lw
r Uw'
Fw2


Translating to bigger cubes (even sizes only. Reason: the algorithm piece before step 3 can't can't even translate.).
I wrote the algorithm in SiGN notation and rewrote it as I usually do to insert the interior conjugates (in bold)

3f2 3l' 3u 2R' 3u' 3l 3u 3l' 
*3R'*
3d' 2R' 3d
*3R*
3l 2R 3u' 3f2

=3f2 3l' 3u 2R' 3u' 3l 3u 3l' *3R'* 3d' 2R' 3d 2-3r 3l 3u' 3f2 (18q, 16 btm)
(As usual, the bold move indicates the orbit which the wings does not need to be affected.)


*The Optimal Algorithm for Case 3?*


Spoiler



The second algorithm is even more revolutionary than the algorithm above and the one in the previous post because...(find (*))

Bw2 r Uw' Lw Uw r' Dw' r' Bw' r Bw r Bw' Dw Bw2 (17q, 15 btm)

*Derivation*


Spoiler



1) Commutator Lw' Uw r Uw' Lw Uw r' Uw'

2) Conjugate and quarter turn (this conjugation is pretty weird)
Bw r y'
Lw' Uw r Uw' Lw Uw r' Uw'
y r' Bw'
r

3) Shift
r Uw' Lw Uw r' Uw'
y r' Bw'
r
Bw r y'
Lw' Uw 

4) Uw' y = Dw'

r Uw' Lw Uw r' Dw'
r' Bw'
r
Bw r y'
Lw' Uw 

5) Get rid of y',
r Uw' Lw Uw r' Dw'
r' Bw'
r
Bw r 
Bw' Dw

6) Conjugate once more.
Bw2
r Uw' Lw Uw r' Dw'
r' Bw'
r
Bw r 
Bw' Dw
Bw2


Translating to bigger cubes (even sizes only).
I wrote the algorithm in SiGN notation and rewrote it as I usually do to insert the interior conjugates (in bold)

3b2 2R 3u' 3l 3u 2R' 3d' 2R'
*3R'* 
3b' (2R) 3b
*3R* 
2R 3b' 3d 3b2

Not only did the interior conjugates need to be around the quarter turn (parenthesized move), but we have a double merger here.

= 3b2 2R 3u' 3l 3u 2R' 3d' *2-3r'* 3b' 2R 3b *2-3r* 3b' 3d 3b2 (17q, 15 btm)

So in other words, the only difference between the 4x4x4 version and the translation to all other even cubes is the two bold moves in the 4x4x4 version (shown below) are all right inner layer slices, while the rest of the translation is as expected.

Bw2 r Uw' Lw Uw r' Dw' *r'* Bw' r Bw *r* Bw' Dw Bw2 (17q, 15 btm)

(*)Thus the lower bound for all even cubes for this case has been lowered both in quarter turns and half turns just in one algorithm!

It's a shame it can't translate two odd cubes only because the two + center pieces displaced by the quarter turn aren't restored.
The only adjustment that needs to be done to see this result on, say, the 7x7x7 is to convert the 3u' to 4u' and 3u to 4u.
3b2 2R 4u' 3l 4u 2R' 3d' 2-3r' 3b' 2R 3b 2-3r 3b' 3d 3b2


----------



## Christopher Mowla (Oct 6, 2011)

*The Optimal Algorithm for Adjacent Double Parity Found?*

When I made these two algorithms, I felt so stupid!:fp
I first found an 18 btm that _may_ be faster to execute than the current algorithms (you guys will have to tell me that), but then I just conjugated a little differently (as I felt led to be more efficient) and got a 16 btm. Both algorithms break my former record of 24q, and, according to my knowledge, no one has even created an algorithm like this which was less than 18 btm. Two major breakthroughs in one week!

[r2 F Rw' F': U2 r U2 r U2 r U2 r2] *(23q, 16 btm)*
[Uw' L' U r F: U2 r U2 r U2 r U2 r2] (23q, 18 btm)

Note that U2 r U2 r U2 r U2 r2 = r' r U2 r U2 r U2 r U2 r r, and, by my (best) outline of r U2 r U2 r U2 r U2 r, we can sacrifice one btm to execute instead:

[r2 F Rw' F': U2 r U2 r' Rw2 U2 r U2 Rw2] (17 btm)
[Uw' L' U r F: U2 r U2 r' Rw2 U2 r U2 Rw2] (19 btm), if that's faster.

For those who have been following this thread should see just by dissecting the algorithms why they work. If anyone needs me to elaborate, I can, however.


----------



## mrCage (Oct 6, 2011)

Very nice algorithm, particularly the 16 btm one, a conjugate!!

Notice how Stefan Pochmann's 7-turn permutation parity algorithm is also a conjugate : (Uu)2 (Rr)2 U2 r2 U2 (Rr)2 (Uu)2.
Or writtten out like so [Uw2 Rw2 U2: r2] in your preferred notation.

Yours and Stefan's algs will both generalize to any even sized cube (>2) ...

Stefan's other algorithm [Rw2 Fw2 U2: r2] works for ANY size cube, odd or even.

Per


----------



## Christopher Mowla (Oct 6, 2011)

Thanks!
Also, I can't see why my alg won't translate to odd cubes too, I mean, it's single slice turn based, and rarely do any of the algorithms I make depend on swapping _extra_ X-center pieces (one of the few exceptions is, for example, this 11 move "oriented" 2 3-cycle algorithm M2 U' r2 F2 r2 F2 U l2 u2 r2 u2). Stefan's algorithm [Rw2 Fw2 U2: r2] can be simply [Rw2 F2 U2: r2]. In the K4 thread, I have recently made two documents which have many 2 2-cycles which are also conjugates of r2. For example, 2_2-Cycles.txt in this post. Those algorithms are transferable to all size cubes too, and they are mostly useful for F3L in the case that both wings are not in the F3L dedge slot and they are unpaired somewhere on the cube. However, a small portion of the algorithms can be used for the last layer. One prime example is [Lw2 U F2 U: l2]. I'm not sure why Thom hasn't added that and other brief (probably optimal) 2 2-cycles I have posted (or attached) in that thread to his ELL page (the K4 Guide).

If the 4 move commutator, U2 r U2 r', wasn't in it (but that's the main ingredient!), this algorithm would conjugate r, similar to how the 2 2-cycle algorithms ^ conjugate r2. (Earlier in this thread, I edited one of my posts with a conjugate for a non center preserving adjacent double parity algorithm: [r2 U Rw' U R U: r'] (13 btm), however ).

The unabridged outline of my 16 btm algorithm is:

r2 F Rw' F'
*r'*
*r*
U2 r U2 r'
*r2 U2*
(r)
*U2 r2*
*r'*
*r*
F Rw F' r2
​, in which the black bold moves conjugate the quarter turn (in parenthesis). Their purpose is to align half of the center blocks in slice r back so that when the quarter turn is done, only half of the center pieces in slice r are unsolved, by which the r, r' conjugates (in green) swap same color centers with each other, and then we undo those conjugates for the double parity algorithm because at least one pair of wings needs to be paired such that both of its wings are "oriented." In this thread, I have called this step (the purpose of the red colored r', r conjugates) "shifting" the base algorithm, in this case, (r U2)5 U2.


----------



## mrCage (Oct 6, 2011)

By the way, did you come up with an efficient way to do the following: permute edges similar to this: r2 D2 l D2 r2, while preserving all the face centers? It is not part of any normal reduction solve scenario. But interesting for me and maybe others ...

Per

There is actually a shorter way to do one of the 3-cycles in your text file. (K4 algs)
[Rw:[F u F', U2]].

Shorter in qtm, but also less intuitive 

Per


----------



## Christopher Mowla (Oct 6, 2011)

mrCage said:


> By the way, did you come up with an efficient way to do the following: permute edges similar to this: r2 D2 l D2 r2, while preserving all the face centers? It is not part of any normal reduction solve scenario. But interesting for me and maybe others ...


Assuming the previous minimum was 13 btm, I did post a 12 btm about 2 months ago.


cmowla said:


> Here's a 12 btm checkerboard 4-cycle (for the 4x4x4 only)
> f2 M2 f2 l2 U2 r S2 r' S2 r' U2 r2


 It is f2 (l2 r2) f2 (l2 r2) + r2 U2 r S2 r' S2 r' U2 r2. Obviously the first piece is the reason why it doesn't work on any other cube size besides the 4x4x4.



mrCage said:


> There is actually a shorter way to do one of the 3-cycles in your text file. (K4 algs)
> [Rw:[F u F', U2]].


I am not aware that I have any 3-cycles in my text file (they are all 2 2-cycles to my knowledge).



mrCage said:


> (duplicate ... hmm ... bug???)


Assuming you are referring to the text file, I am not sure you mean I have the exact same algorithm or an algorithm does the exact same thing. Many of the algorithms do the same exact thing or a rotation of it in a different face. In that same post I provided Algs_Sorted.pdf in which I provided some organization and sorting of the algorithms within. That probably is much better to look off from than the text file (which is unsorted and unabridged). Also, I didn't use a computer solver to make these, so the only possible "bug" is my mistakes.


----------



## Christopher Mowla (Oct 7, 2011)

Just in case anyone is interested in seeing a relatively brief (possibly optimal) adjacent double parity algorithm that rotates only one outer layer face,


x' r2 U' Rw U (l' r) U2 r' U2 r' U2 r' U2 l r U' Rw' U r2 x

=[x' r2 U' Rw U: (l' r) (U2 r')3 U2 l r](25q, 19 btm)

Outline
x' r2 U' Rw U (l' r)
U2 r' U2 r' U2 r' U2 r2
(l r') U' Rw' U r2 x
(The main idea is to use (l' r) as set up moves to move the pieces in F to U before we carry out the normal conjugation so that we can avoid turning those faces. This should not be a new idea to those who read and understood my second post in this thread.)

In addition, here are some algorithms in <U, l, r> like the one above, but these are for the other two adjacent 4-cycle cases:

 Rw U2 M2 U' (l r') U2 r' U2 r2 U2 r' U2 l' U M2 U2 Rw' (18 btm)
l' U2 M2 U (l' r) U2 r U2 r2 U2 r U2 l U' M2 U2 l (18 btm)

And here is another adjacent double parity that, despite that it permutes centers differently than most existing algorithms, it's still translatable to all size cubes. In addition, it is pretty brief in the qtm metric too.
[x Rw F2 U' Rw R: U' r U2 r U2 r U2 r2 U'] (25q, 19 btm, 30 qtm)​

And here is my Collection of Algorithms.



Spoiler: Comments



I admit this thread has a lot of information (mostly repetitive but with alternate routes and for various cases). Therefore I have rewritten most of the algorithms I have posted on the SS forums so that no moves are canceled as a summary of this thread. I have deleted my post full of algorithms because I have put them in a document instead. I have rewritten most of them as a representation (extra moves are often present) which is a much simpler form to understand: you can speed optimize and cancel the extra moves yourself. (The document has been attached to the end of the post).

The algorithms are all for the 4x4x4 and larger cubes. I have rewritten most of these algorithms to hopefully show that they are not gibberish: most of them have the same form. I have removed cube rotations from the majority of the algorithms to simplify things, however, feel free to add in cube rotations to make execution faster. Some algorithms I originally said were only transferable to the 4x4x4 ended up being transferable to all even cubes or all cube sizes for that matter. Some algorithms I originally said were only transferable to all even cubes are actually transferable to all size cubes. (And so forth). I made some new minimal center disruption 2-corner swap algorithms too.


To make seeing the algorithms in my document a lot easier for everyone, I have also attached the CubeTwister file to this post with the notation I described in the document. For those who are not familiar with CubeTwister already, all you do is download it from here and install. Then:


Spoiler: Instructions



1) Run CubeTwister
2) File-> Open (then find and select the file "Algorithm Factory.xml")
3) Click on "Scripts"
4) Select cube (by left clicking the * looking button on the right) (choose anyone you wish, but for the purposes of forming parity algorithms, choose either 4x4x4 super,5x5x5 super, 6x6x6 super, or V-Cube 7 Super)
5) Select notation (by left clicking the * looking button on the right). The notation which matches the algorithms in the document is called "4x4x4 Notation", "5x5x5 Notation", "6x6x6 Notation", and "7x7x7 Notation" for the 4x4x4 through 7x7x7, respectively.
6) Copy the algorithms from my document (Ctrl + C) and paste (Ctrl + V) into the script box.
7) Left click the check button to see the animation.


Here's the .xml file.


----------



## mrCage (Nov 4, 2011)

A whopping, stunning collection. But what do i do with it? Haha.

Per


----------



## Christopher Mowla (Jan 3, 2012)

For the opposite wing edge swap case, I managed to get 1q less than my previous record.


Spoiler



Rw U' r Uw Lw' Uw' r Fw r Fw' r2 Uw Lw u' Rw' (16q, 15 btm)

*Derivation*


Spoiler



[1] Commutator: Uw Lw Uw' r Uw Lw' Uw' r'
[2] Conjugate 1x2x2 blocks into the r slice like so (and add the quarter turn)
Fw' r2
Uw Lw Uw' r Uw Lw' Uw' r'
r2 Fw
(r)
[3] Shift
Uw' r Uw Lw' Uw' r'
r2 Fw 
r
Fw' r2 Uw Lw 
[4] Conjugate one last time:
Rw u
Uw' r Uw Lw' Uw' r' r2 Fw r Fw' r2 Uw Lw 
u' Rw'

On the 6x6x6, (17q, 16 btm)
3r U' 2R 3u 3l' 3u' 2R
(3R2)
3f 2R 3f'
(3R2)
2R2 3u 3l 2-3u' 3r'


This algorithm is not anywhere near as fast as r U2 r U2 F2 r F2 l' U2 l U2 r2 (19q, 12btm), but notice that the average of quarter turns and half turns is the same in both algorithms (for the 4x4x4 translation). (16q+15btm)/2 = (19q+12btm)/2 = 15.5. So if you're like me and consider the optimal algorithm to have the lowest average of half turns and quarter turns, this algorithm is equally as optimal as the well known optimal algorithm on the 4x4x4 cube.


I would like to show one more interior setup move lesson with two different examples.


Spoiler



Up to this point, I have only shown that it is necessary to insert interior conjugates to make translations of wide turn based algorithms to larger cubes possible. For example, the (3R2)s in the 6x6x6 translation in the previous spoiler of this post are interior conjugates. Without them, some center pieces will be discolored (just omit them and see what happens. 

These interior conjugates involve a separate wing edge orbit, but they do not have to for all algorithms.

*Example 1*


Spoiler



Here's an example for the 4x4x4.
Consider the following 17q edge flip algorithm that discolors only two X-center pieces.
Fw' E' y' l' Uw Rw' Uw' l Uw y Lw Dw r' Dw' Lw' y' Rw u' D' Fw (17q, 17 btm)

If you have watched and understood Part IV of the "Holy Grail" (HG) Algorithm derivation (I mentioned this video in this post) then you can make sense of inserting these interior conjugates in parenthesis below:

Fw' E' y' l' Uw Rw' Uw' l Uw y Lw
(D R2 D')
Dw r' Dw'
(D R2 D')
Lw' y' Rw u' D' Fw

You should also be able to verify that the inverse of them ( (D' R2 D) instead of (D R2 D') ) also follows the 3 criteria I listed at the end of the video.

These interior conjugates also work for translation to the 6x6x6.
3f' 4e' y' 2L' 3u 3r' 3u' 2L 3u y 3l
D R2 D'
3d 2R' 3d'
D R2 D'
3l' y' 3r 2-3u' D' 3f 

So no slices of another orbit of wings is needed for the translation in this particular case. We still use a separate orbit (the outer layer), but I thought that this example was a crucial one to show.


*Example 2*


Spoiler



Here is an example of interior conjugates in a more conventional type of algorithm. It is a lot more moves, but it is an excellent example.


Spoiler



For simplicity, I chose to use the "standard edge flip alg."
r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2

We can create a "problem" for us to solve by simply moving the first U2 before the last B2.
r2 B2 l U2 r' U2 r U2 F2 r F2 l' U2 B2 r2
Now two 1x2 center blocks are discolored. By watching Part IV of the HG edge flip alg. derivation and with patience, you should be able to verify why the following choice of interior conjugates work.

r2 B2 l U2 r' U2 r U2 
*D' R' D l' D2 l D' R D* 
F2 r F2
*(D' R' D l' D2 l D' R D)'* 
l' U2 B2 r2








*Summary of the Structure of Symmetrical Algorithms and Introduction to Non-symmetrical Algorithms*


Spoiler






Spoiler



All of the algorithms in this thread so far are what I call "symmetrical" algorithms.

Symmetrical Algorithms - I don't know of a better term to describe them yet, but I call an algorithm symmetrical if and only if its first and last moves (in the canceled move form) are inverses of each other. Sometimes non-symmetrical algorithms' first and last moves are inverses of each other, but seeing the algorithm after removing the first and last moves might be gibberish (it's not a good idea to view them as a symmetrical algorithm). Non-symmetrical algorithms are basically adding multiple algorithm pieces together to accomplish a specific task and possibly shifting the algorithm afterward, while symmetrical algorithms can do the same thing (they have a non-symmetrical base), but they have set up moves (not just shifts alone) on the outside to bring the pieces affected by the inside into desired locations. So in short, creation of symmetrical algorithms requires more testing of a lot of different paths in both creation of the base and outer-most setup moves, whereas the creation of non-symmetrical algorithms requires having knowledge of forming different pieces individually and knowing how to combine them. 

They are algorithms which one can construct by 1) having a commutator or some algorithm that cycles 3 equivalent blocks of pieces, 2) conjugating that algorithm to move all blocks into the r slice (connected), 3) apply a quarter turn, 4) Possibly shift all of that (the "base"), and finally *5) conjugate it to a "pure" algorithm*.

Basically, symmetrical algorithms are of the form:
C
B
A
(commutator)
A'
(quarter turn)
B'
C'

Where:
A is the conjugates to move all pieces into the r slice.
B is the conjugates which shift the "base" (because shifts are just conjugating the algorithm with the inverse of the first move)
C is the final conjugates to make a "pure" algorithm.


Here is a set of "tools" useful to make symmetrical single slice turned based algorithms: a list of three 1x1x3 cycle algorithms for single slice turn based parity algorithms.


Spoiler



I have used the first three in this thread. I have used cube explorer to generate the majority of the 10 to 12 move algorithms, and most of the 8 move solutions I have seen elsewhere before, while the rest I found by hand.

Note that all of the following have the exact same effect on the cube.


Spoiler



F' r' F U2 F' r F U2 = [F' r' F, U2] (8)
F r' F' U2 F r F' U2 = [F r' F', U2] (8)
U2 l U2 r' U2 r U2 l' = [U2, l U2 r'] (8)
U2 l U2 l' B2 r B2 r' (8)
U2 r B2 r' B2 l U2 l' (8)
U' b U r' U2 r U' b' U' = [U' b U: [r' U2 r, (U' y)]] (9)
U f U' r' U2 r U f' U = [U f U':[r' U2 r U2, (U y')]] (9)
r' F' u F U2 F' u' F r U2 = [r' F' u F u', U2] (10)
r' F d F' U2 F d' F' r U2 = [r' F d F' d', U2] (10)
r l' B2 r D2 r' D2 l B2 r' (10)
r l' B2 l B2 r' B2 r B2 r' (10)
r' l F2 l F2 l' U2 r U2 l' (10)
U2 r2 l' D2 r' D2 r' l2 U2 l' (10)
U2 l2 r' F2 r' F2 r2 l' U2 l' (10)
U2 l U2 l2 r D2 r D2 r2 l (10)
U2 l U2 r2 l F2 r F2 l2 r (10)
U f U' B2 U f' U l U2 l' B2 (11)
r l' B2 l B2 r2 l U2 r U2 l' (11)
r l' B2 l B2 l' D2 r D2 r2 l (11)
r' l F2 r U2 r' U2 l F2 r l2 (11)
r' l F2 l F2 r l2 B2 r B2 r' (11)
r' l F2 l F2 r' F2 r F2 r l2 (11)
r2 l2 D2 r F2 r' F2 l D2 r2 l (11)
r2 l2 D2 l D2 r l2 U2 r U2 l' (11)
r2 l2 D2 l D2 l r2 B2 r B2 r' (11)
r2 l2 D2 l D2 r' D2 r D2 r2 l (11)
r2 l2 D2 l D2 l' F2 r F2 r l2 (11)
l' F2 r' F2 l U2 l' F2 r F2 l U2 (12)
U f U r l' B2 r' B2 l U f' U (12)
M D' r' D M' U2 M D' r D M' U2 = [M D' r' D M', U2] (12)
r' D' r' D r U2 r' D' r D r U2 = [r' D' r' D r, U2] (12)
Lw2 F' r' F Lw2 U2 Lw2 F' r F Lw2 U2 = [Lw2 F' r' F Lw2, U2] (12)
U' R U r' U' R' U2 R U r U' R' U' = [U': [R U r' U' R', U2]] (13)
U L U' r' U L' U2 L U' r U L' U = [U: [L U' r' U L', U2]] (13)
r' U2 r U2 r' F2 U b U' F2 U b' U' r (14)
l' U f U' B2 U f' U' B2 l r' U2 r U2 (14)
[F l' F2 l F2 r' F', U2] (16)
[l' U2 l U2 r' U2 r, U2] (16)
r' U R' U' r U' R U r' U' R' U2 R U r U2 (16)
l r' U' R' U' l' U R U r U' R' U' l U R U l' (18)
F' R F Rw' D' Rw' D Rw U2 Rw' D' Rw D Rw F' R' F U2 = [F' R F Rw' D' Rw' D Rw, U2] (18)
D F' R' D' r' R D F U2 F' D' R' r D R F U2 D' = [D: [F' R' D' r' R D F, U2]] (18)


I made all of those algorithms with one simple idea.


Spoiler



Just completely isolate one 1x1x3 block into a face:
Example 1:  l U2 r' (used to make U2 l U2 r' U2 r U2 l') (the isolated 1x1x3 block is in U face, despite that the U face isn't solved itself)
Example 2: F' r' F (used to make F' r' F U2 F' r F U2) (the isolated 1x1x3 block in U and D faces).
Example 3: Lw2 F' r' F Lw2 (used to make [Lw2 F' r' F Lw2, U2]) (the isolated 1x1x3 block in U face).

Also, note that you can even start out with a broken 1x1x3 block and still end up with a good three 1x1x3 block cycle algorithm.

Example: r' D' r D r. There is a broken up 1x1x3 block in the U face.
If we 
1) make this a commutator by letting X = r' D' r D r (what we have already) and Y = U2 (the face that the 1x1x3 block is in--we rotate the face twice to completely replace all 3 cubies in the commutator),
r' D' r D r
U2
r' D' r' D r
U2
and then 2) shift the commutator half way (or just invert the middle r moves)
r' D' r' D r
U2
r' D' r D r
U2
Then viola, we have a good three 1x1x3 block cycle algorithm. It turns out to be equivalent to U2 l U2 r' U2 r U2 l'.

What are these good for? I guess just for exploration.
For those who don't know much about making parity algorithms yet, you can substitute any one of the algorithms in the above spoiler into the "standard dedge flip algorithm:"

r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2 by breaking it up to:
r2 B2 U2 l U2 r' U2 r U2 l' l F2 r F2 l' B2 r2 and inserting one of the algorithms in the above spoiler in place of U2 l U2 r' U2 r U2 l'

That is,
r2 B2 <Insert Here> l F2 r F2 l' B2 r2.





I have a list of wide turn based three block swappers in the post after my next one.


I'm sure brief wide turn based non-symmetrical algorithms exist, which are pieces of different algorithms all done continuously until the algorithm is complete. That is, no outer most setup moves are present.

As a start, we can actually use interior setup moves to do make wide turn based non-symmetrical algorithms. Note that this is an indirect approach and does not yield short algorithms by any means.

A Non-Symmetrical Wide Turn Based Diagonal Wing Edge 2-Cycle Exchange
*Derivation*


Spoiler



[1] Let's take the first base in the list of 11 in this post.
Fw Rw2 r Uw Lw' Uw' r' Uw Lw Uw' Rw2 Fw' r'

[2] Shift: (this is the HG edge flip alg's set up)
Lw' Uw' r' Uw Lw Uw' Rw2 Fw' r'
Fw Rw2 r Uw

[3] Now we will make a non-symmetrical diagonal wing edge swap algorithm from it.
If we were going to make this a "pure" symmetrical algorithm, all we would have to do is conjugate the entire algorithm by one move:
Bw
Lw' Uw' r' Uw Lw Uw' Rw2 Fw' r'
Fw Rw2 r Uw
Bw'

That would easily enable us to not discolor any X-center pieces. However, we are trying to do the same thing WITHOUT CONJUGATING THE OUTSIDE.

Therefore, we take the base and figure out where we can apply interior conjugates (if we can at all). It turns out that the following interior conjugates do the trick.

But first, let me adjust this base with cube rotations to match the "Holy Grail of Edge Flip Algorithms"'s set up exactly (for convenience for those who want to watch the video derivation along with reading this)

Lw' Uw' r' Uw Lw Uw' x2 Rw2 Bw' r'
Bw x2 Rw2 r Uw
=
Lw' Uw' r' Uw Lw Uw' Lw2 Bw' r'
Bw Lw2 r Uw

Now, we rewrite this base and include the interior conjugates:

Lw' Uw' r' Uw Lw Uw' Lw2
*F Bw u Bw' F'*
Bw' r' Bw
*(F Bw u Bw' F')'*
Lw2 r Uw
=Lw' Uw' r' Uw Lw Uw' Lw2 F Bw u Bw2 F' r' Bw2 F u' Bw' F' Lw2 r Uw
As you can see, it's quite long, but it is an example of a wide turn based non-symmetrical algorithm


----------



## AvGalen (Jan 8, 2012)

cmhardw said:


> Wow Chris! Thank you so much for this write-up! I have only watched the derivation of the "standard" algorithm, both parts, and it is amazing to have an idea of how this works. I will want to go through the second part a few times to make sure I fully understand your application of setup turns, but this is amazing! I can't wait to go through the rest of the videos for the other parity algs!
> 
> Chris


 Somebody explaining parity algs to Chris is like somebody explaining how to create life to God!


----------



## Christopher Mowla (Jan 25, 2012)

mrCage said:


> Very nice algorithm, particularly the 16 btm one, a conjugate!!


I don't know why someone hasn't posted this idea before, but here are 4-cycle conjugates.

* 4-Cycles for all Even Cubes*


Spoiler



All in one slice
[Uw2 r' u2 l2 S': u] (17,11)
[f2 l' u2 l2 S' : u] (17,11)

All in once slice (adjusted)
[Uw2 Rw' u2 Lw2 S': u] (17,11)

All diagonal
[Uw Fw2 l' u2 Lw2 S' : u] (19,13)

Checkerboard
[f2 l' u2 Lw2 S' : u] (17,11)*
[Uw2 Fw2 l' u2 l2 S': u] (21,13)

Adjacent checkerboard
[L2 Fw' f' l' u2 Lw2 S' : u] (21,15)*

Other Adjacent 4-cycle case:
[L' Fw' f' l' u2 Lw2 S' : u] (19,15)*

Adjacent double parity
[Uw2 F' D2 F u f2 l' u2 Lw2 S' : u] (31,21)
[Bw' R U b' R' Bw' Uw2 Rw' u2 l2 S': u] (29,23)
[d2 F' Uw L Uw M Uw2 r' u2 Lw2 S': u] (31,23)

Last layer cases:
[u2 Rw' u2 l2 S': u] (19,11)*
[R' U Bw' Uw2 Rw' u2 l2 S': u] (23,17)

Since these are conjugates, one could technically use the general idea to make 4-cycle algorithms for every possible case. I just listed some of them.

To translate these to larger even cubes,
1) Convert all inner layer slices except for the quarter turn to moving all inner layer slices on the side of the cube it occurs.
2) Convert S to moving all inner layer slices.
3) Convert all wide turns to moving half of the cube (outer block turn).
4) N slices used for the quarter turn will affect N orbits of wings. 

For example, for the checkerboard case:
[2-3f2 2-3l' 2-3u2 3l2 s' : 3U]

(Reverse the direction of the quarter turn to get the 4-cycles to go in the other direction.)


The * algorithms are, I believe, the new upper bound for even cubes in btm and in block quarter turns. (For even cubes, of course).

_You can make 2 2-cycles from all of these algorithms just by making the quarter turn a half turn._


It turns out that "The Holy Grail" Edge Flip Alg. is not optimal for even cubes. I found an algorithm that is 19q/18 btm for all cases on even cubes. Like the conjugates above, at least two + center pieces are discolored at best (it does not work for odd cubes).

Modeled on the 6x6x6,

Inner orbit: [3l e 3d: [3d, 3b' 3R' 3b] [2-3r 3d: 3R'] ] (19,18)
Outer orbit: [3l e 3d: [3d, 3b' 2R' 3b] [2-3r 3d: 2R'] ] (19,18)

We can add one conjugate to this algorithm to make it work on odd cubes, but that gives us a (21,20) solution for odd cubes.
[3l S 5e 3d: [3d, 3b' 3R' 3b] [2-3r 3d: 3R'] ] (21,20)
or giving us an average of 20.5 for odd cubes, which is definitely more than the "Holy Grail" alg's average.

So even cube's minimum average of block quarter turns and block half turns has been lowered to 18.5, while the minimum average for odd cubes remains at \( \frac{\left\lfloor \frac{n}{2} \right\rfloor }{2-2^{\left\lfloor \frac{n}{2} \right\rfloor }}+19.5 \).

and therefore the "Holy Grail" is still the only existing algorithm that has an average less than 19.5 for the single edge flip case on all cube sizes, odd and even.


----------



## Christopher Mowla (Feb 25, 2012)

Here are new results I found since my last post (well, most of the 2-gen material I found in the past, but I didn't post it until now).



Spoiler: Non-Symmetrical Wide Turn Based Algorithms Covered in Depth (and more)



I have done some more searching in the wide turn based non-symmetrical algorithm category of odd parity algorithms and have found shorter non-symmetrical solutions to all last layer 2-cycle cases than I made previously (before this post, I only posted one for the diagonal case, however.)
In the post before my last one, I mentioned that we can use interior conjugates to make non-symmetrical algorithms. I was correct, but I didn't realize until I started searching for shorter solutions that all cyclic shifting does for us when we make a base for symmetrical algorithms is it conjugates the quarter turn. Taking this into account, I started to find some interesting algorithms only focusing on conjugating the quarter turn after I moved all 3 1x2x2 blocks (referring to the 4x4x4, of course) into the r slice (or in the process of moving all 3 1x2x2 blocks into the r slice).

Let me first just give a comparison of an optimal (in btm) non-symmetrical algorithm for single slice turns.

The best readily available example is Frédérick Badie's Algorithm (found with Cube Solver).
F2 r2 F2 U2 r U2 r' U2 r2 F2 l F2 l' U2 r (25,15)

I will use this algorithm to illustrate what I am about to present for wide turn based algorithms (my algorithms are in no way related to this algorithm in structure, but...)

Split it up like so:
F2 r2 F2 U2 r U2 r' U2 r' U2
U2 r' F2 l F2 l' U2 r 

The first portion, F2 r2 F2 U2 r U2 r' U2 r' U2, ultimately swaps the two wings in UF, and, at this point in the algorithm, the right wing is in its permanent location already (it's a 4-cycle needing a 3-cycle to finish it/make it a 2-cycle).

The second part of the algorithm, U2 r' F2 l F2 l' U2 r, is a three 1x1x3 block cycle to finish off the algorithm.

If we compare the first piece of that algorithm to, say, [Uw Lw Uw' r Fw2 Lw' Fw F R' F': r], we see that both algorithm pieces induce an odd permutation in the cube, place one wing edge piece into its compliment's location, and leave 3 complete blocks with _n_ - 1 pieces.

Look similar?

Those who know 1x2x2 block cycle algorithms can easily say that the following commutator finishes the job.
[Uw Lw Uw' r Fw2 Lw' Fw F R' F': r] [Uw Lw Uw', r']

The Method
You can either create the three block cycle first or the other piece (the conjugate of the quarter turn). In my opinion, it is much easier to find shorter solutions by starting with a three block cycle algorithm of choice and then adding conjugates to the quarter turn which will both solve back two wing edges and half of the center pieces in slice r, as well as place a wing edge of choice to swap with the original isolated one. When I say "easier," it's actually not as simple to do this in that direction (starting with a three block cycle), but you can avoid having to guess which route is best to take when conjugating the quarter turn first so that you can add the shortest 3 block cycle algorithm as possible (as well as one in which there are move cancellations).

I made the above wide turn based algorithm, [Uw Lw Uw' r Fw2 Lw' Fw F R' F': r] [Uw Lw Uw', r'], by first starting with [Uw Lw Uw', r']' = [r', Uw Lw Uw'] (I inverted it only to illustrate a comparison with Frédérick Badie's algorithm).

_Note that I did not try to translate the wide turn based non-symmetrical algorithms to any other cube size or form any for all cube sizes, but I am sure some of the algorithms can be easily adjusted to do so (it most likely will cost more moves, however)_.

*Route 1: Starting with the quarter turn conjugate (not recommended).*


Spoiler



To make matters easiest, I will list the briefest set of conjugates I found. 
[Lw' Uw2 F' u Bw' Dw': l] (15,13)
[Lw' Uw R' U' Rw' r' Fw: d] (15,15)
[Lw' Uw R' Uw u r' Fw': d] (15,15)
[Bw Rw' l' B l' Bw Uw: r'] (15,15)
[Lw' u Lw2 Fw U R' U': r] (17,15)
[Bw l' B l' Lw' Bw2 Dw: r'] (17,15}
[Lw' Uw R' u Dw Bw2 Lw': f] (17,15)

_As you can see already, assuming that there are no move cancellations between the conjugates above and a three 1x2x2 block cycle to complete the 2-cycle ("finish the job") AND assuming that the three 1x2x2 block cycle algorithm which matches the conjugate is only 8 quarter turns, there is a minimum of 15 + 8 = 23q. So this method is not nearly as efficient as the symmetrical wide turn based algorithms I have been presenting for the past couple of years._

The shortest possible conjugate (and it is unique as well) for the edge flip like those above, [Lw' B' U R': f] (9,9). If someone can find a 3-cycle piece that matches with it, an 18q might be possible.

Here are three conjugates which are two quarter turn moves longer: (none of these follow the example of the set of 7 conjugates I first showed). 
[Rw' Fw2 D' U': l] (11,9)
[Rw U R B' U: r] (11,11)
[Uw L r F' Dw: r] (11,11)

Procedure
Study only the inner layer slice for which the extra quarter turn is applied for at least one of the first 7 conjugates I listed above (not the three directly above) (one should be enough to see the desired setup). Because I linked them to alg.garron.us, let the front face be green and the top face be white of the Rubik's color scheme (to match the alg.garron.us applet's default color orientation).

Let's say we wanted to study the first (and shortest) route I listed, [Lw' Uw2 F' u Bw' Dw': l].
Executing all of the moves before the quarter turn, Lw' Uw2 F' u Bw' Dw', we can see that this setup has the following properties:

(1) The two wings ultimately to be exchanged (once the three 1x2x2 block cycle algorithm is applied) are adjacent to each other in the inner layer slice.
(2) One of the two blocks which contains one of the wings to be swapped by the overall algorithm is complete.
(3) The other half of the slice which we are conjugating (in this case, slice l) is composed of two complete blocks.
(4) The colors of the two center pieces in the single incomplete 1x2x2 block need to correspond to the other block which contains the wing edge you wish to swap the wings with. "Correspond" as in, if you move one of the blocks to the other (and vise versa) by moving the inner layer slice they are both in, the same color centers will be in the locations of both blocks.

Notes about the conditions:
Conditions (2) and (3) need to be verified using a supercube. So, the three complete blocks in slice l are complete, not only color wise, but also supercube wise. This is VERY important. If they are only color complete but not supercube complete, it will not work. (The constraints are VERY strict). The three complete blocks can be ANY of your choice.

Direction of the quarter turn
Technically, you can move the quarter turn in either direction, but choose to move in the direction so that, the completed block which swaps wings with an incomplete block goes towards that incomplete block (just see the examples I provided in that set).
_You should see why we need to move the quarter turn in this direction once I go over "route 2."_

When you first start out, don't worry about how many moves you are using (please use cubetwister or some virtual cube software which can record the moves you do: it makes doing this so much easier). Just experiment, keeping the setup of what you must do in mind. CAUTION: Don't forget that I said the three complete 1x2x2 blocks need to be complete on a supercube, not just complete on a 6-color cube.

Obviously, once you have made a conjugate, you can cycle the three 1x2x2 blocks which clearly need to be cycled in order to complete the 2-cycle.

*Tools*
If I didn't make a mistake, there are only 7 positions in which 8 quarter turn/8 half turn three 1x2x2 block cycles can reach. In addition, if I am not mistaken, some of the cases have two UNIQUE algorithms (taking all 4x4x4 wide turn transformations into account), while some only have one. However, we need to do transformations of them using wide turn equivalences of the 4x4x4 to get corresponding algorithms for odd cubes. Note that capital W means to do a triple layer turn on the 5x5x5 (include the central slice on odd cubes with the wide turn, in general). This is of no concern, however, because I wrote equivalences of all of these three 1x2x2 block cyclers to only have regular wide turns. Many cannot be expressed as a commutator unless a cube rotations are included (which I didn't include).

Case 1
Alg 1.
Rw' Fw' Rw b' Rw' Fw Rw b (even cubes only)
Rw' FW' Rw b' Rw' FW Rw b = Rw' Bw' Dw b' Dw' Bw Rw b
RW' Fw' RW b' RW' Fw RW b = Lw' Uw' Lw b' Lw' Uw Lw b
RW' FW' RW b' RW' FW RW b = Lw' Dw' Bw r' Bw' Dw Lw b
Alg 2.
b Lw Fw' Lw' b' Lw Fw Lw' (even cubes only)
b Lw FW' Lw' b' Lw FW Lw' = b Lw Bw' Uw' b' Uw Bw Lw'
b LW Fw' LW' b' LW Fw LW' = b Rw Uw' Rw' b' Rw Uw Rw'
b LW FW' LW' b' LW FW LW' = b Rw Dw' Fw' r' Fw Dw Rw'

Case 2
Lw' b Lw Fw' Lw' b' Lw Fw (even cubes only)
Lw' b Lw FW' Lw' b' Lw FW = Lw' b Lw Bw' Uw' b' Uw Bw
LW' b LW Fw' LW' b' LW Fw = Rw' u Rw Fw' Rw' u' Rw Fw
LW' b LW FW' LW' b' LW FW = Rw' u Rw Bw' Dw' r' Dw Bw

Case 3
r' Dw r Uw r' Dw' r Uw' (even cubes only)
r' DW r Uw r' DW' r Uw' = r' Uw f Uw f' Uw' r Uw'
r' Dw r UW r' Dw' r UW' = r' Dw r Dw b' Dw' b Dw'
r' DW r UW r' DW' r UW' = r' Uw f Dw r' Uw' b Dw'

Case 4
Uw' Rw d' Rw' Uw Rw d Rw' (even cubes only)
UW' Rw d' Rw' UW Rw d Rw' = Dw' Fw d' Fw' Dw Rw d Rw'
Uw' RW d' RW' Uw RW d RW' = Uw' Lw b' Lw' Uw Lw b Lw'
UW' RW d' RW' UW RW d RW' = Dw' Bw r' Bw' Dw Lw b Lw' 

Case 5
Alg 1.
Rw' Fw' Rw b Rw' Fw Rw b' (even cubes only)
Rw' FW' Rw b Rw' FW Rw b' = Rw' Bw' Dw b Dw' Bw Rw b'
RW' Fw' RW b RW' Fw RW b' = Lw' Uw' Lw b Lw' Uw Lw b'
RW' FW' RW b RW' FW RW b' = Lw' Dw' Bw r Bw' Dw Lw b'
Alg 2.
Uw' Rw d Rw' Uw Rw d' Rw' (even cubes only)
UW' Rw d Rw' UW Rw d' Rw' = Dw' Fw d Fw' Dw Rw d' Rw'
Uw' RW d RW' Uw RW d' RW' = Uw' Lw b Lw' Uw Lw b' Lw'
UW' RW d RW' UW RW d' RW' = Dw' Bw r Bw' Dw Lw b' Lw'

Case 6
Alg 1.
Fw d Fw' Uw Fw d' Fw' Uw' (even cubes only)
Fw d Fw' UW Fw d' Fw' UW' = Fw d Fw' Dw Rw d' Rw' Dw'
FW d FW' Uw FW d' FW' Uw' = Bw r Bw' Uw Bw r' Bw' Uw'
FW d FW' UW FW d' FW' UW' = Bw r Bw' Dw Lw b' Lw' Dw'
Alg 2.
Uw' b' Dw b Uw b' Dw' b (even cubes only)
UW' b' Dw b UW b' Dw' b = Dw' r' Dw r Dw b' Dw' b
Uw' b' DW b Uw b' DW' b = Uw' b' Uw r Uw r' Uw' b
UW' b' DW b UW b' DW' b = Dw' r' Uw f Dw r' Uw' b

Case 7
Uw Lw' Uw' r' Uw Lw Uw' r (even cubes only)
Uw LW' Uw' r' Uw LW Uw' r = Uw Rw' Fw' r' Fw Rw Uw' r
UW Lw' UW' r' UW Lw UW' r = Dw Fw' Dw' r' Dw Fw Dw' r
UW LW' UW' r' UW LW UW' r = Dw Bw' Lw' d' Lw Bw Dw' r

Here are some examples of 2-cycles I made choosing to use the conjugate first and then adding a commutator (or conjugated commutator = commutator as well) to finish off the algorithm.

*Single Edge Flip 2-Cycle Case*
[Lw' Uw2 F' u Bw' Dw': l] [Rw: [b' Rw b, Lw]] (25,21)
[Uw Rw' Uw2 l Uw' F' L F: r] [Dw b' Dw', Fw2] (26,22)
[Lw' Uw2 F' u Bw' Dw': l] [Rw' Uw: [d', Rw' Uw' Rw]] (24,23)

*Diagonal 2-Cycle Case*
[Fw' Uw' Lw D' Lw': b'] [Fw': [Uw Lw2 Uw', r']] (21,18)

*Adjacent 2-cycle Case 3*
[Uw Rw' Uw2 l Uw': r] [Uw r' Uw', Fw2] (19,16)
[Fw' Uw' Dw' f' Dw: b'] [Fw': [Uw Lw2 Uw', r']] (19,16)


*Route 2: Starting with the three block cycler and conjugating the quarter turn*


Spoiler



Procedure: 
[1] It’s ideal to start with a commutator in which two of its 1x2x2 blocks are already in the same slice and are adjacent to each other (or if not, very close to it).
[2] Do moves to bring the third 1x2x2 block into the same slice as the other two (if none of the 1x2x2 blocks are in the same slice, then you need to move two of them into the same slice as one of them). If you desire to have shorter algorithms, you need to simultaneously do at least a portion of step [3] here.
[3] Move appropriate center pieces into the only block in slice r which was not originally involved in the 3-cycle as well as the appropriate wing edge there too (if you want to create a higher cycle, you need to substitute a wing edge for one or more of the three blocks affected by the 3-cycle).
[4] Add quarter turn and reverse conjugates.

_Tip: It’s good to make the first moves of the conjugation the inverse of the last moves of the three 1x2x2 block cycler in order to have the most move cancellations._

*Example*
Assuming that green is the color of the front face, white is the color of the top face, and your cube has the Rubik’s color scheme,

[1] Start out with the commutator [Fw', Uw r' Uw'] = Fw' Uw r' Uw' Fw Uw r Uw'.
By following the “tip,” our first move should be, without the shadow of a doubt, Uw.
Fw' Uw r' Uw' Fw Uw r Uw'
Uw
It works out well for us because it joins two of the 1x2x2 blocks together in the same slice (slice r, in this case).

[2] We have a change to follow the “tip” again by choosing to execute r2 next because it will partially cancel with the second to last move of the commutator, r, and it will make way to place in the third block affected (the red and white one).
Fw' Uw r' Uw' Fw Uw r Uw'
Uw r2

Before I go any further, we need to visualize in which direction the quarter turn should move in. We can figure this out by asking ourselves, “In which direction will solve back half of slice r?” In fact, let's temporally delete the last move, r2, we just added.
Fw' Uw r' Uw' Fw Uw r Uw'
Uw
By looking at the cube, shouldn’t it be r'? Yep. REASON: the green and yellow 1x2x2 block in the front top needs to move to the front bottom.

[3] Now adding Fw' so that the red and white 1x2x2 block is placed in slice r.
Fw' Uw r' Uw' Fw Uw r Uw'
Uw r2 Fw'

[4] Since we know that the direction of the quarter turn is r', let’s go ahead and at that and undo the setup moves we added so far so that we can see which two wing edges swap with each other. This way, we can see which wing edge we can substitute with another to make an alternate 2-cycle but yet swapping the same center pieces.
Fw' Uw r' Uw' Fw Uw r Uw'
Uw r2 Fw' r' Fw r2 Uw'
They are the bottom red and green wing edge and bottom red and orange wing edge.

[5] Resuming from the end of step 3,
Fw' Uw r' Uw' Fw Uw r Uw'
Uw r2 Fw'
We locate the wings which we know are ultimately swapped in the 2-cycle. They are both in the top layer (in slice r of course). Notice that the red and green wing edge is in the 1x2x2 block which is incomplete. This is the wing edge which we can substitute with another to get an alternate 2-cycle. Any wing edge is permitted except those in slice r. In addition, any moves we do must not affect any piece in slice r except for the red and green wing edge piece in slice r.

Without even worrying about setting up the centers (so that they will not be discolored at all), let’s just grab the green and white wing edge in the top of slice L and carry out the conjugation of the quarter turn.
Fw' Uw r' Uw' Fw Uw r Uw'
[Uw r2 Fw' F' L F: r']
No magic at all. Clearly we can see exactly which wing edges are going to swap and we are no longer dependent on shifting or applying outer conjugates as when forming symmetrical algorithms (although these algorithms are longer, we have total freedom of which wings we swap as well as which centers we swap).

[6] Resuming to the end of step 3, we know that the quarter turn must be r' (see step 2 if you have forgotten) and so the colors of the center pieces of the green and orange 1x2x2 block in the top back quadrant of slice r are the colors we must have in the 1x2x2 block in the top front 1x2x2 block in slice r. REASON: r' brings the top back block to the top front block (I first explained this in Part 4 of the “Holy Grail” Edge Flip algorithm derivation—explanation on interior setup moves). Luckily we already have an orange X-center piece in the top front 1x2x2 block in the exact location the orange X-center pieces from the top back 1x2x2 block will be once the quarter turn r' is executed.

Thus we only need to substitute a green X-center piece in for the red center piece in the top front 1x2x2 block because that’s the color of the other X-center piece in the top back 1x2x2 block. We can only grab the green X-center piece in slices u and L, or the X-center piece in slices l and D. The two green X-center pieces in slice r CANNOT BE TOUCHED. The only restriction you have is to not tough slice r, or if you do, you restore it back EXACTLY (supercube speaking) before you close the conjugation of the quarter turn. The closest green X-center piece (move wise) is the one in slices u and L. So we can use f' L f to do that.
Fw' Uw r' Uw' Fw Uw r Uw'

Uw r2 Fw' f' L f
Closing the conjugation of the quarter turn, r', we have the same original 2-cycle as seen in Step 4, only no centers are discolored anymore (which should not be a shocker now). 
Fw' Uw r' Uw' Fw Uw r Uw'
[Uw r2 Fw' f' L f: r']

[7] To make an edge flip algorithm with this which does not color center pieces either, we may again start with:
Fw' Uw r' Uw' Fw Uw r Uw'
Uw r2 Fw'

In Step 5, we found out that the green and red wing edge in the top front is the only wing edge which can be substituted to make a 2-cycle. We also learned that the wing edge that that wing edge swaps with is the orange and green wing edge in the top back portion of slice r. Therefore, we need to substitute the green and red wing edge in the top front with the green and orange wing edge which is in slices u, B, and l. At the same time, in step 6 we found out that the X-center piece we need to substitute for the red X-center piece in the top front 1x2x2 block is the green one in slices L, u and b.

Keeping both of these things in mind, the following moves will satisfy both demands, as well as not affecting any pieces in slice r except for those two slots we are substituting for.
Fw' Uw r' Uw' Fw Uw r Uw'
[Uw r2 Fw' f' U L U' f: r']
= Fw' Uw r' Uw' Fw Uw r Uw' Uw r2 Fw' f' U L U' f r' f' U L' U' f Fw r2 Uw'
= Fw' Uw r' Uw' Fw Uw r' Fw' f' U L U' f r' f' U L' U' f Fw r2 Uw' (23,22)

Since there is so much freedom (the only restriction is, again, to not affect slice r—or whichever inner layer slice the quarter turn needs to be applied to based on your choice of the commutator and beginning conjugation moves), there are multiple paths which can be taken. Here are some more examples of 2-cycles (and higher cycles) I made choosing to start with a three block cycler and then conjugate the quarter turn simultaneously as I moved all three blocks from the three block cycler into the same slice. 

*Single Edge Flip 2-Cycle Case*
[Fw', Uw r' Uw'] [Uw r2 Fw' U L u l Uw': r'] (23,22)
[Fw', Uw r' Uw'] [Uw r2 Fw' f' L Fw R' F': r'] (23,22)
[r', Uw Lw Uw'] [Uw Lw Uw' r Fw2 Lw' Fw F R' F': r'] (25,22)
[Fw', Uw r' Uw'] [Uw r2 Fw2 L Fw F R' F': r'] (25, 22)
[Lw, Uw' r Uw] [Uw' r2 Fw2 L' Fw' F' R F: r] (25,22)
[Dw r' Dw', Lw] [Lw Uw f' Uw F' u Bw' Dw' f' L' f: l'] (25,24)
[Uw Lw Uw', r'] [r' Uw Bw Uw' Bw L Bw B R' B': r'] (25,25)
[Uw Lw' Uw', r'] [r Fw' Uw Lw' L' Uw' F R' F': r'] (27,26)
[Uw Lw' Uw', r'] [r Fw' L' Uw l' F' L' F Uw': r'] (27,26)
[Fw', Uw r' Uw'] [Uw r2 Fw2 U' L U Fw U R U': r'] (29,26)
[Uw Lw' Uw', r'] [r Fw' U l' Dw F Dw' U2 R U: r'] (31,28)

*Directly Opposite 2-Cycle Case*
[Fw', Uw r' Uw'] [Uw r2 Fw' f' L f: r'] (19,18)
[Fw', Uw r' Uw'] [Uw r2 Fw2 L Fw F' L F: r'] (23,20)
[r', Uw Lw Uw'] [Uw Lw Uw' r Fw2 Lw' Fw U' R U: r'] (25,22)

*Diagonal 2-Cycle Case*
[l', Uw Rw' Uw'] [Uw Rw' Fw Uw B' l2 B: r'] (21,19)
[Fw', Uw r' Uw'] [Uw r2 Fw2 L Fw F R2 F': r'] (27,22)

*Adjacent 2-Cycle Case 1*
[Fw', Uw r' Uw'] [Uw r2 Fw2 L Fw U' R2 U: r'] (27,22)

*Adjacent 2-Cycle Case 2*
[Fw', Uw r' Uw'] [Uw r2 Fw2 U L U' Fw: r'] (23,20)
[Fw', Uw r' Uw'] [Uw r2 Fw2 L Fw U' R U: r'] (25,22)

*Adjacent 2-cycle Case 3*
[Fw', Uw r' Uw'] [Uw r2 Fw2 L Fw: r'] (19,16)
[Lw, Uw' r Uw] [Uw' r2 Fw2 L' Fw': r] (19,16)
[r', Uw Lw Uw'] [Uw Lw Uw' r Fw2 Lw' Fw: r'] (19,16)
[Uw Lw Uw', r'] [r' Uw Bw Uw' Bw L Bw: r'] (19,19)

*Adjacent Double Parity 4-Cycle Case*
[Fw', Uw r' Uw'] [Uw r2 Fw2 L Fw R U R' U' F R' F': r'] (33,30)
[Fw', Uw r' Uw'] [Uw r2 Fw2 L Fw R F U R' U' R' F': r'] (33,30)

*Adjacent Checkerboard Case 2*
[Fw', Uw r' Uw'] [Uw r2 Fw2 L Fw F R' F' U R U': r'] (31,28)

*Miscellaneous 4-cycles*
[Fw', Uw r' Uw'] [Uw r2 Fw2 L Fw B L' B': r'] (25,22)
[Fw', Uw r' Uw'] [Uw r2 Fw2 L Fw U' L2 U: r'] (27,22)

*1 2-cycle and 1 3-cycle*
[Fw', Uw r' Uw'] [Uw r2 Fw2 L Fw B' L B: r'] (23,20)

*6-cycle*
[Fw', Uw r' Uw'] [Uw r2 Fw2 L Fw R U R' U' B' L B: r'] (33,30)

As you might be able to see, alternate 2-cycles can be formed if you replace the wing edge which you place in the quarter turn inner layer slice with the rest of the pieces which was NOT involved with the three block cycler to begin with. The higher cycles (4-cycles, 6-cycles, etc.) and disjoint cycles (1 2-cycle and 1 3-cycle, etc.) can be made by replacing any of the other three wings in the quarter turn inner layer slice.

Although it might be obvious, clearly the only case which this method generates a pretty brief algorithm for is the adjacent 2-cycle case #3, being only one half turn move more than the current minimum of 15 btm (which I established a few months ago with my method of symmetrical wide turn based 2-cycle algorithms).



*Application to Single Slice Turn 2-Cycle Algorithms Using Route 2*


Spoiler



Here's a single slice turn algorithm (long, I know) I made up using the same process as for wide turn based algorithms. It's long, but it's a perfect demonstration of how the method can translate to single slice turn based algorithms too.

[l': [U2, l U2 r']] [F2 B l D2 l' B' L2 D' L D: r] (39,29) =
l'
U2 l U2 r' U2 r U2 l'
l
F2 B l D2 l' B' L2 D' L D
r
D' L' D L2 B l D2 l' B' F2

Note that I didn't start out with U2 l U2 r' U2 r U2 l', rather with l' U2 l U2 r' U2 r U2. In fact, it is IMPOSSIBLE to use U2 l U2 r' U2 r U2 l' for this method.
Reason


Spoiler



One might question why we need to do this when we can just move it down after the commutator (or an equivalent to the commutator) U2 l U2 r' U2 r U2 l' is executed.
ANSWER: We cannot use U2 l U2 r' U2 r U2 l' because two of the 1x(n-2) center blocks it affects are the same color. Unlike wide turn based algorithms, if a brief 3 block cycler for a single slice turn based algorithm affects a certain color in two blocks, it affects ALL center pieces of that color. (Brief wide turn based three block cyclers will affect at most 1/2 of the center blocks of a given color and therefore we have some left over to use in the conjugation process).

Maybe an example is best to show why we cannot use it.
Suppose we did choose to use U2 l U2 r' U2 r U2 l'. Then we could start with:
U2 l U2 r' U2 r U2 l'
l F2
The quarter turn needs to be the move r. Assuming that you are using a cube (or cube applet) with the Rubik's color scheme and green is the front face color and white is the top face color, then execute the above algorithm piece on the cube. If you do the move r right now, the blue and white half of slice r (two 1x(n-1) blocks worth of pieces) will be solved back. The problem is in the 1x(n-2) block slot in slice r in D (the bottom center block color is yellow). If we are to make a nonsymmetrical algorithm using this method, we should be able to replace that yellow center block with a white one. Why white? Because the white center block in the back will go to the bottom center block slice as we do the move r. Because white is the color of the center block in the back, white MUST be the color of the center block in the bottom. BUT the other white center block is in face F and needs to go into face U to solve back a fourth of the centers. So we have a lack of center pieces of a certain color (in this case, white). So therefore, we cannot use the commutator U2 l U2 r' U2 r U2 l' or any equivalent of it or any other three 1x(n-1) block cycler that affects center pieces of an entire color.


However, we can use U2 l U2 r' U2 r U2 l' (and equivalences of it) to make a non-symmetrical algorithm.


Spoiler



r2 U2 r2 U2 r U2 r U2 r' U2 B2 U' r' U B2 U' r U' (27,18)
*Derivation*


Spoiler



[1] Start with this commutator to swap three 1x1x(n-1) blocks,
U2 l U2 r' U2 r U2 l'
_Why this one and not its inverse? (As an obvious counterexample).
Because it doesn't discolor all three of the 1x(n-2) center blocks it affects. That is, it doesn't discolor the 1x(n-2) center block in the left half of the U layer.
_
[2] Add F2 to have all three wings in the same slice
U2 l U2 r' U2 r U2 l'
F2

[3] Add r, the quarter turn to solve back one 1x1x(n-1) block and induce the odd permutation.
U2 l U2 r' U2 r U2 l'
F2
r

[4] Add F2 to restore the cube somewhat
U2 l U2 r' U2 r U2 l'
F2
r
F2

[5] Add the following piece to pair up the remaining edges
U2 l U2 r' U2 r U2 l'
F2
r
F2
r' F2 r

[6] Add F2 to restore the cube somewhat
U2 l U2 r' U2 r U2 l'
F2
r
F2
r' F2 r
F2

[7] Add the non-center preserving PLL parity algorithm
U2 l U2 r' U2 r U2 l'
F2
r
F2
r' F2 r
F2
r2 F2 r2 F2 r2

This is a 20 btm algorithm. However, we can make an obvious change to promote a move cancellation to 19 btm.
U2 l U2 r' U2 r U2 l'
F2
r
F2
r' F2 r
r2 F2 r2 F2 r2
F2

Using the commutator F' r' F U2 F' r F U2, we can achieve an 18 btm which is nearly <U, r>:
r2 U2 r2 U2 r U2 r U2 r' U2 B2 U' r' U B2 U' r U'





Here are some more examples. Note that I simplified l' U2 l U2 r' U2 r U2 l' l to l' U2 l U2 r' U2 r U2.

*Edge Flip*
l' U2 l U2 r' U2 r U2 [U2 B2 r' B2 U2 l F2 l' F2: r] (39,25)
F2 (l' U2 l U2 r' U2 r U2) F2 [B' l D2 l' B D R D' : r] (35,27)
l' U2 l U2 r' U2 r U2 [U2 B2 r' B2 U2 F' u L2 u' F': r] (39,27)
l' U2 l U2 r' U2 r U2 [F2 B D2 l D2 l' B' D' L' D: r] (39,29)
l' U2 l U2 r' U2 r U2 [F2 l F' B D2 B' R' F R D R' D' : r] (39,31)

*Adjacent 2-Cycle Case 2*
U2 r' U2 r U2 l' U2 l [F2 l' B D2 B': r'] (27,19)


*Single Slice Turn Based 3 Flips (for all size cubes) using "Route 1"*


Spoiler



For 3-Flips, instead of placing three blocks of equal size into the quarter turn inner layer slice, with this approach, we instead try to place four wing edges into the slice with this type of 4-cycle permutation (and its inverse, depending on which direction we go in) BEFORE we apply the quarter turn.
r U2 r l' U2 r2 U2 r' U2 r U2 r' U2 r' U2 l U2 r'

*Example 1: Double Parity 3 Flip*
[Rw' U2 B' D R D' R2 B: r']

Now we can simply do r U2 r' U2 = [r, U2] to pair up all three dedges.

Even though this is using "route 1" for non-symmetrical algorithms, we can easily make this a symmetrical algorithm by conjugating as follows (again, nothing new for those following this thread).

(r' U2 r' l2 U) [Rw' U2 B' D R D' R2 B: r'] [r, U2] (U' l2 r U2 r) (39,30)

And here is a shorter route that does the same thing.
(r' U2 r' l2 U) [Rw' U' F' R' F R2 U': r'] [r, U2] (U' l2 r U2 r) (35,28)

In the above two algorithms, the conjugations put all three flipped edges in the U layer. It's not like we had any other choice to conjugate differently for the sole purpose of completing the centers.

We can handle this fully using Route 2's technique. For example, let's start out with the shorter route above.

Assuming green to be the color of the front face and white the color of the top face (and assuming your cube has the Rubik's color scheme),
If we execute [Rw' U' F' R' F R2 U': r'] a cube, notice that if the top left center block we green and the bottom right was yellow (and the front right and top right were still white), the r U2 r' U2 would complete the algorithm.

If you execute just Rw' U' F' R' F R2 U' to a cube with the color scheme described above, then you will see that there is a green center block in the bottom right slot and there is a yellow center block in the back right slot. We CANNOT touch the green block in the bottom right, but we can (and should) move the green block in the front left into the back right slot _without affecting ANY other pieces in slice r_.

This really stumps the conventional move set of <U2,D2,F2,B2,l,r,l2,r2>!
[Rw' U' F' R' F R2 U' Lw2 E L2 E': r'] 

Adding r U2 r' U2 (the same piece as in the original 2 examples), we complete the centers without having to move any edges into the U face as we had to before with a symmetrical algorithm mindset.
[Rw' U' F' R' F R2 U' Lw2 E L2 E': r'] [r, U2] (35,27)

Although it's longer, we can make an OLL Parity (only) 3 flip from the route [Rw' U' F' R' F R2 U'...:r'] as well. Since we have seen that this setup creates a double parity 3 flip, we need to add some version of PLL parity to the algorithm to get rid of PLL parity. That is,
[Rw' U' F' R' F R2 U': r'] r U2 r' U2
U2 r2 U2 r2 U2 r2 U2

Ouch! Three center blocks discolored!? Easy fix.
Using the same strategy as in the previous algorithm, if we just execute [Rw' U' F' R' F R2 U': r'] r U2 r' U2 on to a cube (green = front face color, white = top face color, cube has Rubik's color scheme), and then separately execute just r2 U2 r2 U2 r2 on another cube, notice that r2 U2 r2 U2 r2 exchanges the front right and back right center blocks and the two top center blocks with each other. Never mind that it swaps the two top center blocks with each other (since the top face is not affected at all by [Rw' U' F' R' F R2 U': r'] r U2 r' U2), notice that if we did some change to [Rw' U' F' R' F R2 U': r'] r U2 r' U2 such that the bottom right center block would be yellow, the front right would be blue, and the back right would be green, then r2 U2 r2 U2 r2 would finish the 3 flip without discoloring any centers at all.

Because the changes we are about to make are in the conjugate of the quarter turn alone, then we have to see which color center we need to actually focus on. r U2 r' U2 is NOT a part of the conjugate: it's just a commutator we use to pair up the edges and solve back center blocks which are already there from what the conjugate gives us.

If we look at [Rw' U' F' R' F R2 U': r'], we merely need to place some center block which is not in slice r already into slice r in place of the yellow center block in the back right. This way, the bottom right center block after the conjugate is fully executed will be untouched. Because only the top left center block can be touched AND because whichever center block is in the back right slot right before the quarter turn is executed moves to the top left center block location (at this point: Rw' U' F' R' F R2 U'), we move the blue center block which is in the top left slot into the back right slot. This will fix our problem.

[Rw' U' F' R' F R2 U' Lw' E' R2 E: r'] r U2 r' U2 (U2 r2 U2 r2 U2 r2 U2)
= [Rw' U' F' R' F R2 U' Lw' E' R2 E: r'] [r, U2] [U2 r2 U2: r2] (41,31)

*A Shorter OLL Parity (Only) 3 Flip*
Suppose we invert the quarter turn of the conjugate. That is, suppose we start out with the inverse of the conjugate instead.
[Rw' U' F' R' F R2 U': r]
[Quick Note: If you don't know everything r U2 r' U2 does to a supercube, go check it out before trying to follow this example, otherwise you WILL be lost.]

Instead of adding more moves to the conjugate, we can actually use just that conjugate and finish off the algorithm directly. I will explain every move I add, so pay close attention.

[1] As mentioned already, I assume that you start out by executing the algorithm on a Rubik's color scheme cube with green as the front face color and white as the top face color. Start out by executing
[Rw' U' F' R' F R2 U': r].

[2] Next, rotate the cube like so x y2.
[Rw' U' F' R' F R2 U': r] x y2

[3] We ultimately wish to do l' U2 l U2 (at this angle). That will flip the upper front dedge and swap the top left center block with the front left center block. It will also bring the top right center block to the location of where the front left center block is. It will also swap the bottom front left wing edge with the back top right wing edge.

We should automatically be tempted to do U2 to bring the green center block (currently in the top right slot) into the top left slot. But remember that l' U2 l U2 will flip the top front edge (actually, swap the two wing edges in the top front composite edge slot), so we need to first place a complete composite edge into the top back composite edge slot before doing the move U2. Let's choose B' to place the red and yellow composite edge there (you may choose ANY complete composite edge you wish, including the green and white one, which is already in the portion of the middle layers which is being affected), execute U2, and finally invert B' with B (so that the individual wing edges can be swapped as planned).
[Rw' U' F' R' F R2 U': r]
x y2
B' U2 B

[4] Now execute l' U2 l U2, which we have been setting up for.
[Rw' U' F' R' F R2 U': r]
x y2
B' U2 B
l' U2 l U2

[5] Now we merely need to do PLL parity, l2 U2 l2 U2 l2, to get rid of PLL parity currently in the edges and swap the front left and back left center blocks. But let's put U2 in front of and at the end of l2 U2 l2 U2 l2 so that we have more move cancellations with l' U2 l U2.
[Rw' U' F' R' F R2 U': r]
x y2
B' U2 B
l' U2 l U2
U2 l2 U2 l2 U2 l2 U2

[6] Finally, invert B' U2 B with B' U2 B
[Rw' U' F' R' F R2 U': r]
x y2
B' U2 B
l' U2 l U2
U2 l2 U2 l2 U2 l2 U2
B' U2 B
y2 x'
= [Rw' U' F' R' F R2 U': r] [D' F2 D: [r', F2] [F2 r2 F2: r2] ] (39,29)

As another quick example, here is the exact same algorithm choosing to affect the green and white composite edge. Only the moves in red font need to be changed.
[Rw' U' F' R' F R2 U': r] [D' U' F2 U D: [r', F2] [F2 r2 F2: r2] ] (43,33)


*Route 2 for Wide Turn Based Parity Algorithms (Revisited)*


Spoiler



Now don’t hope to find any commutators similar to the one I’m about to present (if you can find another unique commutator as brief as this one, please share!), but the following commutator does an extraordinary thing for us. Unlike the detailed example for the introduction to Route 2 which mentioned having to set up the centers in addition to wing edges to achieve a certain 2-cycle which does not discolor X-center pieces (speaking of the 4x4x4 only, although all algorithms in this post can be translated to all size cubes, but I cannot promise at a pleasant move count), you do not have to set up the centers at all when we are conjugating the quarter turn!

For this one, two 1x2x2 blocks are already in the same slice as well as one displaced X-center piece. The objective is to bring the remaining 1x2x2 block into the same slice as the rest _without moving the other two 1x2x2 blocks or the single displaced X-center piece with respect to each other. In addition, there is another X-center piece in the top left front corner which cannot be touched either because, if you execute the commutator on a supercube, you can see that this X-center piece is also affected_. Once you have done this, you may substitute any wing edge not in slice r in place of the wing edge in the only block in slice r which was not originally involved with this commutator (the wing edge by the single displaced X-center piece in slice r) (not less strict than Route 2’s restrictions/demands, but even more strict).

*Special Commutator for Case 7*
Like the other 3 block cyclers I listed under “Tools” under “Route 1” category, this commutator comes in 4 flavors (versions), three of which might be useful for all size cubes. However, the version with “(all size cubes version)” written next to it definitely works, and the first version will definitely not work on any odd cube size.

[f' Uw Lw' Uw', r'] (even cubes only)
[f' UW Lw' UW', r'] = [f' Dw Fw' Dw', r']
[f' Uw LW' Uw', r'] = [f' Uw Rw' Fw', r'] (all size cubes version)
[f' UW LW' UW', r'] = f' Dw Bw' Lw' d' Lw Bw Dw' f r

Let the front face be green and the top face be white of the Rubik's color scheme.

Here are two examples. They work for all size cubes. Notice that the edge flip algorithm is the same as the algorithm for adjacent 2-cycle case 3 but has U L U' to place the other green and orange wing edge in slice r. 

_Note that the “2r_'” means, according to the notation I mentioned in my document full of algorithms (which is attached to this post) represents all orbits which do not need to be affected. So that you can see them executed with an online applet, I link the big cube version to SiGN Notation.

*Edge flip*
[f' Uw Rw' Fw', r'] [r2 Uw 2r' Rw' Fw' U L U': r'] (in the notation from my document)
On the 5x5x5,
= f' Uw Rw' Fw' r' Fw Rw Uw' f r' Uw Rw' Fw' U L U' r' U L' U' Fw Rw Uw' r2 (25,24)
On the 7x7x7,
= f' Uw Rw' Fw' r' Fw Rw Uw' f r' Uw 2r' Rw' Fw' U L U' r' U L' U' Fw Rw 2r Uw' r2 (27,26)

*Adjacent 2-Cycle Case 3*
[f' Uw Rw' Fw', r'] [r2 Uw 2r' Rw' Fw': r'] (in the notation from my document)
On the 5x5x5,
= f' Uw Rw' Fw' r' Fw Rw Uw' f r' Uw Rw' Fw' r' Fw Rw Uw' r2 (19,18)
On the 7x7x7,
= f' Uw Rw' Fw' r' Fw Rw Uw' f r' Uw 2r' Rw' Fw' r' Fw Rw 2r Uw' r2 (21,20)

How does the commutator work? If we execute [f' Uw Rw' Fw', r'] on a non supercube, it appears that it discolors an extra X-center piece, which is true. However, if we look at it on a supercube (whether it’s a 4x4x4, 5x5x5, 6x6x6, 7x7x7, etc., the white X-center piece in slice L is NOT the one which is usually there, when compared to which white X-center piece the normal commutator for “Case 7”, Uw Rw' Fw' r' Fw Rw Uw' r, puts there. That information, as well as how the conjugation mixes with it, should give a hint as to why this allows us to not have to set up centers as with the usual method I introduced in this post previously. Unfortunately, this commutator is (10,10) and this, by default, the algorithms are two moves more in both metrics than the other non-symmetrical wide turn based algorithms I showed (because they could use (8,8) commutators).








Spoiler: 2-Gen 2-Cycles



2-Gen Edge Flip for the 4x4x4 only. <U,Rw> (cuBerBruce found it with ksolve) 
Rw U Rw' U Rw' U Rw2 U2 Rw2 U Rw' U2 Rw U2 Rw' U2 Rw' U' Rw' U' Rw U Rw' U2 Rw U2 (34,26)
=
U
U' Rw U Rw' U
Rw' U Rw2 U2 Rw2 U' Rw
Rw' U2 Rw' U2 Rw U2 Rw
(Rw)
Rw U2 Rw' U2
U Rw' U' Rw
U Rw' U2 Rw U'
U'
= [U: [U' Rw: U] [Rw' U Rw2: U2] [Rw' U2 Rw': U2] (Rw) [Rw, U2] [U, Rw'] [U Rw': U2] ]

My decomposition is pretty good, in my opinion because it is just a handful of moves more than with the moves cancelled, and, take a look at the 4x4x4 SUPER cube after this portion of the algorithm is executed.
U
U' Rw U Rw' U
Rw' U Rw2 U2 Rw2 U' Rw
Rw' U2 Rw' U2 Rw U2 Rw

The next move, according to my decomposition, is the extra quarter turn Rw. Take a look at which 1x2 blocks are in slice Rw. Seeing this result on a 4x4x4 supercube, you will notice that with the quarter turn Rw, one of the two wing edges (red and white wing edge) is brought to the other (red and white wing edge) with the quarter turn (and so is the X-center piece attached to it brought to the other).

I highly appreciate the briefness of that algorithm because I found one without any solvers that is about 7 times as long. I found the key components of it using repetition, and I compiled it all together using the same methods in this thread.

*Derivation*


Spoiler



[1] Start with the pure 3-cycle
(Rw' U' Rw U2 Rw' U' Rw U2 Rw' U Rw U2)4

[2] Conjugate into another pure 3-cycle
Rw U2 Rw U2 Rw' U Rw2 U' Rw' 
(Rw' U' Rw U2 Rw' U' Rw U2 Rw' U Rw U2)4
Rw U Rw2 U' Rw U2 Rw' U2 Rw'

[3] Add the commutator, Rw U2 Rw' U2.
Rw U2 Rw U2 Rw' U Rw2 U' Rw' 
(Rw' U' Rw U2 Rw' U' Rw U2 Rw' U Rw U2)4
Rw U Rw2 U' Rw U2 Rw' U2 Rw'
Rw U2 Rw' U2

[4] Conjugate to move all affected inner layers into the r slice (same as usual) and add the extra quarter turn (in parenthesis).
U2 Rw2
Rw U2 Rw U2 Rw' U Rw2 U' Rw' 
(Rw' U' Rw U2 Rw' U' Rw U2 Rw' U Rw U2)4
Rw U Rw2 U' Rw U2 Rw' U2 Rw'
Rw U2 Rw' U2
Rw2 U2
(Rw')

[5] Conjugate again to swap same color centers with each other and join the two wing edges into a single dedge (same as usual).
Rw' U2 Rw' U2
U2 Rw2
Rw U2 Rw U2 Rw' U Rw2 U' Rw' 
(Rw' U' Rw U2 Rw' U' Rw U2 Rw' U Rw U2)4
Rw U Rw2 U' Rw U2 Rw' U2 Rw'
Rw U2 Rw' U2
Rw2 U2
(Rw')
U2 Rw U2 Rw

[6] Add PLL Parity so that we can move the 4 unsolved corners with conjugates much more easily.
Rw' U2 Rw' U2
U2 Rw2
Rw U2 Rw U2 Rw' U Rw2 U' Rw' 
(Rw' U' Rw U2 Rw' U' Rw U2 Rw' U Rw U2)4
Rw U Rw2 U' Rw U2 Rw' U2 Rw'
Rw U2 Rw' U2
Rw2 U2
(Rw')
U2 Rw U2 Rw
(Rw2 U2 Rw) (Rw2 U2 Rw2 U2 Rw2) U2 (Rw' U2 Rw2) [PLL Parity]

[7] Conjugate once more so that we only have to do a 3 corner flip and 4-cycle of dedges (dedge preserving 2 4-cycle of wings) left. Add the move U' at the very end to get the cube in position as well.
Rw U Rw U Rw U'
Rw' U2 Rw' U2
U2 Rw2
Rw U2 Rw U2 Rw' U Rw2 U' Rw' 
(Rw' U' Rw U2 Rw' U' Rw U2 Rw' U Rw U2)4
Rw U Rw2 U' Rw U2 Rw' U2 Rw'
Rw U2 Rw' U2
Rw2 U2
(Rw')
U2 Rw U2 Rw
(Rw2 U2 Rw) (Rw2 U2 Rw2 U2 Rw2) U2 (Rw' U2 Rw2) [PLL Parity]
U Rw' U' Rw' U' Rw' 
U'

[8] It might appear that doing PLL parity before was counter productive, but note that the 3 corner twist and the 4-cycle of dedges are made from the same algorithm piece. There will be several move cancellations between each piece.

Add the 3-corner twist and then the 4-cycle of dedges to finish off the algorithm.

Rw U Rw U Rw U'
Rw' U2 Rw' U2
U2 Rw2
Rw U2 Rw U2 Rw' U Rw2 U' Rw' 
(Rw' U' Rw U2 Rw' U' Rw U2 Rw' U Rw U2)4
Rw U Rw2 U' Rw U2 Rw' U2 Rw'
Rw U2 Rw' U2
Rw2 U2
(Rw')
U2 Rw U2 Rw
(Rw2 U2 Rw) (Rw2 U2 Rw2 U2 Rw2) U2 (Rw' U2 Rw2) [PLL Parity]
U Rw' U' Rw' U' Rw' 
U'

3 Corner twist
Rw U2 (Rw' U Rw U2 Rw' U2 Rw U)7 U2 Rw'

4-cycle of dedges
Rw U2 (U' Rw' U2 Rw U2 Rw' U' Rw)3 U2 Rw'
U'
Rw U2 (U' Rw' U2 Rw U2 Rw' U' Rw)3 U2 Rw'
U'
Rw U2 (U' Rw' U2 Rw U2 Rw' U' Rw)3 U2 Rw'

=
[Rw U Rw U Rw U': [Rw' U2 Rw' U2: [U2 Rw2: [Rw U2 Rw U2 Rw' U Rw2 U' Rw': (Rw' U' Rw U2 Rw' U' Rw U2 Rw' U Rw U2)4] [Rw, U2] ] (Rw')] [Rw2 U2 Rw: [Rw2 U2: Rw2] U2] ] [U': [Rw U2: (Rw' U Rw U2 Rw' U2 Rw U)7] ([Rw U2: (U' Rw' U2 Rw U2 Rw' U' Rw)3] U')3]

[9] Cancel moves to get:
Rw U Rw U Rw U' Rw' U2 Rw2 U2 Rw U2 Rw' U Rw2 U' Rw2 U' Rw U2 Rw' U' Rw U2 Rw' U Rw U2 Rw' U' Rw U2 Rw' U' Rw U2 Rw' U Rw U2 Rw' U' Rw U2 Rw' U' Rw U2 Rw' U Rw U2 Rw' U' Rw U2 Rw' U' Rw U2 Rw' U Rw U2 Rw U Rw2 U' Rw U2 Rw2 U2 Rw2 U2 (Rw') U2 Rw U2 Rw' U2 Rw' U2 Rw2 U2 Rw2 U2 Rw' U2 Rw2 U Rw' U' Rw' U' Rw' U' Rw U2 Rw' U Rw U2 Rw' U2 Rw U Rw' U Rw U2 Rw' U2 Rw U Rw' U Rw U2 Rw' U2 Rw U Rw' U Rw U2 Rw' U2 Rw U' Rw' U' Rw U Rw' U2 Rw U2 Rw' U' Rw U' Rw' U2 Rw U2 Rw' U' Rw U' Rw' U2 Rw U2 Rw' U' Rw U2 Rw' U' Rw U Rw' U2 Rw U2 Rw' U' Rw U' Rw' U2 Rw U2 Rw' U' Rw U' Rw' U2 Rw U2 Rw' U' Rw U2 Rw' (244,187)

According to the little note I wrote at the very end of cuBerBruce's <U,Rw> algorithm which I decomposed previously, the wing edges which are ultimately swapped are in slice R at the quarter turn (the outer layer slice). In my algorithm, because I am use to it, I had the two wing edges to be swapped in slice r. So these two algorithms are completely different in nature, despite that they are in the same move set.

To verify that the two wings which are ultimately swapped are in slice r before the quarter turn is executed, observe what the portion of the algorithm before the quarter turn does with the two wings which are ultimately exchanged (hopefully on CubeTwister or some other applet).

Rw U Rw U Rw U' Rw' U2 Rw2 U2 Rw U2 Rw' U Rw2 U' Rw2 U' Rw U2 Rw' U' Rw U2 Rw' U Rw U2 Rw' U' Rw U2 Rw' U' Rw U2 Rw' U Rw U2 Rw' U' Rw U2 Rw' U' Rw U2 Rw' U Rw U2 Rw' U' Rw U2 Rw' U' Rw U2 Rw' U Rw U2 Rw U Rw2 U' Rw U2 Rw2 U2 Rw2 U2

Cool, eh?


*2-Gen Edge Flip for all size cubes. <U,r> (cuBerBruce found it with ksolve)* 
U2 r' U2 r U2 r' U2 r' U r' U r' U2 r2 U2 r' U2 r' U r U' r2 (31,22)
=
U2 r' U2 r 
U2 r' U2 r
r2 U r' U
r' U2 r U2 
U2 r U2 r' U2 r' U2
U' r U' r2
= [U2, r']2 [r2 U r' U: [r',U2] [U2 r U2: r'] ]

*My own intuitive 2-gen edge flip for <U,r>*
r U2 r2 U r' U2 r' U2 r U2 r U2 r2 U2 r2 U2 r2 U r2 U' r' U2 r' U2 r U2 r U2 r2 U2 r2 U2 r2 U r U2 r2 U2 r' (63,39)*
Derivation*


Spoiler



There are a two even permutation sequences that I know off hand which do not affect that many pieces and which are in <U,r>. They are:
r2 U2 r2 U2 r2 (used to create Chris Hardwick's PLL Parity algorithm r2 U2 r2 Uw2 r2 u2 = r2 U2 r2 U2 r2 + r2 u2 r2 u2
and
r' U2 r' U2 r U2 r U2

Please execute these on a supercube (4x4x4 or greater) to see what they do to the top center. Both swap the 1x(n-2) center blocks in the U face (if you are looking at it on a 4x4x4, they rotate the top center 180 degrees).
As we use these pieces, it is not at all ideal to have both 1x(n-2) blocks in the top center affected when we are shuffling pieces in r and U. Maybe you have tried to make a <U,r> before but didn't succeed because of this (I know I did). So what do we do? Since both of the algorithm pieces above affect the top center pieces in the same way, we will use one to counteract the other.

[1] Start with r' U2 r' U2 r U2 r U2. It does something very valuable. Look at the two 1x(n-1) blocks it swaps in D and B. Recall that with the "standard" edge flip algorithm, for example, we must have 3 1x(n-1) blocks in the r slice before we do the extra quarter turn. This of course, for that algorithm is (F2 l') (U2 l U2 r' U2 r U2 l') (l F2). We then add r to that piece (for the "standard algorithm") to have only two 1x(n-1) blocks swapped: (F2 l') (U2 l U2 r' U2 r U2 l') (l F2) (r).

In summary for the "standard" edge flip alg, we have 3 unsolved 1x(n-1) blocks in slice r. We do the quarter turn to solve two back and pull the only 1x(n-1), which was the only one solved before, out of place. This leaves us with two 1x(n-1) blocks unsolved.

Similarly, we can start with all four 1x(n-1) blocks in slice r to be unsolved and then do a quarter turn to solve back two of them to leave just two unsolved. That's what I did in this algorithm because it was the only option I had, given my knowledge of how to handle 2-gen at the time (I didn't see cuBerBruce's algorithms until after I already made this one).

[2] Add r2 U2 r2 U2 r2 for the sole purpose of solving back the two 1x(n-2) center blocks in the U face.
(r' U2 r' U2 r U2 r U2) (r2 U2 r2 U2 r2)

[3] Now that the U face is completely solved (on a supercube), we need to get the wing edge in UrB out of slice r, so that we can work with the two 1x(n-1) blocks in the bottom half of slice r from r' U2 r' U2 r U2 r U2.
Since we can only use U and r moves, we must conjugate with U (or U', it doesn't matter).
U' (r' U2 r' U2 r U2 r U2) (r2 U2 r2 U2 r2) U

[4] Next, we add r2 and then execute the previous piece again, followed by r2.
U' (r' U2 r' U2 r U2 r U2) (r2 U2 r2 U2 r2) U
r2
U' (r' U2 r' U2 r U2 r U2) (r2 U2 r2 U2 r2) U
r2 

_The above can be a commutator as well, by inverting U' (r' U2 r' U2 r U2 r U2) (r2 U2 r2 U2 r2) U after the first r2 is placed, but that would demand more setup moves than what we are about to add in the remaining steps._

[5] Add the extra quarter turn and the outer setup moves to finish off the algorithm (nothing new).

=
r U2 r' r2 r U2
U' (r' U2 r' U2 r U2 r U2) (r2 U2 r2 U2 r2) U
r2
U' (r' U2 r' U2 r U2 r U2) (r2 U2 r2 U2 r2) U
r2 
(r')
U2 r' r2 r U2 r'
= [r U2 r2 U2: ([U': [r' U2 r', U2] [r2 U2: r2] ] r2)2 (r')] (63,39)


*A compromise between my 2-gen algorithm and wide turn 2-gen algorithms.*


Spoiler



The following algorithm about to be derived is by no means as complicated as the <U,Rw> 2-gen algorithm cuBerBruce found (nor is it the same type of algorithm in any sense), but the majority of it is in <U,Rw>. I have posted it in the past, but here's how I found it.

If we convert the commutator in my intuitive 2-gen algorithm, r' U2 r' U2 r U2 r U2, into wide turns, then the center no longer needs to be rotated 180 with r2 U2 r2 U2 r2 (that's the only reason I had r2 U2 r2 U2 r2 there, as I stated in that derivation).
Rw' U2 Rw' U2 Rw U2 Rw U2

Add U2 to it to fully restore the top center.
Rw' U2 Rw' U2 Rw U2 Rw U2 U2

Conjugate this with U (or U', it doesn't matter) and do it twice with the quarters turn r and r' in between each. Also add the extra quarter turn and outer setup moves to finish the algorithm.

Rw' U2 Rw' U2
U Rw' U2 Rw' U2 Rw U2 Rw U2 U2 U'
r
U Rw' U2 Rw' U2 Rw U2 Rw U2 U2 U'
r'
(r')
U2 Rw U2 Rw

Invert every move to bring the flipped edge into UF. Be sure to turn the central slice on odd cubes as well when executing the wide turns (in my document attached to this post, I signify a wide turn that includes the central slice with capital W).

Rw U2 Rw U2
U' Rw U2 Rw U2 Rw' U2 Rw' U2 U2 U
r'
U' Rw U2 Rw U2 Rw' U2 Rw' U2 U2 U
r
(r)
U2 Rw' U2 Rw'
= [Rw U2 Rw U2: [ [U' Rw U2 Rw: U2], r'] (r)] (37,27)

Unlike the cool <U,Rw> algorithm cuBerBruce found (he gave me 3 others of the same length, but I only decomposed that one), this algorithm is transferrable to all size cubes (only the two inner slice turns need to be adjusted, well besides doing a wide turn including the central slice for odd cubes). Technically, it's not even close to 2-Gen for odd cubes, but it "feels" pretty close as it is executed.


----------



## Stefan (Feb 25, 2012)

cmowla said:


> A Collection of Algorithms.pdf



I sadly don't have the time to read it all, but one thing caught my eye:



> Briefest 2-cycle Algorithm that can possibly exist (probably for all move metrics, at least for the 4x4x4 and 5x5x5
> cubes): it preserves only the pairing of the edges.
> l' F' R2 F2 u' F' l (9, 7)



What about u' R F' U R' F u (7, 7)? It's shorter in several metrics and even preserves the centers.


----------



## aronpm (Feb 25, 2012)

Stefan said:


> I sadly don't have the time to read it all, but one thing caught my eye:
> 
> 
> 
> What about u' R F' U R' F u (7, 7)? It's shorter in several metrics and even preserves the centers.


 
l' F' R2 F2 u' F' l can be solved to leave only a 2-cycle, but u' R F' U R' F u can be solved with 3-cycles.


----------



## Stefan (Feb 25, 2012)

Ah ok, so it does intentionally preserve (or change) more than _"only the pairing of the edges"_. I think it would be good to clarify that there.


----------



## Christopher Mowla (Feb 29, 2012)

Hey everyone,

I have found a very simple representation of the optimal (in btm) non-symmetrical single edge flip algorithms (2-cycle case) which I previously attempted to make "somewhat understandable." I could be wrong, but these representations could be the easiest for humans to picture how these algorithms work (with the deepest understanding). Personally, I'm finally satisfied (maybe you will be now too, if you ever wondered what the easiest way to understand these much as possible without looking at "gibberish").

*Frédérick Badie's Algorithm*
F2 r2 F2 U2 r U2 r' U2 r2 F2 l F2 l' U2 r (25,15)


Spoiler



=
U2 r2
r2 U2 F2 r2 F2 U2 r2
r' U2 r' U2 r
r2 U2 
U2 r' F2 l F2 l' U2 r
 = [U2 r2: [r2 U2 F2: r2] [r' U2: r'] ] [r' U2: [U2, r] [F2, l] ]

And actually, the "simple form" algorithm I previously posted (however I have deleted it and posted it in the spoiler below) was actually Frédérick Badie'salgorithm.


Spoiler



F2 r2 F2 U2 r U2 r' U2 r2 F2 l F2 l' U2 r.
=
F2 r2
F2 U2 r U2 r' U2
r2 F2
l F2 l' U2 r
=
F2 r2
F2 U2 r x' F2 r' x U2
r2 F2
l F2 l' U2 r
=
[F2 r2: [F2, U2 r x']]
l F2 l' U2 r
Convert to wide turns
[F2 Rw2: [F2, U2 Rw x']]
Lw F2 Lw' U2 Rw
= (in wide turns)
[F2 Rw2: [F2, U2 Lw]]
Lw F2 Lw' U2 Rw
Making adjustment (bold wide turns means to include central slice with odd cubes)
[F2 *Rw2*: [F2, U2 Lw]]
Rw U2 *Rw'* U2 *Rw*
= [F2 *Rw2*: [F2, U2 Lw]] (Rw) [U2, *Rw'*]





*Cube Explorer's Algorithm (Well, one of them I generated with it)*
r B2 r' U2 r U2 r2 F2 r' D2 l D2 B2 r2 F2 (25,15)


Spoiler



=
U2 l
l' U2 l (L R') U2 r' F2 r F2
L2 R2
l 
l U2 l' (L' R) U2 l'
l2 U2 F2 l2 (L2 R2) F2 U2 l2
l'
l' U2
*Derivation*


Spoiler



A transformation of the algorithm has a similar form to Frédérick Badie's Algorithm (and thus it also does indirectly).
It's too ugly to look at directly to find as simple representation as Frédérick Badie's Algorithm, so I think it is best to show it this way. However, assuming that all 15 btm non-symmetrical algorithms can be represented as product of a three 1x(n-1) block cycle, 4-cycle, and 2 2-cycle, if the algorithm itself cannot, then a transformation of it should. I can't prove this (nor am I declaring it true), but it's a possibility.

Here's a transformation of it that we can start from.
U2 l
l' U2 l U2 r' F2 r F2
l 
l U2 l' U2 l'
l2 U2 F2 l2 F2 U2 l2
l'
l' U2
= l U2 r' F2 r F2 l2 U2 l' U2 l U2 F2 l2 F2 (25,15)

And the transformation (which is how I chose to display the algorithm before this spoiler).
U2 l
l' U2 l (L R') U2 r' F2 r F2
L2 R2
l 
l U2 l' (L' R) U2 l'
l2 U2 F2 l2 (L2 R2) F2 U2 l2
l'
l' U2

Note that:
L and L2 represent all slices on the left side (including the outer layer move, L2, besides the orbits affected).
R', R, and R2 is represents just themselves.
Now, take note that the transformation is completed by introducing cube rotations.
(l L R') U2 r' F2 r F2 (l2 L2 R2) U2 (l' L' R) U2 l U2 F2 (l2 L2 R2) F2 =
(r x') U2 r' F2 r F2 (r2 x2) U2 (r' x) U2 l U2 F2 (r2 x2) F2
=r B2 r' U2 r U2 r2 F2 r' D2 l D2 B2 r2 F2





*Another Optimal (in btm) Non-symmetrical Edge Flip Algorithm*
This algorithm has the briefest representation, so I thought I should include it.
This algorithm was probably made several years ago. It's just a cyclic shift, y2 cube rotation, and mirror of the transformation of "Cube Explorer's Alg" previously shown in this post.
r2 U2 r' U2 r U2 B2 r2 B2 r U2 l' B2 l B2 (25,15)


Spoiler



=
r
r U2 r' U2 r'
r2 U2 B2 r2 B2 U2 r2
r'
r' U2 r U2 l' B2 l B2
= [r: [r U2: r'] [r2 U2 B2: r2] ] [r', U2] [l', B2] (25,15)


@Stefan,
When I first looked at Frédérick Badie's Algorithm, I and saw the r2 turns (I learned how to solve big cubes approximately 5 years ago), I actually thought it was similar to your PLL Parity alg, r2 F2 U2 r2 U2 F2 r2, which I now have found to be the best 2 2-cycle to include in the representations of this odd parity algorithm type! Just to let you know. 

_For those who are not sure why Stefan's PLL Parity algorithm works for these single dedge flip algorithms, you need to see what it does to centers on a supercube._

Also, if you just look at the representations in my document (now attached to the end of my previous post), you will see that the symmetrical algorithms I have derived a couple of years ago also have a brief conjugate such as [r' U2: r] and, of course, a three 1x(n-1) block exchanger. So, if my representations in this post show the easiest way to understand the optimal non-symmetrical single slice turn based algorithms, then the only extra piece (besides conjugates, which are almost always present in the algorithms I have seen in my time) is Stefan's PLL Parity algorithm.


----------



## Christopher Mowla (Aug 23, 2012)

As I have already stated here,

My previous decomposition of Frédérick Badie's algorithm is false because, if you execute the algorithm in wide turns 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'). 

However, the following (new) decomposition uses the move r' as the extra quarter turn.
(See what each line of moves does to understand how this algorithm works).

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
=
U2 r'
r U2 r' U2 l F2 l' F2
r U2
U2 r U2 r'
r2 U2 (r') U2 r2
r2 F2 r2 F2
= [U2 r': [r, U2] [l, F2] ] [U2, r] [r2 U2: (r')] [r2, F2]

With brute force searching done by others for all possible 15 btm solutions (for example, this post), I have eliminated duplicates and found that there are only 10 unique non-symmetrical 15 btm algorithms which flip the UF dedge and affect the top center.

r' U2 l F2 l' F2 r2 U2 r U2 r' U2 F2 r2 F2 (Frédérick Badie)
r' U2 r U2 l' U2 l2 F2 r F2 l' U2 F2 r2 F2
r B2 r' U2 r U2 r2 F2 r' D2 l D2 B2 r2 F2
r B2 r' U2 r U2 l2 B2 r' U2 l U2 F2 l2 F2
r B2 l' B2 l U2 r2 F2 l' F2 r U2 F2 l2 F2

r B2 r' U2 l B2 l2 B2 U2 l U2 l' U2 l2 B2
r B2 r' U2 r D2 r2 U2 F2 l F2 r' D2 r2 B2
r B2 r' U2 r D2 l2 D2 B2 l B2 r' U2 l2 B2
r B2 l' B2 l D2 l2 D2 B2 r D2 l' D2 r2 B2
r' U2 r U2 l' D2 r2 D2 B2 l' D2 r D2 l2 B2

There are actually 40 algorithms if you count mirrors and inverses (and inverses of the mirrors) of each of the 10 unique algorithms, but you can make simple adjustments to obtain those other 30 algorithms.

Since we have the decomposition for Frédérick Badie, we actually have the decomposition for all possible non-symmetrical 15 btm (all are 25q) solutions. In other words, all 15 btm non-symmetrical algorithms for this case are related.


Spoiler: Proof



The 10 unique algorithms can be broken up into two groups. Each of the two groups contain five algorithms which are directly related via transformations (or mirrors of transformations).

Shifting any algorithm from Group 1 will generate an algorithm from Group 2. After the algorithm is shifted, you just rotate the flipped dedge back to UF and the center affected back into U, and, if necessary, take the mirror so that the first move of the algorithm is r or r'. (In short, if we have the decomposition for at least one algorithm in one of the groups, we can derive the decompositions for all algorithms in the other group by shifting (conjugating) its decomposition until a single dedge is flipped again (which only happens one time when shifting) ).



Spoiler: Group 1



To show that the following group of algorithms are directly related (via transformations), let's just use FB (v1) = Frédérick Badie as the tester.

r' U2 l F2 l' F2 r2 U2 r U2 r' U2 F2 r2 F2 |FB (v1)|
r' U2 r U2 l' U2 l2 F2 r F2 l' U2 F2 r2 F2 |FB (v2)|
r B2 r' U2 r U2 r2 F2 r' D2 l D2 B2 r2 F2 |FB (v3)|
r B2 r' U2 r U2 l2 B2 r' U2 l U2 F2 l2 F2 |FB (v4)|
r B2 l' B2 l U2 r2 F2 l' F2 r U2 F2 l2 F2 |FB (v5)|

FB (v2)
r' U2 r U2 l' U2 l2 F2 r F2 l' U2 F2 r2 F2 = Transformation(r' U2 l F2 l' F2 r2 U2 r U2 r' U2 F2 r2 F2).
Proof:
r' U2 l (L R') F2 l' F2 r2 (L2 R2) U2 r U2 r' (L R') U2 F2 r2 F2
=
r' U2 l (L R') (x) U2 l' U2 r2 (L2 R2) (x2) F2 r F2 r' (L R') (x) U2 F2 r2 F2
=
r' U2 l (L R') (L' l' r R) U2 l' U2 r2 (L2 R2) (L2 l2 r2 R2) F2 r F2 r' (L R') (L' l' r R) U2 F2 r2 F2
=
r' U2 r U2 l' U2 l2 F2 r F2 l' U2 F2 r2 F2 ***

FB (v3)
r B2 r' U2 r U2 r2 F2 r' D2 l D2 B2 r2 F2 = Transformation(r' U2 l F2 l' F2 r2 U2 r U2 r' U2 F2 r2 F2).
Proof:
Mirror(r' U2 l F2 l' F2 r2 U2 r U2 r' U2 F2 r2 F2)= l U2 r' F2 r F2 l2 U2 l' U2 l U2 F2 l2 F2.
l (L R') U2 r' F2 r F2 l2 (L2 R2) U2 l' (L' R) U2 l U2 F2 l2 (L2 R2) F2
=
l (L R') (x) B2 r' U2 r U2 l2 (L2 R2) (x2) F2 l' (L' R) (x') D2 l D2 B2 l2 (L2 R2) (x2) F2
=
l (L R') (L' l' r R) B2 r' U2 r U2 l2 (L2 R2) (L2 l2 r2 R2) F2 l' (L' R) (L l r' R') D2 l D2 B2 l2 (L2 R2) (L2 l2 r2 R2) F2
=
r B2 r' U2 r U2 r2 F2 r' D2 l D2 B2 r2 F2 ***

FB (v4)
r B2 r' U2 r U2 l2 B2 r' U2 l U2 F2 l2 F2 = Transformation(r' U2 l F2 l' F2 r2 U2 r U2 r' U2 F2 r2 F2).
Proof:
Mirror(r' U2 l F2 l' F2 r2 U2 r U2 r' U2 F2 r2 F2)= l U2 r' F2 r F2 l2 U2 l' U2 l U2 F2 l2 F2.
l (L R') U2 r' F2 r F2 l2 U2 l' (L' R) U2 l U2 F2 l2 F2
=
l (L R') (x) B2 r' U2 r U2 l2 B2 l' (L' R) (x') U2 l U2 F2 l2 F2
=
l (L R') (L' l' r R) B2 r' U2 r U2 l2 B2 l' (L' R) (L l r' R') U2 l U2 F2 l2 F2
=
r B2 r' U2 r U2 l2 B2 r' U2 l U2 F2 l2 F2 ***

FB (v5)
r B2 l' B2 l U2 r2 F2 l' F2 r U2 F2 l2 F2 = Transformation(r' U2 l F2 l' F2 r2 U2 r U2 r' U2 F2 r2 F2).
Proof:
Mirror(r' U2 l F2 l' F2 r2 U2 r U2 r' U2 F2 r2 F2)= l U2 r' F2 r F2 l2 U2 l' U2 l U2 F2 l2 F2.
l (L R') U2 r' (L R') F2 r (L' R) F2 l2 (L2 R2) U2 l' U2 l (L R') U2 F2 l2 F2
=
l (L R') (x) B2 r' (L R') (x) B2 r (L' R) (x') U2 l2 (L2 R2) (x2) F2 l' F2 l (L R') (x) U2 F2 l2 F2
=
l (L R') (L' l' r R) B2 r' (L R') (L' l' r R) B2 r (L' R) (L l r' R') U2 l2 (L2 R2) (L2 l2 r2 R2) F2 l' F2 l (L R') (L' l' r R) U2 F2 l2 F2
=
r B2 l' B2 l U2 r2 F2 l' F2 r U2 F2 l2 F2 ***





Spoiler: Group 2



To show that the following group of algorithms are directly related (via transformations), let's just use Alg.2(v1) as the tester.
r B2 r' U2 r D2 r2 U2 F2 l F2 r' D2 r2 B2 |Alg.2(v1)|
r B2 r' U2 r D2 l2 D2 B2 l B2 r' U2 l2 B2 |Alg.2(v2)|
r B2 r' U2 l B2 l2 B2 U2 l U2 l' U2 l2 B2 |Alg.2(v3)|
r B2 l' B2 l D2 l2 D2 B2 r D2 l' D2 r2 B2 |Alg.2(v4)|
r' U2 r U2 l' D2 r2 D2 B2 l' D2 r D2 l2 B2 |Alg.2(v5)|

Alg.2(v2)
r B2 r' U2 r D2 l2 D2 B2 l B2 r' U2 l2 B2 = Transformation(r B2 r' U2 r D2 r2 U2 F2 l F2 r' D2 r2 B2)
Proof:
r B2 r' U2 r D2 r2 (L2 R2) U2 F2 l F2 r' D2 r2 (L2 R2) B2
=
r B2 r' U2 r D2 r2 (L2 R2) (x2) D2 B2 l B2 r' U2 r2 (L2 R2) (x2) B2
=
r B2 r' U2 r D2 r2 (L2 R2) (L2 l2 r2 R2) D2 B2 l B2 r' U2 r2 (L2 R2) (L2 l2 r2 R2) B2
=
r B2 r' U2 r D2 l2 D2 B2 l B2 r' U2 l2 B2 ***

Alg.2(v3)
r B2 r' U2 l B2 l2 B2 U2 l U2 l' U2 l2 B2 = Transformation(r B2 r' U2 r D2 r2 U2 F2 l F2 r' D2 r2 B2)
Proof:
r B2 r' U2 r (L' R) D2 r2 (L2 R2) U2 F2 l F2 r' (L R') D2 r2 (L2 R2) B2
=
r B2 r' U2 r (L' R) (x') B2 r2 (L2 R2) F2 D2 l D2 r' (L R') (x) D2 r2 (L2 R2) B2
=
r B2 r' U2 r (L' R) (x') B2 r2 (L2 R2) (x2) B2 U2 l U2 r' (L R') (x) U2 r2 (L2 R2) (x2) B2
=
r B2 r' U2 r (L' R) (L l r' R') B2 r2 (L2 R2) (L2 l2 r2 R2) B2 U2 l U2 r' (L R') (L' l' r R) U2 r2 (L2 R2) (L2 l2 r2 R2) B2
=
r B2 r' U2 l B2 l2 B2 U2 l U2 l' U2 l2 B2 ***

Alg.2(v4)
r B2 l' B2 l D2 l2 D2 B2 r D2 l' D2 r2 B2 = Transformation(r B2 r' U2 r D2 r2 U2 F2 l F2 r' D2 r2 B2)
PROOF:
r B2 r' (L R') U2 r (L' R) D2 r2 (L2 R2) U2 F2 l (L R') F2 r' (L R') D2 r2 B2
=
r B2 r' (L R') (x) B2 r (L' R) (x') D2 r2 (L2 R2) U2 F2 l (L R') (x) U2 r' (L R') (x) (x2) D2 r2 B2
=
r B2 r' (L R') (x) B2 r (L' R) (x') D2 r2 (L2 R2) (x2) D2 B2 l (L R') (x) D2 r' (L R') (x) (x2)(x2) D2 r2 B2
=
r B2 r' (L R') (L' l' r R) B2 r (L' R) (L l r' R') D2 r2 (L2 R2) (L2 l2 r2 R2) D2 B2 l (L R') (L' l' r R) D2 r' (L R') (L' l' r R) (L2 l2 r2 R2) (L2 l2 r2 R2) D2 r2 B2
=
r B2 l' B2 l D2 l2 D2 B2 r D2 l' D2 r2 B2 ***

Alg.2(v5)
r' U2 r U2 l' D2 r2 D2 B2 l' D2 r D2 l2 B2 = Transformation(r B2 r' U2 r D2 r2 U2 F2 l F2 r' D2 r2 B2)
Proof:
Mirror(r B2 r' U2 r D2 r2 U2 F2 l F2 r' D2 r2 B2) = l' B2 l U2 l' D2 l2 U2 F2 r' F2 l D2 l2 B2
l' (L' R) B2 l (L R') U2 l' D2 l2 (L2 R2) U2 F2 r' (L R') F2 l (L R') D2 l2 B2
=
l' (L' R) (x') U2 l (L R') (x) U2 l' D2 l2 (L2 R2) U2 F2 r' (L R') (x) U2 l (L R') (x) (x2) D2 l2 B2
=
l' (L' R) (x') U2 l (L R') (x) U2 l' D2 l2 (L2 R2) (x2) D2 B2 r' (L R') (x) D2 l (L R') (x) (x2)(x2) D2 l2 B2
=
l' (L' R) (L l r' R') U2 l (L R') (L' l' r R) U2 l' D2 l2 (L2 R2) (L2 l2 r2 R2) D2 B2 r' (L R') (L' l' r R) D2 l (L R') (L' l' r R) (L2 l2 r2 R2)(L2 l2 r2 R2) D2 l2 B2
=
r' U2 r U2 l' D2 r2 D2 B2 l' D2 r D2 l2 B2 ***








Spoiler: Examples






Spoiler: Example 1



Decomposition(FB(v2)) = Decomposition(r' U2 r U2 l' U2 l2 F2 r F2 l' U2 F2 r2 F2)
=
U2 r'
r U2 r' U2 (L R') l F2 l' F2
r U2
U2 (L2 R2) r U2 r'
r2 U2 (r') (L R') U2 r2
r2 F2 r2 F2
=
U2 r'
r U2 r' U2 (L R') l F2 l' F2
r U2
U2
(L2 R2) r U2 r' U2
U2
r2 U2 (r') (L R') U2 r2
r2 F2 r2 F2
= [U2 r': [r, U2] (L R') [l, F2] ] [U2: (L2 R2) [r, U2] ] [r2 U2: (r') (L R')] [r2, F2]





Spoiler: Example 2



Decompositon(Alg.2(v3)) = Decomposition(r B2 r' U2 l B2 l2 B2 U2 l U2 l' U2 l2 B2)
=
[y2 l F2 l' U2 r: Decomposition(Frédérick Badie)]'
=
(y2 l F2 l' U2 r
r' U2 l F2 l' F2 r2 U2 r U2 r' U2 F2 r2 F2
r' U2 l F2 l' y2)'
=
(y2 l F2 l' U2 r
U2 r'
r U2 r' U2 l F2 l' F2
r U2
U2 r U2 r'
r2 U2 (r') U2 r2
r2 F2 r2 F2
r' U2 l F2 l' y2)'
=
r B2 r' U2 l
B2 l2 B2 l2
l2 U2 (l) U2 l2
l U2 l' U2
U2 l'
B2 r B2 r' U2 l U2 l'
l U2
l' U2 r B2 r'
=
[r B2 r' U2 l: [B2, l2] [l2 U2: (l)] [l, U2] [U2 l': [B2, r] [U2, l] ] ]

This can be simplified to:
B2 l U2
l' U2
U2 l U2 l' B2 r B2 r'
U2 l
B2 l2 B2 l2
l2 U2 (l) U2 l2
l U2 l' U2
U2 l' B2
=
[B2 l U2: [l' U2: [U2, l] [B2, r] ] [B2, l2] [l2 U2: (l)] [l, U2] ]

Comparing this simplified form to Decomposition(FB),
Recall that Decomposition(FB) =
U2 r'
r U2 r' U2 l F2 l' F2
r U2
U2 r U2 r'
r2 U2 (r') U2 r2
r2 F2 r2 F2

and Decomposition(Alg.2(v3)) =
y2 F2 r U2
(U2 r'
r U2 r' U2 l F2 l' F2
r U2)'
(r2 F2 r2 F2)'
(r2 U2 (r') U2 r2)'
(U2 r U2 r')'
U2 r' F2 y2






With brute force searching done by others for all possible 15 btm solutions (for example, this post), I have eliminated duplicates and found that there are only 16 unique symmetrical 15 btm algorithms which flip the UF dedge and affect the top center.

There are actually 64 algorithms if you count mirrors and inverses (and inverses of the mirrors) of each of the 16 unique algorithms, but you can make simple adjustments to obtain those other 48 algorithms.

To obtain all 16 symmetrical 15 btm single dedge flip solutions (with the UF dedge flipped and the affected center in U), we just need to know the first algorithms in each group. Taking 7 transformations of the first algorithm in Group 1 and taking 7 transformations of the first algorithm in Group 2 will generate all 16 symmetrical algorithm solutions.

Group 1
r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2 (Old Standard Algorithm)
r2 B2 U2 l U2 l' B2 r B2 U2 r U2 r' B2 r2
r2 F2 D2 r' D2 r F2 l' F2 D2 l' D2 l F2 r2
r2 F2 D2 r' D2 l D2 l' D2 B2 l' B2 r F2 r2
r2 B2 U2 r B2 r' B2 l U2 F2 r F2 l' B2 r2
r2 F2 D2 l' F2 l F2 r' D2 B2 l' B2 r F2 r2
r2 B2 U2 r B2 l' D2 r D2 B2 l U2 r' B2 r2
r2 F2 D2 l' F2 r U2 l' U2 F2 r' D2 l F2 r2

Group 2
r2 B2 U2 l' U2 r U2 r' U2 B2 r' B2 l B2 r2
r2 B2 U2 l' U2 l F2 r' F2 U2 r' U2 r B2 r2
r2 F2 D2 r D2 r' B2 l B2 D2 l D2 l' F2 r2
r2 F2 D2 r D2 l' D2 l D2 F2 l F2 r' F2 r2
r2 B2 U2 r' F2 r F2 l' U2 B2 r' B2 l B2 r2
r2 B2 U2 r' F2 l D2 r' D2 F2 l' U2 r B2 r2
r2 F2 D2 l B2 r' U2 l U2 B2 r D2 l' F2 r2
r2 F2 D2 l B2 l' B2 r D2 F2 l F2 r' F2 r2

All 15 btm symmetrical solutions are related.


Spoiler: Proof



Since the first algorithm in Group 1 = r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2 = (r2 B2) (U2 l U2 r' U2 r U2 l') (l F2 r F2 l') (B2 r2), note that the first algorithm in Group 2 is simply a slight modification:
= (r2 B2) (y2) Mirror((U2 l U2 r' U2 r U2 l') (l F2 r F2 l')(y2)) (B2 r2)
= (r2 B2) (y2) (U2 r' U2 l U2 l' U2 r) (r' F2 l' F2 r)(y2) (B2 r2)
= (r2 B2) (U2 l' U2 r U2 r' U2 l) (l' B2 r' B2 l) (B2 r2)
= r2 B2 U2 l' U2 r U2 r' U2 B2 r' B2 l B2 r2

Also,
[1] If we take the first algorithm in Group 1,
r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2
[2] Shift,
r' U2 r U2 F2 r F2 l' B2 r2
r2 B2 U2 l U2
[3] Add back setup moves
r2 B2
r' U2 r U2 F2 r F2 l' B2 r2
r2 B2 U2 l U2
B2 r2
= r2 B2 r' U2 r U2 F2 r F2 l' U2 l U2 B2 r2
[4] Take the inverse,
r2 B2 U2 l' U2 l F2 r' F2 U2 r' U2 r B2 r2 = Second algorithm in Group 2.

Either way, we can see that 15 btm symmetrical solutions are also related because, if we modify an algorithm in one group, we obtain an algorithm from the other group. This follows for all 16 algorithms because all 8 algorithms from each of the two groups are directly related via transformations (or mirrors of transformations)


----------



## Christopher Mowla (Oct 10, 2013)

cmowla said:


> I don't know why someone hasn't posted this idea before, but here are 4-cycle conjugates.


I have revisited conjugates again, and now I have created the 4-cycle of dedges cases for even cubes.

*8 perm*
0 Flip
[M2 U Fw2 r2 u r2 Uw2 S' U' B R B' R2 U: M'] (41,29)
[y' M2 U Fw2 r2 u r2 U S' u2 F2 U' F2 L2 U: M] (45,29)
4 Flip
[y x' M2 Fw f r2 u r2 S' u2: M] (25,17)
[M2 U Fw2 r2 d r2 Uw2 S': M] (27,17)

*O Perm*
0 Flip
[F2 U2 M U Fw2 r2 u S' Rw2 u2: M'] (33,21)
2 Flip
[M2 U Fw2 r2 u r2 U S R' U' R Uw2 R2 U' E2: M] (45,31)
4 Flip
[M2 U Fw2 r2 u S' Rw2 u2: M] (27,17)

So we can create PLL parity by conjugating the move M, not just r2.

_You can adjust the moves in these algorithms to create other algorithms for these cases and other 2 4-cycle cases (or a 4-cycle and a 2 2-cycle if you conjugate l2 r, for example, instead)._


In addition, I have found another checkerboard conjugate in two opposite dedges for even cubes which 2 OBTM less than any previously existing algorithm while also having the current minimum qtm move count.

[Rw2 Uw U S Lw2 u2: r] (19,13) (26 qtm, 18 OBTM)

Lastly, for those who have followed this thread and didn't know, I found 23q pure 3 flip algorithms for all size cubes using cube explorer (the previous minimum was 25q). I have posted these 3 flip algorithms on the 4x4x4 parity algorithms wiki page.


----------



## Christopher Mowla (Dec 27, 2013)

I was searching for 8 perms and O perms in <U,R,r> (by hand), and I came up with a method to create O perms and 8 perms in a new way.

The following two algorithms are results of this method (very long!)

O Perm
[Rw' U' r' U' r' U' R U: [r', U' R' U2 R U' Rw' r' U R U' R' U' R U r] ] (50 qtm, 49 ftm)
8 Perm
[Rw' U2 Rw' U' R U r' U' R U: [r, U R' U' r U' R' U2 R U' r U' R U r'] ] (60 qtm, 56 ftm)

However, what's interesting is that from the thought process of making these by hand (I made several others as well) is that...

I discovered that only 2 inner layer quarter turns are required to solve PLL parity on the 4x4x4! (The previous minimum was 4, I believe.)
(r' U' D' R2 U' D' S2 r')(F' U' D' F2 R F2 U2 R E' R F2 L' U2 R D2 R B2 R' x2 y')
(U' R F' R U' R' F2 R' D' R F' R D' S2)(l' S2 U D R2 U D l')

Or more specifically, I believe I have found the optimal PLL parity algorithm in the qtm metric (it can be directly translated to all big cube sizes)!
r' S2 U D R2 U D r' (you may invert both of the r turns as well to get a second algorithm)
Basically, the idea behind this algorithm is to:
[1] Do a quarter turn to slice r: r'
[2] Move the 1x2 centers in slice r into slice l: r' E2 S2
[3] Swap UF and DB (or DF and UB) with each other without affecting any other pieces in M as well as preserving the orientation of those two composite edges: r' E2 S2 U2 F2 U2 E R2 E'
[4] Do a quarter turn to slice l to solve back the centers: r' E2 S2 U2 F2 U2 E R2 E' l'

After I found that, I decided to just keep it on the right side, and found the optimal algorithm!

From this also, I believe I have created the move optimal supercube safe unoriented 8 perm.
M2 U' S2 r' S2 U D R2 U D r' U' D' R2 D' M2 = [M2: [U' S2: r'] [D R2 U D: r'] ]

EDIT:
I guess I should have known that only two inner layer quarter turns are required to solve PLL parity, as I did a full of analysis of 12 objects, here, (I found that 2 2-cycles as well as 2 4-cycles can be solved with two iterations of a single quarter turn, surrounded by 3x3x3 moves ).


----------



## Christopher Mowla (Jan 24, 2016)

*The Holy Grail Pure Edge Flip Parity Algorithm Finally Matched!*

Today was my annual search day for a possible 18q single dedge flip algorithm. (I still search about once a year.)

I didn't find an 18q, but, after more than 6 years, today I found a single dedge flip algorithm which matches the move count of the Holy Grail algorithm for the nxnxn!

It is the same quantity of block half turns and block quarter turns for all (and the same) cases, but it is actually _shorter than the Holy Grail alg_ for the nxnxn in the:

single slice turn metric 
plane half turn metric (OBTM) 
*plane quarter turn metric (QTM) * 

Since the Holy Grail alg was (one of) the shortest algorithms in QTM (for all size cubes), we now have an algorithm that is fewer QTM than any other algorithm in history! This algorithm is 22 QTM on the 4x4x4 and 5x5x5, and 24 QTM on individual orbits on the 6x6x6 and 7x7x7! (It's 22 QTM for nxnxn cases like the ones I posted images of in *this post*.)

In addition to its move count being shorter in the three above move metrics than the Holy Grail (and matching the lengths of the other two move metrics),


This algorithm is the first single dedge flip algorithm I have ever seen which can be *reverted* (not just inverted) to achieve the exact same affect. 
This algorithm, unlike the Holy Grail and *all* 19q algorithms I have ever found, only exchanges center pieces in the top face on the supercube. 

May I represent, "*Challenger*", and its twin, "*Reverter*"!


Spoiler: Challenger and Reverter



"Challenger in its general form,
Rw Uw' L Dw' R Uw' *r* Uw R' *r'* Dw LW2 Dw' *r* Dw LW2 L' Uw Rw'
= [Rw Uw' L Dw': [R Uw': (r)] [r', Dw LW2 Dw'] ]

and here is its move inverted "twin", "Reverter" (the inverse of its reverse),
Rw' Uw L' Dw R' Uw *r'* Uw' R *r* Dw' LW2 Dw *r'* Dw' LW2 L Uw' Rw 
= [Rw' Uw L' Dw: [R' Uw: (r')] [r, Dw' LW2 Dw] ]



LW2 means to turn the left half of the cube on even cubes and the left half of the cube + the central slice on odd cubes. 
The bold r moves indicate the slices that you apply to the orbits of wings you wish to affect. 

Now, I will link (Challenger: you can just invert all moves without changing their locations to get Reverter's animations) to alg.cubing.net in SiGN notation for each cube size (with moves simplified specific to each case).

4x4x4
r u' L d' R u' 2R u r' d l2 d' 2R d l 2L u r'

5x5x5
r u' L d' R u' 2R u r' d 3l2 d' 2R d 3l 2-3l u r'

6x6x6 (outer orbit)
3r 3u' L 3d' R 3u' 2R 3u 2r' 3d 3l2 3d' 2R 3d 3l 2-3l 3u 3r'

6x6x6 (inner orbit)
3r 3u' L 3d' R 3u' 3R 3u R' 3R' 3d 3l2 3d' 3R 3d 3l 2-3l 3u 3r'

7x7x7 (outer orbit)
3r 3u' L 3d' R 3u' 2R 3u 2r' 3d 4l2 3d' 2R 3d 4l 2-4l 3u 3r'

7x7x7 (inner orbit)
3r 3u' L 3d' R 3u' 3R 3u R' 3R' 3d 4l2 3d' 3R 3d 4l 2-4l 3u 3r'




Using the same conjugate of the quarter turn idea, I found a (20,17) even cube algorithm.


This first single edge flip algorithm with this ratio of block quarter turns to block half turns. 
Reverting (in addition to inverting) produces a working algorithm as well (but it flips UB instead of UF). 
This algorithm is only 20q on the 4x4x4 and on the nxnxn even cube when consecutive slices from the corners need to be affected. 



Spoiler: New Parity Algorithms (3 and 4)



General Form:
Lw E Lw2 Dw *r'* Dw' Lw2 Dw R2 Uw *r'* Uw' R2 *r* Dw' E' Lw'
= [Lw E: [Lw2, Dw r' Dw'] [Dw r': [R2 Uw: (r')] ] ] 

On the 4x4x4
l e r2 u 2R' u' r2 d R2 u 2R' u' r R d' e' l'

On the 6x6x6 outer orbit
3l e 3r2 3u 2R' 3u' 3r2 3d R2 3u 2R' 3u' 2r R 3d' e' 3l'

And its "twin"'s general form (this flips the back dedge)
Lw' E' Dw' *r* R2 Uw' *r'* Uw R2 Dw Lw2 Dw' *r'* Dw Lw2 E Lw



I will post these (four) new algorithms in the wiki soon.


----------



## Christopher Mowla (Jan 25, 2016)

I have contacted Ben, and he was curious about what mental process I used to find Challenger and Reverter, and I just decided to make a brief (well, brief for me) video about this and my comments (which I already have basically written in my previous post).

Enjoy!​


----------



## Christopher Mowla (Jan 28, 2016)

*18q Single Dedge Flip Algorithm Found for the 4x4x4!*

Am I dreaming? I must be...

I just found an 18q single dedge flip algorithm for the 4x4x4 from my original method! (It's ironic that I really don't care about this that much anymore that I finally found it. I thought I--or someone else would have to--do a computer search of sorts to find one, if I ever did.)
b' D' 2U' r' 2R' f' 2R' f 2R' R d b' r' 2B' r b e' b (18,18)

It's only 18q on the 4x4x4 though. It is 19q (proportionally) on all even size cubes (due to the presence of an interior setup move), but it doesn't work at all on odd cubes, despite that where I got it from did originally work on odd cubes.

*Story*
I perhaps rediscovered an uncommon outer-most setup move conjugation (like I previously used for the 19q l' F' 2B' r' b' r 2U r' b r 2U2 b' 2U b 2U 2B F l posted in the wiki) to a specific base form. I found that the base algorithm I had wasn't ideal when I rediscovered this setup, but I had a hunch, and after looking at my algs for other 2-cycle types on the 4x4x4 parity algorithms wiki page tonight, I spotted this one that I found in the past.

And it worked. The base alg for this 18q is from "[Fw Uw': [Uw Rw' Fw', r'] [Rw' (1-2r)2 Fw': r'] ] (17,17 for large cubes and 16,16 for 4x4x4 and 5x5x5)" in my "A Collection of Algorithms" PDF, which can be downloaded in this post.

6x6x6 (inner orbit)
3b' D' 2-3u' 2-3r R' *3R* 3f' *3R'* 3f 2-3r' R 3d 3b' 3r' *3B'* 3r 3b e' 3b (19,19)

6x6x6 (outer orbit)
3b' D' 2-3u' 2-3r R' *2R* 3f' *2R'* 3f 2-3r' R 3d 3b' 3r' *2B'* 3r 3b e' 3b (19,19)

On the 4x4x4,
= b' D' 2U' 2R R' 2R f' 2R' f 2R' R d b' r' 2B' r b E' b
= b' D' 2U' 2R' R' 2R' f' 2R' f 2R' R d b' r' 2B' r b E' b
= b' D' 2U' r' 2R' f' 2R' f 2R' R d b' r' 2B' r b e' b (18,18)

Decomposition (on the outer orbit of the 6x6x6)
3b' U D' 
3u' 2R
3r' 2-3r2 3f' 2R' 3f 2-3r2 3r
3u 3r' 3f' 2R' 3f 3r
D U' 3b
= [3b' U D' 3u' *2R*: [3r' 2-3r2 3f': (*2R'*)] [3u 3r' 3f', *2R'*] ]

In short, I did all of the hard work years ago, but I didn't put two and two together to get what I was after. Then, several years after the fact, I _guess_ I was "distant enough" from all of the previous chaos (after the dust settled) to be able to spot a destined to be match just by sheer luck (this was the second algorithm I looked at in the wiki: I could have potentially looked at several more before I would have found one that worked).
People like Ben and qqwref (and anyone else following my work) can try to find an alg that is 18q on the 4x4x4 and 5x5x5 and 19q on all size cubes (it could exist).

Until either I or someone does this, the Holy Grail, Challenger, and Reverter still claim the number one seats for the BQTM move metric on the nxnxn.


----------



## TMarshall (Jan 28, 2016)

Congratulations! This is really cool, even though I know practically nothing about cube theory. Maybe this will motivate me to learn more about the cube


----------



## G2013 (Jan 28, 2016)

Christopher, as your cube notation is not the standard one, I usually don't get it :S
Is 2U the same as Uw, and u the same as u? Or how is it? Also, what does "e" mean? I always get a scrambled cube when I try to perform some of your algs :/

But, as I understand, this is a quite impressive discovery, so congratulations!


----------



## ryanj92 (Jan 28, 2016)

G2013 said:


> Christopher, as your cube notation is not the standard one, I usually don't get it :S
> Is 2U the same as Uw, and u the same as u? Or how is it? Also, what does "e" mean? I always get a scrambled cube when I try to perform some of your algs :/
> 
> But, as I understand, this is a quite impressive discovery, so congratulations!



Can you not view the alg.cubing.net links?
To answer your questions, 2U is the inner slice only. e is both inner slices in the E direction (I guess it is lower case because E and e would mean different things on 5x5x5 and up)


----------



## Christopher Mowla (Jan 29, 2016)

Thanks for the compliments, guys.

Here is a "move optimized" 4x4x4 version (without cube rotations) that I have added to the wiki.
r' 3u' 2U' l' 2R' u' 2R' u 3l 2R' u l' u' 2R' u l e' r


----------



## qqwref (Jan 29, 2016)

Wow, congrats, cmowla! Amazing find. It's so weird how the moves are seemingly random, and yet everything but those two pieces comes back together in the end...


----------



## rokicki (Jan 29, 2016)

qqwref said:


> Wow, congrats, cmowla! Amazing find. It's so weird how the moves are seemingly random, and yet everything but those two pieces comes back together in the end...



Congratulations; that's really awesome! Maybe this will inspire some more explorations.


----------



## bcube (Jan 30, 2016)

I don't realize the aspects of your finding, but based on the responses of others, you have pushed the limits of some sort (again). Hats off to you, sir. Well done.


----------



## Christopher Mowla (Jan 30, 2016)

Again, thanks everyone for the compliments!



bcube said:


> I don't realize the aspects of your finding, but based on the responses of others, you have pushed the limits of some sort (again). Hats off to you, sir. Well done.



*History of 4x4x4 Single Dedge Flip Algorithms
*
AlgorithmBlock Quarter TurnsDate of Discovery2R2 B2 U2 2L U2 2R' U2 2R U2 F2 2R F2 2L' B2 2R2251998 (or earlier)y r' U' 2R' 2L' x' U2 2R' u 2R' x' u l' u' 2R' u l u' 2R2 x 2U' U x 2L 2R U r y'24August 17, 2009r y 2L 3l y' 3l' B z' 2L' x u2 y' r2 u' 2L' u r2 u' 2L 3u' u' F 2R' L' u' x y23December 13, 2009y' r u2 x' U D 2R y u2 r2 u 2R u' r2 d 2R' 2U D' x u2 r' y22December 28, 2009y2 r' s 2R' 2U' y' r' 2U' r d2 r' 2U r' y x 2L' u2 y' 3r' r' z y 2R s' r y220January 7, 2010r' 2U' d' D' y r 2D r' u r 2D' r' y' 2L' u' 2L u 2L 2U D y' r19January 12, 2010b' D' 2U' r' 2R' f' 2R' f 2R' R d b' r' 2B' r b e' b18January 27, 2016

*Notes*


I found the 18-24 algorithms by hand, and I assume that the 25 was found using a 3x3x3 setup on an optimal 3x3x3 solver. I was born in the late 80s, and thus I do not have a way of knowing when the first brief single dedge flip algorithm was discovered (and by whom). 
To give an accurate account, I listed the original algorithms that I found for every given length, including the exact cube rotations that were present when I derived them. 
I did not post any of the 24-19 move algorithms until after I started my methods thread. (I don't think I ever posted this 23 anywhere because it's hideous in comparison to others that I found). 
It turns out that if we would have used a program such as Cube Explorer, we could technically have found at least two 22s (and A LOT of 23s) if we would know how to translate them to the 4x4x4 properly.
r' U2 B 2R' B' U2 F2 l' B2 2R' B2 l B 2R F2 B' r
r' U2 B 2R' B' U2 F2 r' U2 2R' U2 r B 2R F2 B' r
(It's also possible that Clément Gallet's 4x4x4 solver could have also found these 22s.) 
Also, make no mistake, we could technically use 3x3x3 solvers to find the "base 2-cycle algorithm" for probably every algorithm I ever found using this "wide turn based method". 
After I found my 19q, I found evidence that cubers such as Chris Hardwick (the coolest cuber ever?) were very close (if they did not discover these type of wide-turn based algorithms for these 2 wing edge swaps and didn't notice what they had).
For example, all he had to do is convert the U face turns and the F turn in the algorithm:
(Rr) U (Rr)' U' (Rr)' F (Rr)2 U' (Rr)' U' (Rr) U (Rr)' (Ff)'
to inner slice turns, and he would have had what I have been calling a "wide turn base algorithm".

In fact, my 24, 23, and 22 were actually just a conjugation of this setup (but I created a different algorithm which generated this setup). (The minimum number of required setup block quarter turn moves is 5, and thus 22 is the minimum--that is if you have a move cancellation between the base and the setup moves.) 
I found the 19 and 20 via cyclic shifting (which I discovered/invented on my own--independently of any external sources--at the time when I found the 20: I didn't know what group theory was, nor was I well-versed in past forum posts.) 
Now that I recall, I found the 18q's base by including a face turn as part of the conjugation of the quarter turn (just as I did for Challenger and Reverter).


----------



## Christopher Mowla (Aug 23, 2018)

Hi everyone. (I know for many of the currently active members will probably not know of me or this thread, so this ought to be fun!)

It's been about two and a half years since I updated this thread, but recently I resumed my work on what I define as wide turn based 2-cycle parity algorithms in the Wiki.

Perhaps older members might have noticed that I have added many more brief algorithms of this type (for all last layer 2-cycle cases) to the Wiki this year (the Wiki page seemed to disappear with the upgrade: here is a backup until it comes back up.), and the following 45 minute video explains why. In addition, with the procedure I introduce in the video, I found probably one of the (if not the) largest collection of 4x4x4 2-cycle parity algorithms ever found. (Although most are useless on probably all accounts.) (A download link to this set is included at the bottom of the video description.)






(Also, I apologize about the video quality. Should have been more careful with the screen-recorder region! I should know better. But, oh well. It's still watchable.)

I present a challenge at the end of the video (for those who are interested to participate/try). I will take submissions of 2-cycle seed algorithms either in the video comments or I suppose in replies to this post.


----------



## PapaSmurf (Sep 4, 2018)

Hi. Your discoveries for cube theory have been pretty cool tbh and very impressive! How do you gen your algs, and is there a way you could help me gen my own 4x4 parity alg? I'm looking for one that preserves eoline with 11 edges orientated.


----------



## Christopher Mowla (Sep 6, 2018)

Hi everyone. Since I managed to complete my *Wide Turn Based 2-cycle parity algorithms* research project, I figured why not finish my last parity algorithm project: finding humanly comprehensible *2-Gen* parity algorithms by hand for the 4x4x4!


I am no a guru of 2-Gen, but I managed to create reasonably brief and/*or* relatively easy-to-understand single dedge flip algorithms for the 4x4x4 *in all 5 different 2-Gen move sets*. I ended up making a 7-part video series entitled *"**2-Gen 4x4x4 Parity Algorithms**"*.

*UPDATE:*
For "Type III" (<r,Uw>), see *this post* for a 53 move algorithm which is based off of the algorithm derived in the "Type II" (<r,3Uw>) video. _Seeing the video for Type III is still good, as I use the same setup moves in both algorithms. In addition, it turns out that these same setup moves are used in the optimal solution found by Ben Whitmore!_
For "Type V" (<Rw,3Uw>), see *this post* for a collection of 150 move algorithms (which are 10 move sequences repeated 15 times). In a few posts that follow, Tom Rokicki posted an 87 move algorithm. _(These algorithms are significantly shorter than the one I derive in the video.)_



Of course, none of these algorithms are practical to actually use in a solve, especially since even the move optimal solutions are not.


Currently, the length of the move-optimal single dedge flip algorithm in the move set <Rw,3Uw> is unknown. I am not aware that any single dedge flip algorithms have ever been found in that move set, but I do show how to derive a (LONG) supercube safe one in the final video of the series.


Many thanks to Ben Whitmore for inspiring me to explore all 5 types. His *2-gen collection on his website* is very thorough! I also would like to thank Lucas Garron and Bruce Norskog, as they did computer searches for 2-Gen 4x4x4 parity algorithms in the past as well.


Lastly, I hope those who are interested in the series do enjoy it!
*AND, it is important to watch the videos in the order I present them, as the knowledge gained from one type is potentially used in the next.* So, don't just skip to the last video because it's short. You "won't get it" unless you have watched all of the videos before watching it.


----------



## xyzzy (Sep 7, 2018)

Christopher Mowla said:


> Currently, the length of the move-optimal single dedge flip algorithm in the move set <Rw,3Uw> is unknown. I am not aware that any single dedge flip algorithms have ever been found in that move set, but I do show how to derive a (LONG) supercube safe one in the final video of the series.


I have some semi-crazy idea for finding a sub-optimal but not unreasonably long alg for this. I haven't watched the video, so I don't know how long your "LONG" alg is, but I sure hope my idea will get something shorter.

We'll see in a couple of hours!


----------



## rokicki (Sep 7, 2018)

xyzzy said:


> so I don't know how long your "LONG" alg is



In the video his long alg is long: 574 moves. That's definitely suboptimal.

The optimal algorithm is at least 48 moves long.

Here's one algorithm that is 115 moves long (there is cancellation on the repetitions).

(r 3u' r 3u2 r' 3u2 r 3u2 r' 3u2 r' 3u2 r2 3u2 r2 3u' r2 3u2 r2 3u2 r' 3u2 r' 3u2 r 3u2 r' 3u2 r 3u' r' 3u2 r 3u2 r 3u2 r 3u2 r2)3


----------



## xyzzy (Sep 7, 2018)

rokicki said:


> In the video his long alg is long: 574 moves. That's definitely suboptimal.
> 
> The optimal algorithm is at least 48 moves long.
> 
> ...


115 moves might be hard to beat with my method, heh. I was thinking of reducing to subgroups generated by longer sequences, e.g. 3u' r 3u, then using the same idea of forcing everything to have short odd cycles. It takes nine moves to reduce pure UF flip to the ⟨3u' r 3u, r⟩ subgroup, so that doesn't leave too much room for anything else.

Is 39 moves optimal for UF flip + (everything else is a 3-cycle)?


----------



## rokicki (Sep 7, 2018)

xyzzy said:


> Is 39 moves optimal for UF flip + (everything else is a 3-cycle)?



I would guess it is not; certainly the way I determined the result does not enforce that. You clearly see how I came up with the algorithm.

Depth 48 finished; UF single edge flip is at least 49 in this metric. I may or may not let depth 49 finish.


----------



## xyzzy (Sep 8, 2018)

rokicki said:


> I would guess it is not; certainly the way I determined the result does not enforce that. You clearly see how I came up with the algorithm.


I was wondering if the optimal just happened to also have all the edges and corners solved. But indeed it is not—here's a 34f edge flip with some wing 3-cycles, centre 3-cycles, and corner twists: 3u1 r3 3u2 r2 3u2 r1 3u3 r1 3u2 r1 3u2 r3 3u2 r3 3u3 r3 3u2 r1 3u1 r3 3u2 r1 3u3 r2 3u2 r3 3u1 r2 3u1 r2 3u3 r2 3u1 r2. (This might not be optimal either.)

No move cancellations, so repeating it gives 102 moves.


----------



## rokicki (Sep 8, 2018)

Wow, that's impressive. Gotta ask, how did you find it? Making a pruning table that enforces only three-cycles seems challenging.


----------



## xyzzy (Sep 8, 2018)

Not just challenging; I don't have any clue on how to go about doing that either! What I used was this: solving four wing pieces (the UF dedge and two other pieces), five centre pieces, and one corner piece; this was done with two small pruning tables (~4-5 million entries). I then multiplied the resulting pruning value by 2, which makes it almost certainly not optimal, and filtered the solutions (which can have up to 16 unsolved wings and 17 unsolved centres) for those that had only fixed points and 3-cycles.

Now I'm running a full optimal search (i.e. solving only the UF dedge, no restrictions on other pieces), but it's only finished exploring 25 moves so far. (The code is… not fast.) Edit: finished searching up to 27 moves now; still hasn't found anything. Edit 2: oops, found a bug—it was searching something completely different. Disregard this whole paragraph!


----------



## abunickabhi (Sep 10, 2018)

rokicki said:


> Wow, that's impressive. Gotta ask, how did you find it? Making a pruning table that enforces only three-cycles seems challenging.



Is making three-cycle pruning table that hard? I have no idea how to go about it.


----------



## rokicki (Sep 10, 2018)

Maybe making a three-cycle pruning table is not hard, but I don't know how to do it.

Minimum length is now 50 (the depth-49 search completed).


----------



## Christopher Mowla (Sep 14, 2018)

I mentioned in the fourth video of my 2-gen series about "Type 3" == <r,Uw> that there is room for improvement. In the video, I derived a 61 move algorithm. Below is a derivation of a 53 by simply reusing the 37 move algorithm I found which is in <r,3Uw> ("Type 2"). (An algorithm which I derived without repetition.)

Specifically,


Spoiler: Derivation



[1] Below is the algorithm which is derived by *16:03* of the video on <r,3Uw>.
*[Link]*
r
r2 3Dw2 r2 3Dw2 r2
3Dw2 r'
3Dw2 r2 3Dw2 r' 3Dw2 r2 3Dw2
r2
r 3Dw2
r'
3Dw r 3Dw r2 3Dw' r' 3Dw' r 3Dw r 3Dw r2 3Dw' r' 3Dw' r'

[2] Converting all 3Dw to Uw moves,
*[Link]*
2R
2R2 Uw2 2R2 Uw2 2R2
Uw2 2R'
Uw2 2R2 Uw2 2R' Uw2 2R2 Uw2
2R2
2R Uw2
2R'
Uw 2R Uw 2R2 Uw' 2R' Uw' 2R Uw 2R Uw 2R2 Uw' 2R' Uw' 2R'

[3] Shifting the last 10 moves to the beginning of the algorithm,
*[Link]*
Uw' 2R Uw 2R Uw 2R2 Uw' 2R' Uw' 2R'
2R
2R2 Uw2 2R2 Uw2 2R2
Uw2 2R'
Uw2 2R2 Uw2 2R' Uw2 2R2 Uw2
2R2
2R Uw2
2R'
Uw 2R Uw 2R2 Uw' 2R'

[4] Conjugate with essentially the same setup moves as I used in the video on "Type 3":
*[Link]*
2R2 Uw2 2R' Uw' 2R' Uw 2R Uw' 2R' Uw 2R2

Uw' 2R Uw 2R Uw 2R2 Uw' 2R' Uw' 2R'
2R
2R2 Uw2 2R2 Uw2 2R2
Uw2 2R'
Uw2 2R2 Uw2 2R' Uw2 2R2 Uw2
2R2
2R Uw2
2R'
Uw 2R Uw 2R2 Uw' 2R'

(2R2 Uw2 2R' Uw' 2R' Uw 2R Uw' 2R' Uw 2R2)'

[5] Simplifying and cancelling moves:
= *r2 Uw2 r' Uw' r' Uw r Uw' r' Uw r2 Uw' r Uw r Uw r2 Uw' r' Uw' r2 Uw2 r2 Uw2 r2 Uw2 r' Uw2 r2 Uw2 r' Uw2 r2 Uw2 r' Uw2 r' Uw r Uw r2 Uw' r Uw' r Uw r' Uw' r Uw r Uw2 r2 * (73,53)


Since the move optimal algorithm in <r,Uw> (again, I was using old WCA notation) is 27, then this algorithm is about double that, obviously.


----------



## rokicki (Sep 14, 2018)

rokicki said:


> Maybe making a three-cycle pruning table is not hard, but I don't know how to do it.
> 
> Minimum length is now 50 (the depth-49 search completed).


The depth-50 search completed yesterday, so the minimum length is now 51. Still running.

Here's a cute little algorithm that does it in 3150 moves (clearly not optimal):

(3u2 r 3u r 3u2 r' 3u' r 3u r)315

I have still not been able to beat the record 102 set by xyzzy. But I have found that there is no sequence shorter than 26 moves that when repeated 3 times is a pure double edge flip on UF.


----------



## Christopher Mowla (Sep 14, 2018)

rokicki said:


> The depth-50 search completed yesterday, so the minimum length is now 51. Still running.
> 
> Here's a cute little algorithm that does it in 3150 moves (clearly not optimal):
> 
> ...


I wrote a little routine in Mathematica earlier this year to find repeats of short sequences via a random scramble. (I did this to see if I could find alternate short move sequences to repeat 5 times to get OLL parity.) I just adjusted it to the given constraints and it is giving me move sequences with a random number of required repeats.

Below are the shortest so far (I started with "depth"/Length 8).

_All of these flip a single dedge, but most do not flip the UF one. Ones which do flip the UF dedge have an * next to them. My program is finding one sequence every few seconds, on average._

*Length of 8*_ (All are 4,680 moves.)_
*(3Uw' Rw2 3Uw Rw 3Uw' Rw' 3Uw2 Rw)585*
(Rw' 3Uw2 Rw 3Uw Rw' 3Uw' Rw2 3Uw)585
(Rw 3Uw Rw2 3Uw' Rw 3Uw2 Rw' 3Uw')585
(Rw' 3Uw Rw2 3Uw' Rw' 3Uw Rw 3Uw2)585
(3Uw' Rw' 3Uw2 Rw 3Uw' Rw2 3Uw Rw)585
(Rw2 3Uw' Rw' 3Uw Rw 3Uw2 Rw' 3Uw)585
(Rw 3Uw Rw' 3Uw' Rw2 3Uw Rw' 3Uw2)585
(Rw 3Uw2 Rw' 3Uw' Rw 3Uw Rw2 3Uw')585
(Rw2 3Uw Rw' 3Uw2 Rw 3Uw Rw' 3Uw')585
(3Uw Rw2 3Uw' Rw 3Uw2 Rw' 3Uw' Rw)585
(3Uw Rw 3Uw' Rw' 3Uw2 Rw 3Uw' Rw2)585
(Rw2 3Uw Rw 3Uw' Rw' 3Uw2 Rw 3Uw')585
(3Uw2 Rw 3Uw Rw' 3Uw' Rw2 3Uw Rw')585
(3Uw2 Rw' 3Uw Rw2 3Uw' Rw' 3Uw Rw)585
(Rw 3Uw2 Rw' 3Uw Rw2 3Uw' Rw' 3Uw)585
(3Uw2 Rw 3Uw' Rw2 3Uw Rw 3Uw' Rw')585
(Rw2 3Uw' Rw 3Uw2 Rw' 3Uw' Rw 3Uw)585
(Rw 3Uw' Rw' 3Uw2 Rw 3Uw' Rw2 3Uw)585
(3Uw Rw' 3Uw2 Rw 3Uw Rw' 3Uw' Rw2)585
(Rw' 3Uw' Rw 3Uw Rw2 3Uw' Rw 3Uw2)585
(3Uw2 Rw' 3Uw' Rw 3Uw Rw2 3Uw' Rw)585
(3Uw' Rw' 3Uw Rw 3Uw2 Rw' 3Uw Rw2)585
(Rw' 3Uw Rw 3Uw2 Rw' 3Uw Rw2 3Uw')585
(3Uw' Rw2 3Uw Rw' 3Uw2 Rw 3Uw Rw')585
(3Uw' Rw 3Uw2 Rw' 3Uw' Rw 3Uw Rw2)585

*Length of 10 *(_Tom, it also found the same sequence you posted which is of length 10, so I didn't include it_.)

_All of the following are obviously 150 moves._
*(3Uw' Rw2 3Uw2 Rw2 3Uw2 Rw 3Uw2 Rw' 3Uw2 Rw)15*
(Rw' 3Uw2 Rw 3Uw2 Rw2 3Uw2 Rw2 3Uw' Rw 3Uw2)15
(Rw2 3Uw' Rw 3Uw2 Rw' 3Uw2 Rw 3Uw2 Rw2 3Uw2)15
(3Uw2 Rw' 3Uw2 Rw 3Uw2 Rw' 3Uw Rw2 3Uw2 Rw2)15
(3Uw2 Rw' 3Uw2 Rw2 3Uw2 Rw2 3Uw Rw' 3Uw2 Rw)15
(3Uw2 Rw' 3Uw2 Rw 3Uw' Rw2 3Uw2 Rw2 3Uw2 Rw)15
(3Uw2 Rw 3Uw2 Rw' 3Uw2 Rw2 3Uw2 Rw2 3Uw Rw')15
(3Uw2 Rw 3Uw2 Rw' 3Uw2 Rw 3Uw' Rw2 3Uw2 Rw2)15
(Rw' 3Uw2 Rw 3Uw' Rw2 3Uw2 Rw2 3Uw2 Rw 3Uw2)15
(Rw2 3Uw2 Rw2 3Uw2 Rw' 3Uw2 Rw 3Uw2 Rw' 3Uw)15
*(Rw' 3Uw' Rw' 3Uw2 Rw 3Uw Rw' 3Uw' Rw' 3Uw2)315* (3150 moves)*
*(Rw2 3Uw' Rw' 3Uw Rw' 3Uw' Rw2 3Uw2 Rw' 3Uw2)285* (2850 moves)


It seems that algorithms of Length 8 is the minimum, but I can't prove this. I am running my solver again to see if it finds any solutions which consist of repeating an algorithm 7 moves long. In addition, I may run it for Length 30 or so to see if I can beat xyzzy's alg length.


----------



## xyzzy (Sep 14, 2018)

24×5 = 120 moves: (3u r2 3u2 r3 3u2 r3 3u r3 3u3 r 3u3 r2 3u2 r 3u2 r 3u2 r 3u2 r2 3u r2 3u2 r2)5

24 is optimal for UF flip + 5-cycles. (This is assuming centres are distinguishable, as on a supercube. My code doesn't handle the normal, non-supercube case.)


----------



## rokicki (Sep 15, 2018)

24x5 is minimal for a normal non-super-cube as well.

These are the numbers I see:

315x10
117x11
15x13
9x18
5x24

I'm still looking for the minimum sequence of 3.


----------



## Christopher Mowla (Sep 17, 2018)

Maybe we could observe xyzzy's algorithm as a product of commutators, conjugates, and short repeated sequences to perhaps find other short algorithms?

3u r' 3u2 r2 3u2 r 3u' r 3u2 r 3u2 r' 3u2 r' 3u' r' 3u2 r 3u r' 3u2 r 3u' r2 3u2 r' 3u r2 3u r2 3u' r2 3u r2
=
[3u r' 3u2: r2] [r 3u2 r 3u2: r'] [r 3u r' 3u2 r: 3u] (r' 3u2 r')2 (r 3u2)2 [3u', r2]2


----------



## rokicki (Sep 18, 2018)

Finally found one (or two). This is not necessarily optimal. It has a length of 31, but there are
move cancellations when repeating it thrice so the total length is 91.

r 3u' r' 3u2 r' 3u' r' 3u2 r' 3u r' 3u2 r' 3u2 r 3u' r2 3u2 r2 3u2 r2 3u' r' 3u2 r 3u2 r' 3u2 r 3u2 r

Any shorter sequence that repeated thrice gives the UD edge flip must be of length at least 27.

These deep searches take a long time to run (days) for me.


----------



## rokicki (Sep 19, 2018)

Here's a better one; this one has more cancellations so the total length of the result is 87.

r' 3u r 3u' r' 3u' r 3u r 3u' r' 3u r 3u r2 3u' r 3u r 3u r' 3u r 3u2 r 3u r 3u2 r' 3u r


----------

