• Welcome to the Speedsolving.com, home of the web's largest puzzle community!
    You are currently viewing our forum as a guest which gives you limited access to join discussions and access our other features.

    Registration is fast, simple and absolutely free so please, join our community of 35,000+ people from around the world today!

    If you are already a member, simply login to hide this message and begin participating in the community!
Joined
Jan 21, 2009
Messages
3,287
Likes
74
Location
England
WCA
2009YAUR01
YouTube
Robert271291
Yu Sajima's OLL parity algorithm as seen from here http://www.youtube.com/watch?v=OkqaXYabgW0

Original:
r U2' r' U2' r U2' r U2' l' U2' r U2' r' U2' x' U2' r2

Mirrors and inverses:
r2 U2 x U2 r U2 r' U2 l U2 r' U2 r' U2 r U2 r'
r' U2 r U2 r' U2 r' U2 l U2 r' U2 r U2 x U2 r2
r2 U2 x' U2 r' U2 r U2 l' U2 r U2 r U2 r' U2 r

Lefty algs:
l' U2 l U2 l' U2 l' U2 r U2 l' U2 l U2 x' U2 l2
l2 U2 x U2 l' U2 l U2 r' U2 l U2 l U2 l' U2 l
l U2 l' U2 l U2 l U2 r' U2 l U2 l' U2 x U2 l2
l2 U2 x' U2 l U2 l' U2 r U2 l' U2 l' U2 l U2 l'

Just in case anyone is wondering, he does it in 2.6 seconds in that video with a 0.2 sec lockup
 
Joined
Sep 17, 2009
Messages
901
Likes
45
Location
New Orleans, LA
YouTube
4EverTrying
R perm
R U R' U2' R' U2 L R2 U' R' U L' R' U2' R U2'

RUL. I think I am going to use it for OH.
Found it a long time ago but only thought it was worth posting now
Nice alg. It's already in the wiki though. "Alg.5" under R Permutation b on the PLL page.


Anyway, here's a transformation of my M layer double parity algorithm: r U2 r' U2 r' D2 r D2 r' B2 r B2 r' (19,13) which I posted on 1-9-2010 (that post no longer exists though).
r U2 r' U2 l2 r U2 r U2 l' U2 r U2 l' (20,14)

This might have been made in the past, but I didn't see it posted anywhere in public. So I hope I'm not posting an old (version) of my (19,13).

r U2 r' U2 r' D2 r D2 r' B2 r B2 r'
= r U2 r' U2 r' x2 U2 r U2 r' x2 x' U2 r U2 r' x
= r U2 r' U2 r' x2 U2 r U2 r' x U2 r U2 r' x
= r U2 r' U2 r' (L2 l2 r2 R2) U2 r U2 r' (L' l' r R) U2 r U2 r' (L' l' r R)
= r U2 r' U2 l2 r (L2 R2) U2 r U2 l' (L' R) U2 r U2 l' (L' R)

Omitting the L and R outer layer turns to obtain the transformation,
= r U2 r' U2 l2 r U2 r U2 l' U2 r U2 l'
---------------------------------------------------------------------------------------------------------------------
Also, for those who participated in the WANTED: New Dedge Flip Algorithm! thread, everyone was telling reThinking the Cube that his "reParity" algorithm Rw U2 Lw' U2 x' Rw' U2 Lw U2 Rw' U2 Lw U2 Lw' U2 y' M2 y' was identical to my 4-cycle double parity algorithm r U2 r' F2 l' B2 l B2 l' D2 l D2 l' F2 U2. Well, it is, as others have said for the inner layer turn portion of the algorithms.

Only for those who didn't compare those two algorithms before,
"reParity"
= Rw U2 Lw' U2 x' Rw' U2 Lw U2 Rw' U2 Lw U2 Lw' U2 S2 y2

In single slice turns,
= r U2 l' U2 x' (L' R) r' U2 l U2 r' U2 l U2 l' U2 S2 y2
= r U2 l' U2 (L l r' R') (L' R) r' U2 l U2 r' U2 l U2 l' U2 S2 y2
= r U2 l' U2 l r2 U2 l U2 r' U2 l U2 l' U2 S2 y2

Note from this point, when I say "reParity", I am referring to the single slice turn version above).

To affect only the M-Layer,
= r U2 l' U2 l r2 U2 l U2 r' U2 l U2 l' U2 S2 y2 + y2 S2 U2 (l2 r2)
= r U2 l' U2 l r2 U2 l U2 r' U2 l U2 l r2
Let's call this algorithm (*).

Now, is (*) a transformation of my alg (let's just temporarily call it "cmowla") (which existed before reParity)?

Is (*) = T(cmowla)?

cmowla
= r U2 r' F2 l' B2 l B2 l' D2 l D2 l' F2 U2
= r U2 r' x U2 x' l' x' U2 l U2 l' x x2 U2 l U2 x2 l' x U2 x' U2
= r U2 r' (x) U2 l' (x2) U2 l U2 l' (x') U2 l U2 l' (x') U2 (x') U2
= r U2 r' (L' l' r R) U2 l' (L2 l2 r2 R2) U2 l U2 l' (L l r' R') U2 l U2 l' (L l r' R') U2 (L l r' R') U2
= r U2 l' (L' R) U2 l r2 (L2 R2) U2 l U2 r' (L R') U2 l U2 r' (L R') U2 l r' (L R') U2

Removing the L and R outer layer turns to create the transformation,
T(cmowla) = r U2 l' U2 l r2 U2 l U2 r' U2 l U2 r' U2 l r' U2

And (*) + (l' r) U2 (l r') U2
= r U2 l' U2 l r2 U2 l U2 r' U2 l U2 l r2 + (l' r) U2 (l r') U2
= r U2 l' U2 l r2 U2 l U2 r' U2 l U2 (l r') r' (l' r) U2 (l r') U2
= r U2 l' U2 l r2 U2 l U2 r' U2 l U2 r' U2 l r' U2 = T(cmowla)

So (*)
= T(cmowla) - (l' r) U2 (l r') U2
= T(cmowla) + ((l' r) U2 (l r') U2)'
= T(cmowla) + U2 (l' r) U2 (l r')

Since (*) = reparity + y2 S2 U2 (l2 r2), then reparity
= (*) - y2 S2 U2 (l2 r2)
= (*) + (l2 r2) U2 S2 y2

Therefore, (reParity)
= (*) + (l2 r2) U2 S2 y2
= [T(cmowla) + U2 (l' r) U2 (l r')] + (l2 r2) U2 S2 y2
= T(cmowla) + U2 (l' r) U2 (l' r) U2 S2 y2

and it turns out that T(reParity)
= cmowla + U2 (l' r) U2 (l' r) U2 S2 y2
= r U2 r' F2 l' B2 l B2 l' D2 l D2 l' F2 U2 + U2 (l' r) U2 (l' r) U2 S2 y2
= r U2 r' F2 l' B2 l B2 l' D2 l D2 l' F2 (l' r) U2 (l' r) U2 S2 y2
However, the first 13 turns of "reParity" are completely identical to r U2 r' U2 l2 r U2 r U2 l' U2 r U2 l' (20,14) (the transformation of my (19,13), which I posted even earlier than r U2 r' F2 l' B2 l B2 l' D2 l D2 l' F2 U2...a total of 6 days before reThinking the Cube posted his "reParity").

Just add cube rotations to the beginning and end of the algorithm in wide turns.
(y2 x') Rw U2 Rw' U2 x Lw' U2 Rw U2 Lw' U2 Rw U2 Lw' (x' y2)

Just simplify:
y2 Lw U2 Rw' U2 x Lw' U2 Rw U2 Lw' U2 Rw U2 Rw' y2
Rw U2 Lw' U2 x' Rw' U2 Lw U2 Rw' U2 Lw U2 Lw'
Versus:
Rw U2 Lw' U2 x' Rw' U2 Lw U2 Rw' U2 Lw U2 Lw' U2 y' M2 y'

I can't believe no one compared his algorithm to my (19,13) M layer double parity algorithm. They're identical!

**Note to mods**
I didn't want to bump that old thread back up again to just mention this. However, if you all want me to move the second part of this post into a new post in that thread, just let me know.
 
Joined
Jan 21, 2009
Messages
3,287
Likes
74
Location
England
WCA
2009YAUR01
YouTube
Robert271291
Adjacent two corner swap

a. Rw' U' R U r U' R' U R2 U R' U' r U R U' Lw Uw2 Rw' U' Rw Dw2 Rw' U Rw' F'
b. Rw' U' R U r U' R' U R2 U R' U' r U r' F' Rw U Rw' U' Rw' F Rw2 U' Rw' U'
c. Rw' U' R U r U' R' U R2 U R' U' r U r' U' Rw' F Rw2 U' Rw' U' Rw U Rw' F'

Useful for 444 and 666 (and 888 etc)
 
Joined
Sep 17, 2009
Messages
901
Likes
45
Location
New Orleans, LA
YouTube
4EverTrying
Adjacent two corner swap

a. Rw' U' R U r U' R' U R2 U R' U' r U R U' Lw Uw2 Rw' U' Rw Dw2 Rw' U Rw' F'
b. Rw' U' R U r U' R' U R2 U R' U' r U r' F' Rw U Rw' U' Rw' F Rw2 U' Rw' U'
c. Rw' U' R U r U' R' U R2 U R' U' r U r' U' Rw' F Rw2 U' Rw' U' Rw U Rw' F'

Useful for 444 and 666 (and 888 etc)
Decomposition(a) = [Rw: [r': [R2: [r', U' R U] ] [U R' U', r] ] [y2: [Rw: [Dw2, Rw' U' Rw] ] [Rw': (F')] ] ] (29,26)

Decomposition(b) = [Rw: [r': [R2: [r', U' R U] ] [U R' U', r] ] [U Rw': [F' Rw U, Rw'] [Rw U' Rw': (U')] ] ] (28,26)

Decomposition(c) = [Rw: [r': [R2: [r', U' R U] ] [U R' U', r] ] [Rw' F: [F' Rw U, Rw'] [Rw U' Rw': (U')] ] ] (28,26)

Using the parity algorithm [U': [Lw U Lw' U', Rw] [U Rw: (U)] ] instead (just for my curiosity),

Adjacent
Rw U R' U' r' U R U' R2 U' R U r' U' R' Lw U Lw' U' Rw U Lw U' Lw' Rw' U Rw U (29,28)

If Robert(b) is shifted, only one set up move needs to be added to make an opposite case.
F Rw' F Rw2 U' Rw' U' Rw' U' R U r U' R' U R2 U R' U' r U r' F' Rw U Rw' U' F' (30,28)

And just to let those who don't know, these 2-corner swap algorithms only exchange 2 X-center pieces on the 4x4x4 (or \( \frac{\left( n-2 \right)^{2}}{2} \) center pieces on the nxnxn even cube).

Here are the shortest algorithms I have found. As you will see, assuming that the solutions below are optimal, Robert's algorithms are only a few more moves than the optimal ones for this category of algorithms.
Adjacent

[1]
L Bw2 Dw2 Bw U Bw' Dw2 Bw U' F2 b L' d2 L F' U' F L' d2 L F' U S z' (29,23)

= [L Bw2: [Dw2, Bw U Bw'] [Bw2: L] ] [B' F: [F L' d2 L F', U'] ]
=
L Bw2
Dw2 Bw U Bw' Dw2 Bw U' Bw'
Bw2 L Bw2
Bw2 L'
B' F
F L' d2 L F' U' F L' d2 L F' U
F' B
[2]
Fw' L2 Uw F' U R U' F r2 F' U R' U' F r2 Fw Uw' L Uw Fw' Uw' L Fw L (27,24)
= [Fw' L2 Uw: [F' U R U' F, r2] [Uw' L: [L', Uw Fw Uw'] [L Fw: L] ] ]
=
Fw' L2 Uw
F' U R U' F r2 F' U R' U' F r2
Uw' L
L' Uw Fw Uw' L Uw Fw' Uw'
L Fw L Fw' L'
L' Uw
Uw' L2 Fw
[3]
Fw' L2 Uw r2 F' U R U' F r2 F' U R' U' F Fw Uw' L Uw Fw' Uw' L Fw L (27,24)
= [Fw' L2 Uw: [r2, F' U R U' F] [Uw' L: [L', Uw Fw Uw'] [L Fw: L] ] ]
=
Fw' L2 Uw
r2 F' U R U' F r2 F' U R' U' F
Uw' L
L' Uw Fw Uw' L Uw Fw' Uw'
L Fw L Fw' L'
L' Uw
Uw' L2 Fw

Opposite


[1]
F r2 F' U R' U' F r2 Fw Uw' L Uw Fw' Uw' L Fw L Fw' L2 Uw F' U R U' (27,24)
= [U R' U' F: [F' U R U' F, r2] [Uw' L: [L', Uw Fw Uw'] [L Fw: L] ] ]
=
U R' U' F
F' U R U' F r2 F' U R' U' F r2
Uw' L
L' Uw Fw Uw' L Uw Fw' Uw'
L Fw L Fw' L'
L' Uw
F' U R U'
 
Joined
Sep 17, 2009
Messages
901
Likes
45
Location
New Orleans, LA
YouTube
4EverTrying
A list of all 15 btm "pure" one dedge flips

I don't know if this has been done before (probably, but I don't know where it is mentioned on the web), but I am going to list all of the UNIQUE 15 btm "pure" one dedge flip algorithms.

Clément Gallet listed all possible 15 btm solutions 3.5 years ago (it was probably done well before that though) in this post. I translated all of the algorithms in his list to WCA notation, and I rotated all of them so that they affect the FU dedge and the U center.

Eliminating exact duplicates (which were many), here is the "complete" list (the mirrors and inverses are also possible solutions).

Note:
There are only 4 unique algorithms which flip the FU dedge and affect the top center. All other algorithms are transformations (or mirrors or inverses). Hence, I list them showing how the algorithms are directly related.

Symmetrical Algorithms (16)
r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2|Alg.1(v1)|
r2 B2 U2 l U2 l' B2 r B2 U2 r U2 r' B2 r2|Alg.1(v2)|
r2 F2 D2 r' D2 r F2 l' F2 D2 l' D2 l F2 r2|Alg.1(v3)|
r2 F2 D2 r' D2 l D2 l' D2 B2 l' B2 r F2 r2|Alg.1(v4)|
r2 B2 U2 r B2 r' B2 l U2 F2 r F2 l' B2 r2|Alg.1(v5)|
r2 F2 D2 l' F2 l F2 r' D2 B2 l' B2 r F2 r2|Alg.1(v6)|
r2 B2 U2 r B2 l' D2 r D2 B2 l U2 r' B2 r2|Alg.1(v7)|
r2 F2 D2 l' F2 r U2 l' U2 F2 r' D2 l F2 r2|Alg.1(v8)|

r2 B2 U2 l' U2 r U2 r' U2 B2 r' B2 l B2 r2|Alg.2(v1)|
r2 B2 U2 l' U2 l F2 r' F2 U2 r' U2 r B2 r2|Alg.2(v2)|
r2 F2 D2 r D2 r' B2 l B2 D2 l D2 l' F2 r2|Alg.2(v3)|
r2 F2 D2 r D2 l' D2 l D2 F2 l F2 r' F2 r2|Alg.2(v4)|
r2 B2 U2 r' F2 r F2 l' U2 B2 r' B2 l B2 r2|Alg.2(v5)|
r2 B2 U2 r' F2 l D2 r' D2 F2 l' U2 r B2 r2|Alg.2(v6)|
r2 F2 D2 l B2 r' U2 l U2 B2 r D2 l' F2 r2|Alg.2(v7)|
r2 F2 D2 l B2 l' B2 r D2 F2 l F2 r' F2 r2|Alg.2(v8)|

Non-Symmetrical Algorithms (10)
r' U2 l F2 l' F2 r2 U2 r U2 r' U2 F2 r2 F2 |Frédérick Badie (v1)|
r' U2 r U2 l' U2 l2 F2 r F2 l' U2 F2 r2 F2 |Frédérick Badie (v2)|
r B2 r' U2 r U2 r2 F2 r' D2 l D2 B2 r2 F2 |Frédérick Badie (v3)|
r B2 r' U2 r U2 l2 B2 r' U2 l U2 F2 l2 F2 |Frédérick Badie (v4)|
r B2 l' B2 l U2 r2 F2 l' F2 r U2 F2 l2 F2 |Frédérick Badie (v5)|

r B2 r' U2 l B2 l2 B2 U2 l U2 l' U2 l2 B2 |Alg.2(v1)|
r B2 r' U2 r D2 r2 U2 F2 l F2 r' D2 r2 B2 |Alg.2(v2)|
r B2 r' U2 r D2 l2 D2 B2 l B2 r' 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)|

Thus there are exactly 26 (52 if you including mirrors and 104 if you also include inverses) one dedge flip 15 btm algorithms which flip the FU dedge and affect the top center.

And actually,
[1] Shifting any of the symmetrical algorithms from the first group and adding back the two setup moves yields algorithms from the second group. (and vice versa).
[2] Shifting any of the non-symmetrical algorithms from the first group yields algorithms from the second group (and vice versa).

*Therefore, in reality, there are only two unique paths for 15 btm move solutions: Frédérick Badie and the (old) standard algorithm. This has been my guess for a while, but I wasn't absolutely sure until I looked at all possible solutions and found relationships between them.

Would it be too much if I list all 26 of these algorithms here? (Two of them are there already).
[wiki]Impure Dedge Flips with Wide Turns/Pure Flips with Inner Layer Turns (SiGN Notation)[/wiki]
 
Top