# Algorithm Thread



## Username (Jun 22, 2013)

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 (Jun 22, 2013)

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


----------



## Username (Jun 22, 2013)

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 (Jun 24, 2013)

Username said:


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



Username said:


> 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 (Jun 24, 2013)

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


----------



## coldsun0630 (Jul 3, 2013)

*How do these algorithms work?*

Recently, I'm trying to understand how does algorithms work,
but I have no idea for these...:confused:


Spoiler: algoritims



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 (Jul 3, 2013)

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


----------



## Renslay (Jul 3, 2013)

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.


----------



## AvGalen (Jul 3, 2013)

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)


----------



## coldsun0630 (Jul 3, 2013)

SweetSolver said:


> 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,


Spoiler: example1



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





Spoiler: example2



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)





makssl6911 said:


> I think he means how they work.


Exactly.



Renslay said:


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


Then... [L': [U, R' d2] ] U'
Thank you!



AvGalen said:


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


----------



## Renslay (Jul 3, 2013)

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)


----------



## Username (Jul 3, 2013)

F R U' R' U' R U R' F' = [F R U' R': U']


----------



## coldsun0630 (Jul 3, 2013)

Renslay said:


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


I understood this alg. Thank you!


----------



## AvGalen (Jul 3, 2013)

coldsun0630 said:


> 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 (Jul 3, 2013)

AvGalen said:


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



AvGalen said:


> 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 (Jul 3, 2013)

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


----------



## Christopher Mowla (Jul 3, 2013)

coldsun0630 said:


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


Spoiler: Notes




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. 






Spoiler: My Explanations



R' U' R U' R U R U' R' U R U R2 U' R' U2 (Z Perm)


Spoiler: Decomposition



=
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)


Spoiler: Decomposition



=
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)


Spoiler: Decomposition



=
(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)


Spoiler: Decomposition



=
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)


Spoiler: Decomposition



=
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)


Spoiler: Decomposition



=
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)


Spoiler: Decomposition



=
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)


Spoiler: Decomposition



=
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)


Spoiler: Decomposition



(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)


Spoiler: Decomposition



=
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'


----------



## coldsun0630 (Jul 5, 2013)

cmowla said:


> 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?



Spoiler: algorithms



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





Spoiler: about algorithms or etc



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


----------



## Christopher Mowla (Jul 5, 2013)

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.



Spoiler: Category 1: Corner 3-cycles set 1



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'
...well, start with:
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)


Spoiler: This is the same as conjugating with U2



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





Spoiler: Category 2: The N-Perm



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





Spoiler: Category 3: The remaining corner 3-cycles



(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?


----------



## Renslay (Jul 5, 2013)

cmowla said:


> 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?


----------



## cuBerBruce (Jul 5, 2013)

Renslay said:


> Somehow the permutation of the corners is restricted in <R,U>. The question is: why?


See: http://www.jaapsch.net/puzzles/pgl25.htm


----------



## Christopher Mowla (Jul 5, 2013)

Renslay said:


> 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?


Oh. The answer boils down to something quite simple: you cannot isolate a corner in either the U face or R face using <U,R> turns.

Or, more generally,
You cannot put the DBR corner in the UBR slot *preserving the formation of the remaining 3 corners in the U layer* D R D' R', for example. If we could do this, then we could do a 2-cycle of corners if we accompany it with the proper 4-cycle of corners.

In more detail,


Spoiler



Using coldsun0630's first corner 3-cycle commutator's X as an example, U' R' F R U, obviously you could create a 3-cycle of corners using only U and R turns if you could isolate a corner like this. Since a product of 3-cycles can create all even permutations, we can see why we can't create all even permutations of corners using only U and R slices.

So suppose we started with an algorithm which does a 2-cycle of edges: U R2 U' R2 U R2 U' R2 U2 R2 U2 R2 U. If you can do a 2-cycle, you can do a product of that 2-cycle to create all odd and even permutations. So that's why we can have any permutation of the edges in the U and R faces (but we of course can't change their orientation).

This algorithm also does a 4-cycle of corners. So we need to do the proper 2 2-cycle of corners in order to make it a 2-cycle. A 2 2-cycle of corners can easily be done doing simply U2 or R2 (U2 if all 4 corners in the U face need to be in a "X" 2 2-cycle or R2 if ""...).

Using the same example algorithm which does a 2-cycle of edges and a 4-cycle of corners, let's start off with a solved cube and "force" DBR in the UBR slot without changing the formation of the remaining 3 corners in the U layer, do U2 (a 2 2-cycle of all the corners in U), and undo those "forced" setup moves:
(D R D' R') U2 (R D R' D')

Now let's add this 2 2-cycle to our 4-cycle algorithm to get a 2-cycle of corners:
U R2 U' R2 U R2 U' R2 U2 R2 U2 R2 U
(D R D' R') U2 (R D R' D')

As you can see, lacking the ability to isolate a corner is both the reason we cannot create all even permutations AND why we can't create all odd permutations.

Note that I could have easily created a 2-cycle of corners in the U face, for example, if I was able to create a 3-cycle of corners in the U face + either the move U or U', but I thought that the example I gave would be more satisfying.


----------



## coldsun0630 (Jul 6, 2013)

cmowla said:


> I have an explanation for all 10 of your remaining algorithms.



First of all, I haven't read cmowla's second and third writing. Because I didn't had much time to read that.
I was reading his first writing and analyzing his decomposition. I'm very sorry about that.

In the writing, some of the decomposition was impossible to understand to me, so I decided to try to decompose them in defference way, and I got some outputs.


Spoiler: Outputs



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


Spoiler: Decomposition



R' U R U' R' // setup move
F' U' F R U R' F' U F U' // 3 pair cycle
U F' U' F // 3 edge cycle, 2x2 corner cycle
F R' F' R // 3 edge cycle, 2x2 corner cycle
R U' R' U // 3 edge cycle, 2x2 corner cycle
U' // extra quarter turn
R U R' U' R // reverse setup move
View at alg.garron.us

Without the setup moves, it is ZBLL-T R Perm.
I couldn't understand this alg perfectly because I don't know how (U F' U' F2 R' F' R2 U' R' U) works.


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


Spoiler: Decomposition



- Skeleton: F' U F' U' F' U F' U' F' // 2 edge, 4 corner cycle
F' U F' U' F' U F'
F' U' // setup move
U F2 U' F R' F' R2 U' R' U R' F R F2 U F' U' // 2x2 corner cycle (E Perm)
U F // reverse setup move
U' F'
View at alg.garron.us

I don't know how (F' U F' U' F' U F' U' F') makes 2 edge, 4 corner cycle,
and I also don't know how (U F2 U' F R' F' R2 U' R' U R' F R F2 U F' U') makes E Perm.

+
U F2 U' F R' F' R2 U' R' U R' F R F2 U F' U' (E Perm)


Spoiler: Decomposition



U F2 U'
F R' F' R
R U' R' U
R' F R F'
F' U F' U'
View at alg.garron.us

There's no meant.









...and while the term of the days, I got some more questions.


Spoiler: Questions



1. How (U F' U' F2 R' F' R2 U' R' U) works?

2. How (F' U F' U' F' U F' U' F') makes 2 edge, 4 corner cycle? and how to write this alg in commutator?

3. How (U F2 U' F R' F' R2 U' R' U R' F R F2 U F' U') makes E Perm?

4. How [R U R' U', R' U2 R] works?

5. What is 'extra quarter turn' actually means? What is 'do extra quarter turn'?


----------



## Lagom (Jul 11, 2013)

When you started doing OH, did you have to re-learn a lot of algs?

Since i pretty much know full OLL 2h, I would really like to be able to learn how to do all these algs 2h without having to re-learn them for OH muscle memory...
I just can´t do it tho, all algs are in my muscle memory and I can´t do them slowly.

Or is it just easier to learn all OH OLLS?


----------



## jayefbe (Jul 11, 2013)

Lagom said:


> When you started doing OH, did you have to re-learn a lot of algs?
> 
> Since i pretty much know full OLL 2h, I would really like to be able to learn how to do all these algs 2h without having to re-learn them for OH muscle memory...
> I just can´t do it tho, all algs are in my muscle memory and I can´t do them slowly.
> ...



If you want to be fast, you really have to learn OH algs at some point. I didn't for a long time, and am finding switching to better OH algs has a huge effect. I also find it hard to use 2H algs in OH, you still need to develop new OH muscle memory.


----------



## coldsun0630 (Jul 12, 2013)

cmowla said:


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





cmowla said:


> Oh. The answer boils down to something quite simple: you cannot isolate a corner in either the U face or R face using <U,R> turns.


Now I just read your all writing and it was AWESOME!
Your explanation was enough to understand eventhough I was novice on that area...
Anyway, thank you very much!


----------



## ben1996123 (Aug 3, 2013)

HTM move optimal 2 edge flip: [F'EF',R2U2R2]

F'EF': flips UF
U2: switches UB and UF
R2s: stuff


----------



## antoineccantin (Aug 3, 2013)

ben1996123 said:


> HTM move optimal 2 edge flip: [F'EF',R2U2R2]
> 
> F'EF': flips UF
> U2: switches UB and UF
> R2s: stuff



This does a 3 edge cycle.


----------



## ben1996123 (Aug 3, 2013)

antoineccantin said:


> This does a 3 edge cycle.



it does if you dont know what E moves are


----------



## coldsun0630 (Mar 29, 2015)

*PLL Decomposition Set*

Since one and half years ago, I saw some PLL algs were decomposed in this page, which were done by cmolwa. I tried to understand how does these PLL algs work with his table, some of them were successful, but some of them were failed. So, I tried to explain myself these PLL algs in my way, and the below is the result. Some of those algs were not finished decomposing yet (which you can see 'Temp'), but since I can't continue cubing for a long while for now, so I'm going to post my old result here now.
Some of those decomposition were done clearly by cmolwa, so I'd let you know which were done by him. I also thanks to cmolwa who answered my bunch of questions kindly before.

* '(Temp)' is a mark that decomposing the alg were not finished yet, or I haven't understand how the alg works intuitively yet.

/

Edit: All decompositions were moved. Please check this post.


----------



## coldsun0630 (Mar 29, 2015)

*+ some other things*

I tried to decompose the V Perm alg before, but I couldn't find any worth things. This is the result. (I saw that I've posted here before, so I'm just copying it.)


Spoiler



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


Spoiler: Decomposition



- Skeleton: F' U F' U' F' U F' U' F' // 2 edge, 4 corner cycle

F' U F' U' F' U F'
F' U' // setup move
U F2 U' F R' F' R2 U' R' U R' F R F2 U F' U' // 2x2 corner cycle (E Perm)
U F // reverse setup move
U' F'
View at alg.garron.us

I don't know how (F' U F' U' F' U F' U' F') makes 2 edge, 4 corner cycle,
and I also don't know how (U F2 U' F R' F' R2 U' R' U R' F R F2 U F' U') makes E Perm.

+
U F2 U' F R' F' R2 U' R' U R' F R F2 U F' U' (E Perm)


Spoiler: Decomposition



U F2 U'
F R' F' R
R U' R' U
R' F R F'
F' U F' U'
View at alg.garron.us

There's no meant.





R' U' R U' R U R U' R' U R U R2 U' R' U2 (Z Perm)


Spoiler



(R' U' R U' R U) R2 (U R U' R U' R') U2 // 3 edge cycle
U2 R U R' U // setup move
(R' U' R' U') R' (U R U R) U // 3 edge cycle
U' R U' R' U2 // reverse setup move






/

Also, I have some question that I've curioused for a long time. The questions are below:
1. At BH Corners, What makes *8 turns 3-cycle of corner algs* devide into 3 different cases, _Direct Insert_, _Drop and Catch_ and _Toss Up_?
2. How the 3-cycle of edges algorithm(R2 B2 L2 U L2 B2 R2 D) does work?
3. What does the 10-turns case mean, 'Orthogonals'?

That's all for now. Thank you.

/

Edit: All problems were solved.


----------



## coldsun0630 (Feb 18, 2016)

*Yet Another PLL Decomposition Set*

After two and half years from my first attempt, finally I finished to decompose the whole PLL sets(I have) in my way. I did this because some algs were remained 'not understood' for me.

I tried to decompose them as possible as I can, not only to explain with commutators/conjugates, but also to find what we understood already. It means(for instance), I tried to explain the algs with pure-3 cycles or sexy moves, not using some uncommon commutators, such as [F' R U2, R']. So, I believe this is more easy-to-understand than the current Christopher Mowla's decomposition.(on this thread, SS Wiki, or elsewhere.)

Some comparisons are at below.(I edited his decomposition to make similar with my explanation form.)



Spoiler: Comparison



R' U' R U' R U R U' R' U R U R2 U' R' U2 (Z Perm)


Spoiler: Christopher Mowla's Explanation



[U R: [(R' U')2: R'] U [U' R' U' R' U': R2] U2 [U2: [(U' R')2: U2] R2][U2 R2: U2] R2][U R': U2 [(R U)2: R2]]

U R // setup move 1 (cyclic shift)
(R' U' R' U') R' (U R U R) U // edge 3-cycle
(U' R' U' R' U') R2 (U R U R U) U2 // edge 3-cycle
U2 // setup move 2
(U' R' U' R') U2 (R U R U) R2 // edge 3-cycle
U2 // reverse setup move 2
(U2 R2) U2 (R2 U2) R2 // edge 2x2-cycle
R' U' // reverse setup move 1
U R' // setup move 3
U2 (R U R U) R2 (U' R' U' R') // edge 3-cycle
R U' // reverse setup move 3

View at alg.cubing.net





Spoiler: My(= Park Jubin's) Explanation



[U': [[U, R'], [U', R]][U' R U R' U: [(R' U')2: R'] U]]

U' // setup move 1 (cyclic shift)
(U R' U' R) (U' R U R') (R' U R U') (R U' R' U) // edge 3-cycle
U' R U R' U // setup move 2 (insertion)
(R' U' R' U') R' (U R U R) U // edge 3-cycle
U' R U' R' U // reverse setup move 2
U // reverse setup move 1

View at alg.cubing.net



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


Spoiler: Christopher Mowla's Explanation



[R U R' U': [R' U: [R, U2]][R', [U': L']] U]

R U R' U' // setup move 1
R' U // setup move 2
R U2 R' U2 // commutator - [R, U2]
U' R // reverse setup move 2
R' (U' L' U) R (U' L U) // corner 3-cycle
U // extra quarter turn
U R U' R' // reverse setup move 1

View at alg.cubing.net





Spoiler: My(= Park Jubin's) Explanation



[R U R' U': [U' R': [R U : [R', U]][L', [U: R]] U]]

R U R' U' // setup move 1
U' R' // setup move 2 (cyclic shift)
R U // setup move 3
R' U R U' // edge 3-cycle, corner 2x2-cycle
U' R' // reverse setup move 3
L' (U R U') L (U R' U') // corner 3-cycle
U // extra quarter turn
R U // reverse setup move 2
U R U' R' // reverse setup move 1

View at alg.cubing.net




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


Spoiler: Christopher Mowla's Explanation



[R U: [R': [F' R U2, R']][R', U] U' [R', U']]

R U // setup move 1
R' // setup move 2
(F' R U2) R' (U2 R' F) R // commutator - [F' R U2, R']
R // reverse setup move 2
R' U R U' // edge 3-cycle, corner 2x2-cycle
U' // extra quarter turn
R' U' R U // edge 3-cycle, corner 2x2-cycle
U' R' // reverse setup move 1

View at alg.cubing.net





Spoiler: My(= Park Jubin's) Explanation



[R U R' F': [R U: [U, R']][R U R' U' R', F]] U'

R U R' F' // setup move 1
R U // setup move 2
U R' U' R // edge 3-cycle, corner 2x2-cycle
U' R' // reverse setup move 2
(R U R' U' R') F (R U R U' R') F' // corner 3-cycle
F R U' R' // reverse setup move 1
U' // extra quarter turn

View at alg.cubing.net




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


Spoiler: Christopher Mowla's Explanation



[F' R' F' R: [R' F R U: F'][R, U']]

F' R' F' R // setup move 1
R' F R U // setup move 2
F' // transposition
U' R' F' R // reverse setup move 2
R U' R' U // edge 3-cycle, corner 2x2-cycle
R' F R F // reverse setup move 1

View at alg.cubing.net





Spoiler: My(= Park Jubin's) Explanation



[F' U F' U' F': [F, R'][R, U'][U, F'][F', U F U' R'] F']

F' U F' U' F'// setup move
(F R' F' R) (R U' R' U) (U F' U' F) // orient 5 pieces
F' (U F U' R') F (R U F' U') // pair 3-cycle
F' // extra quarter turn
F U F U' F // reverse setup move

View at alg.cubing.net






Actually, my PLL set doesn't contains the whole algs on SS Wiki. There are a lot of same algs(rotation, mirror, inverse, etc.), and that's why I didn't check there. If I have more time later, I will do the decomposition of them, too. But, it still contains a bunch of algs!

I merged my whole decomposition set in a single post on my blog, so you can see it at *here*. Well, the post contains some Korean texts, but they are not really important. All of the explanation were written in English.

If you have a question about this, please let me know! And also, any feedback is welcomed!


----------



## Christopher Mowla (Feb 20, 2016)

coldsun0630 said:


> And also, any feedback is welcomed!


I first note that the _inverse_ of my decomposition for the v perm is much easier to understand than how it's currently written in your post (at least to me). (I think this modification makes it easier-to-understand than yours, as it follows the "_classic_" parity algorithm setup.) But your representation is creative. That must have taken a while to make.

As far as the rest of yours, they are too similar to mine for the most part for me to think that they are _that_ much better than the ones I presented, but I agree you did improve on them. I taught you well!

Now, I have come up with a new presentation for the first three cases you listed, as to give us all another perspective on the matter. 

They all have sune-type algorithms in them, which I think many on here will like.



Spoiler: R' U' R U' R U R U' R' U R U R2 U' R' U2 (Z Perm): Two Algorithm Combination



I can't say that this is the best possible way to make this alg more understandable, because the second algorithm piece is quite long, but it is certainly better than the other ones, IMO.

R' U' R U' R' U2 R U2 // (sune with all moves inverted/sune rotated about y2 and mirrored about M) + U2
U2 R' U2 R2 U R U' R' U R U R2 U' R' U2 //a long sune alg.

Combine and cancel moves, we get the alg.





Spoiler: R U R' U' R' U R U2 R' L' U R U' L U' R U' R' (F Perm): Derivation



[1] Start with sune

R U R' U R U2 R'

[2] Add 3 corner cycle, L' U R U' L U R' U'

R U R' U R U2 R'
L' U R U' L U R' U'

[3] Add extra quarter turn
R U R' U R U2 R'
L' U R U' L U R' U'
(U)

[4] Shift
R' U R U2 R'
L' U R U' L U R' U'
(U) R U 

[5] Conjugate
R U R' U'
R' U R U2 R'
L' U R U' L U R' U'
(U) R U 
U R U' R'

[6] Cancel moves
= R U R' U' R' U R U2 R' L' U R U' L U' R U' R'





Spoiler: R U R' F' R U2 R' U2 R' F R U R U2 R' U' (R Perm): Derivation



[1] Start with Sune

R U R' U R U2 R'

[2] Conjugate

U2
R U R' U R U2 R'
U2

[3] Add extra quarter turn
U2
R U R' U R U2 R'
U2
(U)

[4] Add 3 corner cycle R' F' R U2 R U2 R' F R U2 R' U2 R' R
U2
R U R' U R U2 R'
U2
(U)
R'
F' R U2 R U2 R' F R U2 R' U2 R'
R

[5] Shift (conjugate)

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

[6] Take the inverse

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

[7] Cancel moves
= R U R' F' R U2 R' U2 R' F R U R U2 R' U'


----------



## coldsun0630 (Feb 26, 2016)

*Re: Feedback*



Christopher Mowla said:


> I agree you did improve on them. I taught you well!


 Hello again, it's nice to see you! It has been for a while since I learned from you how algs does works on the cube. At that time, actually I wasn't experienced enough at cubing. So I could figure out some easy algs like some U Perms or J Perms, but I failed to decompose other computer-generated algs, so I asked here about them before. Most of them were answered on your old post, and it was very, very helpful to understand the cube itself. I still appreciate you for this. But some of your description were not enough to accept, and that's why I tried to re-decompose the algs.




Christopher Mowla said:


> As far as the rest of yours, they are _too similar_ to mine.


 The decomposition set presents you "how I understood the algorithms", so it means they are just my collection, but not the "correct answer". Of coursely, the way to decompose could be same with yours. Some algs are so obvious that is hard to find other ways to decompose. But some algs are not: the decomposition may be varied by the difference of one's perspective. Oh, please be sure that the comparison is not to show that my explanation is better than yours, but to show that how the interpretation of each algs could be different.

Of course you may find some of them are _too similar_ to yours, bacause some of them are actually "the same" to yours. As I said above, this is the way to understand how the algs work, but which I prefer. Some of your decomposition (from the old post) didn't worked for me, but the rest were very enough to explain. And this is why your explanation are included in my decomposition set. But I only brought them from the old post, so If mine and the SS Wiki one are same? Then I don't know, it's just an accident. Maybe they're in the first case, which the algs looks so obvious. Actually, most of the PLL algs are in this case.




Christopher Mowla said:


> I first note that the inverse of my decomposition for the V Perm is much easier to understand than how it's currently written in your post (at least to me).


 I have two rules on my decomposition:
#1. Every moves should be reasonable.
#2. Each decomposition may compatible with its derivated algs.

For the _rule #1_, it means that an alg should be explained with series of elements, like commutators, setup moves, extra moves, etc.) And that's what decomposition is for. In this case, for me, a 'pure cycle' is more prefered than a sexy move, because a pure cycle looks more clear than [R, U], which swaps 7 pieces. So when I decomposing an alg, I usually try to avoid extra moves. And, this is why I decomposed the V Perm in another way. Of course your decomposition is still valid, and now I prefer your decomposition. Oh, I didn't added this on my decomposition set yet. I'm gonna edit the post soon.

For the _rule #2_, it means that if the basic structure/execution of two algs is same, it may decomposed in same way. If not, I would prefer a decomposition which can explain the both algs. Here's an example.


Spoiler






> L F2 R2 D R D' R F2 L' U



The alg could be decomposed like this:


> L F2 R2 D R D' R F2 L' U
> 
> L F2 R' // setup move
> R' D R D' // sexy move (edge 3-cycle, corner 2x2-cycle)
> ...



I know another alg which solves same case.


> R U2 R' L' U R U' L U2 R' U
> 
> R U' // setup move
> U' R' [1] U R // sexy move
> ...



...and you may see that it has the same structure with the shifted one.


> *R* U2 R' *L'* U R U' *L* U2 *R'* U
> = *r* U2 R' *l'* U R U' *l* U2 *r'* U



Then it may be decomposed in same way. The alternative decomposition is following:


> R U2 R' L' U R U' L U2 R' U
> 
> *l* F2 *r'* // setup move
> R' D R D' // sexy move (edge 3-cycle, corner 2x2-cycle)
> ...





> r U2 R' l' U R U' l U2 r' U
> 
> *r* U' // setup move
> U' R' [1] U R // sexy move
> ...









Christopher Mowla said:


> They all have sune-type algorithms in them, which I think many on here will like.


Okay. Let's take a look one by one.



Christopher Mowla said:


> *R' U' R U' R U R U' R' U R U R2 U' R' U2 (Z Perm): Two Algorithm Combination*
> 
> R' U' R U' R' U2 R U2 // sune alg + U2
> U2 R' U2 R2 U R U' R' U R U R2 U' R' U2 // a long sune alg


Well, I edited the post once because I copied wrong decomposition of the Z Perm. So, I wonder if you saw this new one:


Spoiler: My Decomposition of the Z Perm



U' // setup move 1 (cyclic shift)
(U R' U' R) (U' R U R') (R' U R [1] U') (R U' R' U) // edge 3-cycle
U // reverse setup move 1

Insert at [1]: (R' U' R' U') R' (U R U R) U // edge 3-cycle


(The key algorithm is [U R' U' R, U' R U R'], and I think it's not really hard to understand.)

Your decomposition doesn't satisfy my _rule #1_, at least for me, because it actually seems just a coincidence. the short sune alg can be explained as [R' U': [R, U']]. The [R, U'] explains everything about the 3-cycle of edges and the orientation state of corners. But I don't think that 'a long sune alg' could be explained as simple as the first one. I love simple and precise one so I don't like this explanation. I'd rather prefer your previous decomposition which explains with five 'pure' cycles.




Christopher Mowla said:


> *R U R' U' R' U R U2 R' L' U R U' L U' R U' R' (F Perm): Derivation:*
> 
> R U R' U' // setup move 1
> R' U R U2 R' [1] U R U // shifted sune alg + extra quarter turn
> ...


Well, this is basically same as my explanation. I always decompose sune algs using 2-moves-conjugation and sexy move. And for the shift, I was used to explain it with setup moves, which called "cyclic shift". (I brought the term from BH Method.) In this case, I explain the shift like this:


Spoiler



R' U R U2 R' U R U
U' R' // setup move (cyclic shift)
R' U R U2 R' U R U // sune alg + extra quarter turn
R U // reverse setup move



Oh, I actually was able to reduce the number of setup moves! Here's my updated one.


Spoiler



R U R' U' R' U R U2 R' L' U R U' L U' R U' R'
[R U R' U': [R', U][U' R': [L', [U: R]] U]]

R U R' U' // setup move 1
R' U R U' // edge 3-cycle, corner 2x2-cycle
U' R' // setup move 2
L' (U R U') L (U R' U') // corner 3-cycle
U // extra quarter turn
R U // reverse setup move 2
U R U' R' // reverse setup move 1

View at alg.cubing.net






Christopher Mowla said:


> *R U R' F' R U2 R' U2 R' F R U R U2 R' U' (R Perm): Derivation:*
> 
> R U' R' U2 // setup move 1
> R' // setup move 2
> ...



Firstly, my decomposition is sune type alg, too!


Spoiler



R U R' F' // setup move
*R U2 R' U' R U' R' // a sune alg*
(R U R' U' R') F (R U R U' R') F' // corner 3-cycle
F R U' R' // reverse setup move
U' // extra quarter turn



Well, I arranged your decomposition a bit.


Spoiler: Ver.1



R U' // setup move
(U2 R' F' R U2) R' (U2 R' F R U2) R // corner 3-cycle
R' U' R U2 R' U' R U' // shifted sune alg + extra quarter turn
U R' // reverse setup move





Spoiler: Ver.2 - Final



[R U': [U2 R' F' R U2, R'][R', U']] U'

R U' // setup move
(U2 R' F' R U2) R' (U2 R' F R U2) R // corner 3-cycle
R' U' R U // edge 3-cycle, corner 2x2-cycle
U R' // reverse setup move
U' // extra quarter turn

View at alg.cubing.net


Wow, this version of decomposition is much better! I will add it on my list. Thank you for giving me another look!


Well actually, I have a problem with the R Perm decomposition. In my old decomposition, I took setup move [R U R' F'], because of my _rule #2_. But I failed to decompose which compatible with these alg. Would you please decompose them with a *same* explanation?


Spoiler



R U R' F' R U (　　　　 )　R' U' R' F R (　　　　 )　R U' R' // [J Perm]
R U R' F' R U (U R' U' R)　R' U' R' F R (U R U' R')　R U' R' // [R Perm]
R U R' F' R U (U R' U' R)2 R' U' R' F R (U R U' R')2 R U' R' // [G Perm]
R U R' F' R U (U R' U' R)3 R' U' R' F R (U R U' R')3 R U' R' // [J Perm]
R U R' F' R U (R' U R U')2 R' U' R' F R (R U R' U')2 R U' R' // [R Perm]
R U R' F' R U (R' U R U')　R' U' R' F R (R U R' U')　R U' R' // [G Perm]




It's all for now. Thank you for your response!


----------



## coldsun0630 (Dec 6, 2016)

An answer for my old question:


coldsun0630 said:


> *Re: Feedback*
> 
> 
> Well actually, I have a problem with the R Perm decomposition. In my old decomposition, I took setup move [R U R' F'], because of my _rule #2_. But I failed to decompose which compatible with these alg. Would you please decompose them with a *same* explanation?
> ...



R U R' F' R U R' [1] U' R' F R2 U' R' (U')
[1]: [[R, U]*n, [U', l']]

i) n=3k+1: PLL R-Perm
ii) n=3k+2: PLL G-Perm
iii) n=3k: PLL J-Perm (the insertion does nothing.)


----------

