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

#### mrCage

##### Member
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

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

Last edited:

#### Christopher Mowla

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

##### Member
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

Last edited:

#### Christopher Mowla

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

##### Member
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

Last edited by a moderator:

#### Christopher Mowla

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

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

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

Last edited:

#### Christopher Mowla

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.

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

Last edited:

#### mrCage

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

Per

#### Christopher Mowla

For the opposite wing edge swap case, I managed to get 1q less than my previous record.
Rw U' r Uw Lw' Uw' r Fw r Fw' r2 Uw Lw u' Rw' (16q, 15 btm)

Derivation
 Commutator: Uw Lw Uw' r Uw Lw' Uw' r'
 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)
 Shift
Uw' r Uw Lw' Uw' r'
r2 Fw
r
Fw' r2 Uw Lw
 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.
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
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
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.
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
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.
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.
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.
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
 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'

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

 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

Last edited:

#### AvGalen

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

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
All in one slice
[Uw2 r' u2 l2 S': u] (17,11)
[f2 l' u2 l2 S' : u] (17,11)

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

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

[L' Fw' f' l' u2 Lw2 S' : u] (19,15)*

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

Last edited:

#### Christopher Mowla

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

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

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

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)

[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
Procedure:
 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).
 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  here.
 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).
 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,

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

 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.

 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'

 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.

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

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

 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)

[Fw', Uw r' Uw'] [Uw r2 Fw2 L Fw U' R2 U: r'] (27,22)

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

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

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

[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
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
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.
r2 U2 r2 U2 r U2 r U2 r' U2 B2 U' r' U B2 U' r U' (27,18)
Derivation
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.

 Add F2 to have all three wings in the same slice
U2 l U2 r' U2 r U2 l'
F2

 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

 Add F2 to restore the cube somewhat
U2 l U2 r' U2 r U2 l'
F2
r
F2

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

 Add F2 to restore the cube somewhat
U2 l U2 r' U2 r U2 l'
F2
r
F2
r' F2 r
F2

 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)

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

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.

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

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

 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

 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

 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

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

[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).
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
(Rw' U' Rw U2 Rw' U' Rw U2 Rw' U Rw U2)4

 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'

 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

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

 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

 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]

 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'

 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]

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

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

 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)

 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

 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.

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

Last edited:

#### Stefan

##### Member
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

##### Member
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

##### Member
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

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

F2 r2 F2 U2 r U2 r' U2 r2 F2 l F2 l' U2 r (25,15)
=
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.
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)
=
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
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)
=
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.

Last edited:

#### Christopher Mowla

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

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 ***
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 ***
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]
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.
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,
 If we take the first algorithm in Group 1,
r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2
 Shift,
r' U2 r U2 F2 r F2 l' B2 r2
r2 B2 U2 l U2
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
 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

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

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:
 Do a quarter turn to slice r: r'
 Move the 1x2 centers in slice r into slice l: r' E2 S2
 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'
 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 ).

Last edited: