kinch2002
Premium Member
By the way, using the same logic, 7 is a lower bound for 3 algs. I wonder whether this is even close to the actual minimum - pretty cool if it is that low!
Did you end up fixing this problem then? I just read through that thread, and I don't remember you saying that you dealt with those bad cases, so just wondering.No, you're right. It's actually unsolvable with this system.
There are around 10 cases like this. I'm thinking of either just generating algs for them for 1LLL when it comes up or doing some other thing (I have a few ideas). The probability of each appearing is 1/~4600, so not a huge deal at the moment.
I think you forgot AUF and no algs (3 states). That would give you the same calculation as mine: 4n*4n+4n+4
Of course no difference to the result
I see this as analogous to looking at the question of how many 1 inch discs you would need to fully cover a 5-inch disc and deciding that the lower bound is 25 because 25 1-inch discs together have the same surface area as 1 5-inch disc. In either case, common sense tells you that it is obviously impossible to satisfy the condition with a number of discs/algorithms anywhere near that low, but rigorously codifying exactly why is rather tricky, as is establishing a more realistic lower bound.I agree that with 32 being a lower bound.
Initial state: 1 state
AUF + 1 alg applied: 4*31 = 124 states
AUF + 1st alg + AUF + 2nd alg: 124*4*31 = 15376 states
Max total reached states: 1 + 124 + 15376 = 15501 < 15552
So 31 not sufficient:
For 32, I get 1 + 128 + 16384 = 16513 > 15552; so it seems 32 could work.
Did you end up fixing this problem then? I just read through that thread, and I don't remember you saying that you dealt with those bad cases, so just wondering.
Glad you brought that thread up again, it's fun to read and I was too much of a nub to follow it when it was active.
Oops, yes you're right. Thank you.No, if you count AUF as reaching 3 new states, then you must consider there are 62208 states in all.
Thus, it might be possible to create a list of algs (even though they might be longer than optimal) which are closely related as these are.
I gather from this that the 48 also assumes that you are counting an algorithm and its inverse together as one algorithm. I, however, am not. By my reckoning, an algorithm is distinct from its inverse, its mirror, and it's mirror inverse. Together they would comprise 4 distinct algorithms. By this method of counting, I have now managed to lower the upper bound of n=67 to n=66, and I suspect it can go no lower than that.61 is taking into account the x number of cases you'd need extra algs for. It would be 48 without.
I actually forgot that you could just invert the algs that were extra, so that would only require 55 because each has a pair.
A few weeks have passed since my last message in this thread. During that time, I have run scenarios almost constantly, but the weather is getting too hot for non-stop processing. It burns about 100 extra watts to run, and that's heat I don't need right now, so I am discontinuing the work for the moment, but I think I've gathered some useful information with which to answer your question, and I've found some surprising results.what is the minumum number of algorithms needed such that for any last layer case, you can apply 2 algorithms and solve the cube?
This one has a very interesting result because it seems to defy what's written in the wiki. Here's what the wiki says about 3LLL:what about 3 look?
That would seem to indicate that the smallest set of algorithms anyone else has found that is sufficient to do 3-Look Last Layer is a set of 25. My program, however, has found that it is possible to do 3LLL using just ELEVEN.The Speedsolving.com Wiki said:The 3 Look Last Layer involves completing the last layer in 3 steps or looks. It usually consists of a 2-Look OLL, followed by a 1-Look PLL which requires knowledge of 31 algorithms in total (including mirrors) with an average of 31 moves. Another method is an LLEF followed by a OCLL-EPP and finally a CPLL which requires 26 algorithms in total (25 if excluding a possible reuse of an algorithm) with an average of 27 moves.
So are those based on a set of steps used to achieve the solved state, or are they simply algs that any combination required to solve the last layer stays within 3 steps?That would seem to indicate that the smallest set of algorithms anyone else has found that is sufficient to do 3-Look Last Layer is a set of 25. My program, however, has found that it is possible to do 3LLL using just ELEVEN.
Here is one such set:
U F2 R' F' R F' U2 F R U2 R' F' (12f)
U2 F U F' U' R' U F' R' F' R F2 U' F' R (15f)
U' F' R2 F' U F2 U F2 U2 F2 U F' R2 F U (15f)
U2 R' F' R U2 F R' F R F2 U2 R' F R U' (15f)
R U2 R U2 R' U F R2 U' R' U R' U R2 U F' (16f)
R U R2 F R2 U R' U' F2 U2 F (11f)
U R U R' F2 U2 F U F' U F2 R U' R' U (15f)
U R U2 R2 F R F' R U2 R2 F' U' F U R (15f)
R U2 R2 F' U' F U R U R U R' F' U' F U' (16f)
F' R' U' R U2 F2 R2 F' U' R U' F' U2 F R2 (15f)
U' F U F' U F' U' F2 R U' R' F2 U F U2 (15f)
If anyone is interested in examples of sets of algorithms that display these properties, let me know.
Very cool. I'd also be interested in having more of this information posted (maybe in a spoiler?).My program, however, has found that it is possible to do 3LLL using just ELEVEN.
Here is one such set:
- U F2 R' F' R F' U2 F R U2 R' F' (12f)
- U2 F U F' U' R' U F' R' F' R F2 U' F' R (15f)
- U' F' R2 F' U F2 U F2 U2 F2 U F' R2 F U (15f)
- U2 R' F' R U2 F R' F R F2 U2 R' F R U' (15f)
- R U2 R U2 R' U F R2 U' R' U R' U R2 U F' (16f)
- R U R2 F R2 U R' U' F2 U2 F (11f)
- U R U R' F2 U2 F U F' U F2 R U' R' U (15f)
- U R U2 R2 F R F' R U2 R2 F' U' F U R (15f)
- R U2 R2 F' U' F U R U R U R' F' U' F U' (16f)
- F' R' U' R U2 F2 R2 F' U' R U' F' U2 F R2 (15f)
- U' F U F' U F' U' F2 R U' R' F2 U F U2 (15f)
The latter. They are simply a set of algorithms that, bracketed by AUFs as necessary, my computer has determined sufficient to get from any last layer state to any other last layer state in only three hops. Put in terms of graph theory, if you envision the 15,552 possible upper layer states as nodes of a graph, and these eleven algorithms as dictating the edges of that graph, then the resulting graph has a diameter of 3.So are those based on a set of steps used to achieve the solved state, or are they simply algs that any combination required to solve the last layer stays within 3 steps?
Send me everything.
As you wish.Very cool. I'd also be interested in having more of this information posted (maybe in a spoiler?).
I'm not sure as to your meaning when you say "inverses and stuff". By "stuff", do you mean mirrors? If you are saying that ZZ can get from any LL state to any other in 2 looks using a set of 28 algorithms and their mirrors/inverses/mirror-inverses, then I suppose my reply would be that 19 is smaller than 28. If you meant something else, please clarify.28 or less if you count inverses and stuff with ZZ!
I do not personally know how one would apply them intelligently, but the computer would know just by being able to remember every possible scenario at once. Perhaps a set of guidelines or rules could be developed, but I have not tried to do so. I've just thrown processing power and tricky programming at it to try to answer the question of what's possible.
With some small changes to the code, that should be possible, but the more you micromanage the computer's decisions, the more likely it becomes that it will require more than 19 algorithms. I'll try to work up a version that allows the input of a list of forced algorithms, such that the machine will only try to decide the remaining ones.It's a shame that those 19 cases are not very nice to execute. Would you be able to generate other groups? Would you be able to force certain algs to appear in the lists?
With some small changes to the code, that should be possible, but the more you micromanage the computer's decisions, the more likely it becomes that it will require more than 19 algorithms. I'll try to work up a version that allows the input of a list of forced algorithms, such that the machine will only try to decide the remaining ones.
EDIT: On second thought, the 19 you mentioned implies that you meant 2LLL and that you meant to include both mirrors and inverses.
The problem would be of course the cases where you already know a 1 look alg that is bad (Let's say N-Perm for example). With this new system it might become a 2 look that is still slower than the 1 look bad alg that you already know