Developing a better LL system

[Kirjava]

I put my trust in you.

As I'm definitely not a common speedcuber I expect to be granted early acces

I intend to make the data available to everyone. When I said not accessable to the common cuber yet, I meant that it might be too hard for them to understand or learn until the organised version has been completed.

How about making the "cross-check program" (for lack of a better name...) accessable so people can input their own alg sets?

Maybe, but if they have their own alg sets they think are better they should contribute them to the project! This should really be done before work is started on the next part. I don't mind sharing the solver but unsure what use it would be to people outside of this kind of use.

"FRUR'U'F' then Sune. This doesn't appear in any other system.
Strange, this combination occasionally solves my LL when I"m CFOP-ing????

fatboyxpc pretty much explained what I meant. A better example would be that one of the last layer cases will be T Perm then Sune

 

[jeff081692]

I'm pretty excited for this. Just got on summer vacation so I can devote an insane amount of time into learning it.

 

[cemoss]

waiting for it to come!

 

[Thunderbolt]

Sorry guys but I have no idea what is this. Could someone explain this to me. I see only list of algs but I don't see how to recognize the cases wtf

 

[MostEd]

Sorry guys but I have no idea what is this. Could someone explain this to me. I see only list of algs but I don't see how to recognize the cases wtf

There are common algs, such as sune, niklas, FRUR'U'F' etc..
This method uses those algs to solve the LL and theres 2 algs(2 different ones) per case, you do one then another one

and you recognise by recognising

 

[Noahaha]

I may learn this since I used to use Petrus's one look two algorithm COLL.

 

[ncube]

Kirjava, could you give some examples on a few ll cases to demonstrate recognition with the two algs? Thx

 

[zzomtceo]

Theoretically, with more algs couldn't this be a method for the whole solve?

 

[Kirjava]

Small update -

Solving the cases is taking longer than I though (my computer isn't that good). So far 3/48 of the table is complete.

 

[yoinneroid]

For those wondering how this works, this site should help

 

[bobthegiraffemonkey]

I never thought this kind of thing would be feasible, but if there's anyone who is crazy, awesome and creative enough to make it work, it's you.

Will this work well for LL subsets do you think? Eg. using this just for COLL cases? I know it would miss the point a little, but I'm curious. And yes, I am seriously considering doing that, at least for 'bad' COLL cases.

 

[Kirjava]

Haha, while working on this I discovered the most horrific LL case I've ever seen.

Optimal solution is; F R D2 F' R2 U B' R2 B U' R2 F D2 R' F' (15f) (<+Brest> [F R D2 F' R2 U B': R2] cute)

Will this work well for LL subsets do you think? Eg. using this just for COLL cases? I know it would miss the point a little, but I'm curious. And yes, I am seriously considering doing that, at least for 'bad' COLL cases.

Sure, he basic idea is what I used to learn OLLCP.

 

[ncube]

R2 U2 R' U2 y L' U2 L R U2 R' U2 F U2 F2, Same case, but 14 turns...
Also, for the Mirror, I found
r’ U2 R U x R’2 U2 R U2 R’ U2 x’ R2 U’ R’ U2 r, which flows nicely.

 

[~Adam~]

Seems like a good idea but recognition sounds horrific.

 

[Kirjava]

R2 U2 R' U2 y L' U2 L R U2 R' U2 F U2 F2, Same case, but 14 turns...
Also, for the Mirror, I found
r’ U2 R U x R’2 U2 R U2 R’ U2 x’ R2 U’ R’ U2 r, which flows nicely.

That's a different case, the optimal solution for the case I listed is 15 moves.

Also, due to the nature of the system I can't actually use any of those algs.

 

[aronpm]

Small update -

Solving the cases is taking longer than I though (my computer isn't that good). So far 3/48 of the table is complete.

Update:
Running the solver on my machine, it's almost 3/48ths done (it's running about twice as fast as for Kir, and the output is already 400kb ). Raw table should be generated in about 24 hours, then Kir has to organise it. And stuff.

 

[bamilan]

Comparing OLL and your algorithms, they take ~ the same time to execute, but recog of OLL is better.
PLL algorithms are speed optimized, they can be done sub-2. Most of the algorithms in your list take at least 1-1.5 seconds to execute, so the time you can cut using that system is somewhere <0.5 sec in my opinion (assuming that recog for PLL is the same as recog for 2nd algorithm).
Does it really worth to learn?

 

[Godmil]

Ok I think I get it now. It's a really interesting/creative idea. However, due to recog/recoll issues I can't see it being faster than OLL/PLL. But I'm so impressed that you came up with it. Much cooler than all those new LS systems.

 

[LarsN]

Haha, while working on this I discovered the most horrific LL case I've ever seen.

Optimal solution is; F R D2 F' R2 U B' R2 B U' R2 F D2 R' F' (15f) (<+Brest> [F R D2 F' R2 U B': R2] cute)

What is the solution with this new system then?

EDIT: just ran it through your list but didn't find a solution. Most likely a fail on my side though

 

[Robert-Y]

[01:19.53] <Athefre> Shortest CE gives is: F R D2 F' R2 U B' R2 B U' R2 F D2 R' F'
[01:20.04] <Kirjava> is that optimal?
[01:20.08] <Athefre> 15
[01:20.11] <Kirjava> hah.
[01:20.14] <Kirjava> also
[01:20.16] <Kirjava> fuuuuu
[01:20.29] <RobertY> wow this case is so evil
[01:20.34] <Kirjava> yeah
[01:20.37] <Kirjava> there's *nothing*
[01:20.50] <RobertY> no matter what your LL system is
[01:20.55] <RobertY> even 1LLL sucks XD
...
[01:35.16] <RobertY> Kirjava: all I'm doing is trying out random short diag OLLCP algs, then hoping that the resulting OLLCP alg will skip EPLL upon execution
...
[01:36.01] <RobertY> I like this:
[01:36.02] <RobertY> ,i (R U R B' R' B U' R') (R' F R F' R' F R F' R U R' U' R U R')
[01:36.03] <Nibblr> inverse: R U' R' U R U' R' F R' F' R F R' F' R R U B' R B R' U' R'

My best is 1.7x with (R U' R' U R U' R' F R' F' R F R' F' R) (R U B' R B R' U' R')

Anyone think they can find a better alg and beat this?