# [video] Permutation of last layer without algorithms



## circular (May 27, 2012)

Hello, here is a video showing how to permute the last layer using only moves that you can understand. So no algorithm to learn, just pure logic. If you have any comment, or suggestion on how to make it even better, feel free to propose any improvement.

The general explanation for 3-cycle is at 4:25. The first example on rotating corners is just a way of applying this principle to corners.






EDIT: More explanation on how to create algorithms using commutators :


----------



## applemobile (May 27, 2012)

Looked like you were performing Algorithms to me.


----------



## sa11297 (May 27, 2012)

applemobile said:


> Looked like you were performing Algorithms to me.


 
yep http://dictionary.reference.com/browse/algorithm?s=t


----------



## circular (May 27, 2012)

Well by algorithm that I mean no "sequence of move that you don't understand what is going on you just apply them in some case and you got the result".

What I am doing here, I think you can understand everything that is going on. Basically it's about using commutators. But I show the result so you don't have to figure it out.


----------



## cubernya (May 27, 2012)

circular said:


> Well by algorithm that I mean no "sequence of move that you don't understand what is going on you just apply them in some case and you got the result".
> 
> What I am doing here, I think you can understand everything that is going on. Basically it's about using commutators. But I show the result so you don't have to figure it out.


 
I understand everything that goes on in my PLL algs (more so than your explanation in this video anyway)


----------



## circular (May 27, 2012)

Well if it's not useful to you in particular, that's ok for me. But if you're so smart, you should have understood what I am showing here...


----------



## cubernya (May 27, 2012)

circular said:


> Well if it's not useful to you in particular, that's ok for me. But if you're so smart, you should have understood what I am showing here...


 
I understand commutators very well, but the way you explained it made no sense at all. If somebody that doesn't know commutators understood that, I need to figure out how


----------



## circular (May 27, 2012)

Is the a way to ignore messages from a member on this forum ?


----------



## Godmil (May 27, 2012)

Just watched the first few mins. I thought it was really interesting. When you see them broken down like that they're super easy to memorise.


----------



## applemobile (May 27, 2012)

circular said:


> Is the a way to ignore messages from a member on this forum ?


 
Yeah, there is a button at the very top right of the page.


----------



## circular (May 27, 2012)

Thanks !


----------



## Rpotts (May 27, 2012)

Your A perm and H perm are longer, slightly more complicated versions of already very intuitive commutators/conjugates. The E perm was cool though.

Also, your second U perm and J perm /are/ the optimal algs for the case, you're just explaining them, which is good. I might suggest starting with pure block commutators to give viewers who don't know about them a better grasp of them before moving on to 'A9' equivalents.


----------



## circular (May 27, 2012)

Rpotts said:


> Your A perm and H perm are longer, slightly more complicated versions of already very intuitive commutators/conjugates.


Which sequence would you propose instead ?

I find the H perm in this video very intuitive, and it's 8 moves long, whereas the optimal one is 7 moves. So I do not agree.



> The E perm was cool though.


Thanks. I noted that in fact it can be optimised by avoiding the U2 and rotating the whole algorithm instead. So then it becomes optimal (14 moves).



> Also, your second U perm and J perm /are/ the optimal algs for the case


The U perm is optimal, but not the J perm, which is 11 moves whereas the optimal is 10 moves (F2 D F D' F L2 B' U B L2)



> you're just explaining them, which is good.


Thanks.



> I might suggest starting with pure block commutators to give viewers who don't know about them a better grasp of them before moving on to 'A9' equivalents.


Well I wanted to avoid complex vocabulary so that someone who just don't know anything would understand what I am talking about. 

I don't understand what you mean by A9.


----------



## cubersmith (May 27, 2012)

It might be easier just to learn A perm and U perm


----------



## Rpotts (May 28, 2012)

circular said:


> Which sequence would you propose instead ?


H perm - M2 U M2 U2 M2 U M2 which can be notated in commutator notation as [M2 U: [M2, U2]] 

A perm - R2 D2 R U R' D2 R U' R which can be notated as [R': [R' D2 R, U]]



> I find the H perm in this video very intuitive, and it's 8 moves long, whereas the optimal one is 7 moves. So I do not agree.



The H perm in the video is intuitive, but so is the standard alg for the case. Might as well teach how to understand the better one, shorter SQTM one.



> The U perm is optimal, but not the J perm, which is 11 moves whereas the optimal is 10 moves (F2 D F D' F L2 B' U B L2)



That J perm _is_ optimal, 10 moves is optimal +1 AUF.

EDIT: My mistake, the alg you posted is 10 moves from the common 'solved' AUF, didn't know that.



> I don't understand what you mean by A9.



A9 is a type of commutator that is a pure, 8-mover that is conjugated by one move, which cancels into the commutator at either the beginning or end. A perm is an example of an A9.


----------



## Nico1 (May 28, 2012)

theZcuber said:


> I understand commutators very well, but the way you explained it made no sense at all. If somebody that doesn't know commutators understood that, I need to figure out how


 
I don't understand commutators (need to find a good video on that...) and I didn't understand anything in this video except that he was performing pre-memorized algorithms. 

@circular, maybe you could edit your videos to teach how to make an algorithm yourself to solve pll instead of explaining the algorithms that you have memorized (that would help me a lot as there aren't many videos on this!)


----------



## Christopher Mowla (May 28, 2012)

I didn't watch the video yet, but here is an intuitive 2-edge and 2-corner swapper I made without using any methods, commutators, conjugates, etc.

B L U' F U L' B' U R U R' U2

Just conjugate with U2 to get a J-Perm.


----------



## circular (May 28, 2012)

Rpotts said:


> H perm - M2 U M2 U2 M2 U M2 which can be notated in commutator notation as [M2 U: [M2, U2]]
> 
> A perm - R2 D2 R U R' D2 R U' R which can be notated as [R': [R' D2 R, U]]


Euh, how would you explain them?



> A9 is a type of commutator that is a pure, 8-mover that is conjugated by one move, which cancels into the commutator at either the beginning or end. A perm is an example of an A9.


Ok, thanks.



Nico1 said:


> I don't understand commutators (need to find a good video on that...) and I didn't understand anything in this video except that he was performing pre-memorized algorithms.
> 
> @circular, maybe you could edit your videos to teach how to make an algorithm yourself to solve pll instead of explaining the algorithms that you have memorized (that would help me a lot as there aren't many videos on this!)


Didn't you see in the video? I explain the 3-cycle at 4:24.



cmowla said:


> I didn't watch the video yet, but here is an intuitive 2-edge and 2-corner swapper I made without using any methods, commutators, conjugates, etc.
> 
> B L U' F U L' B' U R U R' U2
> 
> Just conjugate with U2 to get a J-Perm.


How would you explain it?


----------



## Christopher Mowla (May 28, 2012)

circular said:


> Rpotts said:
> 
> 
> > A perm - R2 D2 R U R' D2 R U' R which can be notated as [R': [R' D2 R, U]]
> ...





circular said:


> Didn't you see in the video? I explain the 3-cycle at 4:24.


You didn't really explain that the affected corners and edges in the bottom would be undone when you repeat the swaps an even number of times, though that is how your 3-cycle algorithm for swapping corners was: L' R' D2 L R U' R' U L' D2 L U' R U. I'm not criticizing you at all: your video was absolutely beautiful, but I felt it was only "telling one side of the story." But the key thing you mentioned was "the buffer."

In the A-perm Rpotts showed, look at the cube after R' D2 R is executed: the whole purpose was to separate a corner in UFR for which the turn U replaces that corner with another in the U-Layer. Then you undo R' D2 R with R' D2 R, and then undo U with U'. So now you have 3 corners swapped.

R' D2 R
U
R' D2 R
U'

They are not all in the same layer, but we can make it so by adding a setup move, just as you did for your 3-cycle of 3 edges to be placed in the U-Layer. Same idea.



circular said:


> cmowla said:
> 
> 
> > I didn't watch the video yet, but here is an intuitive 2-edge and 2-corner swapper I made without using any methods, commutators, conjugates, etc.
> ...


See here. Take note that this algorithm does consist of a commutator and two conjugates, but that's not how I made it (as I have already explained) = [B L U': F] [U: [R, U] ].

Also, I don't know why you didn't use your idea to at least do a 3-cycle of corners and edges at the same time:

M2 U M2 U' M2
L R d2 L' U' L d2 L' U R'
M2 U M2 U' M2

Again, great job on the video. I too love simplicity, and you expressed it very well by using the same type of commutator, but you didn't even mention why you must place edges and corners facing a certain way before you exchange. It happens to work out, but you still didn't explain why you get PLLs from the moves you chose. But keep up the good work.


----------



## circular (May 28, 2012)

cmowla said:


> In the A-perm Rpotts showed, look at the cube after R' D2 R is executed: the whole purpose was to separate a corner in UFR for which the turn U replaces that corner with another in the U-Layer. Then you undo R' D2 R with R' D2 R, and then undo U with U'. So now you have 3 corners swapped.
> 
> R' D2 R
> U
> ...


Ok I got it. The setup move is merged with the commutator, and it moves the two corners instead of moving the buffer corner.

I still do not understand your move. But I kinda understand the principle you've used.



> Also, I don't know why you didn't use your idea to at least do a 3-cycle of corners and edges at the same time:
> 
> M2 U M2 U' M2
> L R d2 L' U' L d2 L' U R'
> M2 U M2 U' M2


That's interesting. I didn't think about it. Is it really shorter than combining with 3-cycle of edges ?


----------



## Rpotts (May 28, 2012)

> Euh, how would you explain them?



Well cmowla did an excellent job explaining the A perm so I'll just do H perm.

M2 U M2 U2 M2 U M2 or [M2 U: [M2, U2]] which follows the form [c: [a, b]] which when expanded reads c a b a' b' c'.

When you break down that commutator notation it would read - M2 U (M2 U2 M2 U2) U' M2

The M2 U2 M2 U2 is the simple 2-2 swap you used in your H perm as well, it swaps DF-DB and UF-UB. In H perm we want to swap UF-UB and UL-UR. The first setup move, M2, separates the 2-2 swaps into different layers, moving the UF-UB swap to DB-DF, while leaving UL-UR unchanged. Then the second setup move, U, moves UL-UR to UB-UF. After just two moves, compared to your alg's three, we've setup to the simple [M2, U2] commutator. After doing [M2, U2] you'll still need to undo the conjugation by doing U' M2, however the last U2 of [M2, U2] cancels into the U' of the setdown to just leave U.

M2 U M2 U2 M2 U M2


----------



## circular (May 28, 2012)

Ok. Thanks. Well, no in my alg, there is no setup move. It's just a simple commutator.


----------



## Christopher Mowla (May 28, 2012)

circular said:


> Is it really shorter than combining with 3-cycle of edges ?


Mine is 20 STM, and yours is 24 STM (STM = slice turn moves, where you count E2, R2, R, E, etc. as one move each).

Because I believe you would handle that case (I didn't go back to the video to see) like so:

(L' R' D2 L R U' R' U L' D2 L U' R U) (L' R' E2 L U L' E2 L U' R) (24 STM)

But if you cancel moves in mine, then it is 19 STM



cmowla said:


> M2 U M2 U' M2
> L R d2 L' U' L d2 L' U R'
> M2 U M2 U' M2



Since M2 L R = (L R x2)',

M2 U M2 U' L' R' x2
d2 L' U' L d2 L' U R'
M2 U M2 U' M2

But, I don't really recommend doing the alg I did because it's much easier to do two shorter algorithms rather than one, especially that they are this close in moves. I just wanted to see your idea apply to a more complex case without just trivially breaking that up into 2 steps. When I heard "PLL", I was actually expecting you to be able to intuitively handle every one of the PLL cases in one step.

Also, if you adjust my alg (which IS based off of your preferred type of commutator), you can get an R Perm if you add one move at the end. The following red moves are inverted, and the blue move is the one which was added:

M2 U M2 U M2
L R d2 L' U' L d2 L' U R'
M2 U' M2 U' M2
U' 
Link

Perhaps you could experiment with doing both of them at once to generate the rest of the odd permutation PLLs directly.


----------



## AbstractAlg (May 29, 2012)

Long live commutators!! 

Love them, they are awesome to use in BLD.


----------



## Godmil (May 29, 2012)

OK, this is the first time I've picked up a 3x3 in a few days, I tried to do an A perm as you demonstrated it in your video, having only seen it that one time (when you first posted it), and I did it correct first try, without having to even think about it.
So I'm quite convinced that you're video is very good for making alg memorisation easy.


----------



## circular (May 30, 2012)

Thanks Godmil 

@cmowla: Yeah I'm getting a little bit lost with conjugating big commutators.

But I found one that is interesting :

(L' U' L U) + (U R U' L d2 L' U L d2 L' R') + (U' L' U L)
(conjugate) + (J perm) + (deconjugate)

Which gives Y perm.

It can be simplified to
L' U' L + L U' R d2 R' U R d2 R' L' U + L' U L
(conjugate without top align) + (rotated J perm with top rotation after) + (deconjugate)

which of course simplifies into
L' U' L2 U' R d2 R' U R d2 R' L' U L' U L

or, avoiding d2 :
L' U' L2 U' R U2 L' U L U2 R' L' U L' U L (16 moves)

which can be done for example as :

(L' U' L) (L U') (R U2) (L' U L) U2 R' (L' U) (L' U L)



cmowla said:


> When I heard "PLL", I was actually expecting you to be able to intuitively handle every one of the PLL cases in one step.


I woud like too


----------



## circular (May 30, 2012)

cmowla said:


> Mine is 20 STM, and yours is 24 STM (STM = slice turn moves, where you count E2, R2, R, E, etc. as one move each).
> 
> Because I believe you would handle that case (I didn't go back to the video to see) like so:
> 
> (L' R' D2 L R U' R' U L' D2 L U' R U) (L' R' E2 L U L' E2 L U' R) (24 STM)


No, it would be 
(R' (U L' D2 L U' L' D2 L) R)(F2 U') (M' U2 M) (U' F2)



cmowla said:


> Also, if you adjust my alg (which IS based off of your preferred type of commutator), you can get an R Perm if you add one move at the end. The following red moves are inverted, and the blue move is the one which was added:
> 
> M2 U M2 U M2
> L R d2 L' U' L d2 L' U R'
> ...


That's a bit complicated for me. But thinking about it, I found this one to do the R perm :
(M2 U2 M2)(U L' R' d2 R U R' d2 R U' L)(M2 U2 M2)



> Perhaps you could experiment with doing both of them at once to generate the rest of the odd permutation PLLs directly.


Sure. Why not.

I can't find the T perm and the F perm. Well for example, the F perm may be with a 7 move long conjugate, which is 14 moves, which is much longer than doing a 3-cycle of edges. But anyway, finding conjugates for two adjacent corners only is interesting only if the conjugate is 3 moves long or less, because the 3-cycle of edges is 7 moves long.

So it may be more interesting for opposite corners for V or N to find something with a J perm.

I noticed that for V, it's faster to exchange adjacent pairs (J) then rotate corners, instead of exchanging opposite pairs (N) then rotate edges, because J is shorter.


----------



## circular (May 31, 2012)

Here is a video to explain how to create algorithms using commutators :


----------

