The New Method / Substep / Concept Idea Thread

[LexCubing]

Let me explain: as far as I know, no one has learned all 3668 1lll cases or algs so why do you then ask for a 1llsll which is 817344, that cannot be reduced further than 20000 algs from mirrors and inverse and auf so the only way of achieving anything with any relation to 1llsll is complex setup so even if it could be done it is not a viable speedsolving method I do not believe that recognition could ever be sub1 second also algs would be long and the execution would be hard so it is not viable for speedsolving as it either requires complex setup or a rediculous amount of very long algs

I gave up on this but so you know I can reduce it to ~4k - 2k depending on what I do on my 3rd slot. As long the math checks out.

Yes just like how ZZ reduce a 4k alg set to 493 I can reduce ~400k - 1M alg set to around the size of 1LLLL.
And that's the magic of math.

As long the math checks out.

 

[cuber314159]

I gave up on this but so you know I can reduce it to ~4k - 2k depending on what I do on my 3rd slot. As long the math checks out.

Yes, but this is my point, you are not reducing alg numbers, you are merely forcing complex setup, which may be intuitive but still takes extra solve time. ZBLL is not pure 1lll it is more technically a subset of 1lll, the CPEP for 7 of the 57 OLL cases, and I presume your 1llsll will be similar. The only way to reduce alg sets is by mirrors and inverses and even still requires learning that alg anyway as it is hard to figure out an inverse first time while performing the alg sub1 as anyone wishing to learn 1llsll would likely aim for.
Edge orientation during F2L is setup and therefore makes ZBLL not pure 1LLL

 

[Neuro]

I've got a dilemma on my ZZ variant doc that I would like your opinions on

I have ZZ-OLLPLL and ZZ-VH on my variant stats document along with many LS+LL variants. However, all the "bases" I use for my scrambles go to F2L-1 (all variants are tested by first taking a scramble and solving to F2L-1 so as to effectively test the efficiency and variance of the techniques)

My concern arises when looking at OLLPLL and VH in that they are NOT LS+LL variants, so you'd actually want to build full F2L before you use that variant. All my bases are, again, done solving to F2L-1. Will this make the tests for OLLPLL and VH void as they are not built to a proper base to test, as you have to add extra moves to get to "the proper base"; or can they still be considered good tests to see the efficiency to solve from F2L-1? If you're confused here's a solve where I marked the base and everything.

One concern is that if I build full F2L for those solves specifically they get an unfair advantage, as they now use different bases from the other variants. But now, they have the disadvantage of not being at their proper F2L stage.

TLDR: ZZ Stats doc builds to F2L-1 to test. You have to solve F2L before using OLLPLL or VH whereas on the other variants you don't. Is this an issue?

 

[Neuro]

Oh and here's a 4x4 variant I've been playing with, based off of Hoya/Lewis/Meyer

1: Hoya Centers+DB edge
2: L and R blocks+last 2 centers (K4, blockbuilding, freeslice, anything really)
3: Pair edges (commutators/Meyer style)
4: CLL+Parity (easy to MU your way to setup)
5: L5E

EDIT: ¡Es horrible, no prestar atención a este método!

 

[Ognjen Lecic]

So we all know about coll and zbll and regular oll pll, with zbll you have one look 1 alg, with coll you have 2 looks 1,5 algs(1 for oll and .5 for epll because those are really easy and fast) and oll pll you have 2 looks 2 algs, but what if you had 1 look 2 algs, basically a long zbll, that would be l4c +epll in 1 look, l4c has 84 algs which are zblls that dont affect the edges so you can predict epll and do it right after that zbll, it has close to 90 algs for the entire ll a lot less than zbll ovc you would need to use some last slot method or just use zz or even alg for 2 look oll could work if you know what it does to the pieces, what do you guys think about this?

 

[LexCubing]

Yes, but this is my point, you are not reducing alg numbers, you are merely forcing complex setup, which may be intuitive but still takes extra solve time. ZBLL is not pure 1lll it is more technically a subset of 1lll, the CPEP for 7 of the 57 OLL cases, and I presume your 1llsll will be similar. The only way to reduce alg sets is by mirrors and inverses and even still requires learning that alg anyway as it is hard to figure out an inverse first time while performing the alg sub1 as anyone wishing to learn 1llsll would likely aim for.
Edge orientation during F2L is setup and therefore makes ZBLL not pure 1LLL

What do you even mean by reducing the alg count? Mirrors/Inverses don't reduce it though. It's still the same # of algs. Ua and Ub PLL are inverses of each other but how many algs? 1? No 2.

ZZ did reduce the alg set and also extra solve time depends on the how the method. ZZ-a is on top w/ 1LLLL Method and its other variations.

 

[xyzzy]

You don't need full L4C to preserve the edges, just half of it, because the edges can be off by a H perm and it wouldn't matter.

The algs for EP-preserving COLL are in some cases the same as the usual COLL algs (e.g. the 3-cycles don't even affect edges), but there are some that are significantly worse than the usual COLL algs, and this would have a higher move count than COLL/EPLL.

Pros: only one recognition pause.
Cons: EP recognition with unsolved corners is harder than EPLL recog (you have parity to account for if you use two-sided recog wrt a fixed corner); the recognition pause with COLL/EPLL can be eliminated with lookahead; algs are worse; you can already predict EPLL with COLL if you memorise how the alg affects the edges.

 

[AlphaSheep]

The problem with ZBLL is not learning algs. It takes me around 10 minutes to learn a new alg. The hard part is associating your recognition for the case with the alg. Since a 1 look, 2 alg method doesn't really affect the number of cases you need to associate recognition for, it's actually not as much of an advantage as you'd think.

 

[Sue Doenim]

Oh and here's a 4x4 variant I've been playing with, based off of Hoya/Lewis/Meyer

1: Hoya Centers+DB edge
2: L and R blocks+last 2 centers (K4, blockbuilding, freeslice, anything really)
3: Pair edges (commutators/Meyer style)
4: CLL+Parity (easy to MU your way to setup)
5: L5E

EDIT: ¡Es horrible, no prestar atención a este método!

Wouldn't it be "no presta atención," because you're in command form? Or did you just use Google translate?

I had an interesting idea. Almost like FreeFOP but with ZZ.
1) Roux style first block
2) 2x2x2 (left block B square+DB+centers)
3) L5EOP (Orient edges and place FD), modified for when edge in F2L slot is misoriented.
4) Solve as ZZF2L-1
I think it has the potential to be just about as good as ZZ. I believe movecount would be lower.
Example solve (into ZZ-CT):
Scramble:L B' U B D' L' D2 B2 R F2 D2 B R2 B' U2 L2 B2 R2 L2
Inspection: y
FB: F' U r' D' U2 B U2 r B (9/9)
2x2x2: R U R M U' M2 R' U R M2 U M' (12/21)
L5EOP: r U2 r' U2 M' U M U' M' U2 M (11/32)
TLSE: U R' D' r U2 r' D R (8/40)
TTLL: D R2 U' R2 U' R2 U2 R2 U D' (10/50)
TSLE and TTLL were both pretty lucky, but to counterbalance that, the previous steps could almost certainly have been more efficient.

 

[Hazel]

Wouldn't it be "no presta atención," because you're in command form? Or did you just use Google translate?

I had an interesting idea. Almost like FreeFOP but with ZZ.
1) Roux style first block
2) 2x2x2 (left block B square+DB+centers)
3) L5EOP (Orient edges and place FD), modified for when edge in F2L slot is misoriented.
4) Solve as ZZF2L-1
I think it has the potential to be just about as good as ZZ. I believe movecount would be lower.
Example solve (into ZZ-CT):
Scramble:L B' U B D' L' D2 B2 R F2 D2 B R2 B' U2 L2 B2 R2 L2
Inspection: y
FB: F' U r' D' U2 B U2 r B (9/9)
2x2x2: R U R M U' M2 R' U R M2 U M' (12/21)
L5EOP: r U2 r' U2 M' U M U' M' U2 M (11/32)
TLSE: U R' D' r U2 r' D R (8/40)
TTLL: D R2 U' R2 U' R2 U2 R2 U D' (10/50)
TSLE and TTLL were both pretty lucky, but to counterbalance that, the previous steps could almost certainly have been more efficient.

You could have done FB + 2x2x2 in 10 moves total (without the y in inspection): D' R U' D2 L2 F2 D B D R2

 

[Neuro]

Wouldn't it be "no presta atención," because you're in command form? Or did you just use Google translate?

Ah I think you're right! I'm not a fluent speaker and almost never write in Spanish so I forget stuff sometimes :/

On the method, it's basically a MCELL variant. Could be good if you can identify all cases quickly enough. Wouldn't it be L6EOP though? By my understanding you have DF, FR, and all U layer edges to orient.

 

[ShyGuy1265]

I had and 2 ideas for Square-1 methods:

1. Cubeshape
2. Solve 1st layer corners
3. EO (5 algs)
4. 1st layer edges + PLL (439 algs?)
If you really want to learn algs, you can learn this. I think the last step has 219 algs without parity. CSP gives better cases, although the parity cases might not be much longer than the non-parity cases because corner permutation is not solved.

1. Cubeshape
2. Solve 1st layer corners
3. EO + CLL (27 algs?)
4. EP (99 algs)
This one has less algs and better recognition. If you use CSP, EP has 49 nicer algs.

EDIT: You can put your last layer color on the first layer if you get a good case for the 2nd step. Then once you are done with the 3rd step or 4th step, you can cancel into switching the layers.

 

[Hazel]

I had an idea for an LS subset where if the LS edge is already solved (or maybe even only permuted), then you can insert the corner while solving EO for the Last Layer. There would be 21 cases I think for if the LS edge orientation had to be solved, I think 42 or so otherwise.

 

[Neuro]

I had an idea for an LS subset where if the LS edge is already solved (or maybe even only permuted), then you can insert the corner while solving EO for the Last Layer. There would be 21 cases I think for if the LS edge orientation had to be solved, I think 42 or so otherwise.

Sounds like a less intense ZBLS. By less intense, you brought the case # from 302 to 24 (48 if you allow the edge to be disoriented, which I'd recommend)! 8 EO possibilities for both oriented and disoriented sets and x3 for corner orientation.

However, it would probably be better if you have sets in which the corner can be in the LS, as that it has a 1/5 chance of ending up there while solving last F2L edge. This, assuming orientation or disorientation gives us an algcount of 66.

If you were to implement phasing, you'd get ZZLL and have probably one of the most feasible techniques for 1LLL using CFOP! You'd probably want to reduce it to only possibilities of disorientation, as your algcount drops to 90 as oppossed to 198. Assuming only disorientation is allowed and phasing is used, you need 239 algs excluding mirrors to have a 1LLL, lower than ZBLL and of course better recog!

Good job, looks like it has very high potential to be (one of) the future(s) of CFOP!

EDIT: Fullstep solve. 46 moves (used HARCS to get xcross and super easy F2L admittedly but still pretty good) and LS Solve, 26 moves but the phasing+LS probably could've been better if slice/wide moves were used

 

[Hazel]

@Neuro Thanks for the high praise! One question though, what is phasing? Also, could you rephrase what you said in the 3rd paragraph, it was a bit confusing to me, sorry!

 

[Shiv3r]

You don't need full L4C to preserve the edges, just half of it, because the edges can be off by a H perm and it wouldn't matter.

The algs for EP-preserving COLL are in some cases the same as the usual COLL algs (e.g. the 3-cycles don't even affect edges), but there are some that are significantly worse than the usual COLL algs, and this would have a higher move count than COLL/EPLL.

Pros: only one recognition pause.
Cons: EP recognition with unsolved corners is harder than EPLL recog (you have parity to account for if you use two-sided recog wrt a fixed corner); the recognition pause with COLL/EPLL can be eliminated with lookahead; algs are worse; you can already predict EPLL with COLL if you memorise how the alg affects the edges.

this is a thing already, it's called EZBLL, and Lars petrus has a page on it. the smallest number of algs that any two can solve every case in ZBLL is 12.

I had and 2 ideas for Square-1 methods:

1. Cubeshape
2. Solve 1st layer corners
3. EO (5 algs)
4. 1st layer edges + PLL (439 algs?)
If you really want to learn algs, you can learn this. I think the last step has 219 algs without parity. CSP gives better cases, although the parity cases might not be much longer than the non-parity cases because corner permutation is not solved.

1. Cubeshape
2. Solve 1st layer corners
3. EO + CLL (29 algs?)
4. EP (99 algs)
This one has less algs and better recognition. If you use CSP, EP has 50 nicer algs.

EDIT: You can put your last layer color on the first layer if you get a good case for the 2nd step. Then once you are done with the 3rd step or 4th step, you can cancel into switching the layers.

these are pretty interesting. you may want to look at methods like Lin or LBL. they both seem not that good compaed to LBL, which just broke WR single.
one of the more efficient methods I have seen (without CSP) is where you orient everything, then check both layers to see if you have parity, execute a much nicer and shorter parity alg, then do CP then EP

 

[Neuro]

@Neuro Thanks for the high praise! One question though, what is phasing? Also, could you rephrase what you said in the 3rd paragraph, it was a bit confusing to me, sorry!

So basically phasing is getting 2 opposite edges across from each other (i.e. yellow/red in UF and yellow/orange in UB). Phasing is implemented in ZZLL in order to drop the algcount significantly, because you no longer have to deal with edges that are opposites color-wise but end up adjacent to one another. It's kinda hard to explain in words, so I'd look at case images for ZZLL. A PLL that has phasing in it is the T perm. All edges are opposite of each other. Another example is the H perm.

As for the third paragraph, what you would want to do in order to implement phasing effectively is to put the last F2l edge into the slot misoriented. Having only misoriented cases brings the case count down to 90 for full phasing and EOLS. As ZZLL has 169 algs, your case count is 239 excluding mirrors. Therefore, it has the possibility of being the most effective 1LLL methods for CFOP, as recog for EOLS+Phasing is quite easy (Egide has a LS technique he uses for ZZ, you can easily modify it to work with this method. Just egidecubing.com) and ZZLL recog isn't too bad due to less cases to memorize and frequently appearing patterns.

Hopefully this clarified it somewhat!

 

[Thermex]

So basically phasing is getting 2 opposite edges across from each other (i.e. yellow/red in UF and yellow/orange in UB). Phasing is implemented in ZZLL in order to drop the algcount significantly, because you no longer have to deal with edges that are opposites color-wise but end up adjacent to one another. It's kinda hard to explain in words, so I'd look at case images for ZZLL. A PLL that has phasing in it is the T perm. All edges are opposite of each other. Another example is the H perm.

As for the third paragraph, what you would want to do in order to implement phasing effectively is to put the last F2l edge into the slot misoriented. Having only misoriented cases brings the case count down to 90 for full phasing and EOLS. As ZZLL has 169 algs, your case count is 239 excluding mirrors. Therefore, it has the possibility of being the most effective 1LLL methods for CFOP, as recog for EOLS+Phasing is quite easy (Egide has a LS technique he uses for ZZ, you can easily modify it to work with this method. Just egidecubing.com) and ZZLL recog isn't too bad due to less cases to memorize and frequently appearing patterns.

Hopefully this clarified it somewhat!

I've been working on a very similar method to what you just wrote with JTay that we're calling "ribbon". One thing I'd like to mention is that it's bit more efficient and ergonomic if you insert the edge in its slot while solving the cross (this forms a ribbon shape). Our idea was that for the last slot you
1) Orient all the pieces (DFR corner+last layer) and orient the DR edge (300 algs, but it can be cut to 150 if you fully solve the DR edge during the ribbon)
2) TTLL (100 algs)

I still like our idea a lot but I think your method has slightly less algs. Which do you think is better?

 

[Teoidus]

Here's a simple idea: ZZ with intuitive LSLL

The idea is to solve the edges <R,U>, then the corners <R,U,D>. Here are some example solves:

43 STM (lucky)
59 STM (unlucky)
50 STM (expected)
49 STM (expected)

 

[Neuro]

I've been working on a very similar method to what you just wrote with JTay that we're calling "ribbon". One thing I'd like to mention is that it's bit more efficient and ergonomic if you insert the edge in its slot while solving the cross (this forms a ribbon shape). Our idea was that for the last slot you
1) Orient all the pieces (DFR corner+last layer) and orient the DR edge (300 algs, but it can be cut to 150 if you fully solve the DR edge during the ribbon)
2) TTLL (100 algs)

I still like our idea a lot but I think your method has slightly less algs. Which do you think is better?

Ribbon sounds quite good as well, but yes mine has less algs. I think that mine'd be more efficient as well (ZZLL takes ~12 moves and ~11 moves for phasing+EOLS). However, TTLL recog is still easier than ZZLL and it could be argued that OLC has better recog than EOLS+Phasing. Second part is up to debate for me though, I can recognize it super fast. I think that people will gravitate to Ribbon because of the recog, despite the higher algcount (although they are actually quite similar, Ribbon=243 and mine=239) Good luck to you and JTay!