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.
