I hate the G perm the most, I can prove it.

Note: This a rather cube-oriented post, and will be better if you have a cube with you, and will be a lot better if you're fully familiar with Singmaster notation.

Warning: These algorithms are only useful for academic purposes and will probably just slow you down in the long run. Learn the lesson, not the algorithms.

I still don't do CFOP that well, and if you're just learning it now, you should have fewer bad habits than me because you have the benefit of years of refinement of the method even before you ever saw any algorithms.

I was rather skeptical about the CFOP method when I first encountered it, because I didn't think that most people would be able to memorize algorithms for 80ish last layer cases (57 orientation cases, or OLLs and 21 permutation cases, or PLLs) in addition to some specialized F2L (first two layer) cases. But, I was using a method that needs less than 20 algorithms and had just barely caught up to the speed of its creator only years later. In the meantime, CFOP times kept going down. I later figured out that there were potentially a decent number of mirror image cases that kept the number of cases manageable.

I also realized that when I had used a layer by layer method, I had the decided disadvantage of having learned one (Nourse) that left the solved layer up instead of one that leaves the solved layer down (Taylor). While I saw the move efficiency of putting the middle layer edges in with the first layer corners, I still had been working with the bad habit of not turning the cube over until I finished the first two layers.

When I finally accepted that I should start learning some PLL's, the two major resources I was looking at was speedcubing.com, and Jessica Fridrich's page. I probably started with the U perm, because I figured out that R2US'U2SUR2  is just the same as the U2M'U2M edge 3-cycle with some setup moves. I was OK with left-handed and right-handed versions of that easily enough. I may have learned the T perm next, and was so glad that it was symmetrical and I didn't have to learn a second version of it. Strangely, the version of the T perm that I learned is the inverse of one of the algorithms on the speedcubing.com page (but hey - it's symmetrical so it's also functionally its own inverse), so I'm not sure how I got to that version of the algorithm. But, I digress - and it's going to look like I'm doing it some more but bear with me. If you want to play along, this would be a good time to grab a cube.

For the N perm, I took the easy-to-memorize route, and went with  

LU'RU2L'UR' LU'RU2L'UR' U 

because the first segment and the second segment are the same thing. This was the first of the PLLs that I learned that had a diagonal swap, do I had to use this a lot when I was still doing 4 look last layer.

So if you start with a solved cube, and do the first segment of that move, you get the fr and bl F2L pairs swapped, and you get two U-layer corner-edge pairs swapped, like the J perm. Doing the second segment resolves the two F2L pairs, and swaps the second set of U layer corner-edge pars, creating the N perm.

I also figured out that if you inserted a U' or a U move in the middle of the N perm above, cancelling part of the U layer swap from the first segment to the second, you got a J perm. I later learned a better algorithm for one of the J perms, but I still use the method above for the other.

So, in my weird bag of cube tricks, I knew that there was another way to fix the 2 F2L pairs that were undone by the first part of the N perm. Start with a solved cube again.

LU'RU2L'UR'  y  L'R'U2LR gets you something that looks like... Could it be? The G perm! So now, I just had to reverse engineer it. (Put down your cube momentarily.)

The G perm isn't really all the way symmetrical the way we would like, and it's not its own inverse. Therefore, you need four versions of the move. Left-handed, right-handed, left inverse, and right inverse.

The version of the G perm that the above example solves is with headlights on the front, and a bar on the back with the ub and the ubr pieces. The mirror image is still headlights on the front and the bar between ub and ubl. For a long while, this was as far as I was, as I had not bothered to write down the move and properly figure out the inverse.

Headlights on the back, bar on the right between ur and ufr, which is what you might have if you did the above bold move from a solved cube, (OK pick up the cube again...) is solved with

L'R'U2LR y' LU'RU2L'UR'.

And you should be back to a solved cube.

Now you could try the other two, the mirror images. Like before, one will undo the other.

R'UL'U2RU'L y' RLU2L'R', 

and LRU2L'R' y R'UL'U2RU'L.

So, while I can't recommend these algorithms to anyone other than just for academic interest or just basic insight into the algorithm building process, I hope that someone can use this to actually make some better algorithms.

Just a little more dissection of the 22.95 solve, this time LSE.

 I apparently could not wait to do more typing about the 22.95 Minh Thai solve.  Scroll down to the previous post if you're not caught up here.

LSE refers to Last Six Edges. Four of them are in one of the slice layers, and then you have one edge each on the two other layers. Technically, this term didn't exist until the Roux method was proposed, but that's exactly where you find yourself in Minh Thai's method once you have completed three edges each on two opposite sides.

If you look at the last part of the reconstruction from last time, you have this:

u R' E' R E2 R E R' // LSE 
R2 E E' r2 E M2 E' // centers

If you would like to skip ahead to this part of the solve, perform this on a solved cube: 

z’ D2 U2 F' D2 F' U2 F' L2 F' R2 F' R2 F' L' R' U' L' R F D' from standard solved white top/green front. 

So, looking at the moves that are labeled as "LSE", but from the standpoint of Minh's solution guide, I see that breaks down as follows:

u // Aligns upper and lower layers

R' E' R // Puts upper edge in lower target position From Stage III, part 2 (pg 48) "If both (edges) are somewhere in the horizontal middle layer, it will be easy to flip either one of them into the other one's target position."

E2 // puts lower edge in position to be matched with upper Setup move to do Case #2

R E R' // inserts both edges similar to stage III, part 2 case 2.

At this point, all we have is a Dot Case, and there is no edge orientation to do. So, this is a big skip at this point. Perhaps that's why there's the (E - E' ) in the centers because he's excited, or maybe he's just checking to make sure one of the edges in the back isn't flipped first before he fixes the centers. If he had edge orientation to complete, that would have been between 9 and 14 more moves, at least half of which would have been slice moves. Unlike modern cubes, slices can be quite an effort on 80's cubes. So, without that, you get to skip straight to edge permutation, and while it's the worst one, it's not that bad.

So again, we learned that this solve had relatively simple components, a little luck, and was not a  byproduct of a large available algorithm set.

Because Social Media isn't Verbose, and CLL isn't as common in 1982.

 People have complained to me on more than one occasion that I am verbose. As far as I know, this is a completely undesirable trait most of the time. However, I am always found wanting more information and specificity when I ask about things, so I have attempted to learn how to (mostly) politely interrogate people so that I get the sort of answers that I'm looking for.

When I'm the person giving the answers, it's terrible, but mostly because I have given more answer than the other party wanted, and even sometimes to questions that the other party only wanted a meaningless superficial answer to. I have been told on more than one occasion that I talk too much or overexplain, and even once have been told in response that "people aren't going to read my @#$%^$%$$% novel" when I typed out a thorough answer to something.

Every once in a while, I see something that's a tiny bit underexplained, and it bugs me, but I usually have enough sense to not cause problems. What follows is a byproduct of me now fixing something that was a little bit under-explained (or oversimplified, you pick) and I finally bothered to sort it out myself.

So the first Rubik's cube official record was Minh Thai's 22.95. 

 

https://www.youtube.com/watch?v=WJTZhgrbgt8&t=325s

And, thanks to reddit users /u/qqwref and /u/BrestCubing, a lot of important solves have been reconstructed - including this one - and we'll get to that.  Most of the modern solves are done with a method that everyone is more familiar with, what used to be called Fridrich and is now referred to as CFOP. But, Minh's solve is done with his own method, and it's even well documented. ("The Winning Solution", ISBN 0-440-09795-9, 1982.) 

Minh's book was a step ahead of many things that were available at the time because he had individual orientation algorithms for the second set of corners, when nearly every other solution book had some sort of incremental method for orienting the second set of corners. It was one of the first published cube books to explicitly detail and demonstrate the idea that if you had more algorithms at your disposal you could solve faster.  Interestingly enough, there were also a handful of extra algorithms in the examples that started to make me consider the idea that Minh had actually been able to orient and permute second layer corners in a single algorithm.

So, that leads me to the reconstruction. Michael Gottlieb's (qqwref) reconstruction is as follows:

U L2 D' B2 U' R2 B2 F2 D' F2 L2 R2 F R2 D L2 R2 B' L' D' R F' 


x2 y // inspection 
D' R u D R' y' D' R D R' // FL corners + 1 edge 
y D r' E' L // FL center + 2nd edge 
z2 U y l D R' z' R' x z' r' R2 U2 z D R2 D2 // CLL 
R' l' z M D2 M' // FL 3rd edge 
z2 y R z' M z R' // LL 1st edge 
z' r' L' z D R' E R // LL 2nd edge 
U' u' R E' R' // LL 3rd edge 
u R' E' R E2 R E R' // LSE 
R2 E E' r2 E M2 E' // centers

 

This is typical of modern reconstructions. The scramble is shown first, starting from a solved cube with white on top and green on front, moves are shown in standard Singmaster notation, including cube rotations, and double slashes at the end of a line to give a place to put comments.  So, at the end of line four there, it says "CLL". The implication there is that Minh solved both permutation and orientation in a single algorithm. However, that's not the case. Also, it's largely overlooked because it's typically more move-efficient to orient first before permuting. So, here's my marked-up version of the reconstruction. I added notes in one color and comments in another so I could keep track. The Stage/Section references are from Minh's solution guide.

 

U L2 D' B2 U' R2 B2 F2 D' F2 L2 R2 F R2 D L2 R2 B' L' D' R F'

x2 y // inspection  yellow top, red front 

D' R u D R' (y' D') R D R' // FL corners + 1 edge ends with orange corners on top but still yellow top red front 

(y D) r' E' L // FL center + 2nd edge ends with orange on front, red corners need diagonal swap 

 z2 U y l D R' z' R' x z' r' // corners in correct cycle, orange on bottom 

This is equivalent to the permutation algorithm in Stage 2, Section 1, C3, (LFUF’U’L’) with cube rotations and wide moves.  This is permutation only, so I wouldn’t exactly count this as CLL. 

 R2 U2 z D R2 D2 // CLL corners oriented, orange on left  

This is equivalent to the orientation algorithm in Stage 2, Section 2, T7, (R2 F2 R F2 R2) with one cube rotation. 

R' l' z M D2 M' // FL 3rd edge 

z2 y R z' M z R' // LL 1st edge 

z' r' L' z D R' E R // LL 2nd edge 

U' u' R E' R' // LL 3rd edge keyhole piece is at ‘dr’ for the LL edges 

u R' E' R E2 R E R' // LSE 

R2 E E' r2 E M2 E' // centers

Taking another look at this reconstruction solidified two things for me - one, the confirmation that he wasn't doing full CLL, and second, that he rarely performs any sort of F or F' moves despite how often they appear in his solution guide. I had already gotten a sense of that from some other video of him, but it was nice to have the confirmation from a good reconstruction.

So, that's not to say that _nobody_ was doing CLL in the 80's, it just wasn't Minh Thai. Mark Waterman has a well-documented (on the web, at least) corners first solution that has a CLL step.

The next time we take a swing at this, I will have to look at the "LSE" step.