Thread starter
#41

**The Holy Grail Pure Edge Flip Parity Algorithm Finally Matched!**

Today was my annual search day for a possible 18q single dedge flip algorithm. (I still search about once a year.)

I didn't find an 18q, but, after more than 6 years, today I found a single dedge flip algorithm which matches the move count of the Holy Grail algorithm for the nxnxn!

It is the same quantity of block half turns and block quarter turns for all (and the same) cases, but it is actually

*shorter than the Holy Grail alg*for the nxnxn in the:

- single slice turn metric
- plane half turn metric (OBTM)
**plane quarter turn metric (QTM)**

Since the Holy Grail alg was (one of) the shortest algorithms in QTM (for all size cubes), we now have an algorithm that is fewer QTM than any other algorithm in history! This algorithm is 22 QTM on the 4x4x4 and 5x5x5, and 24 QTM on individual orbits on the 6x6x6 and 7x7x7! (It's 22 QTM for nxnxn cases like the ones I posted images of in

**this post**.)

In addition to its move count being shorter in the three above move metrics than the Holy Grail (and matching the lengths of the other two move metrics),

- This algorithm is the first single dedge flip algorithm I have ever seen which can be
**reverted**(not just inverted) to achieve the exact same affect. - This algorithm, unlike the Holy Grail and
**all**19q algorithms I have ever found, only exchanges center pieces in the top face on the supercube.

May I represent, "

**Challenger**", and its twin, "

**Reverter**"!

Rw Uw' L Dw' R Uw'

**r**Uw R'

**r'**Dw LW2 Dw'

**r**Dw LW2 L' Uw Rw'

= [Rw Uw' L Dw': [R Uw': (r)] [r', Dw LW2 Dw'] ]

and here is its move inverted "twin", "Reverter" (the inverse of its reverse),

Rw' Uw L' Dw R' Uw

**r'**Uw' R

**r**Dw' LW2 Dw

**r'**Dw' LW2 L Uw' Rw

= [Rw' Uw L' Dw: [R' Uw: (r')] [r, Dw' LW2 Dw] ]

- LW2 means to turn the left half of the cube on even cubes and the left half of the cube + the central slice on odd cubes.
- The bold r moves indicate the slices that you apply to the orbits of wings you wish to affect.

Now, I will link (Challenger: you can just invert all moves without changing their locations to get Reverter's animations) to alg.cubing.net in SiGN notation for each cube size (with moves simplified specific to each case).

4x4x4

r u' L d' R u' 2R u r' d l2 d' 2R d l 2L u r'

5x5x5

r u' L d' R u' 2R u r' d 3l2 d' 2R d 3l 2-3l u r'

6x6x6 (outer orbit)

3r 3u' L 3d' R 3u' 2R 3u 2r' 3d 3l2 3d' 2R 3d 3l 2-3l 3u 3r'

6x6x6 (inner orbit)

3r 3u' L 3d' R 3u' 3R 3u R' 3R' 3d 3l2 3d' 3R 3d 3l 2-3l 3u 3r'

7x7x7 (outer orbit)

3r 3u' L 3d' R 3u' 2R 3u 2r' 3d 4l2 3d' 2R 3d 4l 2-4l 3u 3r'

7x7x7 (inner orbit)

3r 3u' L 3d' R 3u' 3R 3u R' 3R' 3d 4l2 3d' 3R 3d 4l 2-4l 3u 3r'

Using the same conjugate of the quarter turn idea, I found a (20,17) even cube algorithm.

- This first single edge flip algorithm with this ratio of block quarter turns to block half turns.
- Reverting (in addition to inverting) produces a working algorithm as well (but it flips UB instead of UF).
- This algorithm is only 20q on the 4x4x4 and on the nxnxn even cube when consecutive slices from the corners need to be affected.

Lw E Lw2 Dw

**r'**Dw' Lw2 Dw R2 Uw

**r'**Uw' R2

**r**Dw' E' Lw'

= [Lw E: [Lw2, Dw r' Dw'] [Dw r': [R2 Uw: (r')] ] ]

On the 4x4x4

l e r2 u 2R' u' r2 d R2 u 2R' u' r R d' e' l'

On the 6x6x6 outer orbit

3l e 3r2 3u 2R' 3u' 3r2 3d R2 3u 2R' 3u' 2r R 3d' e' 3l'

And its "twin"'s general form (this flips the back dedge)

Lw' E' Dw'

**r**R2 Uw'

**r'**Uw R2 Dw Lw2 Dw'

**r'**Dw Lw2 E Lw

I will post these (four) new algorithms in the wiki soon.