Developing a better LL system

[Pyjam]

Would this get much easier if edges were pre-oriented?

OCLL + PLL is good enough for 2LLL with pre-oriented edges, isn't it?

 

[kashyap7x]

well, it would be a 1 look 2 alg kinda ZBLL, slightly increasing movecount but drastically dropping the required number of algs. Whether or not it will be better than COLL/Edges we'll have to see. It is likely that the edges oriented cases will be worse than the others though. Again, have to wait and see.

 

[yoinneroid]

well, it would be a 1 look 2 alg kinda ZBLL, slightly increasing movecount but drastically dropping the required number of algs. Whether or not it will be better than COLL/Edges we'll have to see. It is likely that the edges oriented cases will be worse than the others though. Again, have to wait and see.

this?

 

[kashyap7x]

Yeah, that. But, from the page..

It needs a lot more work, and is not all that reliable, but it's a start.

Its going to end up as a subset of the LL system being developed. If this system turns out superior or as good as other conventional ones the edges oriented version might be worth using too. Hopefully.

 

[Kirjava]

Posting updates is fun :3

This is honestly going way better than I expected.

I've organised 1879/4128 cases "by alg". After the entire thing is organised in this format, it'll start getting closer to being learnable. At that point cases will start to be grouped and the actual number of cases will be reduced.

The cool part? All those cases start with Sune/FatSune/Antisune. Yeah. Almost 50% chance of the first alg being a Sune is the kind of thing I was talking about when I said 'better good case distribution'.

Although I think after finishing this (huge) task it would be cool for the community to help Kir generate and optimise a set of algs for ZBLL

I actually started doing this when I started learning ZBLL, but abandonded it when I went for OLLCP. (At that point I hadn't thought about it as much as I've thought about this though, I've found too many new ideas and improvements between then and now)

Maybe it'll be worth making a ZBLL version just to demonstrate the validity of the technique.

 

[Noahaha]

Do you think it will ever be feasible to have a program where you can put in your fifty or so favorite algs and it will generate a learnable complete LL table using this system, sorted by the first alg?

 

[Escher]

Posting updates is fun :3

This is honestly going way better than I expected.

I've organised 1879/4128 cases "by alg". After the entire thing is organised in this format, it'll start getting closer to being learnable. At that point cases will start to be grouped and the actual number of cases will be reduced.

The cool part? All those cases start with Sune/FatSune/Antisune. Yeah. Almost 50% chance of the first alg being a Sune is the kind of thing I was talking about when I said 'better good case distribution'.

That is cool O_O

Maybe it'll be worth making a ZBLL version just to demonstrate the validity of the technique.

Definitely. Making the ZBLL subset 'learnable' using this technique would make it so, so much more viable - one could eventually replacing all 'bad' cases with more unique algs - I'm not surprised if plenty of advanced cubers would use this approach as a stepping stone. Almost like learning full OLL as just a combination of two sunes or something...

Edit: @ Noahaha, that depends on the minimum number of algorithms required, which would probably have to be brute-forced I'm guessing, a different kind of proof would have to be very elegant... It also depends on the minimum number of 'alg types' needed.
Obviously, it would be somewhat easier for ZBLL.

 

[LarsN]

Posting updates is fun :3

I'm impressed that you've gotten so far. And it's great to hear that things are turning out to be good. I'd love to be a test person if you need help of some kind or another.

 

[Kirjava]

So looking at the organised data has given me a few ideas.

My original organisation ideas are now more of a backup incase none of the crazy things I've been thinking about work.

A flowcharting system akin to jaap's sq1 cubeshape diagram might be able to be used.

Since half the cases can be solved with some Sune variation, maybe there is a trait that they all have in common. Then maybe there is a trait that all the mirrored sune cases have in common, etc.

It might not be possible on this scale, but will def. be possible for smaller sets. Common patterns appear to crop up. It's just a huge extension of my case reduction idea.

This could get really easy. I'll release more data at some point and see if anyone can help work it out.

 

[Godmil]

I'm really curious about what your saying about sune cases being so common (for the first move?). Is that something that was apparent from looking at the raw data, or did you say go into it wondering how many could start with a sune case?
I'm just curious if maybe you picked any group of 3 or 4 algs, if you could find they could be used for starting half of the cases.
Anyway keep up the good work, and thanks for the updates.

 

[StachuK1992]

http://codepad.org/xLYp8b8L

 

[Mollerz]

I was discussing this with Kirjava last night as well, this may only really work on odd numbered cubes. OLL Parity is easy enough to spot but unless the recognition system becomes so easy that spotting PLL Parity isn't a problem, then it could potentially be problematic.

 

[Kirjava]

This is a 3x3x3 method. I forgot that people do 3x3x3 LL on 4x4x4 too XD

I'm really curious about what your saying about sune cases being so common (for the first move?). Is that sometime that was apparent from looking at the raw data, or did you say go into it wondering how many could start with a sune case?

I just used grep to list all the cases that start with Sune. Turns out, many.

I knew I wouldn't know exactly how I was going to organise the data until I started looking deeper at it, but I wasn't expecting this.

I'm just curious if maybe you picked any group of 3 or 4 algs, if you could find they could be used for starting half of the cases.

Probably, but I picked Sune because it's good. I'm hoping I can cover the other half with FRUR'U'F' etc. Should make any solution stupid fast.

 

[blah]

Didn't read the whole thread, so my questions may have been answered: Are there "usable" necessary and/or sufficient conditions that determine if an arbitrary set of algs can solve any LL case in two steps? Naturally, the next question is what is the minimum number of algs necessary?

 

[bobthegiraffemonkey]

I was discussing this with Kirjava last night as well, this may only really work on odd numbered cubes. OLL Parity is easy enough to spot but unless the recognition system becomes so easy that spotting PLL Parity isn't a problem, then it could potentially be problematic.

I wonder if it's possible at all to treat a certain pair of opposite edges as being the same, then you would get a solved LL or pure PLL parity. Not sure how this would affect the recog system, since nobody knows what it is yet. Not that I would ever use this system for 4x4 anyway, I'll stick with going for 1-looking OLL and PLL using various tricks to make the parity cases nicer (I've 'learned' OLL already, although I've forgotten some which I need to pick up again, and I need to finish working on PLL).

 

[Kirjava]

3577/4128

Using Sune, SexyHammer, FRURUF & DblFRURUF for first alg so far.

EDIT:

3853/4128

Added M'UMU2M'UM, R'U'R'FRF'UR, RUR'U'M'URU'r'

 

[Jaycee]

& DblFRURUF

Hmm?

 

[jeff081692]

Hmm?

Maybe he meant FRUR'U'F'.

 

[Mollerz]

Hmm?

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

 

[Jaycee]

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

Oh. Dbl = double. I get it.