The New Method / Substep / Concept Idea Thread

[shadowslice e]

Orders of magnitudes, though. efattah's idea has an alg count "only" in the thousands, whereas you're thinking of something in the tens of millions. (Learning thousands of algs sounds ridiculous now, but just a decade ago people said the same thing about full ZBLL and look at where we are today.)

At the same time though, I could quite easily achieve the same sub-35 move count with "only" a few hundred algorithms using a modified version of 42 or even Roux FMC so long as I use comms for L7E or LSE. In fact, if we extend to the algorithms efattah proposes for L7E (which could easily be <1000) it could quite easily be sub-30 moves.

 

[Neuro]

Hey so I came up with a second version of ZZ-Tripod. It has the same amount of algs, but it *should* have higher efficiency and reliability overall.

.5: Build to F2L-1C while making a 1x1x2 block on top
1: Use 1 alg to solve LC and last U layer edge to form the 1x2x2 block. Still 35 algs and has good recog
2: TELL (Tripod EO Last Layer) to solve. 50 algs just as before

So it's still 85 algs, but I feel this is more viable for speedsolving, as building a single pair +LE is easier than a 1x2x2 block and is quite efficient. LS recog is still very easy, as you just see where the LC and edge are in 1 look. And of course TELL is still a good algset with easy recog. So, let me know if you think it's worth it!

 

[Raumaan Kidwai]

Tripod variant: Tripod+

1) Form F2L-1 however you like
2) EOSquare

In either order:
2a) Solve a square in U
2b) Solve EO

3) Form the final F2L pair and insert while phasing (intuitive but very hard)
4) L3C

Total: 0 algs, but step 3 is insanely difficult without at least a few algs for inserting pairs while phasing.

Tripod++ is a slight variant that uses a set of 24 algs to pair and insert the pair while phasing LL edges (dubbed T+LS or Tripod+ Last Layer), and a 2 look last layer approach which uses 8 easy OCLLs (collectively dubbed TOLL or Tripod OLL) to reduce to an A perm or solved state.

T+LS is used by using R U' R' U to move the edge that should go in FR to UR, and performing an alg from there. The set is split up into 2 sets, T+LS 0 and T+LS 1. T+LS 0 is for when there is no LL edge currently solved, and T+LS 1 is for when there is. Each of the two has 12 algs for each position of the final D sticker.

Total: T+LS (24) + TOLL (8) + reduced CPLL (2) = 34 algs

This is definitely NOT a good method on its own, but can be useful for when you already have a square/3 move square/3 move EOSquare, which are common situations.

This was typed on mobile so please excuse the lack of formatting.

 

[Abram Lookadoo]

new method (bcpe)

1) crate a 1x1x3 cp block
build a 1x1x3 block and solve relative cp (no eo)
2) build an opposite 1x1x2 pair
build a 1x1x2 pair (lengthwise side opposite color to a lengthwise color on the 1x1x3 block) placed parallel and opposite to the 1x1x3 block of the opposite color
3) L5c
solve the remaining 5 corners using an algorithm (1/105 algs)
4) eP (edge pairs)
place an edge from left side and right side oriented in DB DF, turn L and R to match the edges, preform a U M2 U' or U' M2 U to place the 2 edges correctly (do this twice)
5) L6e
solve the left and right sides and solve eo, then permute the M slice

 

[Sue Doenim]

new method (bcpe)

1) crate a 1x1x3 cp block
build a 1x1x3 block and solve relative cp (no eo)
2) build an opposite 1x1x2 pair
build a 1x1x2 pair (lengthwise side opposite color to a lengthwise color on the 1x1x3 block) placed parallel and opposite to the 1x1x3 block of the opposite color
3) L5c
solve the remaining 5 corners using an algorithm (1/105 algs)
4) eP (edge pairs)
place an edge from left side and right side oriented in DB DF, turn L and R to match the edges, preform a U M2 U' or U' M2 U to place the 2 edges correctly (do this twice)
5) L6e
solve the left and right sides and solve eo, then permute the M slice

This kinda looks like LMCF, honestly. Also a bit like WaterRoux. Solve certain blocks, finish corners, LXE. That's a method template I'll want to look into more.

 

[Raumaan Kidwai]

new method (bcpe)

1) crate a 1x1x3 cp block
build a 1x1x3 block and solve relative cp (no eo)
2) build an opposite 1x1x2 pair
build a 1x1x2 pair (lengthwise side opposite color to a lengthwise color on the 1x1x3 block) placed parallel and opposite to the 1x1x3 block of the opposite color
3) L5c
solve the remaining 5 corners using an algorithm (1/105 algs)
4) eP (edge pairs)
place an edge from left side and right side oriented in DB DF, turn L and R to match the edges, preform a U M2 U' or U' M2 U to place the 2 edges correctly (do this twice)
5) L6e
solve the left and right sides and solve eo, then permute the M slice

This is extremely similar to Roux for Drew, a method I'm working on to compliment <MUD> (a parody of the terrible methods in this thread).

 

[Teoidus]

new method (bcpe)

1) crate a 1x1x3 cp block
build a 1x1x3 block and solve relative cp (no eo)
2) build an opposite 1x1x2 pair
build a 1x1x2 pair (lengthwise side opposite color to a lengthwise color on the 1x1x3 block) placed parallel and opposite to the 1x1x3 block of the opposite color
3) L5c
solve the remaining 5 corners using an algorithm (1/105 algs)
4) eP (edge pairs)
place an edge from left side and right side oriented in DB DF, turn L and R to match the edges, preform a U M2 U' or U' M2 U to place the 2 edges correctly (do this twice)
5) L6e
solve the left and right sides and solve eo, then permute the M slice

Can you please write posts with proper spelling, punctuation, and capitalization? Some of your ideas seem decent, but to be honest I rarely am willing to read them because of how horribly they're formatted.

 

[Thermex]

Hey everyone, apologies for being gone so long. I try to keep up with this thread but sometimes my schoolwork catches up with me.

I've had about 5-6 ideas jogging around in my head I've been working on lately, but recently something happened to my laptop and it deleted ALL of my files, including my cubing ones. All the hours I poured in to working on BOPE, L7E stuff, Twisty EG and a couple of other secret methods I've been working on were deleted So yeah at this point anyone who wants to collaborate with me on any of these can just PM me, hopefully I can get at least one of them done by Christmas :/

This kinda looks like LMCF, honestly. Also a bit like WaterRoux. Solve certain blocks, finish corners, LXE. That's a method template I'll want to look into more.

I've also been looking into this a lot, I've found a lot of efficient methods use this template (WaterRoux, Bope, Roux, and 42). A lot of the projects I was working on were L6E, L7E, L8E, and L9E (WaterRoux) related systems that work as finishes for the above methods.

 

[Teoidus]

I'm sorry about your laptop--have you tried recovering the data? If you haven't touched the disk at all since you discovered this, a partial recovery could be possible (deleted files don't actually truly vanish until they are overwritten on disk, "deleting" a file just marks that part of the disk as overwriteable for your operating system).

As a side note, this is partially why I store my methods on something cloud-related

 

[Thermex]

I'm sorry about your laptop--have you tried recovering the data? If you haven't touched the disk at all since you discovered this, a partial recovery could be possible (deleted files don't actually truly vanish until they are overwritten on disk, "deleting" a file just marks that part of the disk as overwriteable for your operating system).

As a side note, this is partially why I store my methods on something cloud-related

My computer completely shut down and wouldn't turn on without some weird error messages- so I wiped the disk completely clean. There was really no other option :/ Next time I'll try save my files to a thumbdrive or something.

I actually just noticed that I uploaded my first Twisty EG file to some random thread, so I should be able to recover that, but everything else is toast.

 

[Thom S.]

So this is a Square - 1 Method(Currently only Concept) which is quite Lookahead friendly and efficient but at the cost of Algorithms

Cubeshape: Nothing too special there, usually takes 4-6 Slices
Corner Orientation: easy lookahead from Cubeshape and to the next step, takes 1-3 Slices
EO + CP Bottom Layer: This can be done almost without pauses as Vandenbergh solvers recognise EO and CP at the same time, estimating no more than 8 Slices
PLL + EPFL: not nessesary the best Set as it has 387 Algorithms but recognition is quite nice and with CSP after PLL recognition you have 2-Sided for the bottom, as there is Parity my estimate is 13-15 Slices at most

 

[Thermex]

So this is a Square - 1 Method(Currently only Concept) which is quite Lookahead friendly and efficient but at the cost of Algorithms

Cubeshape: Nothing too special there, usually takes 4-6 Slices
Corner Orientation: easy lookahead from Cubeshape and to the next step, takes 1-3 Slices
EO + CP Bottom Layer: This can be done almost without pauses as Vandenbergh solvers recognise EO and CP at the same time, estimating no more than 8 Slices
PLL + EPFL: not nessesary the best Set as it has 387 Algorithms but recognition is quite nice and with CSP after PLL recognition you have 2-Sided for the bottom, as there is Parity my estimate is 13-15 Slices at most

Not a terrible idea, but I don't feel like saving 3-4 slices per solve is worth an extra ~350 algs.

A long time ago I proposed a squan method that I'm coming back around to and sorta starting to like:

1) CSP
2) Seperate the pieces on the U and D layers so you have at least 3 correct corners and edges on each layer (ultra quick, ~3 slices)
3) Finish corners (this is essentially NLL on squan, 36 algs that are probably ~4 slices each)
4) Finish edges (a TON of algs, probably like 6 slices per alg, idk. I'd have to figure out how recog works for this step)

I would try to experiment more with this and provide example solves or something, but I know barely anything on square-1. Maybe someone a little more experienced could help me with this (I also don't have any software that could generate algs for the last 2 steps).

 

[Thom S.]

Not a terrible idea, but I don't feel like saving 3-4 slices per solve is worth an extra ~350 algs.

A long time ago I proposed a squan method that I'm coming back around to and sorta starting to like:

1) CSP
2) Seperate the pieces on the U and D layers so you have at least 3 correct corners and edges on each layer (ultra quick, ~3 slices)
3) Finish corners (this is essentially NLL on squan, 36 algs that are probably ~4 slices each)
4) Finish edges (a TON of algs, probably like 6 slices per alg, idk. I'd have to figure out how recog works for this step)

I would try to experiment more with this and provide example solves or something, but I know barely anything on square-1. Maybe someone a little more experienced could help me with this (I also don't have any software that could generate algs for the last 2 steps).

Yes, it's quite Algorithm-heavy but my intention is that(as subsets will become bigger over time to optimize even more) the essential part is reducing looks and have nice recognition. This is the nice part about this Method.
With my lookahead there are two pauses(EO + Bottom CP and PLL + EPFL) And a 3 on Top, 2 on Bottom - sided recognition is possible.

Your Method is really similar to Yau-1* so you might want to check it out since you like it. But I'd be really happy to show you how to generate Algorithms for Square-1.

*Yau-1 is
Cubeshape
3/4 of a Layer
last five Corners
last five Egdes

 

[Thermex]

Yes, it's quite Algorithm-heavy but my intention is that(as subsets will become bigger over time to optimize even more) the essential part is reducing looks and have nice recognition. This is the nice part about this Method.
With my lookahead there are two pauses(EO + Bottom CP and PLL + EPFL) And a 3 on Top, 2 on Bottom - sided recognition is possible.

Your Method is really similar to Yau-1* so you might want to check it out since you like it. But I'd be really happy to show you how to generate Algorithms for Square-1.

*Yau-1 is
Cubeshape
3/4 of a Layer
last five Corners
last five Egdes

Interesting, I'd never heard of Yau-1 until now, it looks pretty cool. The method proposed was pretty much just Yau-1, but the pieces don't have to be permuted on the d-layer in the second step. This allows the solve to flow much more smoothly since you don't have to check the actual colors of the pieces- you can just use white/yellow recognition. This of course adds lots of algs (30 more for corners and probably about 100-200 more for edges) but provides crazy efficiency.

How do you generate algs for square-1? I've been wanting to know that for a while.

 

[pizo45]

Efficient beginners method (EBM?)
1. solve all of the 2nd layer edges (a lot harder to solve later on)
2. do last layer twice on the top and bottom layers

this way you don't have to do cross and corners

 

[shadowslice e]

Efficient beginners method (EBM?)
1. solve all of the 2nd layer edges (a lot harder to solve later on)
2. do last layer twice on the top and bottom layers

this way you don't have to do cross and corners

This is called belt and it's actually really hard to do the first step as you would have to move the white pieces to the white face and yellow pieces to the yellow face. In addition, beginner's LL is very inefficient so having to do it twice would actually be slower than F2L (assuming good lookahead).

It's an interesting idea though it has quite a few issues and I've not seen a truly viable (sub-8 or so) belt based method.

 

[pizo45]

This is called belt and it's actually really hard to do the first step as you would have to move the white pieces to the white face and yellow pieces to the yellow face. In addition, beginner's LL is very inefficient so having to do it twice would actually be slower than F2L (assuming good lookahead).

It's an interesting idea though it has quite a few issues and I've not seen a truly viable (sub-8 or so) belt based method.

oh, I didn't think of that... back to the drawing board

 

[Thom S.]

Efficient beginners method (EBM?)
1. solve all of the 2nd layer edges (a lot harder to solve later on)
2. do last layer twice on the top and bottom layers

this way you don't have to do cross and corners

Did you think this through? At first there needs to be a layer seperation step with algorithms like M' U2 M and (R U R' U')3, which are arguably better than R U R' and U R U' R' U' F' U F but still.
Beginners Last layer(as Shadowslice said) takes long and is inefficient + there could be a "parity"(as in 3BLD Parity) after the first Last Layer which potentially confuses beginners

 

[pizo45]

OKAY I've read a bunch about some of the methods about there and I think I can take some of the strengths from each and make a method that uses them all
pizo hybrid strain:
1. blockbuild a 1x2x3 on left and right like in Roux
2. use M and U moves to complete the cross and orient the edges
3. do OLL and PLL (and you'll only get OLL cases with all edges oriented)

the combines the efficiency of Roux with the raw insane tps of CFOP.

 

[Thermex]

OKAY I've read a bunch about some of the methods about there and I think I can take some of the strengths from each and make a method that uses them all
pizo hybrid strain:
1. blockbuild a 1x2x3 on left and right like in Roux
2. use M and U moves to complete the cross and orient the edges
3. do OLL and PLL (and you'll only get OLL cases with all edges oriented)

the combines the efficiency of Roux with the raw insane tps of CFOP.

This is a very efficient method; although it's been proposed many times before as "LLOB". A couple of youtubers such as Tao Yu and CriticalCubing have gotten sub 10 averages with it (using ZBLL) but overall it's not super significant. You're on the right track, though.