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.

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 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

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'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.

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.

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'

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.)

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

F U R U' R' F' R' F' U' F U R

R' U2 R2 U R2 U R U' R U' R'

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 R2 U' R' U2 R

F R2 D R' U R D' R2 U' F'

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' R U' R' U2 R

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' R2 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'

(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.

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.

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.

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.

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)).

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...

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.

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.

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.

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?

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?

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.

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?

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.

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.

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.

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.

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.

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.

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.

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!

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.

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