Alternative 2-Look CMLL: Permute-First

[dudefaceguy]

This is how I do 2-look CMLL in Roux. I prefer intuitive solving, so I've never done a CFOP solve, and I don't have any preference for orientation before permutation. I think permutation first is easier and more intuitive, and it also has a much lower move count.

Advantages:

Significantly lower move count: full-step is 13-23 versus 19-29 for orient-first

All of these algs are used in full CMLL, just as with orient-first, so progression is easy.

2-corner cases all become a single case with easy recognition and execution.

Good cases exist in the second look. A first look with only 2 algs makes influencing easier, further reducing average move count. Using influencing, there is an overall 64% chance for 15 moves or less and a 90% chance for 19 moves or less, the same as the best full-step case in orient-first.

Inspecting edge orientation during corner orientation is easy, helping lookahead.

Disadvantages:

Corner twist commutator is long, somewhat awkward, and very common (44%).

Nobody else does this so maybe it is bad for some reason I haven't thought of??
EDIT: Slow recognition is the reason.

Why use this method?

The main reason is because it is easy to learn and it has a low move count.

The purpose of 2-look CMLL vs full CMLL is not speed, but rather ease of memorization, recognition, and execution. So of course, a cuber should just use what they prefer. I like this method because algs are short, intuitive, and easy to learn, avoiding the long permutation algs used in orient-first. And I enjoy influencing the second look.

Easy lookahead to edge orientation is also very helpful. All but one orientation algorithm preserves edge orientation, so it's very easy to inspect the edges while executing the orientation algorithm. The 2-corner commutator doesn't even permute edges - although it is the longest algorithm, you can fully inspect and plan your EO while executing it.

Of course full CMLL will be faster, but I don't want to learn full CMLL because I don't find it fun to learn algorithms. For me, this method is much faster and easier than orient-first, and of course it has more potential because of the significantly reduced move count. I think others might benefit from the lower move count and easy lookahead, so I made this guide.

Nasty Corner Twists

The biggest problem is the 2-corner cases in the orientation step. By random chance, 44% of orientation cases will be bad 2-corner cases. Although they are easy to recognize and the commutator is simple, it is somewhat more awkward to execute compared to the other cases, and has a comparatively long move count. (Of course, the move count is only 1 move longer than the best second-look case in orient-first.)

You could learn 3 specialized algs for the 3 corner twist cases to save a few moves, but there is really no good way to solve a 2-corner twist: all of the algs are either long or awkward to execute.

I avoid these bad cases by influencing the orientation step during the permutation algorithms, using a few simple rules to force good cases. This doesn't require learning more algs - you just adjust the U layer before starting the permutation algs, as the guide explains.

I don't believe it's possible to influence the permutation step in the orient-first method in the same way, since almost all of the orientation algs must be executed from a single direction. And you would only reduce the second-look move count from 17 to 13, saving 4 moves, so it's unlikely to be worth it.

In this method, the best benefit you can get from influencing is converting a 15-move 2-corner case to a 7-move Sune case, which saves 8 moves and is much easier to execute. I think that's worth it, even if it slows recognition slightly. And I think it's fun, which is the most important thing. Obviously if you really want to be fast, just learn full CMLL.

Math

I calculated probabilities based on the 162 possible corner cases. For the chart in the influencing guide, I removed the 27 permutation skip cases, and calculated only the orientation cases that could come after a permutation algorithm, since those are the only cases that you can influence. The chart approximately matches my observed cases.

So the percentage chart in the influencing guide doesn't include step-one permutation skips. If you include permutation skips and influencing, this method has a 24% chance to skip either step. Based on randomness, the chance of a skip should be about 20%, since there is always a 17% random chance of a permutation skip and a 3% chance of an orientation skip. The orient-first method should therefore have a 20% chance to skip either step.

The overall 64% chance for 15 moves or less and 90% chance for 19 moves or less includes skips, since this is an overall comparison to orient-first. Orient-first only has a 20% chance to have fewer than 19 moves, since this requires a skip.

Have Fun

I hope that some people find this alternative 2-look CMLL method useful. If you do about 4 TPS during your CMLL execution, it should save 1-3 seconds compared to orient-first (edit: not counting recognition time!). At the very least, I think it is a lot of fun.

 

[Fred]

The original Petrus method (https://lar5.com/cube/index.html) permutes then orients the corners. So why not do it also for 2-look CMLL? Due to not caring about edges, we get a much better diagonal swap and a better pi orientation. For the cases with two misoriented corners, another good option favored by Petrus is to do a combination of two Sunes (or a triple Sune). For the first Sune, try to figure out how to get to three twisted corners.

 

[dudefaceguy]

Yes, this is absolutely inspired by Petrus. I spent some time using 2 Sunes to solve every orientation case, following the Petrus heuristics described on his site. But the pause for recognition between the 2 Sunes really turned it into a 3-look method.

With, Roux, the ability to ignore edges saves a few moves compared to the Petrus algs as you say. But on the other hand, using the Petrus algs would make edge orientation lookahead easier by preserving orientation.

On the other hand again, I suppose it would be possible to influence EO when using the Fsexy algs...

 

[abunickabhi]

Yes, this is absolutely inspired by Petrus. I spent some time using 2 Sunes to solve every orientation case, following the Petrus heuristics described on his site. But the pause for recognition between the 2 Sunes really turned it into a 3-look method.

With, Roux, the ability to ignore edges saves a few moves compared to the Petrus algs as you say. But on the other hand, using the Petrus algs would make edge orientation lookahead easier by preserving orientation.

On the other hand again, I suppose it would be possible to influence EO when using the Fsexy algs...

Nice analysis presented by you!

Do you aim to try 1-CMLL soon? It is just 42 algs yo.

 

[dudefaceguy]

Thank you, I'm glad you found it interesting.

I actually don't plan on learning full CMLL. I'm not much of a speed solver, and I really don't like learning algorithms. I am much more into intuitive solving. I'm averaging around 32 seconds right now, and most of that time is from my atrocious second block and LSE. Corners are really the least of my worries.

I currently know 6 algs so 42 still sounds like a lot to me haha.

Edit: My goal is to improve speed through smooth and efficient solves with good lookahead, so that is what I'm concentrating on right now. Doing slow solves, my move count is in the 50s, which I think is appropriate for an intermediate 2-look solve. I just need to improve recognition and lookahead to translate that efficiency into a speed solve.

Edit: ao100 is down to 28.24

 

[ProperGentleman]

@dudefaceguy, this is fantastic! I assumed that I since I never heard of permute-first, orient-first must be the clear winner. But this way is absolutely better, IMO. I propose calling it the Roux-Dude method.

People act like 1-look CMLL is so easy to learn. Well, maybe, if you're doing 200 solves a day. If you're doing 5 solves a day, not so much. I have mad respect for people who know it, but I'm not going to learn it anytime soon. 2-look is the only realistic option for me for the foreseeable future, and maybe forever.

Now, 2-look orient-first is actually pretty good. Very easy to learn and remember, can be done even when muscle memory isn't available (say, OH or big cubes), trivial recognition, and reasonably fast execution. Though in the back of my mind I'm a little bugged by how much less efficient it is than 1-look. (L cases in particular; the orientation alg is F R U' R' U' R U R' F', and it seems to usually need a diagonal perm that ALSO starts with F R U' R' U' R U R' F', which is weird deja vu with an F' F in the middle.)

But permute-first, although it definitely takes some effort to learn, seems to be (objectively) faster than orient-first once you're used to it, and (subjectively) more fun due to the influencing. Also, it's not incompatible with learning 1-look; you can add 1-look algorithms to the mix.

Currently I check the orientation, and if it's an O/H/L I use 1-look, otherwise I use 2-look perm-first. It's a bit odd to check the orientation, only to ignore it and do perm-first, but checking the orientation is so fast, so why not? If you're planning to learn 1-look in a month, I'd say perm-first is a needless distraction. But if you expect to be doing 2-look for a long time, I'd definitely suggest at least checking out perm-first.

Now, some questions and comments on specific points:

1. For left Niklas (what I call it because of its opening L move; swaps the two R corners), you give L U R U' L' U R'. Is that correct? I thought it was wrong at first, until I noticed it works if you add an x' in front, but is that what you meant? I strongly prefer these algorithms:

Right Niklas: R U' r' F R' F' r
Left Niklas: L' U l F' L F l'

2. I'm having some trouble with quick recognition for the permutation step (without considering influencing). I've been trying out both your way and Lars Petrus' way, and I'm not sure which I like better. I'm also considering a hybrid approach, where you choose one of these methods based on what you see first.

Your way: permute one corner, if 2 or 4 corners are correct you know the case, else permute the diagonally opposite corner and then you'll know the (adjacent swap) case.

Lars Petrus' way: find two adjacent corners with a non-top color in common, move them to the side with that color; either 4 corners are correct, or 2 adjacent corners are incorrect, or none are correct and you need a diagonal swap.

3. "full-step is 13-23 versus 19-29 for orient-first." How did you arrive at these counts?

Permute-first best full-step case is F sexy F (6) plus Sune/anti-Sune (7), for 13 total, as you said.

Permute-first worst full-step case is Niklas (7) plus corner twist commutator (15), for 22 total (you said 23). Are you adding 1 for AUF after permuting?

Orient-first best full-step case is U (F sexy F', 6) plus T-perm (14), for 20 total (you said 19).

Orient-first worst full-step case is H (F 3*sexy F', 14) plus Y-perm (17), for 31 total (you said 29). Maybe you would do the orientation as R U R' U R U' R' U R U2 R', which is fewer moves (11) but arguably slower. But then that would be 28 total, though maybe you're adding 1 for AUF.

4. "You could learn 3 specialized algs for the 3 corner twist cases to save a few moves"

Is this theoretical, or do you actually have the algs?

5. I'm having a hard time with the corner twist commutator for OH. Assuming I don't get better at it, I might add a third look, or I might use orient-first for OH.

6. "A corner twist commutator can start from any twisted corner as long as you know which direction to twist the first corner."

Starting from a particular twisted corner means having it in the FR position, right? If you have the "wrong" twisted corner (not the one shown in your diagram) there, what exactly do you do?

 

[Spencer131]

the recognition of the permutation step seems difficult. it seems about equal in difficulty to full cmll recognition. so at that point why not just learn full cmll

 

[Fred]

1. For left Niklas (what I call it because of its opening L move; swaps the two R corners), you give L U R U' L' U R'. Is that correct? I thought it was wrong at first, until I noticed it works if you add an x' in front, but is that what you meant? I strongly prefer these algorithms:

Right Niklas: R U' r' F R' F' r
Left Niklas: L' U l F' L F l'

Looks like he goofed here. He should have written L' U R U' L U R'. Your algs work too for fingertricking.

2. I'm having some trouble with quick recognition for the permutation step (without considering influencing). I've been trying out both your way and Lars Petrus' way, and I'm not sure which I like better. I'm also considering a hybrid approach, where you choose one of these methods based on what you see first.

Your way: permute one corner, if 2 or 4 corners are correct you know the case, else permute the diagonally opposite corner and then you'll know the (adjacent swap) case.

Lars Petrus' way: find two adjacent corners with a non-top color in common, move them to the side with that color; either 4 corners are correct, or 2 adjacent corners are incorrect, or none are correct and you need a diagonal swap.

Permutation recognition is certainly the hardest part of this form of 2-look CMLL. I'm not sure what's the fastest way to recognize the case, short of learning full CMLL recognition. The first option seems to require up to 2 AUFs for recognition, which would make it less efficient. However, I don't think the second AUF is necessary. You can identify the adjacent case by checking one of the corners next to the correctly permuted corner. If both of the side stickers don't match the block it's on top of, the other two corners are adjacent. If one of the side stickers does match, that is one of the adjacent corners.

3. "full-step is 13-23 versus 19-29 for orient-first." How did you arrive at these counts?

Permute-first best full-step case is F sexy F (6) plus Sune/anti-Sune (7), for 13 total, as you said.

Permute-first worst full-step case is Niklas (7) plus corner twist commutator (15), for 22 total (you said 23). Are you adding 1 for AUF after permuting?

Orient-first best full-step case is U (F sexy F', 6) plus T-perm (14), for 20 total (you said 19).

Orient-first worst full-step case is H (F 3*sexy F', 14) plus Y-perm (17), for 31 total (you said 29). Maybe you would do the orientation as R U R' U R U' R' U R U2 R', which is fewer moves (11) but arguably slower. But then that would be 28 total, though maybe you're adding 1 for AUF.

In the worst case you'd have an AUF before each alg, but if you're good at mirroring (left-right and front-back) and inverting the corner twist commutator you can avoid that AUF. Also there are better algs as per your next question, but the longest one of those is also 15 moves. For orient-first, the best case can also use J-perm (13). Not sure how he was counting the worst case. 29 could be AUF + double sune + Y-perm, though you could skip the AUF if you do double antisune.

4. "You could learn 3 specialized algs for the 3 corner twist cases to save a few moves"

Is this theoretical, or do you actually have the algs?

Triple sune for two opposite corners twisted. Have the top stickers facing left and back then do R U R' U R U' R' U R U' R' U R U2 R'.
For two adjacent corners twisted, put them in the front. If the top stickers both face you, do R U R' U R U2 R2 U' R U' R' U2 R (2 sunes). If they face left and right, do the inverse: R' U2 R U R' U R2 U2 R' U' R U' R' (2 anti-sunes).

5. I'm having a hard time with the corner twist commutator for OH. Assuming I don't get better at it, I might add a third look, or I might use orient-first for OH.

I would just do a z' rotation so it's a RUL alg. Or do the sune-based algs above.

6. "A corner twist commutator can start from any twisted corner as long as you know which direction to twist the first corner."

Starting from a particular twisted corner means having it in the FR position, right? If you have the "wrong" twisted corner (not the one shown in your diagram) there, what exactly do you do?

Do the second half of the commutator first. As written, the alg rotates the first corner counter-clockwise (R' D' R D R' D' R) and the second one clockwise (R' D R D' R' D R). So the modification is that you can rotate the first corner clockwise (R' D R...) and the second corner counter-clockwise (R' D' R...).

 

[ProperGentleman]

the recognition of the permutation step seems difficult. it seems about equal in difficulty to full cmll recognition. so at that point why not just learn full cmll

Yes, the permutation recognition is definitely a downside compared to orient-first. I haven't really figured it out yet, but I've been getting more comfortable.

I see your smiley, but just to be clear for everyone, 2-look takes a tiny fraction of the memorization effort needed for 1-look. It's not just 9 (or so) algs vs. 42; it's 9 easy algs vs. 42 mostly hard algs, and your practice time is spread across all of them. For people who don't like learning algs, 1-look might not be a good choice.

@Fred Thanks for all that, especially the different ways of twisting 2 corners. I'm definitely going to look into them.

 

[xyzzy]

9 easy algs vs. 42 mostly hard algs

CMLL algs are mostly easy, not mostly hard; by my count there are like 11-ish cases that aren't either (i) a basic commutator with at most 1 setup move, (ii) Niklas/fruruf/Sune combo that's equivalent to permute-first or (iii) repeats of Sune/fruruf.

If you accept subpar algs (e.g. Niklas + Sune for this case), that gets rid of a few more cases and you're left with around 7 algs to learn.

 

[ProperGentleman]

CMLL algs are mostly easy, not mostly hard; by my count there are like 11-ish cases that aren't either (i) a basic commutator with at most 1 setup move, (ii) Niklas/fruruf/Sune combo that's equivalent to permute-first or (iii) repeats of Sune/fruruf.

If you accept subpar algs (e.g. Niklas + Sune for this case), that gets rid of a few more cases and you're left with around 7 algs to learn.

You're setting the bar for "hard" a lot higher than I do.

I've been casually working on the 1-look H cases for like a year, and I'm still not sure if I have the column and row cases down. In R' F2 D R2 U R2 D' F2 R, I might switch the D/D', or the F2/D. In r U' r2' D' r U' r' D r2 U r', I might switch the D/D' or make the middle U' a U.

I kind of know the L cases. I know front commutator starts with U2 R U2 R, and back commutator starts with something similar. But is it U R' U2 R', or U2 R' U R', or U R U2 R, or what? It all feels very random. Even if I get it right this time, that doesn't mean I'll get it right next time, which might be a week from now.

Compare that with 2-look (say, orient-first), where the algs are so simple that I can not only easily remember them, but I can actually recite the moves, not having to rely on muscle memory. This means I can do them one-handed or on big cubes, something I couldn't do with the CFOP 4LLL algs.

If learning full CMLL wasn't that hard for you, great. But that has not been my experience at all. It would be different if I drilled the algs a lot more, but my motivation for that is very limited.

Anyway, this thread is not so much about why someone should use 2-look rather than 1-look, but 2-look perm-first vs 2-look orient-first.

 

[ProperGentleman]

I wanted to follow up after using 2-look perm-first CMLL for a few months. It's been both better and worse than I expected.

Better in that it really is more fun than orient-first. CMLL was always my least favorite Roux step, feeling very mechanical and out of place compared to the other steps. But permute-first is much more intuitive, and influencing makes me feel like I'm doing something, not just executing algorithms.

Worse in that I've had this nagging suspicion that it's actually slower than orient-first, at least for me. So I got some data to check that theory. I don't know what I average; let's say sub-minute. I timed 10 CMLLs both ways.

Orient-first
8 7 8 6 8 6 6 10 6 6
avg 7.1 seconds

Permute-first
10 5 10 5 10 10 10 9 7 9
avg 8.5 seconds

So perm-first took 1.4 seconds longer on average. And this was despite there being no ugly 2-corner twist cases. (Actually there was one, but I messed it up (as I sometimes do), so I took another scramble.)

This is disappointing but not too surprising. The move count is lower with perm-first, but the recognition (especially with influencing) is much slower. Although YMMV if you recognize fast or turn slow.

I still plan to use perm-first for one-handed and big cubes, where I don't care about time. But for 2H 3x3, I guess I'm going back to 2-look orient first, with a few 1-look algorithms thrown in.

 

[dudefaceguy]

Wow, very embarrassing that I messed up the Niklas alg notation! It should be fixed now as I replaced the graphic guide.

@Fred answered all of your initial questions correctly, so thank you Fred! My estimations for move count did add some AUF for the permute-first calculation, and for orient-first I probably used some shorter, but unpopular, algs because I don't actually do orient-first. The general point is that permute-first has a lower average move count.

EDIT: for OH corner twist commutators, I just rotate the cube with the R side up so it's basically just sexy moves.

@ProperGentleman you now probably have more experience with this method than I do. I'm not surprised that it's slightly slower than orient-first despite the lower move count. It is interesting to see that the volatility is different: the permute-first splits have your fastest, but also your slowest, times. I'm not surprised that recognition is slower - I thought perhaps that practice and familiarity would mitigate this, but it seems not to be the case.

But I'm very happy that you think it's fun, which is the most important thing (for me)! I figure if I'm not doing full CMLL I already don't care that much about speed, so decreasing corner speed by 20% while increasing fun is a fair trade. I also like to tinker with unusual methods for fun.

I have 2 questions for the new expert on this permute-first method:
1. When you were using permute-first, did you inspect the edges while executing the corner orientation alg (I do this often but not consistently)?
2. Did you develop any systematic recognition method for corner permutation (I never really did)?

 

[ProperGentleman]

The dude is back! Let's hear it for the dude!

The volatility makes sense because while the reduced move count is stable (without 2-corner twist cases), the recognition delay varies greatly. I might get lucky and immediately see how the corners are permuted. But I also might freeze up during recognition if I can't immediately assess the situation, and I sometimes hesitate during influencing if I'm not sure I'm doing it right. It's not hard, but I have a hard time doing it fast consistently. It wouldn't surprise me if some people can though.

Heh, I'm no expert, but I'm happy to share what I know. I never developed a systematic recognition method for corner permutation. I only use it when I'm already taking my time anyway, so taking my time here doesn't bother me. When going for speed it did bother me that I didn't have a great approach for this, but I didn't find one.

I never really inspected the edges during orientation. I actually don't do any deliberate look ahead at any point of the solve, as I don't think I'm there yet. But I'm curious how that would work. Does your lookahead tell you exactly what moves you're going to do for EO, or just the general idea?

As I recall, the orientation algs other than FsexysexyF' leave the bottom edges completely alone, and on top they preserve the bad edge pattern (e.g., arrow), though they don't preserve each individual edge (thereby affecting EOLR), and may do an AUF. Does that sound right?

Suppose that after permuting, you have an arrow pointing towards the front, and the DF edge is bad. During orientation, do you think "After orienting, I'll do whatever AUF is needed to point the arrow to the front again, and do M' U' M unless I see an EOLR opportunity?" Or do you know how the orientation alg will affect the UL/UR pieces and the AUF, so you know exactly what you're going to do? The latter seems really hard to me. The former seems much easier, but I'm not sure I see much benefit.

 

[dudefaceguy]

Yes, I do a general edge inspection to see how many bad edges there are - not a detailed prediction of the exact next moves I need to execute. But the only real time there could be a significant difference is when there are 2 bad edges on the U layer - the cases are very different if the edges are adjacent versus opposite. But if there's 1 or 3 bad edges on the U layer, you just need to identify the necessary AUF after completing the corner orientation (4 bad edges on U is symmetrical). So you skip the part where you recognize the case, and go right to AUF/execution.

I usually do this during the 2-corner twist cases since I have more time and the execution is very easy. I inspect edges less consistently during the other orientation algs since they are shorter and take more of my concentration to execute.

 

[ProperGentleman]

Oh, I didn't realize that orienting could affect the arrangement of 2 bad edges. Good to know.

But beyond the bad edge pattern, the specific edges matter for EOLR. If you have an arrow pre-commutator, you know you'll have an arrow post-commutator. But you won't know how to solve it until you know where the UL/UR pieces end up (e.g., for a stacked arrow, you do an M move for EOLR, then finish with misoriented centers).

 

[CR7GoatSiuuu]

why not after you one look the first block and square in inspection you form fr pair and do cpls it is super short you can do it for the cases with solved pair in U layer or with R U R' and F' U F cases and it i think like 4 cases for each so just 16 and you lower your movecount also isnt their a faster cmll solution than the commuater one? finally this alg reduction means you can learn a few extra co algs to prevent a 6 flip after the corner

 

[That0newe1rdo]

why not after you one look the first block and square in inspection you form fr pair and do cpls it is super short you can do it for the cases with solved pair in U layer or with R U R' and F' U F cases and it i think like 4 cases for each so just 16 and you lower your movecount also isnt their a faster cmll solution than the commuater one? finally this alg reduction means you can learn a few extra co algs to prevent a 6 flip after the corner

CPLS doesnt have the best recog tho.
and there is 6 for each so 12 cases if you do front slot only.(1 opp, 1 solved and 4 adj)

 

[CR7GoatSiuuu]

CPLS doesnt have the best recog tho.
and there is 6 for each so 12 cases if you do front slot only.(1 opp, 1 solved and 4 adj)

but the recog is only a little worse and you save moves

 

[That0newe1rdo]

but the recog is only a little worse and you save moves

The recog is very confusing/for all but 3 f2l cases i think.
Etc, sometimes it looks like the cp isnt solved but its actually is solved