##### Member
This is not a list of algorithms, this is a thread where we can discuss algorithms, what makes them up, what they do to cubes and why and how they can be used.

For example, just a basic thing: If we take these 2 algs: [F R U' R': U'] and R U R' U' R' F R F' (I didn't find any way to shorten it) and put them together, we get what we would call a Y-perm, but if we change the places of the 2 algs, we get a T-perm (which cancels a few moves)

I created this thread, because these kinds of things are interesting to me, and I want to learn more. I didn't find a thread like this one.

#### CubezUBR

##### Member
combining a t-perm starting with r instead of R (r U R' U' r' F R2 U' R' U' R U R' F') + the H oll (R U R' U' M' U R U' r') makes for a really long but fast flowing R(a) perm
also doing a sune with M' instead of R and E instead of U (vice verca) makes a good patternM' E' M E' M' E2 M

Last edited:

##### Member
What does the H-perm actually do?

MU version: M2 U M2 U2 M2 U M2

M2: Puts UB and UF on the bottom layer
U: Places UR and UL into the positions of UF and UB
M2: Places UR and UL onto the bottom, and brings up UB and UF between the wrong corners
U2: Turns the Top layer 180 degrees so that UL and UR (that are on the bottom layer) Can be placed into opposite positions with a M2 + changes the places of UF and UB
M2: Places UL and UR into opposite positions + Puts UF and UB on the bottom layer so that F2 B2 would put the edges into the correct slots
U: Aligns U-face for insertion of the UB and UF edges into opposite position
M2: Places UF and UB into opposite positions, thus solving H-perm

RU version: R2 U2 R U2 R2 U2 R2 U2 R U2 R2

R2 U2 R': Sets up 2 2swaps (UB <-> UF and FR<->BR) that can be solved with R2 U2 R2 U2 R2 U2
R2 U2 R2 U2 R2 U2 solves the 2 swaps
R U2 R2: Undo setup move

That means the alg looks like this: R2 U2 R' (R2 U2 R2 U2 R2 U2) R U2 R2 - R' and R2 cancel into R, making the alg R2 U2 R U2 R2 U2 R2 U2 R U2 R2

#### Christopher Mowla

I didn't find a thread like this one.
Here is a thread which is somewhat related to what you have posted in the first post. Specifically, see the end of my first post in there. When you exchanged the order of the two algorithms [F R U' R': U'] and R U R' U' R' F R F', you just did what people commonly call "cyclic shifts", while I have always just called them "shifts". (Shifts are nothing more than adding setup moves which completely cancel with either the beginning or end of an algorithm).

Towards the middle of that thread, I did some decompositions of some optimal 3x3x3 2-cycle PLLs, for which I later decomposed all of the wiki PLL 2-cycles and started this thread. (I eventually copied my work from that thread to the PLL wiki page and carried out my own proposal.) There also was a little discussion on the same topic in this thread.

If you're interested in 4x4x4 and larger cube parity algorithms, I made decompositions of my algorithms and common algorithms and put them into a PDF. Alternatively, of course, you can see my methods thread and my PLL parity thread for my derivations to various parity algorithms including my own. (Most of the videos on my YouTube channel are linked to in those two threads).

So in summary, apart from 4x4x4 and larger cube parity algorithms which I have discussed in more detail than most would probably care to read (or watch), I have shown the discussions that first come to my mind about 3x3x3 2-cycle PLLs (which you mentioned as a starting example).

What does the H-perm actually do?

MU version: M2 U M2 U2 M2 U M2
...
Hmm. I seemed to like your explanation of the <U,R> algorithm better. All you need to do to describe this algorithm is to look at it like this (come on, you could've gotten this...the <U,R> was harder to see, in my opinion, and you nailed that one):

M2 U
M2 U2 M2 U2 (commutator)
U' M2

#### SpicyOranges

##### Member
What does the Ua perm do? (R U' R U R U R U' R' U' R2)
Assuming you do the inverse(R2 U R U R' U' R' U' R' U R') with white on top, and green in front, the white orange edge is UR, the white red edge is UF, and the white green edge is UL
R- Hides UR edge
U'-Permutes UF edge and UL edge
R- Hides UR and UF edge
U- Moves UL edge back
R- Moves UR and UF edge
U- Brings UL to UB
R- Brings UR back to original spot
U'- Moves UR and UL edge
R'- Hides UF
U'- Permutes UL and UR
R2- Permutes UF

Last edited:

#### coldsun0630

##### Member
How do these algorithms work?

Recently, I'm trying to understand how does algorithms work,
but I have no idea for these...:confused:
R' U' R U' R U R U' R' U R U R2 U' R' U2 (Z Perm)

R U R' U' R' U R U2 R' L' U R U' L U' R U' R' (F Perm)

F2 D' L U' L U L' D F2 R U' R' (G Perm)

x' R U R' D R U R' D' F L F' L' R U2 R' x (G Perm)

L' U R' U2 L U' L' U2 L R U' (J Perm)

(L U' R U2 L' U R')2 U' (N Perm)

R' U R U' R' F' U' F R U R' F R' F' R U' R (N Perm)

R U R' F' R U2 R' U2 R' F R U R U2 R' U' (R Perm)

F' U F' U' R' F' R2 U' R' U R' F R F (V Perm)

R U' L' U R' U' R U' L U R' U2 L' U2 L (V Perm)

F R U' R' U' R U R' F' (3-Pair Cycle)

L F' L D2 R' B R D2 L2 F (ZBLL-T)

R U R' U' R' U L' U2 R U' R' U2 L R2 U' R' (ZBLL-T)

and many other algs...
Would you explain the execution of these algs? Please...

#### SweetSolver

##### Member
What do you mean you want to know the execution? Do you mean 'what are algoritms?' or 'how do I read this?'

#### Renslay

##### Member
The J Perm is a commutator for corner-edge pairs:
L' U R' U2 L U' L' U2 L R U'
=
commutator for 3 corner-edge pairs + U'
=
L' U R' d2 R U' R' d2 R L + U'
=
L' + U + R' d2 R + U' + R' d2 R + L + U'
=
setup + QPQ'P' + setup' + U'

I hope that you do understand commutators. If you do this (L' + U + R' d2 R + U' + R' d2 R + L), you can track the elements easily. It is similar to L' U R' D2 R U' R' D2 R L (simply D2 instead of d2), but in the first case, you move corner-edge pairs, while in the second case, you move only corners.

#### coldsun0630

##### Member
What do you mean you want to know the execution? Do you mean 'what are algoritms?' or 'how do I read this?'
I mean how algs work. for example,
R' U' F' R U R' U' R' F R2 U' R' U' R U R' U R (E Perm)
(R' U' F') (R U R' U' R' F R F') (F R U' R' U' R U R' F') (F U R)
- Setup Move: R' U' F'
- 3-Pair Cycle 1: R U R' U' R' F R F'
- 3-Pair Cycle 2: F R U' R' U' R U R' F'
- Reverse Setup Move: F U R
R U' R' U' R U R D R' U' R D' R' U2 R' U' (R Perm)
- Skeleton: R U' R' U' (1) R U2 R' U'
- Insertion 1: R U' R D R' U' R D' R2 (3-Corner Cycle)
I think he means how they work.
Exactly.

The J Perm is a commutator for corner-edge pairs:
L' U R' U2 L U' L' U2 L R U'
=
commutator for 3 corner-edge pairs + U'
=
L' U R' d2 R U' R' d2 R L + U'
=
L' + U + R' d2 R + U' + R' d2 R + L + U'
=
setup + QPQ'P' + setup' + U'
Then... [L': [U, R' d2] ] U'
Thank you!

Some algs are difficult to understand how they work, but if you can't even understand this one than there really is no use to explain:
(L U' R U2 L' U R')2 U' (N Perm) (Hint: swap 2 diagonals twice)
I've tried until [L U' R, d2] [R U' L, d2] U', but still confused...

Last edited by a moderator:

#### Renslay

##### Member
The 3-pair cycle is easy too.
F R U' R' U' R U R' F' (3-Pair Cycle)

Notice that a additional U move show us the 3 corner-edge pair:
F R U' R' U' R U R' F' U = a visible commutator
=
F R U' R' + U' + R U R' F' + U
=
PQP'Q'

But this is still hard to understand how it works. So, here is the very same algorithm, but in a more tractable way:
x' + u + F L' F' L + u' + L' F L F' + x

Note that this is very similar to a corner commutator (change u to U and u' to U'), but here we move corner-edge pairs instead of corners.
x' + U + F L' F' L + U' + L' F L F' + x

A different (yet similar and shorter) solution:
x' + R' D R + u' + R' D' R + u + x
=
R' F R F' U' F' U F

(+ U' if we want the original case, since our commutator includes the U move)

Last edited:

#### coldsun0630

##### Member
The 3-pair cycle is easy too.
F R U' R' U' R U R' F' (3-Pair Cycle)

Notice that a additional U move show us the 3 corner-edge pair:
F R U' R' U' R U R' F' U = a visible commutator
=
F R U' R' + U' + R U R' F' + U
=
PQP'Q'

But this is still hard to understand how it works. So, here is the very same algorithm, but in a more tractable way:
x' + u + F L' F' L + u' + L' F L F' + x

Note that this is very similar to a corner commutator (change u to U and u' to U'), but here we move corner-edge pairs instead of corners.
x' + U + F L' F' L + U' + L' F L F' + x

A different (yet similar and shorter) solution:
x' + R' D R + u' + R' D' R + u + x
=
R' F R F' U' F' U F

(+ U' if we want the original case, since our commutator includes the U move)
I understood this alg. Thank you!

#### AvGalen

I've tried until [L U' R, d2] [R U' L, d2] U', but still confused...
Ah, by "explain how they work" you mean "write them as a commutator"?

Well, sometimes it doesn't require to think of things as a commutator but you just need to see what happens on the cube. Then when you analyze the alg you can find a commutator but that isn't really needed for understanding.

H-Perm: (R2 U2)*3 U (R2 U2)*3 U' is of course a commutator, but even somebody that has never learned anything about commutators can understand how that works. The same for things as ((RUR'U')*2 D)*3 D

that N-Perm is very similar to the H-Perm I described. "Switch to pairs in the F2L while moving blocks on the last layer, switch the pairs in the F2L back while moving blocks in the last layer again"

#### coldsun0630

##### Member
Ah, by "explain how they work" you mean "write them as a commutator"?
Nope, even I wrote them as a commutator, I coudn't still understand how do they work.

that N-Perm is very similar to the H-Perm I described. "Switch to pairs in the F2L while moving blocks on the last layer, switch the pairs in the F2L back while moving blocks in the last layer again"
Ahhhhh! Now I understand how does [(L U' R U2 L' U R')2 U'] work. Thanks!

/

...and remaining 10 algs...

#### Renslay

##### Member
Ah, by "explain how they work" you mean "write them as a commutator"?
Writing down an algorithm as a commutator does not always help to understand how it works. See my example, [F R U' R', U'] is hard to understand (why F R U' R' ? What does it do?), but thinking it as [x' : [u, F L' F' L]] is way easier to understand, since F L' F' L is just a simple insertion.

Last edited:

#### Christopher Mowla

...and remaining 10 algs...
I have an explanation for all 10 of your remaining algorithms. The 2-gen alg was hard (perhaps Stefan could do better because he's a guru at 2-gen), but the rest were fair.
• All 2-cycles's extra quarter turn move can be automatically be identified if you execute the algorithm on a 3x3x3 supercube.
• For the 2-cycles, you must think of *conjugates*, not just commutators alone. Of course, this is not true for simple 2-cycles such as the J-perm already explained which the extra quarter turn comes at the beginning (or end) (or in situations where it is between two separate but easy-to-understand algorithm pieces).
• There was a lot of repetition in my explanations. Some algorithms I explained in more detail than others, but the explanation missing in some algorithms (for the same algorithm piece type) is said in other algorithms' explanations. In short, see my explanations for all algorithms and that will give you the bigger picture.
• It helps to use alg.garron.us or cubetwister to see these, because it's better to see what each main algorithm part does separately.
• Speaking of which, the short algorithm pieces which have no explanation are just conjugates: so the cycle type by the algorithm (or algorithms) they enclose is preserved but which pieces are affected is changed.
• As the creator of literally hundreds of brief parity algorithms for big cubes (and I understand almost all existing well-known parity algorithms before my time), it is almost always easier to understand them (2-cycles in this case) if you derive them instead of rewriting them in equivalent forms. So if my explanations seem a little hard to understand, imagine deriving the algorithm yourself...just use the pieces I have given for a decent start.
• Lastly, there is no law that states that all algorithms have the structure of a step-by-step linear intuitive solution. I have solved every possible corner case of the 3x3x3 in one commutator (I have not completed my research yet, so I can't answer any questions about it at the moment), and, if I recall correctly, there are around 5 fundamental approaches which tackle different cases: I'm sure the same idea holds true for middle edges. Only 1-2 of them are of the typical form which us humans naturally would expect to be a solution form...so if some of these algorithms "bother" you, assuming I have pinpointed the best way to decompose them for the human mind, they are just one of these "unintuitive" possible ways to tackle a given case.
R' U' R U' R U R U' R' U R U R2 U' R' U2 (Z Perm)
=
R' U' R U' R U R U' R2 U2 R U' //5-cycle of edges

U R' U2 R'
R2 U R U R2 U' R' U' R' U2 R' //3-cycle of edges
R U2 R U'

=
R' U' R' U R U R U R' U' //3-cycle of edges

U R
(U' R' U' R' U') R2 (U R U R U) U2 //3-cycle of edges
U2 U' R' U' R' U2 R U R U R2 U2 //3-cycle of edges
U2 R2 U2 R2 U2 R2
R' U'

U R' U2 R'
R2 U R U R2 U' R' U' R' U2 R' //3-cycle of edges
R U2 R U'
R U R' U' R' U R U2 R' L' U R U' L U' R U' R' (F Perm)
=
R U R' U'//conjugates to orient all pieces
R' U
R U2 R' U2
U' R
R' U' L' U R U' L U//3-cycle of corners
(U)//extra quarter turn
U R U' R'
F2 D' L U' L U L' D F2 R U' R' (G Perm)
=
(F2 D' L U') L (U L' D F2) R U' R'
(1) Study what pieces and blocks slice L contains after (F2 D' L U'). Those are the only pieces which are going to be affected once we undo (F2 D' L U') with (U L' D F2).
(2) Study which blocks (U L' D F2) breaks up or preserves, and map that do the current locations of the affected blocks in the positions generated by (F2 D' L U') L.
(3) Add R U' R' at the end to restore the cube.
x' R U R' D R U R' D' F L F' L' R U2 R' x (G Perm)
=
x' R U
R' D R U R' D' F L F' L' R U' //G perm worth of pieces
U' R' x
=
x' R U
R' D R U R' D' R U' //3-cycle of corners
U R'
F L F' L' //2 2-cycle of corners + 3-cycle of edges
R U'
U' R' x
R' U R U' R' F' U' F R U R' F R' F' R U' R (N Perm)
=
R' U
//All pieces in the U face are the only ones affected by the following conjugate, for which the extra quarter turn is introduced.
(R U' R' F') (U') (F R U R')
F R' F' R//restore the cube
U' R
R U R' F' R U2 R' U2 R' F R U R U2 R' U' (R Perm)
=
R U
R' F' R U2 R' U2 R' F R R//comm. that swaps 4 1x2 blocks worth of pieces.
R' U R U' //solve some pieces back
(U')//extra quarter turn
R' U' R U//solve all pieces back that you can, keeping the odd permutation.
U' R'
F' U F' U' R' F' R2 U' R' U R' F R F (V Perm)
=
F' R' F' R
//All pieces in the F face are the only ones affected by the following conjugate, for which the extra quarter turn is introduced.
(R' F R U) F' (U' R' F' R)
R U' R' U//solve as many pieces as possible back, keeping odd permutation.
R' F R F
R U' L' U R' U' R U' L U R' U2 L' U2 L (V Perm)
=
R U' L' U R' U' L U//3-cycle of corners (commutator)

U' L'
R U' L U R' U' L' U //3-cycle of corners (commutator)
L U

L' U'//conjugates to get all pieces (affected from the algorithm piece below) into U face.
U L U' L' //a commutator that messes up 3 edges
//a conjugate which solves back 2 edges and pulls one out of place, leaving 3 - 2 + 1 = 2 edges swapped.
U' L U' L' U
U L
L F' L D2 R' B R D2 L2 F (ZBLL-T)
(1)
(L D2 R') B (R D2 L')
L' F L F'
(2) Shift (conjugate) the last two moves to get all pieces into the U face:
L F'
(L D2 R') B (R D2 L')
L' F
R U R' U' R' U L' U2 R U' R' U2 L R2 U' R' (ZBLL-F)
=
R U R'
U' R' U L' U2 R U' R' U2 L R //J-Perm
R U' R'
=
R U R'
L'
L U' R' U L' U' R U //3-cycle of corners
(U') //extra quarter turn
R U R' U R U2 R' //A variation of the well-known "Sune" algorithm.
L
R U' R'

Last edited:

#### coldsun0630

##### Member
I have an explanation for all 10 of your remaining algorithms. The 2-gen alg was hard (perhaps Stefan could do better because he's a guru at 2-gen), but the rest were fair.
I was very impressed of your decomposition. Thank you for your detailed explanation.

/

I have more interest about algorithms that I couldn't understand..
Would you please explain for those things?

- (L' U R' U2 L U' R)2 U' (N Perm)
I could understand this alg as below.
[L' U R', d2] [d2, R' U L'] U'
but is there other way to explain this alg?
If you have your own explanation, I want to see it.

- U' R' F R U R' U' R' F' R U R (3 corner cycle)
It is part of R Perm(R' U2 R U2 R' F R U R' U' R' F' R2 U').
I dvided this alg as two OLLs as below.
U' (R' F R U R' U' F' U R) (R' U' F R F' R' U R)
but it doesn't help to understand.
- deference between 'direct insert', 'drop and catch', and 'toss up'
I guess 'toss up' is half turn version of 'direct insert', but that's all.

- about structure of 'cyclic shift'
Is it just a shift? Really?!
(R F) R' F U2 F' R F R' U2
R' F U2 F' R F R' U2 (R F')

- about structure of 'per special'
Weird...
U F2 U' F2 U' R2 U F2 U F2 U' R2
U2 F U2 F' L2 F' L2 F L2 B L2 B'
U2 F R2 F' R2 F' U2 F R2 F R2 F'
U R2 U' B2 U' B2 U B2 D B2 D' R2
U B2 U' B2 U' L2 U B2 U B2 U' L2
U' B2 U R2 U R2 U' R2 D' R2 D B2

- corner permutation of last layer in [R, U] group is always correct.
It's mystery to me. I don't mind if you don't touch this problem.

for now, it's all.

Last edited:

#### Christopher Mowla

Hey coldsun0630,

The 8 algorithms you asked about can be broken into 3 categories; and I will touch on them all. The first two categories are related, as you will soon see.

Idea: The simple commutator:
All we need to do is isolate one corner into a face by itself. That means, our goal is to:
[1] Insert a corner into a face with some move sequence so that all pieces in that slice are solved except for that corner.
[2] Turn that face 90, -90, or 180 degrees.
[3] undo the sequence in step 1
[4] undo the face turn of step 2.

Step 2 simply replaces the corner we put into the face with an alternate corner for step 3. We return an alternate corner to the original slot location from which we moved out the first corner in step 1.

If you rewrite the following algorithms in this form, the same rule applies to every single one.

U' R' F R U R' U' R' F' R U R (3 corner cycle)
=
U' R' F R U (isolates a corner in slice R)
R'
U' R' F' R U
R

U F2 U' F2 U' R2 U F2 U F2 U' R2
=
U F2 U' F2 U'(isolates a corner in slice R)
R2
U F2 U F2 U'
R2

U2 F R2 F' R2 F' U2 F R2 F R2 F'
F R2 F' R2 F' (isolates a corner in slice U)
U2
F R2 F R2 F'
U2
and then shift the U2 (move it to the beginning)
U2
F R2 F' R2 F'
U2
F R2 F R2 F'
U2
U2
U B2 U' B2 U' L2 U B2 U B2 U' L2
=
U B2 U' B2 U' (isolates a corner in slice L)
L2
U B2 U B2 U'
L2
(L' U R' U2 L U' R)2 U' (N Perm)

Similar to the corner 3-cycles in the previous category in which were generated by simple commutators (when I say simple, I mean that it didn't matter how complex the first set of moves (our X) was: all we needed to do was isolate a corner in at least one face. We then turned that face as our Y. (Speaking of a commutator in the form of X Y X' Y' = [X,Y]).

So for this N-perm, instead of trying to isolate a single corner in one face, we isolate a 1x2 block (a matched corner and edge) in one face, say the U face. Notice that we create a 3-cycle of 1x2 blocks once we complete the entire commutator.
U R' U2 L U
U2
U' L' U2 R U'
U2

Okay, so we have a 3-cycle of 1x2 blocks. What is our goal? We want to have two 1x2 blocks touching (adjacent) in the U face so that we can repeat it to swap the two opposite adjacent 1x2 blocks with each other on the second try.

First, let's look at the final product: (L' U R' U2 L U' R)2.
L' U R' U2 L U' R swaps the two back 1x2 blocks: it does NOT swap the two front 1x2 blocks...that part of the U face is pretty much untouched.

(**)For example, if we add U2, we can verify this. However we only have L' U R' U2 L U' R and not L' U R' U2 L U' R U2 because, by not adding U2, we already have the back half of U already in place so that the two 1x2 blocks can be swapped with each other there.

Okay, now, I have to touch on an important detail about the backbone of our N-Perm. As you know, a PLL algorithm means that it preserves the orientation of the pieces. This is important for us as we swap two adjacent 1x2 blocks with each other in the U face because we must swap two AND preserve their orientation. In other words, we must place them in the U face in a special way to have them both oriented.

Let's now look at our commutator (written on one line for convenience)
U R' U2 L U U2 U' L' U2 R U' U2

It swaps two 1x2 blocks in the U face, but they are in the same positions as if it was an N-Perm. This is a problem because, as we've seen, they need to be adjacent to each other. L' U R' U2 L U' R U2
So we get one out:
U R' U2 L U U2 U' L' U2 R U' U2
U' R'

Solve back all of U but leave the other 1x2 block already in U alone,
U R' U2 L U U2 U' L' U2 R U' U2
U' R' U2 L

Now put it back in, adjacent to the 1x2 block in U
U R' U2 L U U2 U' L' U2 R U' U2
U' R' U2 L U R

And restore the cube a little...to have two 1x2 blocks again in U, but now in a favorable formation for what's to come.
U R' U2 L U U2 U' L' U2 R U' U2
U' R' U2 L U R U2 L'

To explain this situation, let's use our N-perm as an example. Suppose we conjugate our N-perm with F. F (L' U R' U2 L U' R)2 U' F' The two 1x2 blocks become unoriented. The opposite it true for our case...we just conjugate with L' to get the pieces oriented
L'
U R' U2 L U U2 U' L' U2 R U' U2
U' R' U2 L U R U2 L'
L

If we refer back to the (**) statement, we need to add a U2 either to the beginning or end of the algorithm so that, when we repreat this entire algorithm twice, both adjacent two pairs of 1x2 blocks will be swapped in the process. Since we have a choice, let's add it to the end of the algorithm to meet our goal:
L'
U R' U2 L U U2 U' L' U2 R U' U2
U' R' U2 L U R U2 L'
L

U2

Writing on one line and cancelling all moves, we get: L' U R' U2 L U' R, and we're done.
(a) U2 F U2 F' L2 F' L2 F L2 B L2 B'
(b) U R2 U' B2 U' B2 U B2 D B2 D' R2
(c) U' B2 U R2 U R2 U' R2 D' R2 D B2

We need to see what the moves R U2 R' do to a solved cube.
(1) The two front corners in U are swapped with each other
(2) The other two corners are swapped with each other.
(3) The front and back edges in U are swapped with each other
(4) The other two edges are swapped with each other.

Take a screen shot of this, draw permutation arrows, or whatever necessary to ingrain this effect in your memory (or just keep it on the side as a reference). Also be aware of what the moves L' U2 L do as well (the mirror case).

[1] Let's rotate these algorithms as follows so we can apply what we know now.
(a) U2 R U2 R' F2 R' F2 R F2 L F2 L'
(b) L U2 L' B2 L' B2 L B2 R B2 R' U2
(c) L' B2 L U2 L U2 L' U2 R' U2 R B2

[2] Let's rewrite these algorithms, introduce cube rotations and breaking them up into fragments of R U2 R' and L' U2 L.
(a) We take the inverse to start with a left or right slice turn: L F2 L' F2 R' F2 R F2 R U2 R' U2. Now we spit it.
y2 x' R U2 R' x y2 F2 x y2 L' U2 L y2 x' F2 R U2 R' U2 = y2 x' R U2 R' U2 L' U2 L y2 x' F2 R U2 R' U2

(b) We just need to split it:
y2 R U2 R' y2 x' U2 L' U2 L U2 R U2 R' x U2

(c) We just need to split it:
x' L' U2 L x U2 y2 R U2 R' y2 y2 U2 L' U2 L y2 B2 = x' L' U2 L x U2 y2 R U2 R' U2 L' U2 L y2 B2

[3] Now we observe each of them separately...it's not easy to see this, but if you study them long enough, having them broken up into pieces of R U2 R' and L' U2 L (or if you would instead prefer L U2 L' and R' U2 R), you can logically trace the pieces as you go. This is exactly how I found this algorithm for the 4x4x4: r U2 r' U2 r' D2 r D2 r' B2 r B2 r'. Note that for this parity algorithm, I started with the piece (r U2) r' (U2 r'), which is a conjugate of the extra quarter turn. Then I used this technique to restore the centers and pair up the wing edges. In other words, instead of keeping my eye on corners and middle edges, I kept my eye on what r U2 r' does to wing edges and 1x2 center blocks, respectively.

I later applied this technique to find ground breaking parity algorithms not in the move set <U2,D2,F2,B2,l,r>, as I describe how I found one such algorithm in this post, and I later applied this same idea again to create my own semi-optimized reduction method which I introduced in this post.

So perhaps these algorithms might be even easier to understand if you translate them to the inner slices of a 4x4x4 (the corners become wing edges and the middle edges become 1x2 center blocks), for example,
y2 r U2 r' y2 x' U2 l' U2 l U2 r U2 r' x U2
As for the <U,R> problem where you said corner permutation is preserved, I'm not sure what you meant. Maybe you mean edge orientation is preserved, or you can't do just a 2-cycle of corners?

Last edited:

#### Renslay

##### Member
As for the <U,R> problem where you said corner permutation is preserved, I'm not sure what you meant.
I think he meant that if you scramble the cube with <R,U>, then you solve DFR and DBR, then all the corners on the up side is permutated well (with AUF), and they only need an orientation. Equivalently: there is no PLL where you swap corners using only <R,U>. Somehow the permutation of the corners is restricted in <R,U>. The question is: why?