The New Method / Substep / Concept Idea Thread

[Arc]

@zz_ proposed his c2gr method in this thread: https://www.speedsolving.com/forum/threads/complex-2-move-generator-reduction-method-c2gr.66089/
c2gr:
1. Permute all corners (CP) and make 3x1x1 block (base line) on DL (whole step predicted in pre-inspection)
2. Expand to 3x2x2 block and orient all edges (EO) meanwhile (whole step using <U,u,R,r> moves)
3. Expand to 3x3x2 block (F2L) using <U,R> moves
4. Complete LL (2GLL) using <U,R> moves

but I found that step 2 is too difficult, so I thought why not do step 1 like in the c2gr method (CPLine) then expand the line to a 3x2x1 block on the left while only using <U,u,R,r> moves, then finish with Roux. Except you don't need to do CMLL but can instead use Bruno, Sune, Antisune to twist the corners ( = Petrus step 6).

This is standard CPRoux with beginner CPFB. The problem here is that the 2gen CMLLs are not necessarily always better than the other CMLLs. Even if they were, and even if you could do full CPFB consistently in 10 moves, it would probably not be better than normal Roux. The only way I can think of to make it worth it is by doing heavy EO influence with multiple CMLL sets, in a style similar to BLS but after LS. Even then I'm not sure if it's worth the inspection drain. As far as C2GR goes, check out @Teoidus' 2GR method. It's a bit more structured and does EO before CPLine. Also check out @shadowslice e's Briggs method. It is very similar to C2GR but instead starts with CPFB.

 

[Neuro]

@zz_ proposed his c2gr method in this thread: https://www.speedsolving.com/forum/threads/complex-2-move-generator-reduction-method-c2gr.66089/
c2gr:
1. Permute all corners (CP) and make 3x1x1 block (base line) on DL (whole step predicted in pre-inspection)
2. Expand to 3x2x2 block and orient all edges (EO) meanwhile (whole step using <U,u,R,r> moves)
3. Expand to 3x3x2 block (F2L) using <U,R> moves
4. Complete LL (2GLL) using <U,R> moves

but I found that step 2 is too difficult, so I thought why not do step 1 like in the c2gr method (CPLine) then expand the line to a 3x2x1 block on the left while only using <U,u,R,r> moves, then finish with Roux. Except you don't need to do CMLL but can instead use Bruno, Sune, Antisune to twist the corners ( = Petrus step 6).

Going off of @Arc, 2GR is a really good method if you can get inspection down fast enough, although I will say that Briggs v1 is probably a bit easier. One method I created a while back that you may be interested in is 2GRoux, here are the steps:

1:CPFB- Broken into *3* steps
a. Pair- find the corner you wish to have at DBL in it's proper orientation and use <UuRrFf> and slice moves to solve DL in relation to the corner
b. CP Line- using <URF> and wide variants, solve DFL while solving CP. This and pair can generally be 1-looked, so I prefer to look at pair and CP line as just one step.
c. Block- using <UuRr> and slice moves, solve the remainder of FB
2:SB+PP- Solve second block while putting the ULUR or UFUB edges oriented on the bottom (Pinkie Pie setup)
3:OLL- Just pseudo-2G OLL
4:LSE- Same as Roux, but much more efficient than normal.

 

[Abram Lookadoo]

new method (BOFL)
1) build a 2x2x3 block in DB
2) solve eo+DF
3) solve the last two f2l pairs+ep
4)L4C (1/84)

 

[Arc]

Going off of @Arc, 2GR is a really good method if you can get inspection down fast enough, although I will say that Briggs v1 is probably a bit easier. One method I created a while back that you may be interested in is 2GRoux, here are the steps:

1:CPFB- Broken into *3* steps
a. Pair- find the corner you wish to have at DBL in it's proper orientation and use <UuRrFf> and slice moves to solve DL in relation to the corner
b. CP Line- using <URF> and wide variants, solve DFL while solving CP. This and pair can generally be 1-looked, so I prefer to look at pair and CP line as just one step.
c. Block- using <UuRr> and slice moves, solve the remainder of FB
2:SB+PP- Solve second block while putting the ULUR or UFUB edges oriented on the bottom (Pinkie Pie setup)
3:OLL- Just pseudo-2G OLL
4:LSE- Same as Roux, but much more efficient than normal.

I actually kind of like this idea except for the bad CPFB. It's perfectly possible to do CPFB straight out. As a normal FB but correcting CP while attaching the last pair. Just takes a bit to wrap your head around it.

HARCS cannot do it directly because custom states are still broken in analyze (@mDiPalma pls). But we can get close.

Optimal numbers:
CFPB: 7.5
SB: 10
Insert DFDB (<=> Insert ULUR): 4.5
2gen OLL: 13
ULUR: 2.5
L4E: 5

Total: 42.5 STM


More realistic human numbers:
CPFB: 10
SB: 15
Insert ULUR: 5
2gen OLL: 13
ULUR: 2.5
L4E: 5

Total: 50.5 STM


Not bad for move count. Ergonomics seem pretty good. I think this is one of the better recent proposals but still loses out to Roux, 2GRoux (EOStripe -> 2GLL), and ZBRoux.

 

[Sue Doenim]

new method (BOFL)
1) build a 2x2x3 block in DB
2) solve eo+DF
3) using trigger style solve the last two f2l pairs+ep
4)L4C (1/84)

What exactly is trigger style? I'm not sure I understand. Otherwise, I think this is basically phasing on steroids, generally not great; I don't think L4C is supposed to be that good.

 

[Neuro]

I actually kind of like this idea except for the bad CPFB. It's perfectly possible to do CPFB straight out. As a normal FB but correcting CP while attaching the last pair. Just takes a bit to wrap your head around it.
<deleted stats>
Not bad for move count. Ergonomics seem pretty good. I think this is one of the better recent proposals but still loses out to Roux, Briggs v1 (EOStripe -> 2GLL), and ZBRoux.

That's a big reason why I don't use or push the method much anymore unless it's to prompt discussion as in this instance. If I were to use a CP based method I'd either use this or Briggs v1, but for the time being I think I'm gonna stick with Roux (although I've been enjoying CFOP quite a bit recently, maybe method neutrality?)

Oh and I am gonna be working on a new OLL subset if anyone wants to help out. One of the worst cases in F2L is when both pieces are solved, but the edge is flipped in place. Why not take this as an opportunity to go directly into OLL? Instead of having to manipulate your F2L when it pops up, just preserve it and make your F2L more efficient in the process. Recognition would be really straightforward as in regular OLL and it wouldn't be many algs (I think it's 56/58 but idk for certain)

Example solve: F' U L B' D' B2 R' U2 R' U2 R2 U' B2 D2 R2 F2 D F2 U B2

z2 U' R2 U' F' U' L D//X-Cross (7/7)
U2 R' U2 R F U' F' U' L U L' U2 R' U2 R2 B' R' B y2//F2L (18/25)
F' U2 F2 R' F r U r' F R2 U R'//FE-OLL (12/37)
R2 F R U R U' R' F' R U2 R' U2 R//PLL (13/50)

 

[efattah]

Oh and I am gonna be working on a new OLL subset if anyone wants to help out. One of the worst cases in F2L is when both pieces are solved, but the edge is flipped in place. Why not take this as an opportunity to go directly into OLL?

\

This is the first good idea I have seen on here in a while. This reminds me of TCLL. You could in some cases actually deliberately solve the last F2L pair with an inverted edge then use 'twisty OLL' instead. This essentially makes the final pair quite significantly faster as you choose the fastest F2L case based on the situation (either true F2L solve or a twisty F2L solve).

 

[Neuro]

\

This is the first good idea I have seen on here in a while. This reminds me of TCLL. You could in some cases actually deliberately solve the last F2L pair with an inverted edge then use 'twisty OLL' instead. This essentially makes the final pair quite significantly faster as you choose the fastest F2L case based on the situation (either true F2L solve or a twisty F2L solve).

Thanks for the support! After doing a few solves with this, I realized how much this helps in inspection and F2L efficiency. X Crosses are made much easier as you can now build them off of flipped-edge 2x2x1 pairs (which aren't super rare actually) and not to mention that these types of pairs can show up mid-F2L and then be inserted at any point as well as make LS more efficient at some points. I'm really starting to like this idea!

Maybe this can be Garza Last Slot

More solves:

R U R2 B U' L' U' R2 F' D2 x//Fake X-Cross (10/10)
B U S' L2 b' U' R U R' U R U' R2 U' R y2//F2L (15/25)
U F' U2 F2 R' F r U r' F R2 U R'//FE-OLL (13/38)
U M2 U' M U2 M' U' M2 U//EPLL (9/47)

R2 F' D' F R2 B R' F' U2 B U' S' L' b' z y//XX-Cross (14/14)
F' U' F L' U L R U' R' U' R U R' y//F2L (13/27)
F U' M' U F' r U M U' r'//FE-OLL (10/37)
U2 R' U2 R U2 R' F R U R' U' R' F' R2 U2//PLL (15/52)

D' R2 D B' R' f2 R U R' F2//X-Cross (10/10)
U S' L2 S U2 F U F' R U' R' y//F2L (11/21)
U' R2 B' R' U F U' B2 U F' B' R'//FE-OLL (12/33)
R' U' F' R U R' U' R' F R2 U' R' U' R U R' U R//PLL (18/51)

L' B2 L F2 D' F L D'//X-Cross (8/8)
U' L U' L F' L2 F B U2 S' L b' y U2 R U' R' F R' F' R//F2L (20/28)
U R2 U R2 B' R S R F D2 R' D2 z'//FE-OLL (12/40)
M2 U M U2 M' U M2//PLL (7/47)

Avg of these+last example solve: (50+47+52+51+47)/5 = 49.4 STM. Not truly representative of speedsolves but hey this is really good for CFOP

 

[efattah]

Thanks for the support! After doing a few solves with this, I realized how much this helps in inspection and F2L efficiency. X Crosses are made much easier as you can now build them off of flipped-edge 2x2x1 pairs (which aren't super rare actually) and not to mention that these types of pairs can show up mid-F2L and then be inserted at any point as well as make LS more efficient at some points. I'm really starting to like this idea!

Thinking more about this it is turning out to be an incredible idea for several astonishing reasons:
1. Normal OLL has either 0, 2 or 4 disoriented edges. The dreaded 'dot' cases include all four edges disoriented, for normal OLL.
2. For Twisty OLL (TOLL), there will be either 1 or 3 disoriented edges on the U layer. This means that twisty OLL actually has significantly fewer cases, approximately 2/3 x 57 = 38. This means that solving a single F2L slot as a twisty pair (on every solve) would actually result in a 'beginner' 2-look LL that has fewer algorithms than standard CFOP and avoids dot cases automatically.
3. Astonishingly, every single TOLL case would look unique and different from classic OLL cases based on the non-identical number of oriented/disoriented edges (1 or 3 vs 2 or 4). This means that if you get into the habit of putting the twisty F2L slot at FR, then you don't even need to remember if you are doing OLL or TOLL, just look at the pattern on the last layer and use one of the 57+38 = 95 algorithms for OLL. The uniqueness means there is no confusion about having 2 algorithms for the same OLL pattern; each pattern has a unique algorithm.
4. During F2L there is a reasonable chance of finding a so-called 'ready made pair' that is now actually a twisty pair. So the odds of a ready-made pair double, although you can only use this advantage once per solve; however, ready made pairs will typically only happen 0 or 1 times per solve anyway.

The only thing remaining is to see how good the algorithms are. Some might even be better than classic OLL. One challenge here is the years of co-operative effort to find effective OLL algorithms, and quite a significant amount of work would be needed to generate a truly optimized set of (approximately) 38 TOLL algorithms. One variable in this development is which is the ideal slot to hold the twisty pair? FR? FL? BR?

I don't think this deserves a 'last slot' acronym. It is not a last slot method, it can be used for any slot including the X-Cross making it far more powerful than any last slot method.

For very advanced solvers, there is another astonishing effect. VLS doesn't work for dot cases; but using a twisty F2L pair, there are no dot cases. Twisty VLS would work all the time, no edge control needed; and Twisty VLS would only have 2/3 the number of cases vs. regulator VLS (2/3 x 216 = 144).

 

[Micki]

Oh and I am gonna be working on a new OLL subset if anyone wants to help out. One of the worst cases in F2L is when both pieces are solved, but the edge is flipped in place. Why not take this as an opportunity to go directly into OLL? Instead of having to manipulate your F2L when it pops up, just preserve it and make your F2L more efficient in the process. Recognition would be really straightforward as in regular OLL and it wouldn't be many algs (I think it's 56/58 but idk for certain)

This has already been done 2 times and is called FLS or OLS-FE. I learned all of the algs once and I only think it would be useful if you learned different algs depending on what slot it is in

 

[Neuro]

Thinking more about this it is turning out to be an incredible idea for several astonishing reasons:
1. Normal OLL has either 0, 2 or 4 disoriented edges. The dreaded 'dot' cases include all four edges disoriented, for normal OLL.
2. For Twisty OLL (TOLL), there will be either 1 or 3 disoriented edges on the U layer. This means that twisty OLL actually has significantly fewer cases, approximately 2/3 x 57 = 38. This means that solving a single F2L slot as a twisty pair (on every solve) would actually result in a 'beginner' 2-look LL that has fewer algorithms than standard CFOP and avoids dot cases automatically.
3. Astonishingly, every single TOLL case would look unique and different from classic OLL cases based on the non-identical number of oriented/disoriented edges (1 or 3 vs 2 or 4). This means that if you get into the habit of putting the twisty F2L slot at FR, then you don't even need to remember if you are doing OLL or TOLL, just look at the pattern on the last layer and use one of the 57+38 = 95 algorithms for OLL. The uniqueness means there is no confusion about having 2 algorithms for the same OLL pattern; each pattern has a unique algorithm.
4. During F2L there is a reasonable chance of finding a so-called 'ready made pair' that is now actually a twisty pair. So the odds of a ready-made pair double, although you can only use this advantage once per solve; however, ready made pairs will typically only happen 0 or 1 times per solve anyway.

The only thing remaining is to see how good the algorithms are. Some might even be better than classic OLL. One challenge here is the years of co-operative effort to find effective OLL algorithms, and quite a significant amount of work would be needed to generate a truly optimized set of (approximately) 38 TOLL algorithms. One variable in this development is which is the ideal slot to hold the twisty pair? FR? FL? BR?

I don't think this deserves a 'last slot' acronym. It is not a last slot method, it can be used for any slot including the X-Cross making it far more powerful than any last slot method.

For very advanced solvers, there is another astonishing effect. VLS doesn't work for dot cases; but using a twisty F2L pair, there are no dot cases. Twisty VLS would work all the time, no edge control needed; and Twisty VLS would only have 2/3 the number of cases vs. regulator VLS (2/3 x 216 = 144).

WHile I knew a majority of this, the alg count sounds amazing! idk the best place to keep the twisted-pair, but the algs I am making right now keep it in FR. THinking about it, I agree with your statement on it not being an LS method.

Twisty VLS actually sounds very intriguing, I may create those algs as well; especially considering the case count and flexibility when paired with normal VLS.

This has already been done 2 times and is called FLS or OLS-FE. I learned all of the algs once and I only think it would be useful if you learned different algs depending on what slot it is in

Ugh, I wasn't aware of this!! I think that I'll continue to research it but I'll be sure to credit the creator from now on. Thanks for letting me know!

What if we created an OLL skip set for F2L where it's a sledgehammer insert?

 

[Tao Yu]

What if we created an OLL skip set for F2L where it's a sledgehammer insert?

That's just a subset of VLS. The algs can be found here: http://rowe.cubing.net/rls/uf.php. I think insert+ZBLL is better for many of the cases (especially when from the back slots), but it's still quite useful.

 

[Hazel]

New method idea:
1) LEOLine - solve EOline on left
1.5) Finish the Roux block on left keyhole style
2) 2x2x1 block in RB while setting up the last F2L pair
2.5) Winter Variation
5) Solve DB while permuting corners
4) L5E

 

[Neuro]

That's just a subset of VLS. The algs can be found here: http://rowe.cubing.net/rls/uf.php. I think insert+ZBLL is better for many of the cases (especially when from the back slots), but it's still quite useful.

I'm sorry I used the wrong term, I'm thinking of F R' F' R. Looking at it again, you can just rotate and do mirrored VLS so it's getting scrapped anyway

 

[Thermex]

WHile I knew a majority of this, the alg count sounds amazing! idk the best place to keep the twisted-pair, but the algs I am making right now keep it in FR. THinking about it, I agree with your statement on it not being an LS method.

Twisty VLS actually sounds very intriguing, I may create those algs as well; especially considering the case count and flexibility when paired with normal VLS.

Ugh, I wasn't aware of this!! I think that I'll continue to research it but I'll be sure to credit the creator from now on. Thanks for letting me know!

What if we created an OLL skip set for F2L where it's a sledgehammer insert?

Since these algs have already been made, I have a pretty decent idea to push it further, especially if you want to study this idea more. I proposed this a while back, it's called "fish" (this was the metnod that inspired @JTay's ribbon method). The steps go as follows:

1. The "fish" (cross+1 corner, ~8 moves)
2. Solve the remaining three pairs (18 moves)
3. FE-OLL (apparently only 96 algs, ~10 moves since you don't need to perserve FR)
4. HWLL (this was the step that was first used in ZZ-CT, formerly known as ZZ-HW. There are 72 cases (so I've heard) and they're about 14 moves on average).

This is very good variant of ribbon with far fewer algs, the main problem is that I've heard HWLL algs aren't so great. Message me if you're interested.

Also Twsity VLS sounds like a nice idea, I never realized how few algs it was. Imo the best way it coule be utilized would be TVLS+TTLL, that would make for a pretty nice 2 look LS.

 

[efattah]

I found the existing FLS algorithms:
https://drive.google.com/file/d/0BwMVT4oFDQbINExyRnBhaVVCM00/view
It appears there are 54 cases.
And Antonie Paterakis video:

This was only pasted May 9th, so it seem pretty new. Not sure if it was ever done long ago.

For twisty VLS, I think the key is to allow one of the first three slots as flipped. The final VLS pair would be a normal pair; this would be so you could still do flipped X-cross and use up free flipped pairs earlier in the solve.

 

[Neuro]

For twisty VLS, I think the key is to allow one of the first three slots as flipped. The final VLS pair would be a normal pair; this would be so you could still do flipped X-cross and use up free flipped pairs earlier in the solve.

The problem I see with this would be lack of flexibility in which LS slot you must set up. What I mean by this is that you'd need to generate 3 different sets; accommodating for flip in FL, BL, or BR, or having to build F2L in a certain way so that your flipped F2L pair is always in 1 of the 3 remaining spots. Perhaps just have the edge in the last F2L pair be flipped instead? It would make building the pair easier. Not to mention it still works with regular FE OLL and you can preserve the flipped 2x2x1 pairs while solving.

 

[Sue Doenim]

I found the existing FLS algorithms:
https://drive.google.com/file/d/0BwMVT4oFDQbINExyRnBhaVVCM00/view
It appears there are 54 cases.
And Antonie Paterakis video:

This was only pasted May 9th, so it seem pretty new. Not sure if it was ever done long ago.

For twisty VLS, I think the key is to allow one of the first three slots as flipped. The final VLS pair would be a normal pair; this would be so you could still do flipped X-cross and use up free flipped pairs earlier in the solve.

There was talk about this some back in page 191.

 

[TheDopeCantaloupe]

So I main with ZZ and the FLS idea gave me another idea. A lot of times when solving f2l/blocks you'll have a corner paired with the wrong edge, but since the wrong edge is already oriented it has to be the edge diagonal from its solved position. If you solved that slot with its opposite edge then completed COLL normally then you'd be left with EPLL + opposite edges, which probably wouldn't be too many algs since EPLL is only 4 algs. Idk how to calculate the number of algs needed or anything but this subset would double the already high chances of having a premaid pair which would make F2L even faster/more efficient. This should also work in Petrus or anything that uses COLL.

 

[Abram Lookadoo]

new method (BFLP)
1) block face
create 2 F2l pairs next to each other,
and place three edge pieces on the bottom (where you would place to form a 2x2x3 block) oriented correctly
along with the 2 centers that will go at the ends of the block. (build in DB)
2) F2L
place an edge piece at DF oriented correctly, then
place 2 correct F2l pairs in the correct slot
3) pSMollcp (1/331) algs
you orientate and permutate the top layer corners and orient the top layers edges without nessisarily keeping the permutation or seperation of the top and botom layers edge pieces.
4) pl8e
permutate the last 8 edges using <M,E,U,D>

example solve - this method is complex so i made an example solve
scramble: U' F2 B' U R' F2 L2 R' B F' U2 F D' B' R' B2 L2 F2 B2 U2 R' F' B' L' D2
1) z2 F' u2 L F' L' F' y' M U M'
2) F' U' R U R' U R U R' L' U2 L U' L' U2 L U2 L' U L
3) U R U' R' F' U' F U2 R U R' U' R U R' - not optimal
4) U2 M U2 M D' U' M' U2 M' U M2 u M' U2 M2 U2 M'