First, I want to say ThanksX10 to Christopher Mowla (cmowla) -

for inspiring on this forum, a wealth of interesting discussion and ideas related to parity, and for creating and sharing some his bigcube parity methods and algs.

Okay reThinker,

This algorithm is not necessarily faster than what you would hope, but I believe you will enjoy its length and its effects on a cube.

Here is a

**17h/23q** OLL parity (NOT DOUBLE PARITY) algorithm which utilizes the front-right F2L slot and U layer being unsolved, but flips the top-front edge. Here it is - On Even Cubes:

r U2 x' U2 x' U' 2L' U F2 U' 2L U 2R U2 2L' U2 l' x U2 2R'
Ok, I would like to share my thoughts on this recently posted (freeF2L?) parity alg. I put the /?/ in there, because it is not clear how the algorithm actually *utilizes* or takes full advantage of the unsolved front-right F2L slot. At first glance this alg appears to be rather pointless, but cmowla's cool trick that converted it to a pure OLL was very interesting to me, and so I decided to spend some time looking into it.

All notation is SiGN™ (courtesy of Lucas Garron), and I tried to be as concise as possible with this rather challenging post.

Starting with cmowla's alg (freeF2L?):

r U2 x' U2 x' U' 2L' U F2 U' 2L U 2R U2 2L' U2 l' x U2 2R'
In order to better examine this, I first had to take out the internal cube rotations which gives:

r U2 B2 D' 2L' D B2 D' 2L D 2R D2 2L' D2 l' B2 2R' x'
I then spotted the interesting commutator in the middle of the alg (B2 D' 2L' D B2 D' 2L D), and if wide turns were used instead of slices, it would also be a cool (3)(3x2x1 block) commutator:

B2 D' l' D B2 D' l D which has the same effect as [B2,r 3f2 r'].

Not only is this block commutator interesting for its effect, but it also uses the single face turns of /D/, and is outside <R,L,U2,D2,F2,B2> (Domino Homomorphism). Seeing stuff like this, further backs up cmowla's claim -

* "I DID NOT use a computer solver to form any of the algorithms I have (or will) release. I have derived them all by hand."*
r U2 B2 D' 2L' D B2 D' 2L D

**2R** D2 2L' D2 l' B2

**2R'** x' (17h/23q)

As cmowla has already shown, the trick here - by converting the 2R's to r, will yield a pure OLL parity alg:

r U2 B2 D' 2L' D B2 D' 2L D r D2 2L' D2 l' B2 r' x'
Now that is a very cool way to get a (17h/23q) pure OLL, but I don't think I can make that alg execute as fast, nor is it any simpler than even the old standard parity alg below. (I also realized that cmowla might have proved himself wrong, concerning some earlier assertions, to give me an alg that did otherwise!)

OldStandardOLL =

2R2 B2 2L' B2 2R B2 U2 2R U2 2R' U2 2L U2 B2 2R2
It is interesting to note that OldStandardOLL is based move|move on a hybrid 3x3x3 F-perm [(UL><UR) +non-oriented corner swap (UFR><FUL)] (click on link below to see the effect it has on a 4x4x4 cube)

Fx-perm =

R2 B2 L' B2 R B2 U2 R U2 R' U2 L U2 B2 R2
Converting face turns <R,L> to (Domino Homomorphic) single slices <2R,2L> SiGN™ gives:

OldStandardOLL parity =

2R2 B2 2L' B2 2R B2 U2 2R U2 2R' U2 2L U2 B2 2R2
4x4x4 Speedversion making all <R,L> doublewide turns <r,l> SiGN™ gives:

SpdOldStandardOLL =

r2 B2 l' B2 r B2 U2 r U2 r' U2 l U2 B2 r2
Please note that performing lucasparity =

r U2 x r U2 r U2 r' U2 l U2 r' U2 r U2 r' U2 r' does EXACTLY the same thing on a 4x4x4 as performing SpdOldStandardOLL.

And of course, the speed form of this algorithm is achieved if all slice turns are converted to wide (you can do the conjugates to get it in the U-layer, but remember, it's my alg no matter how you change it!

). On the 4X4X4:

r U2 x' U2 x' U' l' U F2 U' l U r U2 l' U2 l' x U2 r'
Now going back to the /inner rotation free/ version of cmowla's alg, and converting all slice turns to wide turns gives: SpdCmowlaF2L?parity (17h/23q) =

r U2 B2 D' l' D B2 D' l D 2R D2 l' D2 l' B2 r' x'
I noticed that after doing that alg, and adjusting with the cube rotations [x y2], the position would be identical to SpdStandardOLL (15h/25q), which also does the same thing as lucasparity [r U2 x r U2 r U2 r' U2 l U2 r' U2 r U2 r' U2 r' (17h/25q)], which I believe to be faster/easier than any possible transforms of [r U2 (B2 D' l' D B2 D' l D) r D2 l' D2 l' B2 r' x' (17h/23q)], and reParity™ - r U2 l' U2 x',(r' U2 l U2)2, l' U2 y' 2m2 (15h/23q) is even better! So based on those comparisons, I'm not inclined to over-conjugate myself on finger-trick transforms of cmowlaF2L?parity.

Very interesting approach nonetheless, and I enjoyed the challenge of analyzing this.

Thanks again,