Warning: touch() [function.touch]: Utime failed: Permission denied in [path]/includes/class.latex-vb.php on line 167
Methods for Forming 2-Cycle Odd Parity Algorithms for Big Cubes - Page 4

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

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

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

2. Originally Posted by mrCage
Very nice algorithm, particularly the 16 btm one, a conjugate!!
I don't know why someone hasn't posted this idea before, but here are 4-cycle conjugates.

4-Cycles for all Even Cubes
Spoiler:
All in one slice
[Uw2 r' u2 l2 S': u] (17,11)
[f2 l' u2 l2 S' : u] (17,11)

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

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.

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

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

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

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

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

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

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

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

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

Look similar?

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[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
Spoiler:
Here's a single slice turn algorithm (long, I know) I made up using the same process as for wide turn based algorithms. It's long, but it's a perfect demonstration of how the method can translate to single slice turn based algorithms too.

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

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

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

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

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

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

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

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

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

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

Using the commutator F' r' F U2 F' r F U2, we can achieve an 18 btm which is nearly <U, r>:
r2 U2 r2 U2 r U2 r U2 r' U2 B2 U' r' U B2 U' r U'
Here are some more examples. Note that I simplified l' U2 l U2 r' U2 r U2 l' l to l' U2 l U2 r' U2 r U2.

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

U2 r' U2 r U2 l' U2 l [F2 l' B D2 B': r'] (27,19)
Single Slice Turn Based 3 Flips (for all size cubes) using "Route 1"
Spoiler:
For 3-Flips, instead of placing three blocks of equal size into the quarter turn inner layer slice, with this approach, we instead try to place four wing edges into the slice with this type of 4-cycle permutation (and its inverse, depending on which direction we go in) BEFORE we apply the quarter turn.
r U2 r l' U2 r2 U2 r' U2 r U2 r' U2 r' U2 l U2 r'

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

As another quick example, here is the exact same algorithm choosing to affect the green and white composite edge. Only the moves in red font need to be changed.
[Rw' U' F' R' F R2 U': r] [D' U' F2 U D: [r', F2] [F2 r2 F2: r2] ] (43,33)
Route 2 for Wide Turn Based Parity Algorithms (Revisited)
Spoiler:
Now don’t hope to find any commutators similar to the one I’m about to present (if you can find another unique commutator as brief as this one, please share!), but the following commutator does an extraordinary thing for us. Unlike the detailed example for the introduction to Route 2 which mentioned having to set up the centers in addition to wing edges to achieve a certain 2-cycle which does not discolor X-center pieces (speaking of the 4x4x4 only, although all algorithms in this post can be translated to all size cubes, but I cannot promise at a pleasant move count), you do not have to set up the centers at all when we are conjugating the quarter turn!

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

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

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

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

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

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

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

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

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

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

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

Derivation
Spoiler:
(Rw' U' Rw U2 Rw' U' Rw U2 Rw' U Rw U2)4

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

My own intuitive 2-gen edge flip for <U,r>
r U2 r2 U r' U2 r' U2 r U2 r U2 r2 U2 r2 U2 r2 U r2 U' r' U2 r' U2 r U2 r U2 r2 U2 r2 U2 r2 U r U2 r2 U2 r' (63,39)
Derivation
Spoiler:
There are a two even permutation sequences that I know off hand which do not affect that many pieces and which are in <U,r>. They are:
r2 U2 r2 U2 r2 (used to create Chris Hardwick's PLL Parity algorithm r2 U2 r2 Uw2 r2 u2 = r2 U2 r2 U2 r2 + r2 u2 r2 u2
and
r' U2 r' U2 r U2 r U2

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

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

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

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

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

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

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

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

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

=
r U2 r' r2 r U2
U' (r' U2 r' U2 r U2 r U2) (r2 U2 r2 U2 r2) U
r2
U' (r' U2 r' U2 r U2 r U2) (r2 U2 r2 U2 r2) U
r2
(r')
U2 r' r2 r U2 r'
= [r U2 r2 U2: ([U': [r' U2 r', U2] [r2 U2: r2] ] r2)2 (r')] (63,39)
A compromise between my 2-gen algorithm and wide turn 2-gen algorithms.
Spoiler:
The following algorithm about to be derived is by no means as complicated as the <U,Rw> 2-gen algorithm cuBerBruce found (nor is it the same type of algorithm in any sense), but the majority of it is in <U,Rw>. I have posted it in the past, but here's how I found it.

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

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

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

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

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

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

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

4. Originally Posted by cmowla
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.

5. Originally Posted by Stefan
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.

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

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

And actually, the "simple form" algorithm I previously posted (however I have deleted it and posted it in the spoiler below) was actually Frédérick Badie'salgorithm.
Spoiler:
F2 r2 F2 U2 r U2 r' U2 r2 F2 l F2 l' U2 r.
=
F2 r2
F2 U2 r U2 r' U2
r2 F2
l F2 l' U2 r
=
F2 r2
F2 U2 r x' F2 r' x U2
r2 F2
l F2 l' U2 r
=
[F2 r2: [F2, U2 r x']]
l F2 l' U2 r
Convert to wide turns
[F2 Rw2: [F2, U2 Rw x']]
Lw F2 Lw' U2 Rw
= (in wide turns)
[F2 Rw2: [F2, U2 Lw]]
Lw F2 Lw' U2 Rw
Making adjustment (bold wide turns means to include central slice with odd cubes)
[F2 Rw2: [F2, U2 Lw]]
Rw U2 Rw' U2 Rw
= [F2 Rw2: [F2, U2 Lw]] (Rw) [U2, Rw']
Cube Explorer's Algorithm (Well, one of them I generated with it)
r B2 r' U2 r U2 r2 F2 r' D2 l D2 B2 r2 F2 (25,15)
Spoiler:
=
U2 l
l' U2 l (L R') U2 r' F2 r F2
L2 R2
l
l U2 l' (L' R) U2 l'
l2 U2 F2 l2 (L2 R2) F2 U2 l2
l'
l' U2

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

Here's a transformation of it that we can start from.
U2 l
l' U2 l U2 r' F2 r F2
l
l U2 l' U2 l'
l2 U2 F2 l2 F2 U2 l2
l'
l' U2

= l U2 r' F2 r F2 l2 U2 l' U2 l U2 F2 l2 F2 (25,15)

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

Note that:
L and L2 represent all slices on the left side (including the outer layer move, L2, besides the orbits affected).
R', R, and R2 is represents just themselves.
Now, take note that the transformation is completed by introducing cube rotations.
(l L R') U2 r' F2 r F2 (l2 L2 R2) U2 (l' L' R) U2 l U2 F2 (l2 L2 R2) F2 =
(r x') U2 r' F2 r F2 (r2 x2) U2 (r' x) U2 l U2 F2 (r2 x2) F2
=r B2 r' U2 r U2 r2 F2 r' D2 l D2 B2 r2 F2
Another Optimal (in btm) Non-symmetrical Edge Flip Algorithm
This algorithm has the briefest representation, so I thought I should include it.
This algorithm was probably made several years ago. It's just a cyclic shift, y2 cube rotation, and mirror of the transformation of "Cube Explorer's Alg" previously shown in this post.
r2 U2 r' U2 r U2 B2 r2 B2 r U2 l' B2 l B2 (25,15)
Spoiler:
=
r
r U2 r' U2 r'
r2 U2 B2 r2 B2 U2 r2
r'
r' U2 r U2 l' B2 l B2

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

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

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

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

8. 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.
Proof:
The 10 unique algorithms can be broken up into two groups. Each of the two groups contain five algorithms which are directly related via transformations (or mirrors of transformations).

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

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

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

FB (v2)
r' U2 r U2 l' U2 l2 F2 r F2 l' U2 F2 r2 F2 = Transformation(r' U2 l F2 l' F2 r2 U2 r U2 r' U2 F2 r2 F2).
Proof:
r' U2 l (L R') F2 l' F2 r2 (L2 R2) U2 r U2 r' (L R') U2 F2 r2 F2
=
r' U2 l (L R') (x) U2 l' U2 r2 (L2 R2) (x2) F2 r F2 r' (L R') (x) U2 F2 r2 F2
=
r' U2 l (L R') (L' l' r R) U2 l' U2 r2 (L2 R2) (L2 l2 r2 R2) F2 r F2 r' (L R') (L' l' r R) U2 F2 r2 F2
=
r' U2 r U2 l' U2 l2 F2 r F2 l' U2 F2 r2 F2 ***

FB (v3)
r B2 r' U2 r U2 r2 F2 r' D2 l D2 B2 r2 F2 = Transformation(r' U2 l F2 l' F2 r2 U2 r U2 r' U2 F2 r2 F2).
Proof:
Mirror(r' U2 l F2 l' F2 r2 U2 r U2 r' U2 F2 r2 F2)= l U2 r' F2 r F2 l2 U2 l' U2 l U2 F2 l2 F2.
l (L R') U2 r' F2 r F2 l2 (L2 R2) U2 l' (L' R) U2 l U2 F2 l2 (L2 R2) F2
=
l (L R') (x) B2 r' U2 r U2 l2 (L2 R2) (x2) F2 l' (L' R) (x') D2 l D2 B2 l2 (L2 R2) (x2) F2
=
l (L R') (L' l' r R) B2 r' U2 r U2 l2 (L2 R2) (L2 l2 r2 R2) F2 l' (L' R) (L l r' R') D2 l D2 B2 l2 (L2 R2) (L2 l2 r2 R2) F2
=
r B2 r' U2 r U2 r2 F2 r' D2 l D2 B2 r2 F2 ***

FB (v4)
r B2 r' U2 r U2 l2 B2 r' U2 l U2 F2 l2 F2 = Transformation(r' U2 l F2 l' F2 r2 U2 r U2 r' U2 F2 r2 F2).
Proof:
Mirror(r' U2 l F2 l' F2 r2 U2 r U2 r' U2 F2 r2 F2)= l U2 r' F2 r F2 l2 U2 l' U2 l U2 F2 l2 F2.
l (L R') U2 r' F2 r F2 l2 U2 l' (L' R) U2 l U2 F2 l2 F2
=
l (L R') (x) B2 r' U2 r U2 l2 B2 l' (L' R) (x') U2 l U2 F2 l2 F2
=
l (L R') (L' l' r R) B2 r' U2 r U2 l2 B2 l' (L' R) (L l r' R') U2 l U2 F2 l2 F2
=
r B2 r' U2 r U2 l2 B2 r' U2 l U2 F2 l2 F2 ***

FB (v5)
r B2 l' B2 l U2 r2 F2 l' F2 r U2 F2 l2 F2 = Transformation(r' U2 l F2 l' F2 r2 U2 r U2 r' U2 F2 r2 F2).
Proof:
Mirror(r' U2 l F2 l' F2 r2 U2 r U2 r' U2 F2 r2 F2)= l U2 r' F2 r F2 l2 U2 l' U2 l U2 F2 l2 F2.
l (L R') U2 r' (L R') F2 r (L' R) F2 l2 (L2 R2) U2 l' U2 l (L R') U2 F2 l2 F2
=
l (L R') (x) B2 r' (L R') (x) B2 r (L' R) (x') U2 l2 (L2 R2) (x2) F2 l' F2 l (L R') (x) U2 F2 l2 F2
=
l (L R') (L' l' r R) B2 r' (L R') (L' l' r R) B2 r (L' R) (L l r' R') U2 l2 (L2 R2) (L2 l2 r2 R2) F2 l' F2 l (L R') (L' l' r R) U2 F2 l2 F2
=
r B2 l' B2 l U2 r2 F2 l' F2 r U2 F2 l2 F2 ***
Group 2:
To show that the following group of algorithms are directly related (via transformations), let's just use Alg.2(v1) as the tester.
r B2 r' U2 r D2 r2 U2 F2 l F2 r' D2 r2 B2 |Alg.2(v1)|
r B2 r' U2 r D2 l2 D2 B2 l B2 r' U2 l2 B2 |Alg.2(v2)|
r B2 r' U2 l B2 l2 B2 U2 l U2 l' U2 l2 B2 |Alg.2(v3)|
r B2 l' B2 l D2 l2 D2 B2 r D2 l' D2 r2 B2 |Alg.2(v4)|
r' U2 r U2 l' D2 r2 D2 B2 l' D2 r D2 l2 B2 |Alg.2(v5)|

Alg.2(v2)
r B2 r' U2 r D2 l2 D2 B2 l B2 r' U2 l2 B2 = Transformation(r B2 r' U2 r D2 r2 U2 F2 l F2 r' D2 r2 B2)
Proof:
r B2 r' U2 r D2 r2 (L2 R2) U2 F2 l F2 r' D2 r2 (L2 R2) B2
=
r B2 r' U2 r D2 r2 (L2 R2) (x2) D2 B2 l B2 r' U2 r2 (L2 R2) (x2) B2
=
r B2 r' U2 r D2 r2 (L2 R2) (L2 l2 r2 R2) D2 B2 l B2 r' U2 r2 (L2 R2) (L2 l2 r2 R2) B2
=
r B2 r' U2 r D2 l2 D2 B2 l B2 r' U2 l2 B2 ***

Alg.2(v3)
r B2 r' U2 l B2 l2 B2 U2 l U2 l' U2 l2 B2 = Transformation(r B2 r' U2 r D2 r2 U2 F2 l F2 r' D2 r2 B2)
Proof:
r B2 r' U2 r (L' R) D2 r2 (L2 R2) U2 F2 l F2 r' (L R') D2 r2 (L2 R2) B2
=
r B2 r' U2 r (L' R) (x') B2 r2 (L2 R2) F2 D2 l D2 r' (L R') (x) D2 r2 (L2 R2) B2
=
r B2 r' U2 r (L' R) (x') B2 r2 (L2 R2) (x2) B2 U2 l U2 r' (L R') (x) U2 r2 (L2 R2) (x2) B2
=
r B2 r' U2 r (L' R) (L l r' R') B2 r2 (L2 R2) (L2 l2 r2 R2) B2 U2 l U2 r' (L R') (L' l' r R) U2 r2 (L2 R2) (L2 l2 r2 R2) B2
=
r B2 r' U2 l B2 l2 B2 U2 l U2 l' U2 l2 B2 ***

Alg.2(v4)
r B2 l' B2 l D2 l2 D2 B2 r D2 l' D2 r2 B2 = Transformation(r B2 r' U2 r D2 r2 U2 F2 l F2 r' D2 r2 B2)
PROOF:
r B2 r' (L R') U2 r (L' R) D2 r2 (L2 R2) U2 F2 l (L R') F2 r' (L R') D2 r2 B2
=
r B2 r' (L R') (x) B2 r (L' R) (x') D2 r2 (L2 R2) U2 F2 l (L R') (x) U2 r' (L R') (x) (x2) D2 r2 B2
=
r B2 r' (L R') (x) B2 r (L' R) (x') D2 r2 (L2 R2) (x2) D2 B2 l (L R') (x) D2 r' (L R') (x) (x2)(x2) D2 r2 B2
=
r B2 r' (L R') (L' l' r R) B2 r (L' R) (L l r' R') D2 r2 (L2 R2) (L2 l2 r2 R2) D2 B2 l (L R') (L' l' r R) D2 r' (L R') (L' l' r R) (L2 l2 r2 R2) (L2 l2 r2 R2) D2 r2 B2
=
r B2 l' B2 l D2 l2 D2 B2 r D2 l' D2 r2 B2 ***

Alg.2(v5)
r' U2 r U2 l' D2 r2 D2 B2 l' D2 r D2 l2 B2 = Transformation(r B2 r' U2 r D2 r2 U2 F2 l F2 r' D2 r2 B2)
Proof:
Mirror(r B2 r' U2 r D2 r2 U2 F2 l F2 r' D2 r2 B2) = l' B2 l U2 l' D2 l2 U2 F2 r' F2 l D2 l2 B2
l' (L' R) B2 l (L R') U2 l' D2 l2 (L2 R2) U2 F2 r' (L R') F2 l (L R') D2 l2 B2
=
l' (L' R) (x') U2 l (L R') (x) U2 l' D2 l2 (L2 R2) U2 F2 r' (L R') (x) U2 l (L R') (x) (x2) D2 l2 B2
=
l' (L' R) (x') U2 l (L R') (x) U2 l' D2 l2 (L2 R2) (x2) D2 B2 r' (L R') (x) D2 l (L R') (x) (x2)(x2) D2 l2 B2
=
l' (L' R) (L l r' R') U2 l (L R') (L' l' r R) U2 l' D2 l2 (L2 R2) (L2 l2 r2 R2) D2 B2 r' (L R') (L' l' r R) D2 l (L R') (L' l' r R) (L2 l2 r2 R2)(L2 l2 r2 R2) D2 l2 B2
=
r' U2 r U2 l' D2 r2 D2 B2 l' D2 r D2 l2 B2 ***
Examples:
Example 1:
Decomposition(FB(v2)) = Decomposition(r' U2 r U2 l' U2 l2 F2 r F2 l' U2 F2 r2 F2)
=
U2 r'
r U2 r' U2 (L R') l F2 l' F2
r U2
U2 (L2 R2) r U2 r'
r2 U2 (r') (L R') U2 r2
r2 F2 r2 F2
=
U2 r'
r U2 r' U2 (L R') l F2 l' F2
r U2
U2
(L2 R2) r U2 r' U2
U2
r2 U2 (r') (L R') U2 r2
r2 F2 r2 F2
= [U2 r': [r, U2] (L R') [l, F2] ] [U2: (L2 R2) [r, U2] ] [r2 U2: (r') (L R')] [r2, F2]
Example 2:
Decompositon(Alg.2(v3)) = Decomposition(r B2 r' U2 l B2 l2 B2 U2 l U2 l' U2 l2 B2)
=
[y2 l F2 l' U2 r: Decomposition(Frédérick Badie)]'
=
(y2 l F2 l' U2 r
r' U2 l F2 l' F2 r2 U2 r U2 r' U2 F2 r2 F2
r' U2 l F2 l' y2)'
=
(y2 l F2 l' U2 r
U2 r'
r U2 r' U2 l F2 l' F2
r U2
U2 r U2 r'
r2 U2 (r') U2 r2
r2 F2 r2 F2
r' U2 l F2 l' y2)'
=
r B2 r' U2 l
B2 l2 B2 l2
l2 U2 (l) U2 l2
l U2 l' U2
U2 l'
B2 r B2 r' U2 l U2 l'
l U2
l' U2 r B2 r'
=
[r B2 r' U2 l: [B2, l2] [l2 U2: (l)] [l, U2] [U2 l': [B2, r] [U2, l] ] ]

This can be simplified to:
B2 l U2
l' U2
U2 l U2 l' B2 r B2 r'
U2 l
B2 l2 B2 l2
l2 U2 (l) U2 l2
l U2 l' U2
U2 l' B2
=
[B2 l U2: [l' U2: [U2, l] [B2, r] ] [B2, l2] [l2 U2: (l)] [l, U2] ]

Comparing this simplified form to Decomposition(FB),
Recall that Decomposition(FB) =
U2 r'
r U2 r' U2 l F2 l' F2
r U2
U2 r U2 r'
r2 U2 (r') U2 r2
r2 F2 r2 F2

and Decomposition(Alg.2(v3)) =
y2 F2 r U2
(U2 r'
r U2 r' U2 l F2 l' F2
r U2)'
(r2 F2 r2 F2)'
(r2 U2 (r') U2 r2)'
(U2 r U2 r')'
U2 r' F2 y2

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

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

To obtain all 16 symmetrical 15 btm single dedge flip solutions (with the UF dedge flipped and the affected center in U), we just need to know the first algorithms in each group. Taking 7 transformations of the first algorithm in Group 1 and taking 7 transformations of the first algorithm in Group 2 will generate all 16 symmetrical algorithm solutions.

Group 1
r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2 (Old Standard Algorithm)
r2 B2 U2 l U2 l' B2 r B2 U2 r U2 r' B2 r2
r2 F2 D2 r' D2 r F2 l' F2 D2 l' D2 l F2 r2
r2 F2 D2 r' D2 l D2 l' D2 B2 l' B2 r F2 r2
r2 B2 U2 r B2 r' B2 l U2 F2 r F2 l' B2 r2
r2 F2 D2 l' F2 l F2 r' D2 B2 l' B2 r F2 r2
r2 B2 U2 r B2 l' D2 r D2 B2 l U2 r' B2 r2
r2 F2 D2 l' F2 r U2 l' U2 F2 r' D2 l F2 r2

Group 2
r2 B2 U2 l' U2 r U2 r' U2 B2 r' B2 l B2 r2
r2 B2 U2 l' U2 l F2 r' F2 U2 r' U2 r B2 r2
r2 F2 D2 r D2 r' B2 l B2 D2 l D2 l' F2 r2
r2 F2 D2 r D2 l' D2 l D2 F2 l F2 r' F2 r2
r2 B2 U2 r' F2 r F2 l' U2 B2 r' B2 l B2 r2
r2 B2 U2 r' F2 l D2 r' D2 F2 l' U2 r B2 r2
r2 F2 D2 l B2 r' U2 l U2 B2 r D2 l' F2 r2
r2 F2 D2 l B2 l' B2 r D2 F2 l F2 r' F2 r2

All 15 btm symmetrical solutions are related.
Proof:
Since the first algorithm in Group 1 = r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2 = (r2 B2) (U2 l U2 r' U2 r U2 l') (l F2 r F2 l') (B2 r2), note that the first algorithm in Group 2 is simply a slight modification:
= (r2 B2) (y2) Mirror((U2 l U2 r' U2 r U2 l') (l F2 r F2 l')(y2)) (B2 r2)
= (r2 B2) (y2) (U2 r' U2 l U2 l' U2 r) (r' F2 l' F2 r)(y2) (B2 r2)
= (r2 B2) (U2 l' U2 r U2 r' U2 l) (l' B2 r' B2 l) (B2 r2)
= r2 B2 U2 l' U2 r U2 r' U2 B2 r' B2 l B2 r2

Also,
[1] If we take the first algorithm in Group 1,
r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2
[2] Shift,
r' U2 r U2 F2 r F2 l' B2 r2
r2 B2 U2 l U2
r2 B2
r' U2 r U2 F2 r F2 l' B2 r2
r2 B2 U2 l U2
B2 r2
= r2 B2 r' U2 r U2 F2 r F2 l' U2 l U2 B2 r2
[4] Take the inverse,
r2 B2 U2 l' U2 l F2 r' F2 U2 r' U2 r B2 r2 = Second algorithm in Group 2.

Either way, we can see that 15 btm symmetrical solutions are also related because, if we modify an algorithm in one group, we obtain an algorithm from the other group. This follows for all 16 algorithms because all 8 algorithms from each of the two groups are directly related via transformations (or mirrors of transformations)

#### Posting Permissions

• You may not post new threads
• You may not post replies
• You may not post attachments
• You may not edit your posts
•