The New Method / Substep / Concept Idea Thread

[Hazel]

@Neuro You've clearly put a lot of thought into this The problem with that though is that you have to memorize extra algorithms that may not be that good just for the edge orientation, and I don't know if recognition would be all that great either. Maybe your ideas would just be an advanced variant? I personally like doing it my way and I'd rather not learn a bunch of extra algs and steps.

 

[xyzzy]

F2L+WV

If I knew full ZBLL and could recognise them instantly, I wouldn't bother with any of the WV cases other than the three-movers. PLL has a very minor move count advantage over ZBLL and it doesn't make any sense to spend 3+ moves force oriented corners when PLL saves less than that over ZBLL. (In practice, some ZBLL sets are harder to recognise than others and move count isn't the only deciding factor, but the rough idea is still the same—WV is a lot less useful if you're using ZBLL.)

It would probably be a bit less efficient movecount wise, but I'm sure it's much more ergonomic since L5EOP is two gen for the most part.

It's MU 2-gen provided that the free edge is in DF or DB. If it's in DL or DR, you need a y/y' rotation to fix it.

I mean, it's not a new method and it's not really bad either (look up 3CFCE and ZBRoux). Around 0.1% of the time, when I mess up my F2L blockbuilding, I do the "L5EOP into ZBLL" thing. (I never force it, but when it happens, it happens.) This method has some nice advantages, like being able to look ahead to determine your CLL case while doing L5EOP, and it should even be relatively easy to look ahead to the EP (arrow EO case has two stickers immediately visible!), essentially telling you which ZBLL case you have so (in theory) you don't have to pause to recognise at all.

 

[Neuro]

I just remembered the method I worked on a while back called WaterRoux, and I realized you can apply 42 style corner recog to it and greatly decrease the # of corner algs. It'd look something like this for those who don't remember WaterRoux:

1) Roux style FB (1x2x3 on Left)
2) L6C (this is only 42/84 algs because of 42 style recog. 42 for standard, 84 if you use EG set)
3) ANY 2 Redges (this can be either algorithmic or intuitive. 35 cases including mirrors. Either RrUM or different moves if it's faster obviously)
4) L7E
4a) Insert 1 redge while doing EO (algorithmic or intuitive)
4b) Solve UL and last redge
4c) Same as in Roux, adjust R layer as needed

42 to 150+ algs depending on variant

I think this may have some decent potential. Influencing corners shouldn't be too hard and a lot of the solve can just be algs. You don't have to switch in and out of face moves/RrUM moves so if that was a problem for anyone this may help. Should be really efficient if L7E is done properly (more research on L7E needed.) Let me know what you think

EDIT: EG Corners in 42 doesn't work, do normal 42 only. EG's still a useful set and if you want to be OP you could learn the algsets required to do EG-42

 

[1001010101001]

It is off topic here, but:
Roux CMLL can be solved with only commutators. I use this CMLL because I hate learning algs ( I developed my own)
Example: U, X Checkerboard:
(r' U r' D') ( R U R' ) (D r U' r)

 

[shadowslice e]

It is off topic here, but:
Roux CMLL can be solved with only commutators. I use this CMLL because I hate learning algs ( I developed my own)
Example: U, X Checkerboard:
(r' U r' D') ( R U R' ) (D r U' r)

Well yeah. Any positon can be solved using commutators (hence BLD) and it's possible to deconstruct most (all?) algs into cancelled comms and conjugates.

 

[1001010101001]

So Roux has zero algs with this cmll method.

 

[xyzzy]

So Roux has zero algs with this cmll method.

If you don't memorise any of the commutators and conjugates you use and always come up with them on the fly, then yeah, "zero algs".

But now I'm curious: how would you do the twelve S/AS cases, in a way such that you can explain the purpose of every move? ("Zero algs", like you said.)

 

[Thom S.]

So Roux has zero algs with this cmll method.

Well, you can applicate Commutators to any Twisty Puzzle and have a Zero Algorithms Method so it doesn't mean that much

 

[_zoux]

A ZZ variant that someone probably experimented with: ZZ-42
Step 1: EO
Step 2: F2L-1 + 1 oriented top layer corner
Step 3: Conjugated COLL
Step 4: L5E
The most practical way to do L5E is using conjugated EPLLs for 3 cycles and 2-2 swaps, while using optimised algs for 5 cycle cases.

There aren’t many advantages of using this over 42 as far as I know. The only one I can think of is low alg count for L5E since EO is solved.
I’ll do example solves when I have time.

that's zipper.

 

[Sion]

Here's another whim method I feel May be better for beginners compared to LBL, because it is very intuitive and simple. It is a sort of belt method, but I don't feel like going through 248 pages to see if it's new.

I Call it SBS- Sion's Bread Slice. I don't know why I call it this, but I do.

1: Solve the middle layer minus one edge.

2: Through the missing edge, intuitively permits the D Layer. You don't need advanced algorithms, if any at all.

3: Solve missing edge. I assume if you want to speed this method up for some reason, you could use some sort of Alg set to orient the Last layer while inserting the final belt edge.

3: Solve the Last layer with any method of your choice.

The reason this would be more beginner friendly is that it doesn't rely on any algorithms for the F2l. You don't need to break apart a first layer, which is what most beginners fear. Instead, they are greeted with a 3/4 belt -which for some reason I call a Bread Slice- which has an open edge to insert stuff through.

Here is an example solve with SBS: https://alg.cubing.net/?type=reconstruction&setup=U-_R2_B2_U_F2_U_F2_L2_B2_R2_B-_D_F-_D-_U2_B-_F2&view=playback&alg=D_F_y-_M2_L_U_L-//Belt_ y_M_U2_M-_D2_R_U_R-_D_R_U-_R-_D_M-_U2_M_D_R_U_R-_D-_U_R_U-_R-_D-_M__U2_M-_D-__U_R_U_R-//D_Layer_ U_R_U-__R-_U-_F-_U_F//_Last_Edge U_r_U-_r-_U-_r_U_r-_y-_R-_U_R//OLL z_U_R-_D_R2_U-_R_U_D-_R-_D_R2_U-_R_D-//_PLL L_//_D_Layer_&title=Bread Slice Method Example

Scramble: U' R2 B2 U F2 U F2 L2 B2 R2 B' D F' D' U2 B' F2

D F y' M2 L U L'//Bread Slice

y M U2 M' D2 R U R' D R U' R' D M' U2 M D R U R' D' U R U' R' D' M U2 M' D' U R U R'//D Layer

U R U' R' U' F' U F// Last Edge

U r U' r' U' r U r' y' R' U R//OLL

z U R' D R2 U' R U D' R' D R2 U' R D'// PLL

L // D Layer

Surprised it made it under 100 moves. The solve wasn't optimised, and the LL had some rather long and move consuming PLLs.

 

[Neuro]

Here's another whim method I feel May be better for beginners compared to LBL, because it is very intuitive and simple. It is a sort of belt method, but I don't feel like going through 248 pages to see if it's new.

1: Solve the middle layer minus one edge.

2: Through the missing edge, intuitively permits the D Layer. You don't need advanced algorithms, if any at all.

3: Solve missing edge. I assume if you want to speed this method up for some reason, you could use some sort of Alg set to orient the Last layer while inserting the final belt edge.

3: Solve the Last layer with any method of your choice.

The reason this would be more beginner friendly is that it doesn't rely on any algorithms for the f2l. You don't need to break apart a first layer, which is what most beginners fear.

Here is an example solve (With an inefficient OLL https://alg.cubing.net/?type=reconstruction&setup=U-_R2_B2_U_F2_U_F2_L2_B2_R2_B-_D_F-_D-_U2_B-_F2&view=playback&alg=D_F_y-_M2_L_U_L-//Belt_ y_M_U2_M-_D2_R_U_R-_D_R_U-_R-_D_M-_U2_M_D_R_U_R-_D-_U_R_U-_R-_D-_M__U2_M-_D-__U_R_U_R-//D_Layer_ U_R_U-__R-_U-_F-_U_F//_Last_Edge U_r_U-_r-_U-_r_U_r-_y-_R-_U_R//OLL z_U_R-_D_R2_U-_R_U_D-_R-_D_R2_U-_R_D-//_PLL L_//_D_Layer_&title=Bread Slice Method Example

Scramble: U' R2 B2 U F2 U F2 L2 B2 R2 B' D F' D' U2 B' F2

D F y' M2 L U L'//Belt

y M U2 M' D2 R U R' D R U' R' D M' U2 M D R U R' D' U R U' R' D' M U2 M' D' U R U R'//D Layer

U R U' R' U' F' U F// Last Edge

U r U' r' U' r U r' y' R' U R//OLL

z U R' D R2 U' R U D' R' D R2 U' R D'// PLL

L // D Layer

Surprised it made it under 100 moves. The solve wasn't optimised, and the LL had some rather long and move consuming PLLs.

I actually quite like this idea, gives beginners a different way to do F2L that's more flexible but can still be easy to understand if taught correctly. I'd still say to use EO->CO->CP->EP for LL of course. For D layer, I think there's two approaches to use, a 2-phase style and a direct, blockbuilding style. The 2-phase style places edges and then does corners similar to standard beginners method and is what I'd probably teach people first. Second approach is straightforward and most people should be able to understand it quickly. Here're example solves with both styles for D layer

BLOCKBUILDING

2 STEP

May I make a video on the method and see what people think? You'll get full credit of course. Any other modifications you have in mind can be put in the video as well.

 

[Sion]

May I make a video on the method and see what people think? You'll get full credit of course. Any other modifications you have in mind can be put in the video as well.

Oh absolutely! I would actually appreciate if you displayed Sion's Bread Slice further into the community!

Maybe it could lead to an optimised form if it gets popular, like how CFOP is an optimized LBL, Maybe other people could find ways as to make SBS a speed method.

I personally think it has some potential, especially from how easy it is to build a 3/4 belt, which allows for a plethora of freedom in turns. Not to mention, Your Blockbuilding variant and my Traditional variant both made it under the 100 movecount mark, even when the solves were intended to be optimal. Your 2 Step Seems insanely easy to understand as well, especially since the D layer is broken down into its constituent parts as compared to Where I proposed to just do it wherever as long as it was permuted correctly.

I can't wait to see where this goes!

 

[Palmtop Tiger]

Here's another whim method I feel May be better for beginners compared to LBL, because it is very intuitive and simple. It is a sort of belt method, but I don't feel like going through 248 pages to see if it's new.

I Call it SBS- Sion's Bread Slice. I don't know why I call it this, but I do.

1: Solve the middle layer minus one edge.

2: Through the missing edge, intuitively permits the D Layer. You don't need advanced algorithms, if any at all.

3: Solve missing edge. I assume if you want to speed this method up for some reason, you could use some sort of Alg set to orient the Last layer while inserting the final belt edge.

3: Solve the Last layer with any method of your choice.

The reason this would be more beginner friendly is that it doesn't rely on any algorithms for the F2l. You don't need to break apart a first layer, which is what most beginners fear. Instead, they are greeted with a 3/4 belt -which for some reason I call a Bread Slice- which has an open edge to insert stuff through.

Here is an example solve with SBS: https://alg.cubing.net/?type=reconstruction&setup=U-_R2_B2_U_F2_U_F2_L2_B2_R2_B-_D_F-_D-_U2_B-_F2&view=playback&alg=D_F_y-_M2_L_U_L-//Belt_ y_M_U2_M-_D2_R_U_R-_D_R_U-_R-_D_M-_U2_M_D_R_U_R-_D-_U_R_U-_R-_D-_M__U2_M-_D-__U_R_U_R-//D_Layer_ U_R_U-__R-_U-_F-_U_F//_Last_Edge U_r_U-_r-_U-_r_U_r-_y-_R-_U_R//OLL z_U_R-_D_R2_U-_R_U_D-_R-_D_R2_U-_R_D-//_PLL L_//_D_Layer_&title=Bread Slice Method Example

Scramble: U' R2 B2 U F2 U F2 L2 B2 R2 B' D F' D' U2 B' F2

D F y' M2 L U L'//Bread Slice

y M U2 M' D2 R U R' D R U' R' D M' U2 M D R U R' D' U R U' R' D' M U2 M' D' U R U R'//D Layer

U R U' R' U' F' U F// Last Edge

U r U' r' U' r U r' y' R' U R//OLL

z U R' D R2 U' R U D' R' D R2 U' R D'// PLL

L // D Layer

Surprised it made it under 100 moves. The solve wasn't optimised, and the LL had some rather long and move consuming PLLs.

This kinda reminds me of how f2l is done in some of these single alg methods like the Sexy method (https://www.speedsolving.com/wiki/index.php/Sexy_Method)
But instead of starting with belt-1 they start with cross and do the belt-1 afterwards. The question is what is better. To me

1.cross
2.belt

seams more intuitive than

1.belt
2.cross

 

[Sion]

This kinda reminds me of how f2l is done in some of these single alg methods like the Sexy method (https://www.speedsolving.com/wiki/index.php/Sexy_Method)
But instead of starting with belt-1 they start with cross and do the belt-1 afterwards. The question is what is better. To me

1.cross
2.belt

seams more intuitive than

1.belt
2.cross

Cross then belt would actually be trickier for a beginner, because then beginners would be more concerned about breaking apart the cross to form the belt. It would also rely more on algorithms. SBS is intended to have a fully intuitive F2l that tries to ease up on breaking certain structures (Eg: Trying to not break the cross apart in F2l, Trying not to break the F2B blocks in roux, etc.)

The open edge in the belt is an open access point to properly place cubies in the D layer.

Also, the Bread Slice/Belt helps give reference to beginners of where one layer cubies should go. when solving Cross and Corners in LBL, The most common thing I see is that they solve it, but only the face, not the layer. Because there is a Belt, It shows beginners how corners match with edges, and how edges match with centers more intuitively.

 

[Micah Wingfield]

So I have been working on this method for about a month. It is a method where you do cross and f2l then you permute and orient corners at the same time leaving you with one of three olls which give you u, z, or h perm. Let me know what you think about it.

 

[shadowslice e]

This is CFOP with OLLCP.
(or CFOP with COLL? When do you do EO?)

 

[Micah Wingfield]

not coll. in a way it is because of the permutation of corners but it is in evey case and the olls you are left with won't move the corners keeping them permuted

 

[shadowslice e]

not coll. in a way it is because of the permutation of corners but it is in evey case and the olls you are left with won't move the corners keeping them permuted

OLLCP solves OLL and CP

 

[Micah Wingfield]

ok well I guess my method is ollcp just less algs since it's just cp

 

[SomeRandomZZUser]

Isn't it just CFCE but with 2-look ell?