# What is the minimum number of algorithms needed for 2 look last layer?

#### 10461394944000

##### Banned
what is the minumum number of algorithms needed such that for any last layer case, you can apply 2 algorithms and solve the cube?

it's probably some really silly thing that would be silly to recognize but it seems like an interesting question.

what about 3 look?

I can't really think of a way of finding such a method so i'll let the puzzle theory people find it instead

#### Robert-Y

##### Member
I'm going to make a guess:
Step 1: OCLL+EOLL or OCLL+flip all edges incorrectly
Step 2: PLL or PLL with 4 edges incorrectly flipped

Why? Well I thought about OLL and PLL. I think if we try to halve OLL and double PLL, we will have (slightly) less cases to learn...

#### Robert-Y

##### Member
I don't remember sorry :/

I think my suggestion actually ties with CLL/ELL: 42 + 29 = 71

Step 1: OCLL+EOLL or OCLL+flip all edges incorrectly
Step 2: PLL or PLL with 4 edges incorrectly flipped

28 + 43 = 71

However I'm not completely certain about number of algs required for step 1

#### Lucas Garron

##### Moderator
Staff member
what is the minumum number of algorithms needed such that for any last layer case, you can apply 2 algorithms and solve the cube?
Small, but important detail: look ≠ alg
Any BLD solve is 1-look.

So, with 2 looks, the answer is of course still 1 alg or two algs.

I'm just going to use "step" here. For advanced methods, a step usually has 1 look and one "alg". That would also be the case for the straightforward group theory interpretation of this problem.

it's probably some really silly thing that would be silly to recognize but it seems like an interesting question.

what about 3 look?

I can't really think of a way of finding such a method so i'll let the puzzle theory people find it instead
It *is* an interesting question. We have several "common" ways of splitting up LL into two successive sets of cases (steps_.

AUF + OLL + AUF + PLL gives us roughly 58*4*22*4 = 20416 sequences. There are 15552 LL cases (ignoring AUF) so we're overshooting a bit.
CLL/ELL gives us 4*43*4*30 = 20640, which is also a bit much.
Robert's suggestions gives us 4*29*4*43 = 19952, which is not much better.

The theoretical minimum is around $$\sqrt{1552}/4 = 31.1769$$ cases per steps.
So, it might be possible to find a set of 31 + 32 cases that can solve LL using a 2-step system. This gives us 4*31*4*32 = 15872 > 15552 possible cases, requiring as little as 63 cases to memorize.

You could also use some tricks to reuse the same "alg" for multiple cases, which is arguably in the spirit of the original question.

• It's possible that up to one case from each set could be the "solved" case, as with OLL/PLL.
• In general, it might be possible to share a few cases between some sets. (This usually doesn't happen for speedsolving methods, but it might be possible for this.)
• If we count mirrors as one alg, that always helps. (I think most people would exclude inverses, though.)
• It might be possible to use the same alg for multiple cases, using rotations. For example, (R U R' U R U2 R')(L' U' L U' L' U2 L) can be used sideways as z'(R U R' U R U2 R')(L' U' L U' L' U2 L)z. Because the algs basically need to be restricted to LL (else we can't use an AUF between two of them), I can't think of any other examples, though. We could also allow fancier conjugates, but then we start to blur the definition of an alg (If you know the two parts of Y-perm for OLL, does the Y count as a separate alg?). In general, we could reuse algs in other algs. However, this allows us to solve many cases using 1 look, by applying a BLD method. To keep the question interesting, I think that algs used to construct other algs should not allow us to reduce the count of algs. If you have to remember a variant/conjugation/combination of algs, that counts as a new alg.

So, the theoretical minimum for an "obvious" way to do this is 63 cases, with possible hacks to reduce the amount of algs you need to memorize. I'm willing to bet there's something between 63 and 71, although it's not likely to be pretty.

The analogous answer for 3 steps is $$\sqrt{1552}/4 = 31.1769$$, which allows us to get away with as few as 19 cases in theory. For 4 steps, 12 cases. That sounds like a fun puzzle.

Last edited:

#### GG

##### Member
Didn't read that giant thing above but I can contribute that CFCE uses less algs than regular CFOP for the last layer.
Sorry if i'm a nuisance!! xD

#### Lucas Garron

##### Moderator
Staff member
So, the theoretical minimum for an "obvious" way to do this is 63 cases, with possible hacks to reduce the amount of algs you need to memorize. I'm willing to bet there's something between 63 and 71, although it's not likely to be pretty.
I purposely skimmed over "skips" in the previous post.
If you allow skips, then it makes sense to take out the solved cases. Given two sets of algs – call them A and B – the cases you can solve are

• (AUF + alg from A) or nothing, followed by
• (AUF + alg from B) or nothing

This gives us $$(4|A| + 1)(4|B| + 1)$$.

Now, $$(4\cdot 31 + 1)(4\cdot 31 + 1) = 15625$$
So, if we insist that a skip of either step is for free, we can go down to a (theoretical) minimum of 31+31 = 62 cases that need algs.

Last edited:

#### Athefre

##### Member
OCLL + Separate edges (correct or opposite swapped):

Sune: 6 cases (Swap F+L, F+R, R+B, B+L, Rotate all 90 degrees, and Correct)
AntiSune: 6 cases
TripleSune: 6 cases
T: 6 cases
Pi: 6 cases
H: 4 cases (Swap F+L, F+R, Rotate all 90 degrees, Correct)

CPLL + EOLL + Final Separation:

Adjacent Corner Swap: 16 cases (F+L Misoriented, F+R, R+B, B+L, F+B, L+R, All, None, and multiply all of these by two to account for the state of separation)
Opposite Corner Swap: 10 cases (F+L Misoriented, F+R, F+B, All, None, Multiply by two)

That's 66. This is pretty much NMLL for CFOP. What did I miss? Edit: Duh, when CPLL is complete.

Last edited:

#### Carrot

##### Member
just a thought: U' is solved by exactly what 2 algs? the question didn't mention that you were allowed to insert random moves.
(yes, he probably intended us to be able to insert U turns randomly between algs, but he didn't state it.)

#### 10461394944000

##### Banned
just a thought: U' is solved by exactly what 2 algs? the question didn't mention that you were allowed to insert random moves.
(yes, he probably intended us to be able to insert U turns randomly between algs, but he didn't state it.)
yes AUF is fine

#### cmhardw

yes AUF is fine
Would you allow setup turns?

For example:
M + J perm + M' ?

My thought is that if we're trying to minimize the number of memorized algorithms, then perhaps allowing a setup turn not greater than 1 turn in length before the start of each step could reduce the total number of algorithms?

#### Antonie faz fan

##### Member
28
edge control( 7 oll algs) and all pll's

#### 10461394944000

##### Banned
28
edge control( 7 oll algs) and all pll's
edge control+ocll+pll is 3 look last slot+last layer, not 2 look last layer

Would you allow setup turns?

For example:
M + J perm + M' ?

My thought is that if we're trying to minimize the number of memorized algorithms, then perhaps allowing a setup turn not greater than 1 turn in length before the start of each step could reduce the total number of algorithms?
I guess it would be interesting to see how much lower the number would be with setup moves, but I was originally thinking no setups.

#### Antonie faz fan

##### Member
that is not 2 look last layer.
why not?

edge control while doing f2l the you have corners to solve for oll (first look) and then PLL ( for second look)

#### Jakube

##### Member
Okay then how about let's just use full OLS, and then we can do 2-look last layer with only the 6 algs required for 2-look PLL!!
Don't be stupit.

last slot is not part of the last layer
Even OLS has already 216 algs, not counting forming the pair.