• 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 35,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
Sep 17, 2009
Messages
901
Likes
45
Location
New Orleans, LA
YouTube
4EverTrying
#81
Tempus,

I never doubted you. I asked for proof for the cubing community as a whole because most of us do not have a program handy which can verify that that list is full last layer generating set: but that's as far as things go. Despite your efforts so far in this thread, none of us should have been immediately convinced that your list did what you said it did, as there are many ways to err with any involved calculation. Thom probably does have a good judge of character, but I hope you were joking with that statement (no matter how good someone's character is, they still are able to make mistakes).

Anyway, great finding, and welcome to the forums.
 
Joined
Apr 3, 2014
Messages
72
Likes
0
#82
Tempus,

I never doubted you. I asked for proof for the cubing community as a whole because most of us do not have a program handy which can verify that that list is full last layer generating set: but that's as far as things go. Despite your efforts so far in this thread, none of us should have been immediately convinced that your list did what you said it did, as there are many ways to err with any involved calculation. Thom probably does have a good judge of character, but I hope you were joking with that statement (no matter how good someone's character is, they still are able to make mistakes).
I'm sorry if something I said left you with the impression that I was offended, but I was just being jocose.

Honestly, it never even occurred to me that people might be worried about the possibility of errors. I thought that people were concerned about hoaxes or trolling or something because 18 seemed impossibly low. Perhaps I misunderstood. Either way, it's all good, dude. :tu

Anyway, great finding, and welcome to the forums.
Thanks. It's an interesting place. :cool:
 

Kirjava

Colourful
Joined
Mar 26, 2006
Messages
6,122
Likes
50
WCA
2006BARL01
YouTube
snkenjoi
#83
So, shoot your list of 30 (or more) algorithms my way, and I'll see what my latest creation can make of it. All I ask is that they are expressed in a stationary-core format so that I don't have to hand-translate them.
Excellent, that saves so much time trying to work out lists with algs that are good but multifunctional enough to cover stuff.

Here's my list in a tasty format:

R U R' U R U2 R'
R U R' U R U' R' U R U2 R'
R U R' U R U' R' U R U' R' U R U2 R'
R U R' U' R' F R2 U' R' U' R U R' F'
R U R2 F R F2 U F
R U R2 F R F2 U F
F U R U' R' F' R' F' U' F U R
R' U2 R2 U R2 U R U' R U' R'
L' U2 L U2 L F' L' F
F R' F' R U2 R U2 R'
F R U R' U' F'
F R U R' U' R U R' U' F'
L' R' D2 R U2 R' D2 R U2 L
R U' L' U R' U' L
L F R' F R F2 L'
L F' L' U' L F L' F' U F
R U' R' U' F' U2 F U2 R U2 R'
R B' R F2 R' B R F2 R2
R2 L2 D' R L' F2 R' L D' R2 L2
R2 L2 D R2 L2 U2 R2 L2 D R2 L2
R U R' U' R' F R F'
L F R' F' L' F R F'
R' F R U R' U' F' U R
R' U' R' F R F' U R
R2 U' R F R' U R2 U' R' F' R
F R U R' U' R U' R' U' R U R' F'
F R U' R D R' U2 R D' R2 U' F'
R U R' U F' L' U L F U' R U' R'
L F R' F R F L' F R' F' L F L'R
F' R D2 R' F U2 F' R D2 R' F U2
R2 D R' U2 R D' R' U2 R'
R' F' R U R' U' R' F R U R
R' F' R U R' U' R' F R2 U' R' U2 R
F R2 D R' U R D' R2 U' F'
F' L F L' U' L' U L
R U' L' U R' U L U L' U L
R' U' R U' R' U F' U F R
R' U' R' F R F' U R
R' U' R' F R F' R U' R' U2 R
F R U' R' U' L' U' L U L F' L2 U L
R U R' U' L R' F R F' L'
R' L F R L' U2 R' L F R L'
R U2 R2 U' R2 U' R2 U2 R
L' U R U' L U2 R' U R U2 R'
R' F R2 B' R' F' R2 B R'
R U2 R' U2 R' F R2 U R' U' F'
F R U' R' U2 R U R' F'
R U' L' U R' U L U L' U2 R U' L U R'
F R U' R' U' R U2 R' U' F'
R' U' R U R' F' R U R' U' R' F R2
L F L' R U R' U' L F' L'
R U R' U R U' R' U' R' F R F'
F U R U2 R' U' R U R' F'
F R U R' U' R U' R' U R U R' F'
I haven't checked for isomorphic cases.
 
Joined
Dec 8, 2013
Messages
1,017
Likes
39
YouTube
IRNjuggle28
#84
I'm not talking about the difficulty of learning it, but of speedy recognition. I figure that the speed of a solve relies on three things: speed of turning, speed of recognition, and efficiency of the solution system in reducing the number of turns. Some systems are very efficient in terms of turn count, but very slow in terms of recognition. Some are super-fast in terms of recognition, but require significantly more turns. The goal is a system that both reduces turn count AND aids rapid recognition, and I suspect that these efforts to reduce the number of algorithms actually work against that goal, slowing recognition and increasing turn count.
Posted by Kirjava:
This system would be different from LL systems with large algorithm subsets. I'm inclined to think that the problem they have is algorithm recall, not recognition. The difficulty lies in remembering an alg from a pool of 400.
Yes, that's the problem with stuff like full ZBLL, but not with the method that is currently fast: OLL and PLL. Is there a reason to think that the opposite extreme of ZBLL is what will be fast? It seems like the optimal last layer method would be the maximum number of algs that can be memorized well enough to execute quickly, not simply the smallest number of algs possible. Your explanation for why this could be a viable speedsolving method seemed like it amounted to "memorizing hundreds of algs is impractical, so making a method with 18 will fix that problem," and completely ignored the fact that a method with 78 algs was perfectly viable.
Method development is reaching a point where you need to push into using more abstract concepts and trying ambitious weird things. Step concatenation and other standard structures have maxed out their usefulness and we need to do something new and different to improve on what we already have. I believe if I can circumvent problems with techniques like this (in this case with clever case sorting) they can prove to be a viable alternative.
The only ambitious thing about this method is the very low alg count, and that's not the trait that needs to be ambitious to be a viable speedsolving method. Your "clever case sorting" and recognition tricks, at the very best, will succeed in making this method only a bit worse than OLL/PLL in terms of recognition. Correct me if I'm wrong, but I don't know how a method like this could be adapted to be as easy as recognizing orientation and then recognizing permutation. In terms of speedsolving, having an alg count this low really only helps with learning the method. It doesn't help with execution of it in a speedsolve.

Best case scenaro for this method seems to be the method becoming a decent intermediate last layer method for those unwilling to learn as many algs as OLL and PLL is. And that's it. Not a groundbreaking speedsolving method.

I do not mean any of this as a putdown of the work you and Tempus have put in. You've done astounding method development work before and I have no doubt you can do it again. I just don't see how it will work yet. I think Tempus said it well here:
Don't get me wrong. I'm still interested from a theory standpoint, but I don't believe the result could ever be practical for me. I have trouble just finding the next F2L pair.
 
Last edited:
Joined
Apr 3, 2014
Messages
72
Likes
0
#85
Excellent, that saves so much time trying to work out lists with algs that are good but multifunctional enough to cover stuff.

Here's my list in a tasty format:

R U R' U R U2 R'
R U R' U R U' R' U R U2 R'
R U R' U R U' R' U R U' R' U R U2 R'
R U R' U' R' F R2 U' R' U' R U R' F'
R U R2 F R F2 U F
R U R2 F R F2 U F
F U R U' R' F' R' F' U' F U R
R' U2 R2 U R2 U R U' R U' R'
L' U2 L U2 L F' L' F
F R' F' R U2 R U2 R'
F R U R' U' F'
F R U R' U' R U R' U' F'
L' R' D2 R U2 R' D2 R U2 L
R U' L' U R' U' L
L F R' F R F2 L'
L F' L' U' L F L' F' U F
R U' R' U' F' U2 F U2 R U2 R'
R B' R F2 R' B R F2 R2
R2 L2 D' R L' F2 R' L D' R2 L2
R2 L2 D R2 L2 U2 R2 L2 D R2 L2
R U R' U' R' F R F'
L F R' F' L' F R F'
R' F R U R' U' F' U R
R' U' R' F R F' U R
R2 U' R F R' U R2 U' R' F' R
F R U R' U' R U' R' U' R U R' F'
F R U' R D R' U2 R D' R2 U' F'
R U R' U F' L' U L F U' R U' R'
L F R' F R F L' F R' F' L F L'R
F' R D2 R' F U2 F' R D2 R' F U2
R2 D R' U2 R D' R' U2 R'
R' F' R U R' U' R' F R U R
R' F' R U R' U' R' F R2 U' R' U2 R
F R2 D R' U R D' R2 U' F'
F' L F L' U' L' U L
R U' L' U R' U L U L' U L
R' U' R U' R' U F' U F R
R' U' R' F R F' U R
R' U' R' F R F' R U' R' U2 R
F R U' R' U' L' U' L U L F' L2 U L
R U R' U' L R' F R F' L'
R' L F R L' U2 R' L F R L'
R U2 R2 U' R2 U' R2 U2 R
L' U R U' L U2 R' U R U2 R'
R' F R2 B' R' F' R2 B R'
R U2 R' U2 R' F R2 U R' U' F'
F R U' R' U2 R U R' F'
R U' L' U R' U L U L' U2 R U' L U R'
F R U' R' U' R U2 R' U' F'
R' U' R U R' F' R U R' U' R' F R2
L F L' R U R' U' L F' L'
R U R' U R U' R' U' R' F R F'
F U R U2 R' U' R U R' F'
F R U R' U' R U' R' U R U R' F'
I haven't checked for isomorphic cases.
Okay, I've tried running this list of 54 through my program, and here's some preliminary information:
  • #29 is missing a space, so I added one. Hardly worth mentioning, but enough to make my program fail an assertion. (It's exceedingly picky.)
  • #45 is broken, as it disrupts F2L. I figured this was likely caused by a typo, so I tried tweaking it various ways and found that if I change the middle turn from R' to R2 it will no longer disrupt F2L, so I'm assuming that you meant to say R' F R2 B' R2 F' R2 B R'. Let me know if this is incorrect.
  • #5 is identical to #6, so I'm removing #6.
  • #24 is identical to #38, so I'm removing #38.
  • #22 is equivalent to #32, but #22 is three moves shorter, so I'm removing #32.
  • #9 is a mirror-inverse of #10, but #10 doesn't involve L turns, so I'm removing #9.
  • #21 is a mirror-inverse of #35, but #21 doesn't involve L turns, so I'm removing #35.
  • #28 is a mirror-inverse of #40, but #28 is one move shorter, so I'm removing #40.
(To see the truth of some of the above information, you need to consider AUF.)

  1. R U R' U R U2 R'
  2. R U R' U R U' R' U R U2 R'
  3. R U R' U R U' R' U R U' R' U R U2 R'
  4. R U R' U' R' F R2 U' R' U' R U R' F'
  5. R U R2 F R F2 U F
  6. F U R U' R' F' R' F' U' F U R
  7. R' U2 R2 U R2 U R U' R U' R'
  8. F R' F' R U2 R U2 R'
  9. F R U R' U' F'
  10. F R U R' U' R U R' U' F'
  11. L' R' D2 R U2 R' D2 R U2 L
  12. R U' L' U R' U' L
  13. L F R' F R F2 L'
  14. L F' L' U' L F L' F' U F
  15. R U' R' U' F' U2 F U2 R U2 R'
  16. R B' R F2 R' B R F2 R2
  17. R2 L2 D' R L' F2 R' L D' R2 L2
  18. R2 L2 D R2 L2 U2 R2 L2 D R2 L2
  19. R U R' U' R' F R F'
  20. L F R' F' L' F R F'
  21. R' F R U R' U' F' U R
  22. R' U' R' F R F' U R
  23. R2 U' R F R' U R2 U' R' F' R
  24. F R U R' U' R U' R' U' R U R' F'
  25. F R U' R D R' U2 R D' R2 U' F'
  26. R U R' U F' L' U L F U' R U' R'
  27. L F R' F R F L' F R' F' L F L' R
  28. F' R D2 R' F U2 F' R D2 R' F U2
  29. R2 D R' U2 R D' R' U2 R'
  30. R' F' R U R' U' R' F R2 U' R' U2 R
  31. F R2 D R' U R D' R2 U' F'
  32. R U' L' U R' U L U L' U L
  33. R' U' R U' R' U F' U F R
  34. R' U' R' F R F' R U' R' U2 R
  35. R U R' U' L R' F R F' L'
  36. R' L F R L' U2 R' L F R L'
  37. R U2 R2 U' R2 U' R2 U2 R
  38. L' U R U' L U2 R' U R U2 R'
  39. R' F R2 B' R2 F' R2 B R'
  40. R U2 R' U2 R' F R2 U R' U' F'
  41. F R U' R' U2 R U R' F'
  42. R U' L' U R' U L U L' U2 R U' L U R'
  43. F R U' R' U' R U2 R' U' F'
  44. R' U' R U R' F' R U R' U' R' F R2
  45. L F L' R U R' U' L F' L'
  46. R U R' U R U' R' U' R' F R F'
  47. F U R U2 R' U' R U R' F'
  48. F R U R' U' R U' R' U R U R' F'
(From here on in, I will be using the algorithm numbers of this list instead of the numbers of the original list.)

This list, taken in its entirety, is sufficient to cover all but 56 of the 62208 possible LL states in two looks. The problem I have now is that your precise goal is unclear to me. You have stated that you want to minimize the number of generated algorithms, but surely you must also want to reduce the number of algorithms overall, or you would simply leave all 48 in place. Until you precisely clarify your intent and define how you wish to balance these two conflicting priorities, here are the results of many hours of calculations to tide you over:

Size of Subset:

Minimum Coverage Gap:

Maximum Coverage (Percentage):

...

...

...

17

896

98.56%

18

680

98.91%

19

524

99.16%

20

392

99.37%

21

328

99.47%

22

264

99.58%

23

200

99.68%

24

136

99.78%

25

112

99.82%

26

88

99.86%

27

72

99.88%

28 or more

56

99.91%



An interesting fact to note is that you can remove 20 of the 48 algorithms without reducing the coverage.
 
Last edited:

Kirjava

Colourful
Joined
Mar 26, 2006
Messages
6,122
Likes
50
WCA
2006BARL01
YouTube
snkenjoi
#86
You're posting in the wrong thread and doing so has confused you.

Please understand that the minimum number of algs needed to solve the last layer and my system are two different methods.

Yes, that's the problem with stuff like full ZBLL, but not with the method that is currently fast: OLL and PLL. Is there a reason to think that the opposite extreme of ZBLL is what will be fast? It seems like the optimal last layer method would be the maximum number of algs that can be memorized well enough to execute quickly, not simply the smallest number of algs possible. Your explanation for why this could be a viable speedsolving method seemed like it amounted to "memorizing hundreds of algs is impractical, so making a method with 18 will fix that problem," and completely ignored the fact that a method with 78 algs was perfectly viable.
You've come to the wrong conclusion, my thread was posted 2 years ago before any of this happened - that can't possibly be my line of thinking. My original preposition had 61 algs. I've recently said in the thread that total alg count isn't important.

I'm not interested in the low alg count. I'm interested in the complete case coverage.

The only ambitious thing about this method is the very low alg count, and that's not the trait that needs to be ambitious to be a viable speedsolving method. Your "clever case sorting" and recognition tricks, at the very best, will succeed in making this method only a bit worse than OLL/PLL in terms of recognition. Correct me if I'm wrong, but I don't know how a method like this could be adapted to be as easy as recognizing orientation and then recognizing permutation. In terms of speedsolving, having an alg count this low really only helps with learning the method. It doesn't help with execution of it in a speedsolve.
I've already posted my thoughts on people's overestimation of recognition.

Best case scenaro for this method seems to be the method becoming a decent intermediate last layer method for those unwilling to learn as many algs as OLL and PLL is. And that's it. Not a groundbreaking speedsolving method.
No, that's an awful conclusion - my system will be harder to learn than OLL/PLL. If you really think that recognition of all things is what makes this unusable we don't have anything further to discuss.

Okay, I've tried running this list of 54 through my program, and here's some preliminary information:
Thanks for the fixes, as I said, I hadn't checked for mirrors/inverses.

This list, taken in its entirety, is sufficient to cover all but 56 of the 62208 possible LL states in two looks. The problem I have now is that your precise goal is unclear to me. You have stated that you want to minimize the number of generated algorithms, but surely you must also want to reduce the number of algorithms overall, or you would simply leave all 48 in place.
Minimising the number of generated algorithms is more important than minimising the total count.

Having to use 48 algs instead of 18 is nothing compared to learning which cases go with each alg. People already know all these algorithms anyway. I would have included more but I only attempted to include very good cases.

I think the best situation for my needs is to ensure a reduction in generated algs by keeping everything.

An interesting fact to note is that you can remove 20 of the 48 algorithms without reducing the coverage.
If you can remove 20 of the algorithms and produce the same results, removing 20 is desirable. However, will this have an effect on the extra algs required? I believe it would do so (if minimally)? If so, leave them in. If not, remove them (I can probably select which would be better to remove (I assume only removing certain ones would have this effect)).

You make the best edit reasons.
 
Joined
Apr 6, 2009
Messages
1,754
Likes
11
Location
Sweden
WCA
2010JERN01
YouTube
jernqvist
#90
So basically 1/1000 you get a bad case (solvable in 3 algs perhaps?). I would say that's good enough from a pragmatic speedsolving perspective rather than a theoretical mathematical one. After all some cases are just bad.
 
Joined
Apr 3, 2014
Messages
72
Likes
0
#93
Minimising the number of generated algorithms is more important than minimising the total count.

Having to use 48 algs instead of 18 is nothing compared to learning which cases go with each alg. People already know all these algorithms anyway. I would have included more but I only attempted to include very good cases.

I think the best situation for my needs is to ensure a reduction in generated algs by keeping everything.
Well, if I keep all 48, my program says an additional two generated algorithms is sufficient for 2LLL. If I restrict it to one, it always has a coverage gap of last-layer states.

If you can remove 20 of the algorithms and produce the same results, removing 20 is desirable. However, will this have an effect on the extra algs required? I believe it would do so (if minimally)? If so, leave them in. If not, remove them (I can probably select which would be better to remove (I assume only removing certain ones would have this effect)).
Well, I wrote some crude algorithm length awareness into my program, so that it will use a length score (equal to the total algorithm length plus the maximum algorithm length) as a tiebreaker. Using this, there appears to be only one optimally short (length score=303) 28-algorithm subset that still keeps the coverage gap at 56 last-layer states.
1. R U R' U R U2 R'
2. R U R' U R U' R' U R U2 R'
5. R U R2 F R F2 U F
8. F R' F' R U2 R U2 R'
10. F R U R' U' R U R' U' F'
13. L F R' F R F2 L'
14. L F' L' U' L F L' F' U F
16. R B' R F2 R' B R F2 R2
19. R U R' U' R' F R F'
22. R' U' R' F R F' U R
25. F R U' R D R' U2 R D' R2 U' F'
26. R U R' U F' L' U L F U' R U' R'
27. L F R' F R F L' F R' F' L F L' R
29. R2 D R' U2 R D' R' U2 R'
30. R' F' R U R' U' R' F R2 U' R' U2 R
31. F R2 D R' U R D' R2 U' F'
32. R U' L' U R' U L U L' U L
33. R' U' R U' R' U F' U F R
34. R' U' R' F R F' R U' R' U2 R
35. R U R' U' L R' F R F' L'
36. R' L F R L' U2 R' L F R L'
40. R U2 R' U2 R' F R2 U R' U' F'
43. F R U' R' U' R U2 R' U' F'
44. R' U' R U R' F' R U R' U' R' F R2
45. L F L' R U R' U' L F' L'
46. R U R' U R U' R' U' R' F R F'
47. F U R U2 R' U' R U R' F'
48. F R U R' U' R U' R' U R U R' F'
Now, since one generated algorithm was insufficient to do 2LLL with the whole set of 48, we know that at least 2 will be required here as well, and 2 does indeed prove sufficient. This means that, at least in this case, removing the other 20 had no practical effect.

Here are a half-dozen pairs of generated algorithms, each of which has a length score of 35, and each of which is sufficient, if added to the above set of 28, to form a 30-algorithm 2LLL set. You can choose which pair you want to use based on your own sense of whimsy. :cool:

F R U R2 U2 R2 U R2 U R F' (11f)

F R' U' R2 F R' F' R2 U R U F' (12f)

R' F U F2 U F2 U2 F2 U F R (11f)

R' U F U F2 R' F' R F2 U' F' R (12f)

R' F' U' F2 U2 F2 U' F2 U' F' R (11f)

R' F' R U2 R' U' R U' R' U2 F R (12f)

R' F U F2 U F2 U2 F2 U F R (11f)

R' F' R U2 R' U' R U' R' U2 F R (12f)

R' F U F2 U F2 U2 F2 U F R (11f)

F U' R' U' R2 F R F' R2 U R F' (12f)

R' F U F2 U F2 U2 F2 U F R (11f)

R' F U F2 R' F R F2 U' F' U' R (12f)



Next, I plan to try to figure out what the smallest subset that can be completed using just 2 generated algorithms is, but this may or may not be useful to you. Right now, using 28+2, only 56 cases require using one of the 2. If I manage to make a 27+2 set that works, it will definitely mean that more than 56 LL states will require using a generated algorithm. So, I have to ask you, is the goal to minimize the frequency of solves that require the use of generated algorithms, or is the goal to minimize the number of generated algorithms that must be initially memorized?

You make the best edit reasons.
Thank you. I wasn't sure anyone had noticed. :cool:

[HR][/HR]
um, there are only ~1200 LL states. if you are counting normal/inverse/mirror/mirrorinverse as 1 case then shouldnt there only be about 300-400?
Here's how to mentally count the number of last-layer states:
  • Axiom #1: Parity says that if you know the exact state of seven corners, you can determine the state of the eighth.
  • Axiom #2: For any given corner configuration, the same holds true for the edges.
  • Axiom #3: Whether the number of edge swaps is odd or even is determined by the corner configuration.
  • Now, imagine a cube that has all of the stickers peeled off of one last-layer edge and one last-layer corner.
  • Given Axioms #1 and #2, the number of last-layer states for this hypothetical cube is the same as for a normal cube.
  • There are 4!=24 permutations for the last-layer corners.
  • There are 3^3=27 orientations for the three last-layer corners that still have their stickers.
  • For any given corner configuration, there are 4!/2=12 possible edge permutations. This is because half of them are excluded by Axiom #3
  • There are 2^3=8 possible orientations for the three last-layer edges that still have their stickers.
  • Multiply these all together and you get 24*27*12*8=62,208 possible last-layer states.
[HR][/HR]
Not sure if it's easy for you to check, but what's the chance that these 56 all have much in common?
Eg if they were all dot OLLs they'd be easy to avoid or whatever...
Only 16 of the 56 uncovered last-layer states are "dot" states. It's pleasant to think that they would all have something in common, but it doesn't really make sense to expect it, as what you have left are the corner cases left over after an artificial intelligence has aimed for maximal coverage using minimal resources.

Imagine it this way: If you had a white car and were told to color it red instead using just a stack of large circular red stickers that is slightly too small to cover every square inch of the white paint, would you expect all of the white bits still showing when you were done to have something significant in common?

[HR][/HR]
So basically 1/1000 you get a bad case (solvable in 3 algs perhaps?). I would say that's good enough from a pragmatic speedsolving perspective rather than a theoretical mathematical one. After all some cases are just bad.
'Tis the Puzzle Theory sub-forum. Little by way of pragmatism dwells within these hallowed halls. :cool:
 
Last edited:

stoic

Premium Member
Joined
Feb 17, 2011
Messages
992
Likes
66
Location
Co. Tyrone, N. Ireland
WCA
2013DEAR01
#94
Only 16 of the 56 uncovered last-layer states are "dot" states. It's pleasant to think that they would all have something in common, but it doesn't really make sense to expect it, as what you have left are the corner cases left over after an artificial intelligence has aimed for maximal coverage using minimal resources.

Imagine it this way: If you had a white car and were told to color it red instead using just a stack of large circular red stickers that is slightly too small to cover every square inch of the white paint, would you expect all of the white bits still showing when you were done to have something significant in common?
Thanks for the analogy, nicely done.
I didn't really expect it, but it seemed rude not to ask. :p
 

Kirjava

Colourful
Joined
Mar 26, 2006
Messages
6,122
Likes
50
WCA
2006BARL01
YouTube
snkenjoi
#95
Well, if I keep all 48, my program says an additional two generated algorithms is sufficient for 2LLL. If I restrict it to one, it always has a coverage gap of last-layer states.
2 is great, the best thing is that the algs aren't even that bad.

Well, I wrote some crude algorithm length awareness into my program, so that it will use a length score (equal to the total algorithm length plus the maximum algorithm length) as a tiebreaker. Using this, there appears to be only one optimally short (length score=303) 28-algorithm subset that still keeps the coverage gap at 56 last-layer states.
This helps what I'm trying to do a _lot_ and I didn't even ask you for it. So thoughtful <3

Now, since one generated algorithm was insufficient to do 2LLL with the whole set of 48, we know that at least 2 will be required here as well, and 2 does indeed prove sufficient. This means that, at least in this case, removing the other 20 had no practical effect.
30 algs it is then!

Next, I plan to try to figure out what the smallest subset that can be completed using just 2 generated algorithms is, but this may or may not be useful to you. Right now, using 28+2, only 56 cases require using one of the 2. If I manage to make a 27+2 set that works, it will definitely mean that more than 56 LL states will require using a generated algorithm. So, I have to ask you, is the goal to minimize the frequency of solves that require the use of generated algorithms, or is the goal to minimize the number of generated algorithms that must be initially memorized?
Initial algorithm memorisation quantity isn't an issue. I'd rather reduce the number of cases using a generated algorithm (though they aren't that bad).

This is pretty much beyond what I asked for, and it's going to allow me to complete my system. Thank you so much! I'll mention you in my nobel prize acceptance speech.
 
Joined
Apr 3, 2014
Messages
72
Likes
0
#96
2 is great, the best thing is that the algs aren't even that bad.
That's the crude algorithm length awareness at work. When there are thousands of options to choose from, there is wiggle room, and it can make a big difference, but when the number of options is more limited, it has little effect, as it's just used for tie-breaking.

This helps what I'm trying to do a _lot_ and I didn't even ask you for it. So thoughtful <3
Glad to be of service. :cool:

30 algs it is then!
Over the last couple days, and to satisfy my own curiosity, I've been seeing how far I could push it while still keeping the generated algorithm count at 2. Just for reference, the probability of having to use one of the generated algorithms in your current 28+2 set is 1 in 1,110.857, or about 0.090% Here are the results:
Given this list of 27:
  • 1. R U R' U R U2 R'
  • 2. R U R' U R U' R' U R U2 R'
  • 5. R U R2 F R F2 U F
  • 8. F R' F' R U2 R U2 R'
  • 10. F R U R' U' R U R' U' F'
  • 19. R U R' U' R' F R F'
  • 20. L F R' F' L' F R F'
  • 21. R' F R U R' U' F' U R
  • 22. R' U' R' F R F' U R
  • 23. R2 U' R F R' U R2 U' R' F' R
  • 25. F R U' R D R' U2 R D' R2 U' F'
  • 26. R U R' U F' L' U L F U' R U' R'
  • 27. L F R' F R F L' F R' F' L F L' R
  • 30. R' F' R U R' U' R' F R2 U' R' U2 R
  • 31. F R2 D R' U R D' R2 U' F'
  • 32. R U' L' U R' U L U L' U L
  • 33. R' U' R U' R' U F' U F R
  • 35. R U R' U' L R' F R F' L'
  • 36. R' L F R L' U2 R' L F R L'
  • 40. R U2 R' U2 R' F R2 U R' U' F'
  • 41. F R U' R' U2 R U R' F'
  • 43. F R U' R' U' R U2 R' U' F'
  • 44. R' U' R U R' F' R U R' U' R' F R2
  • 45. L F L' R U R' U' L F' L'
  • 46. R U R' U R U' R' U' R' F R F'
  • 47. F U R U2 R' U' R U R' F'
  • 48. F R U R' U' R U' R' U R U R' F'
...Here are some generated pairs that each complete it:

R U2 R' U R' F' U' F U R2 U R' (12f)

R2 U' F U R' U' F' U R' U' F R' F' (13f)

R U2 R' U' R U' R2 F' U' F U R (12f)

F2 U R' U' F U R U' F U R' F R (13f)

R U' R2 U' F' U F R U' R U2 R' (12f)

R2 U' F U R' U' F' U R' U' F R' F' (13f)

F' U2 F U' F R U R' U' F2 U' F (12f)

F' U' F2 U F2 U F2 U2 F' U F' U F (13f)

U2 F U2 R' F' U' F U R2 U2 R' F' (12f)

R2 F2 R U2 R U R2 F2 R2 U R' F2 R (13f)

F U F' R' F2 U F U' F' U' F' R (12f)

U R' U' F' U F R2 U R' U R U2 R' (13f)



The probability of having to use one of the two generated algorithms is 1 in 864, or about 0.116%
Given this list of 26:
  • 1. R U R' U R U2 R'
  • 2. R U R' U R U' R' U R U2 R'
  • 5. R U R2 F R F2 U F
  • 8. F R' F' R U2 R U2 R'
  • 10. F R U R' U' R U R' U' F'
  • 19. R U R' U' R' F R F'
  • 20. L F R' F' L' F R F'
  • 21. R' F R U R' U' F' U R
  • 22. R' U' R' F R F' U R
  • 23. R2 U' R F R' U R2 U' R' F' R
  • 25. F R U' R D R' U2 R D' R2 U' F'
  • 26. R U R' U F' L' U L F U' R U' R'
  • 27. L F R' F R F L' F R' F' L F L' R
  • 30. R' F' R U R' U' R' F R2 U' R' U2 R
  • 31. F R2 D R' U R D' R2 U' F'
  • 32. R U' L' U R' U L U L' U L
  • 35. R U R' U' L R' F R F' L'
  • 36. R' L F R L' U2 R' L F R L'
  • 40. R U2 R' U2 R' F R2 U R' U' F'
  • 41. F R U' R' U2 R U R' F'
  • 43. F R U' R' U' R U2 R' U' F'
  • 44. R' U' R U R' F' R U R' U' R' F R2
  • 45. L F L' R U R' U' L F' L'
  • 46. R U R' U R U' R' U' R' F R F'
  • 47. F U R U2 R' U' R U R' F'
  • 48. F R U R' U' R U' R' U R U R' F'

...Here are some generated pairs that each complete it:

F R' U' R2 U' R2 U2 R U' F' (10f)

F U F' U F U2 R U' R' U R U R' F' (14f)

R U' R2 U' F' U F R U' R U2 R' (12f)

F' U2 F U2 F R' F' U2 R U R' U R (13f)

F' U F2 U R U' R' F' U F' U2 F (12f)

F R U R' U' R F U F' R' F U' F2 (13f)

R' U' F R' F' R2 F R' U R U' F' (12f)

R U' R' F' U F R U R' U R U' R' (13f)

R U2 R' U R' F' U' F U R2 U R' (12f)

F' U2 F U2 F R' F' U2 R U R' U R (13f)

R' U' F U F' R F2 R' F' R U' F' (12f)

R2 U' F U R' U' F' U R' U' F R' F' (13f)

R U2 R' U R' F' U' F U R2 U R' (12f)

R' U' R U' R' U2 F R F' U2 F' U2 F (13f)

F' U2 F U' F R U R' U' F2 U' F (12f)

R' F' U' F U F' R' U' R F R' U R2 (13f)

F U R' U' R F' R2 F R F' U R (12f)

F2 U R' U' F U R U' F U R' F R (13f)

F U R' U' R F' R2 F R F' U R (12f)

R U' R' F' U F R U R' U R U' R' (13f)

F' U2 F U' F R U R' U' F2 U' F (12f)

F' U2 F U2 F R' F' U2 R U R' U R (13f)

R U2 R' U R' F' U' F U R2 U R' (12f)

R' F2 R U' F U' R U2 R' F' R' F' R (13f)



The probability of having to use one of the two generated algorithms is 1 in 706.909, or about 0.141%
Given this list of 25:
  • 1. R U R' U R U2 R'
  • 5. R U R2 F R F2 U F
  • 8. F R' F' R U2 R U2 R'
  • 9. F R U R' U' F'
  • 10. F R U R' U' R U R' U' F'
  • 14. L F' L' U' L F L' F' U F
  • 19. R U R' U' R' F R F'
  • 22. R' U' R' F R F' U R
  • 23. R2 U' R F R' U R2 U' R' F' R
  • 25. F R U' R D R' U2 R D' R2 U' F'
  • 26. R U R' U F' L' U L F U' R U' R'
  • 27. L F R' F R F L' F R' F' L F L' R
  • 30. R' F' R U R' U' R' F R2 U' R' U2 R
  • 31. F R2 D R' U R D' R2 U' F'
  • 32. R U' L' U R' U L U L' U L
  • 36. R' L F R L' U2 R' L F R L'
  • 39. R' F R2 B' R2 F' R2 B R'
  • 40. R U2 R' U2 R' F R2 U R' U' F'
  • 41. F R U' R' U2 R U R' F'
  • 42. R U' L' U R' U L U L' U2 R U' L U R'
  • 43. F R U' R' U' R U2 R' U' F'
  • 44. R' U' R U R' F' R U R' U' R' F R2
  • 45. L F L' R U R' U' L F' L'
  • 47. F U R U2 R' U' R U R' F'
  • 48. F R U R' U' R U' R' U R U R' F'

...Here are some generated pairs that each complete it:

F U2 F2 U' F2 U' F' U2 F R' F' R (12f)

F' U' F2 R U R' U' F' U2 F R' F' R (13f)

R' F R F' U2 F U F2 U F2 U2 F' (12f)

F R' F' R U2 R' U' F' U F R2 U' R' (13f)

R' F R F' U2 F U F2 U F2 U2 F' (12f)

R U R2 F' U' F U R U2 R' F R F' (13f)

R' F R F' U2 F U F2 U F2 U2 F' (12f)

R' F R F' U2 F U R U' R' F2 U F (13f)



The probability of having to use one of the two generated algorithms is 1 in 555.429, or about 0.180%
Given this list of 24:
  • 2. R U R' U R U' R' U R U2 R'
  • 5. R U R2 F R F2 U F
  • 8. F R' F' R U2 R U2 R'
  • 9. F R U R' U' F'
  • 10. F R U R' U' R U R' U' F'
  • 14. L F' L' U' L F L' F' U F
  • 19. R U R' U' R' F R F'
  • 20. L F R' F' L' F R F'
  • 22. R' U' R' F R F' U R
  • 25. F R U' R D R' U2 R D' R2 U' F'
  • 26. R U R' U F' L' U L F U' R U' R'
  • 27. L F R' F R F L' F R' F' L F L' R
  • 30. R' F' R U R' U' R' F R2 U' R' U2 R
  • 31. F R2 D R' U R D' R2 U' F'
  • 34. R' U' R' F R F' R U' R' U2 R
  • 36. R' L F R L' U2 R' L F R L'
  • 40. R U2 R' U2 R' F R2 U R' U' F'
  • 41. F R U' R' U2 R U R' F'
  • 43. F R U' R' U' R U2 R' U' F'
  • 44. R' U' R U R' F' R U R' U' R' F R2
  • 45. L F L' R U R' U' L F' L'
  • 46. R U R' U R U' R' U' R' F R F'
  • 47. F U R U2 R' U' R U R' F'
  • 48. F R U R' U' R U' R' U R U R' F'

...Here are some generated pairs that each complete it:

R' F' U F R U R2 F R F2 U' F U R (14f)

R' F U R U' F' U2 F2 R' F U2 F' R F2 (14f)

R' U' F' U' F R' F R F' R U' R' U' R (14f)

R' U' F' U F2 R' F' R2 U' R' F' U' F R (14f)

F U F' R2 F' R F2 U' F U F R' F R2 (14f)

R' F' U F R U R2 F R F2 U' F U R (14f)

F U R U R' F R' F' R F' U F U F' (14f)

R' U' F' U F2 R' F' R2 U' R' F' U' F R (14f)

R' U' F' U F2 R' F' R2 U' R' F' U' F R (14f)

R' F U R U' F' U2 F2 R' F U2 F' R F2 (14f)

R' U' F' U F2 R' F' R2 U' R' F' U' F R (14f)

F2 R F' R U R U' R2 F R' F2 R' U R (14f)

R' F' U F R U R2 F R F2 U' F U R (14f)

F2 R F' R U R U' R2 F R' F2 R' U R (14f)



The probability of having to use one of the two generated algorithms is 1 in 457.412, or about 0.219%
I was unable to find a 23+2 set that worked. As you can see, the increase in probability of using a generated algorithm remains quite low even at 24+2, but the quality of the 2 generated algorithms is falling due to a lack of maneuvering room.

Initial algorithm memorisation quantity isn't an issue. I'd rather reduce the number of cases using a generated algorithm (though they aren't that bad).

This is pretty much beyond what I asked for, and it's going to allow me to complete my system. Thank you so much! I'll mention you in my nobel prize acceptance speech.
Well, you're certainly welcome. While putting the finishing touches on this, I've had an audacious idea, and I'm thinking of taking this little experiment in a new direction, but it may take considerable time to program. In fact, I'll probably just get frustrated and give up. But we'll see. :p
 
Joined
Mar 22, 2009
Messages
67
Likes
10
WCA
1982PETR01
#97
Hi, anyone still interested in this thread!

I've been working on this "Combo Algs" stuff for a while. Digging in much harder on some ideas I had 10+ years ago. I've built a web site to explore this, and found some really small complete alg sets.

Small Alg Sets

Here I think of one "alg" as both mirrored versions, but not inverses. So I consider both mirrored Sune versions (F U F' U F U2 F' and F' U' F U' F' U2 F) the same, but AntiSune as a separate alg. I think the discussions here treat both mirrored and inverted versions the same, making it hard to compare.

The smallest set I've found that combines to solve all 3916 LL positions is these 39 algs: http://birdflu.lar5.com/alg_sets/1/algs. The resulting solutions are 15.22 moves on average.

The smallest set for all 494 LL positions with edges oriented is 14 algs: http://birdflu.lar5.com/alg_sets/4/algs. 15.18 moves average.

I searched pretty hard, but it's definitely possible smaller sets exist. If I understand the 24+2 solution above, that is 52 algs the way I count them, but that is of course not a fair comparison.

The Web Site

http://birdflu.lar5.com has all 43 million LL algs of 17 moves or less, organized by positions and categories, and some related features. It's easier for you to explore than for me to explain. I'm happy to explain or fix anything that's weird.

You can also use some predefined combo alg sets and get combo solutions for any position. For the "smallest" ones described above, use these links:
All LL
EO LL

Make your own!


The coolest part is that you can easily make your own combo sets! First log in (WCA login) and pick the Combos section up left. Hit the Create button when ready to make your own. I thought about entering some of the sets discussed here, but there are too many. Let me know which one is "important", and I'll type it in!
 
Last edited:
Joined
Dec 24, 2015
Messages
1,571
Likes
1,063
#98
The coolest part is that you can easily make your own combo sets! First log in (WCA login) and pick the Combos section up left. Hit the Create button when ready to make your own.
I just tried this, but I don't quite understand the user interface. It also reports stuff like "'N96893' is not combinable (yet)" for most things I throw at it.
 
Joined
Mar 22, 2009
Messages
67
Likes
10
WCA
1982PETR01
#99
Ah yes. For an alg to be used in Combos, it needs to be prepared in the DB. The combinable ones are marked with c in the lists. Right now those are 540 mirror pairs that seemed the most useful to me.

It's not hard to add more, but I have to do it manually. So let me know which ones you need, and I should have them up pretty quickly. I assume/hope/pray the algs people actually use can be added pretty quick.

A big part of the UI is that all algs have names. N96893 is the Birdflu name for R U2 R' U' R U R' B' U R U R' U' B
 
Joined
Dec 24, 2015
Messages
1,571
Likes
1,063
Not useful per se, but I think I have a set of 12 ZBLL algs (6 cases and their inverses) that can generate all of ZBLL:

bf4g / L1175
bf4k / J286 (this one and its inverse are already combinable)
bf4a / M16873
bb4l / N257450
Ff4h / K1880
bd4d / N96893
 
Top