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

[cmowla]

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)



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:

The First Portion

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

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 be

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







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

or represents the case

because we have 4 orbits taking all 4 at once.


or represents the cases:
, etc.
because we have 4 orbits taking 3 at once.



or represents the cases:
,etc.
because we have 4 orbits taking 2 at once.

and finally,


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.

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]

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.

[cmowla]

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]

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

[cmhardw]

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

[cmowla]

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.

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.

[cmowla]

Another 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]

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

[Kirjava]

This is amazing.

[bamilan]

wow