The New Method / Substep / Concept Idea Thread

[Neuro]

This is a concept I am positive already exists, but what if you optimised the first layer of 2x2 so you can also permute one or two LL corners, so you could reduce the amout of CLLs to speed recognititon?

Since I have stubby fingers which make it hard for me to turn with a high tps, I might start learning more efficient intuitive methods to accomodate.

Reducing CLL’s would be very easy to do intuitively but whether or not it’s worth it is debatable. It may hinder ability to one-look and increase movecount.

2x2 doesn’t really have a move efficient method unfortunately. All methods seem to bottom out at 14 move average.
3x3 most efficient is Roux and advanced Petrus/ZZ. Petrus can be more efficient than Roux but only with ZBLL imo. ZZ with COLL/EPLL is about the same as CFOP but an arguably better movegroup. Using it with ZBLL will probably get you close to Roux or even lower. Roux is the most efficient in its basic form though.
4x4+ doesn’t really matter what you use. Yau’s really fast but you could get good times using Meyer too. Redux on 6x6 and 7x7.

 

[1001010101001]

2LLS 2x2 LL Skip method ( can’t think of a good name )
Scramble: R2 F U B’ R2 F U
Step 1. Bar on DL, sort D layer pieces, recognise CP case. All in inspection
U’ F’ R
2. Corner Permutation/ 2-gen reduction/ reduction to RU
This is probably the hardest step.
R2 F R F’ swaps two corners on UF. F RUR’U’ F’ swaps two opposite corners like a yperm.
There are two cases which are a skip. One is solved CP and the other is when the D corners are swapped and U has a diagonal swap.
U2 R2 F R F’

3. Place a oriented corner in D and orient all corners 2 gen (guimond algs), However algs for mirror cases will have to be generated. PM me if you want to help
R’ U R’ U2 R
4. Intuitive everything else
This step should be done with R2 and any U move to preserve corner orientation. Solve the bottom layer and then AUF the top layer.
R2 U
Pros:
Half the solve is 2-gen allowing TPS spam
High chance of LL skip (100%)
Uses inspection time well

Cons:
Lookahead, as there is little direct solving until the end
Hard for beginners

Example solve 2.
R U R2 F U F

R’ B’ U2 R2
U R2 F R F’
R U2 R U’ R
U2 R2 U’ R2
18 moves

 

[Duncan Bannon]

2LLS 2x2 LL Skip method ( can’t think of a good name )
Scramble: R2 F U B’ R2 F U
Step 1. Bar on DL, sort D layer pieces, recognise CP case. All in inspection
U’ F’ R
2. Corner Permutation/ 2-gen reduction/ reduction to RU
There are two algs here: F RUR’U’ F’ and R2 F R F’
U2 R2 F R F’

3. Place a oriented corner in D and orient all corners 2 gen (guimond algs)
R’ U R’ U2 R
4. Intuitive everything else
R2 U
Pros:
Half the solve is 2-gen allowing TPS spam
LL skip
Uses inspection time well

Cons:
Lookahead, as there is little direct solving until the end
Hard for beginners

Example solve 2.
R U R2 F U F

R’ B’ U2 R2
U R2 F R F’
R U2 R U’ R
U2 R2 U’ R2
18 moves

Solve 3.
R U F U B’ U2

U R’
F RUR’U’ F’
U R’ U’ R U’ R’ U2 R
U2
17 moves

Interesting.. Do you have an average movecount?

 

[1001010101001]

Interesting.. Do you have an average movecount?

19 I think. Maybe 18 or even 17

 

[Neuro]

2LLS 2x2 LL Skip method
Step 1. Bar on DL, sort D layer pieces, recognise CP case. All in inspection
2. Corner Permutation/ 2-gen reduction/ reduction to RU
3. Place a oriented corner in D and orient all corners 2 gen (guimond algs)
4. Intuitive everything else

While it's a cool idea, I unfortunately don't think it can compete with other methods. CP tracking is very difficult even on a 2x2 and the rest of the steps likely can't be one-looked as a result. Also, the movecount is slightly higher than other methods. I simply don't think the ending movegroup is enough to compensate for the many looks you'll end up using in comparison to CLL+ and even HD. Cool idea, not good for speed.

 

[1001010101001]

While it's a cool idea, I unfortunately don't think it can compete with other methods. CP tracking is very difficult even on a 2x2 and the rest of the steps likely can't be one-looked as a result. Also, the movecount is slightly higher than other methods. I simply don't think the ending movegroup is enough to compensate for the many looks you'll end up using in comparison to CLL+ and even HD. Cool idea, not good for speed.

It’s a 3-look method and is just purely experimental.

 

[Neuro]

I've decided to revisit Ribbon somewhat, and I've come up with a few other variants people may choose to explore in the future @JTay

Alpha- Standard; TOLS, TTLL
Beta- Phasing+EO LC, ZZLL
Gamma- CP+EO LC, 2GLL
Delta- EOLC, ZBLL
Epsilon- OLC, PLL
Zeta- L5C (algs or comms), ELL
Eta- ELC, L4C
Theta- CP+O LC, EPLL
Iota- COLC, 1LLL w/ CO done
Kappa- CO+E LC, L4C (PLL)

I think usable variants are Alpha, Beta, Gamma, Delta, and Zeta. Zeta's interesting because it's usable, intuitive, and can be a 1LLSLL if comms are used on corners. I'm not sure on the alg counts on these variants but I'm fairly certain they're all over 200 algs.

 

[PapaSmurf]

Please excuse my maths if I get it wrong. I'm not a group theory expert, but if I'm right, (5!^3)/3=576,000 including solved. That hasn't accounted for aufs and could be completely wrong, but at even an eighth of of that isn't worth it.

 

[A Nonconformist]

I'm sure this has already been thought up and doesn't compare to cfop or roux, but I'd like to hear how exactly it compares to the two.
FB
SB
EODFDB
ZBLL
Or you could orient corners during the end of SB, EODFDB, PLL

 

[xyzzy]

I'm sure this has already been thought up and doesn't compare to cfop or roux, but I'd like to hear how exactly it compares to the two.
FB
SB
EODFDB
ZBLL
Or you could orient corners during the end of SB, EODFDB, PLL

This is ZBRoux/LLOB, which is pretty efficient and allows for looking ahead into LL during EODFDB, although you do need to know full ZBLL for it to actually be useful. Without ZBLL, it's more efficient to just do standard CMLL into LSE.

 

[Sue Doenim]

Please excuse my maths if I get it wrong. I'm not a group theory expert, but if I'm right, (5!^3)/3=576,000 including solved. That hasn't accounted for aufs and could be completely wrong, but at even an eighth of of that isn't worth it.

It would be (5!×3^4)/2=4860, which still isn't really worth it. However, it probably would be best to just use commutators.

 

[1001010101001]

I've decided to revisit Ribbon somewhat, and I've come up with a few other variants people may choose to explore in the future @JTay

Alpha- Standard; TOLS, TTLL
Beta- Phasing+EO LC, ZZLL
Gamma- CP+EO LC, 2GLL
Delta- EOLC, ZBLL
Epsilon- OLC, PLL
Zeta- L5C (algs or comms), ELL
Eta- ELC, L4C
Theta- CP+O LC, EPLL
Iota- COLC, 1LLL w/ CO done
Kappa- CO+E LC, L4C (PLL)

I think usable variants are Alpha, Beta, Gamma, Delta, and Zeta. Zeta's interesting because it's usable, intuitive, and can be a 1LLSLL if comms are used on corners. I'm not sure on the alg counts on these variants but I'm fairly certain they're all over 200 algs.

Zeta can be completely intuitive with commutator corners and ELL can be done LSE style

 

[Neuro]

Zeta can be completely intuitive with commutator corners and ELL can be done LSE style

I've changed my mind somewhat on Zeta. I no longer consider it viable for speed given how many looks it'd take to do corners. However, I still find it very interesting in that it is still a semi-feasible 1LLSLL. Let me take this opportunity to talk about the pros/cons of the first 4.

Alpha- Easy to recognize cases, but long algs and hard to predict TTLL
Beta- Nicely developed algs, but harder to recognize and still hard to predict
Gamma- Very fast/simple LL, but hard CP/LL recog and hard to predict LL
Delta- Nicely developed algs and decent prediction, but a lot of algs


Many of these variants are just awful, I basically made them to show how many ways there are to solve F2L-1C, although only a few could be viable for speed. Some may be incredible for FMC but awful for speed and vice-versa. Perhaps Zeta could be used as an FMC technique.

Also, I've ran upwards of 100 L10P scrambles and found that EODFDB/ZBLL and CMLL/LSE (EOLR & EOCMLL) were approximately the same movecount (~24) with the Roux approach actually being ~.3 moves more efficient (albeit that's negligible.)

 

[Thom S.]

Also, I've ran upwards of 100 L10P scrambles and found that EODFDB/ZBLL and CMLL/LSE (EOLR & EOCMLL) were approximately the same movecount (~24) with the Roux approach actually being ~.3 moves more efficient (albeit that's negligible.)

That's really nice to know. I actually have more hopes in ZBroux as the EODFDB and ZBLL recognition is arguably better for a theoretical future time period

 

[Arc]

2LLS 2x2 LL Skip method ( can’t think of a good name )
Scramble: R2 F U B’ R2 F U
Step 1. Bar on DL, sort D layer pieces, recognise CP case. All in inspection
U’ F’ R
2. Corner Permutation/ 2-gen reduction/ reduction to RU
This is probably the hardest step.
R2 F R F’ swaps two corners on UF. F RUR’U’ F’ swaps two opposite corners like a yperm.
There are two cases which are a skip. One is solved CP and the other is when the D corners are swapped and U has a diagonal swap.
U2 R2 F R F’

3. Place a oriented corner in D and orient all corners 2 gen (guimond algs), However algs for mirror cases will have to be generated. PM me if you want to help
R’ U R’ U2 R
4. Intuitive everything else
This step should be done with R2 and any U move to preserve corner orientation. Solve the bottom layer and then AUF the top layer.
R2 U
Pros:
Half the solve is 2-gen allowing TPS spam
High chance of LL skip (100%)
Uses inspection time well

Cons:
Lookahead, as there is little direct solving until the end
Hard for beginners

Example solve 2.
R U R2 F U F

R’ B’ U2 R2
U R2 F R F’
R U2 R U’ R
U2 R2 U’ R2
18 moves

I suppose I should post the idea I ripped off Teoidus and Shadowslice. 2x2GR and 22 had a child and I call it 22GR.

1. CPLine + TL5C setup (optimal under 5 moves, shouldn't be too hard to get close)
2. Conjugated TL5C (around 12 moves, 39 algs; could be all 2gen, but better not 2gen)

So basically you do CPLine as described in 2GR while also putting either (but not both) D corner into the wrong spot, regardless of orientation (so you could put DFR in DBR, or DBR in DFR, and in neither case does the corner need to be oriented any particular way). from there you simply recognize your TL5C case which is quite easy. You have six cases for the D corner and you should know this from inspection, I call them front (for DBR being in DFR) and back (for DFR being in DBR) and o for sticker oriented down, + for sticker oriented forward or backward, and - for sticker oriented to the right, making front +, front -, front o, back +, back -, and back o. And I reiterate that you don't need to look at this, you should know it from inspection. From here you simply look at the orientation of the four corners on U, and which one has the D sticker on it.

The algs themselves are simply TOCLLs which is a subset of TCLL which already exists, however some TCLLs twist the wrong D corner, which is important here, and also a lot are garbage. Here is the front- set that I put together and genned a little of myself. Should show the general idea of the recognition and also gives an idea of the algs. I don't have all the algs finished and I don't know if I'll finish them any time soon but if someone wants what I have I can get it together.

This is pretty close to an actual L6C method and I think it's far closer to "100% LL skip" than anything proposed before. Plus I think it's actually not even bad, with a fairly competitive move count for only 39 algs.

Edit: one thing I forgot to mention. I haven't played with forcing diag swap instead of solved CP. This would be very similar but none of the algs could be done 2gen. Though they could still end up being better.

 

[Hazel]

What if you solved CP while making a V, then just do an alg to solve everything else?

 

[Neuro]

That's really nice to know. I actually have more hopes in ZBroux as the EODFDB and ZBLL recognition is arguably better for a theoretical future time period

I suppose it could be suited to big cubes and people that don't enjoy M slices much. Personally, I think that CMLL/LSE is better because there are less algs, recognition is easier, and with proper training MU spam is very fast. However, if you were to train intensely with EODFDB, you could eliminate ZBLL recog altogether. It would take a ridiculous amount of time because of the intricacies of the step, but in theory it could be excellent. Just not sure the effort is worth it in the long-run considering the L10P speed of top Roux solvers.

 

[shadowslice e]

What if you solved CP while making a V, then just do an alg to solve everything else?

Or you could just make a v then use an algs to solve everything else

 

[1001010101001]

Or you could just make a v then use an algs to solve everything else

Bad recognition

 

[shadowslice e]

Bad recognition

No worse than CP. Plus that's why you predict. I find it comparable to ZBLL recog. Probably easier.