The New Method / Substep / Concept Idea Thread

[Hazel]

M-CELL describes the set of methods which leave an edge (and a corner) out of the F2L when solving then solve them either during LL or just before to give easier cases. There's a whole set of variants with lots of different things in them.

This is one variant for petrus;
1) 2x2x3
2) form one pair+insert(+orient?)
3) 2nd pair
Then the edge would be inserted (and permuted perhaps) then whatever's left is solved with an alg (such as ZBLL).

It can also produce extremely low movecount solves.

Ah, okay. Every method I come up with is either bad or already made, I gotta come up with something more original

 

[Neuro]

Ah, okay. Every method I come up with is either bad or already made, I gotta come up with something more original

Even if you weren't the first person to make it, if you like it enough than progress the method into something great. To make progress, sometimes we need to revisit old ideas.

 

[Thermex]

WaterRoux, LMCF, LLOB with ZBLL, and ZZ with ZBLL all have movecounts that low.

I am positive this method has been proposed before or at least some variation of it.

I do think it has potential, just fact check before you post. You can force this to solve in HK as well, would have less algs. It can be quite flexible if used correctly

I said the most efficient I'd SEEN, not the most efficient ever There are probably plenty of methods dotted around this site with 42-43ish movecounts.

Is there a document about BOPE or somewhere to read / learn, cause it's getting confusing to scroll through the last few pages of this thread.

@sqAree because I proposed BOPE only about two days ago there are no current wiki pages or threads, most algorithms aren't even generated yet. But I think your right that it is confusing to flip through these posts, as this is a thread for ALL ideas not just BOPE. I'll probably start a thread for it soon so everybody can check out the method and I'll post any new developments/example solves there. Otherwise I won't create a wiki page until all the algs are actually done.

 

[TDM]

Maybe we can get together and make a CP Roux variation that has some potential?

Hmm, are we going to be able to make much more progress with CP variants? I feel like we're starting to exhaust the possibilities...

What may have some amount of potential is L5C or TCMLL (basically what you proposed). It's also quite easy to break into 2GLL. Other than that, maybe so COLE (Corner Orientation Lase Edge), EODFDB, and TTLL. Throwing ideas around, maybe something will stick 

Hmm, I don't think finishing with LL is necessarily a good idea. It's usually far less efficient. I'd imagine the "ideal" method would involve the least amount of solving pieces and then unsolving them while trying to solve something else.

 

[Thermex]

Just sort of a random question, but how many algs is "twisty" TTLL? If it's 50 algs I have some ideas of maybe how to implement it into some CFOP 2-look LL+LS methods.

 

[Neuro]

Depends on how the twist is done. If it's just the LS corner and the DFR corner it should be relatively low. If you include anything more, it will have a very very high algcount

 

[Hazel]

Depends on how the twist is done. If it's just the LS corner and the DFR corner it should be relatively low. If you include anything more, it will have a very very high algcount

What about Twisty NLL on HD for 2x2? That way you could just skip LOLS on every solve.

Also, I have an idea for maybe an M-CELL Petrus variant using MLS (a subset I had in a previously proposed method) where you insert the LS while orienting all LL corners without regard to LL EO, then solve DF while solving EO as usual so you just have PLL rather than ZBLL.

 

[Neuro]

There are already 36 NLL's and allowing any orientation of the L5C you have 24 possibilities. 864 algorithms. So unless you really REALLY like 2x2, this is impractical unless you reduce the number of NLL sets you can have and/or the L5C orientations.

 

[Thermex]

@Aerma that 3×3 method is probably better than the last one you proposed, it has a similar movecount without the requirement of knowing ZBLL. You should gen some algs for it.

@Neuro by Twisty TTLL I meant DFR corner and one last layer corner twisted.

 

[Neuro]

@Aerma that 3×3 method is probably better than the last one you proposed, it has a similar movecount without the requirement of knowing ZBLL. You should gen some algs for it.

@Neuro by Twisty TTLL I meant DFR corner and one last layer corner twisted.

Oh ok thanks for clarifying! There's 72 TTLL's, x8 for possible # of 1 corner cases and you get 576 new algs. So I probably wouldn't reccomend it, sorry

 

[Thermex]

@Neuro aw darn. sounds like T3LL (as I was thinking of calling it) isn't such a great idea. Okay, so I started up a thread for BOPE, anyone who wants to check it out can use this link: https://www.speedsolving.com/forum/threads/bope-higgs.65984/.
In this thread I'll answer questions about BOPE, post progress, ask for help on some things, etc. I'm actually leaving to go camping from Fri-Sun, so Neuro, Spencer131 and Crafto22 can answer questions and monitor that thread when I'm gone.

 

[Hazel]

@Aerma that 3×3 method is probably better than the last one you proposed, it has a similar movecount without the requirement of knowing ZBLL. You should gen some algs for it.

Cool, and good idea! I'm creating a spreadsheet with MLS cases/algs now.

 

[efattah]

First example of the 'improved ergonomics and reduced rotation' LMCF:

Scramble: F2 U2 R' U2 F2 L F2 D2 L2 D2 R' F' D B' D' U' B' L R U2 B

z y // inspection
L U2 L' S' // green face on D
U R U' R2 U' F U' R2 U2 R // Solve corners EG1 L case
D f R U M' U' R' B' // Z-transform E2L pair with no regrips
x' U2 R' U M' U' R U2 // E2L pair
M2 L2 U l2 U' M' U l' L' U' // Waterman Set 2
M' U2 M' U2 M // Permute Midges
// 44 STM and only 1 rotation

I have also been working on expanding the E2L triplets set and this is working out quite well. On many solves the flow is now
1. Corners
2. First triplet
3. Second triplet
4. L6E

The triplet algorithms are 5-10 moves and all are sub-1 second executions with no regrips.

Furthermore the E2L triplet algorithms have tyrannical caterpillar style F/F' injections that can turn them into quadruplet algorithms in some cases, allowing you to solve 4 edges per 'pair'. The ideal solve would be an extremely easy corners case (0.90 seconds), followed by having 2 R/L edges pre-solved by luck which happens quite often; then doing a single E2L quadruplet (1.2 seconds), followed by a relatively quick L6E case (1.1 seconds).

 

[Hazel]

I also just came up with a weird Petrus-style method that is actually not too bad:
Step 1: solve 2x2x3 block
Step 2: solve last 2 CE pairs
Step 3: Insert last First Layer edge while solving EO (14 super easy M/U algs)
Step 4: ZBLL or COLL/EPLL

Remember when I proposed this? Well, I've thought of 2 ways to make this an LL-skip method. One method would take 211 algorithms, one would take ~176 algorithms (excluding EPLL).
The first way is making use of TSLE/TTLL. You would first solve a Petrus block, then solve one F2L pair, then TSLE, then EODF, then TTLL.
The other is to make a Petrus block, solve one F2L pair, insert the last pair while solving CO and CP (27 MLS cases * 6 CP configurations = 162 algs), then solve EODF with M/U and cancel into EPLL.

Or you could just with go a simpler OLL-skip method route and solve a Petrus block, then 1 F2L pair, then the second with MLS, then EODF, then PLL.

*MLS, or Manning Last Slot, is an LSLL subset similar to Winter Variation where you orient the LL corners while solving your last slot, but it differs from WV because you don't have to preserve LL EO.

 

[Thermex]

First example of the 'improved ergonomics and reduced rotation' LMCF:

Scramble: F2 U2 R' U2 F2 L F2 D2 L2 D2 R' F' D B' D' U' B' L R U2 B

z y // inspection
L U2 L' S' // green face on D
U R U' R2 U' F U' R2 U2 R // Solve corners EG1 L case
D f R U M' U' R' B' // Z-transform E2L pair with no regrips
x' U2 R' U M' U' R U2 // E2L pair
M2 L2 U l2 U' M' U l' L' U' // Waterman Set 2
M' U2 M' U2 M // Permute Midges
// 44 STM and only 1 rotation

I have also been working on expanding the E2L triplets set and this is working out quite well. On many solves the flow is now
1. Corners
2. First triplet
3. Second triplet
4. L6E

The triplet algorithms are 5-10 moves and all are sub-1 second executions with no regrips.

Furthermore the E2L triplet algorithms have tyrannical caterpillar style F/F' injections that can turn them into quadruplet algorithms in some cases, allowing you to solve 4 edges per 'pair'. The ideal solve would be an extremely easy corners case (0.90 seconds), followed by having 2 R/L edges pre-solved by luck which happens quite often; then doing a single E2L quadruplet (1.2 seconds), followed by a relatively quick L6E case (1.1 seconds).

This sounds awesome! I feel like an expanded set of triplet algorithms not only helps the efficiency of the LMCF method but opens the doors for many other edges-last styled methods like BOPE. The one thing I've never quite been able to understand in LMCF is what edges are solves in the triplets; in other words, do you solve all the ledges in one alg and then all the redges in one alg, or is it 2 ledges and 1 redge in the first algorithm followed by 2 redges and 1 ledge in the second alg? Also the "idea solve" you have there is insane, it's a matter of time until someone really fast starts using this and gets a sub-3 single

Remember when I proposed this? Well, I've thought of 2 ways to make this an LL-skip method. One method would take 211 algorithms, one would take ~176 algorithms (excluding EPLL).
The first way is making use of TSLE/TTLL. You would first solve a Petrus block, then solve one F2L pair, then TSLE, then EODF, then TTLL.
The other is to make a Petrus block, solve one F2L pair, insert the last pair while solving CO and CP (27 MLS cases * 6 CP configurations = 162 algs), then solve EODF with M/U and cancel into EPLL.

Or you could just with go a simpler OLL-skip method route and solve a Petrus block, then 1 F2L pair, then the second with MLS, then EODF, then PLL.

*MLS, or Manning Last Slot, is an LSLL subset similar to Winter Variation where you orient the LL corners while solving your last slot, but it differs from WV because you don't have to preserve LL EO.

I like some of the ideas your coming up with, I think there's a lot of potential in Petrus-like methods like this but nothing in particular stands out to me. I think you should continue exploring 2x2x3+BR pair methods though, I see a lot of potential for sub-42 movecounts and good big cube methods there.

 

[Hazel]

Yet another Petrus M-CELL variant:
1: 2x2x3 block
2a: One F2L pair
2b: Insert second F2L pair with CPLS
2c: EODF
4: 2GLL

 

[Sue Doenim]

I had a couple of new method ideas (more long car rides).

Spoiler: SSC/WaterRoux hybrid

SSC/WaterRoux hybrid, kinda vague. ATM is used, as there are a lot of U/D moves going on.
1) Solve FL and BL; set up for SSC style OL5C with BR and either DL or DR, oriented, as the pseudopair/-triplet. ~9 moves?
2) Execute OL5E alg (edge orientation can be ignored) and put BR and DL/DR edge into R-face belt; if possible, orient unused DL/DR edge with Rw move or influence next step otherwise. ~7 moves?
3) Separate corners, choose either Rw2 or R2 moves to ensure unused DL/DR edge is on U. ~5 moves?
4) Permute corners, make sure BR is solved and DL/DR is in RF. ~7 moves?
5) Insert DL and DR with R U/U' M2 U'/U R' or similar. ADF so blocks are solved. ~6.5 moves.
6) WaterRoux L7E. ~17 moves.
~51.5 ATM projected , but I think movecounts are rather high.
Example solve: {Movecounts will be (ATM step/ATM total) [STM step/STM total]}
Scramble: B L U2 F2 L' U R2 L B' D' F2 R U2 R F2 L' D2 B2 R2 L' D2
1) x' (F2 B) (U' D) M (U' D') M' U2 (6/6) [9/9]
2) R2 U R' U' R2 (U' D2) Rw (7/13) [8/17]
3) (U D2) Rw2 (2/15) [3/20]
4) (U D) R2 U' R2 (U D) R2 D' R2 (8/23) [11/31]
5) R U M2 U' R' D' (6/29) [6/37]
6) M' U M' x M' U M U M' U M U x' M' U2 M' U' M U2 M U (19/48) [19/56]
48 ATM, 56 HTM. Maybe not that great.

Spoiler: LLOB/ WaterRoux hybrid

This one's interesting. I haven't finalized it, but it seems really promising.
1) Pseudo FB: basically, you make 2/3 of a ZBLL face. Make sure all edges are oriented and only corners from the correct layer are used. There is a lot of flexibility here: you can phase it, force certain CO's, even permute corners (rather in depth, edges must also be arranged such that there is no parity error and extra algs must be learned later on). ~4 moves.
2) Solve R-layer corners: I haven't yet decided how to do this. Maybe put L-layer corners in L-layer and do CLL on R. This would be really nice because very little has to be preseved. You could also learn extra algs to solve CP for L-layer. However, this would take 126 algs, double that with CP. Since this step is so close to inspection (~4 moves PFB and 2-3 setup) it can be easily seen in inspection. ~9 moves?\
3) ERL: solve 2 R-layer edges, like in WaterRoux. ~8 moves, right?
4) L7E: again like WaterRoux. ~17 moves.
5) ZBLL: Do a z rotation and solve the case. Since EP is recognizable from inspection and CLL case is apparent past step 2 (also done in inspection) you can practically recognize ZBLL from inspection, which is crazy. ~14 moves I think.
Projected movecount of 52. I guess that's not as good as I thought either.
Exmaple solve:
Scramble: B L U2 F2 L' U R2 L B' D' F2 R U2 R F2 L' D2 B2 R2 L' D2 (again)
1) y R F' Rw' F B' (5/5)
2) U2 R U R' F R2 F' U2 (8/13)
3) R U M' U' R U M' U2 M U (10/23)
4) I didn't realize until now that you have to make sure the edges have no parity problem when building the first block. Whoops. Well, you get the idea.

 

[Neuro]

I remember this being proposed. Sadly this method (I think) gives little-to-no advantage over regular Pinkie Pie for 2H because many of the 2-gen or pseudo 2-gen OLLCPs are relatively inefficient. In fact for regular CMLL, the 2-gen U and T cases are two of the worst ones. It may have potential for OH though, where anything pseudo 2-gen is very fast.

So, I did some testing with my variant of Roux w/ CP alongside yours, and it appears that you get very similar movecounts. While mine has less algs and easy recog, TCMLL can be entirely <RU> until inserting LE and is still pretty easy to recognize. It would be personal preference if you ask me, as both are good CP-based Roux methods. Perhaps use them in conjunction? If full SB is really easy use mine and if only block is seen (more likely) use yours? You could do PP setup+block+LE, insert the last corner while doing EO, and LSE as well. Other than that, I can't come up with much else to expand CPRoux methods

 

[Sue Doenim]

I finally got around to making algs for my idea from way back when.

OLLCP with half the algs- use phasing to make sure misoriented edges are opposite of each other.

Note that this is meant for a Roux (Pinkie Pie) solve; the first step is to place a UL/UR edge at DF/DB, meant to be done after second block, like orienting centers.

Spoiler: Algs

UL/UR in DB (mirror for in DF)

Arrow
UR/UL
M’ U/U’ M
UF
U/U’ M’ U’/U M
UB
U2 M’ U2 M
DF
M’ U/U’ M U’/U M’ U2 M

1/1
UB
M’ U/U’ M U/U’ M’ U/U’ M
UL/UR
M’ U/U’ M U/U’ M’ U’/U M
UF
M’ U2 M
DF
M’ U/U’ M U’/U M’ U2 M

Adj
DF
M’ U M U2 M’ U M +mirror
UB (mirror for UL)
U M’ U M
UF (mirror for UR)
M’ U M U2 M’ U’ M

Opp
DF
Skip
UL/UR
U’/U M’ U2 M
UF/UB
U/U’ M’ U’/U M

4-flip
DF
Skip
UB/UF/UL/UR
M’ U2 M U/U’ M’ U/U’ M

Also, I'm thinking about combining ZBLL blocks with regular Roux. I'll explain more later.
EDIT: Never mind, that's not actually that good of an idea. More algs, higher movecount. ZBLL psuedo-blocks are a cool idea, but I cant find a super good way to use them. Some other ideas I've had: During Roux SB, ZZ left block, BOTH blocks (really not a good idea), WaterRoux "second block". Mostly, in my attempts, I've tried to force 2GLL blocks, but that's really too hard and takes away the minimalistic movecount bonus. I'll experiment a bit more with them.

 

[TDM]

So, I did some testing with my variant of Roux w/ CP alongside yours, and it appears that you get very similar movecounts. While mine has less algs and easy recog, TCMLL can be entirely <RU> until inserting LE and is still pretty easy to recognize. It would be personal preference if you ask me, as both are good CP-based Roux methods. Perhaps use them in conjunction? If full SB is really easy use mine and if only block is seen (more likely) use yours? You could do PP setup+block+LE, insert the last corner while doing EO, and LSE as well. Other than that, I can't come up with much else to expand CPRoux methods

Hmm, they're very different methods, which could make neutrality difficult: if the difference is so small, the times saved changing methods may be less than the time taken deciding to change methods!

Also my method doesn't use TCMLL so I don't know where you got that from