• Welcome to the Speedsolving.com, home of the web's largest puzzle community!
    You are currently viewing our forum as a guest which gives you limited access to join discussions and access our other features.

    Registration is fast, simple and absolutely free so please, join our community of 30,000+ people from around the world today!

    If you are already a member, simply login to hide this message and begin participating in the community!

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

Joined
Mar 18, 2014
Messages
687
Likes
3
Location
in d middle of angleland
WCA
2009WHIT01
YouTube
ben1996123
Thread starter #1
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
 
Joined
Jan 21, 2009
Messages
3,287
Likes
73
Location
England
WCA
2009YAUR01
YouTube
Robert271291
#2
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...
 
Joined
Jan 21, 2009
Messages
3,287
Likes
73
Location
England
WCA
2009YAUR01
YouTube
Robert271291
#4
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
Joined
Jul 6, 2007
Messages
3,551
Likes
84
Location
California
WCA
2006GARR01
YouTube
LucasGarron
#6
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[3]{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:

Lucas Garron

Moderator
Staff member
Joined
Jul 6, 2007
Messages
3,551
Likes
84
Location
California
WCA
2006GARR01
YouTube
LucasGarron
#8
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:
Joined
Jul 25, 2006
Messages
880
Likes
0
Location
0, 0
#9
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
Headlights: 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:
Joined
Feb 9, 2009
Messages
1,910
Likes
10
WCA
2008ANDE02
YouTube
Minxer2011
#10
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.)
 
Joined
Mar 18, 2014
Messages
687
Likes
3
Location
in d middle of angleland
WCA
2009WHIT01
YouTube
ben1996123
Thread starter #15
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.
 
Top