The New Method / Substep / Concept Idea Thread

[Burrito]

After finding that the spreadsheet for Mehta is terrible for printing, I just went back to Roux.

 

[voidrx]

After finding that the spreadsheet for Mehta is terrible for printing, I just went back to Roux.

Good choice. Mehta is sub-optimal anyway. If you want a really good method that isn't roux, then try APB.

 

[Spriteblood]

Hi everybody!

I would like to share my idea for a method and hear your thoughts.
I tried to find something similar but with no results so I hope this wasn't suggested before.

In general, I would describe it as a Roux spinoff.

Here are the steps:

1. You solve 4 columns on the lower 2 layers (like F2L withoug Centers and cross)
2. You extend them to the ceiling. (Roux CMLL)
3. You solve DR and DL edge and prepare a roux LSE-Orientation Case, completely ignoring the centers! The focus here is are M/M' and u/u' slices
4. You solve the LSE-Orientation and also the L and R centers (This would be something for ~16 cases to learn. I am bad at inventing algorithms so I only manged to find one XD). Also here you stay on M/M' and u/u' slices. where
5. Solve the rest of the cube with pre-oriented LSE!



I tried to present the idea in a picture!


Example solve.

(best with classic top white, green front)
D2 F2 R F2 D' B F' D2 B2 D' F2 D' R F' D2 F


X Y (Turn the cube to this position, Red front, green top)


1. Solving the 4 columns
u
F' U2 F2
R U' S2 R
U' S F' U F S2 U' R U' R' (Yeah, far from perfect, but whatever XD)

2. Roux CMLL, maybe here could be found some better algs as all centers are free to move)
U + CMLL (r' U r U2 R2 F R F' R)

3. Solve DR and DL edge and prepare a roux LSE-Orientation Case
u M' u M' (now FU and DU on top) u' S2 u' U (D slots + LSE part preparation)

4. LSE-Orientation + L and R centers
u' M' u M u M' u' M u' M' u2 M' u' M' (I had a far shorter algorithm but couldn't reconstruct it, so.. this is clearly something for optimization)

5. Solve pre-oriented LSE
U M U2 M U M2 U' M U2 M' U2 M2 U2


Thx for reading!

 

[1001010101001]

Wouldn't it be better to solve F2B without centres and then do EO/Centres?
It could be a useful roux variant for misoriented centres and lower the movecounts for F2B, especially if solving centres + eolr at the same time (with a lot of algorithms). Wide u moves could be a problem, though.

 

[PapaSmurf]

Aka columns. We've all done it at some point.

 

[V Achyuthan]

I use this method for L5EP. Can anyone tell if it is good? (I made it by myself so it might probably be bad)
https://docs.google.com/document/d/1njb3bQ7ODY5X1TTgM_YTVZ_58aJRA1cRsZQbq2ek4hA/edit?usp=sharing

 

[PapaSmurf]

You should be able to do 2 sided recog for L5EP as long as the non-U edge isn't in UF or UR. If it is, peek at UL as well.

 

[Marijn]

Has anyone ever seen a 3BLD method where you swap edges and corners at the same time?
In the last couple of days I came up with setup moves to PLLs for all the corners and edges.

I found that the setup moves are not as bad as I thought they would be. I made a spreadsheet with all possible combinations of 1 edge and 1 corner. Here's the link: https://docs.google.com/spreadsheets/d/10rt17l8auC-hStzhcCpKKyLxIEOC6OZJJG74DWAXgkU/edit?usp=sharing

I used buffers UBL and UB.
After you have done the corners (and the same amount of edges), you will be left with either 4 or 6 edges most of the time. You can solve these with any method you like, but it is easy to do with M2 because I used buffer UB. You can not get parity with this method.

The memo is very different and more difficult than normal memo. Because you need to remember 1 edge and 1 corner for each letter pair.
Maybe the memo will make this method impossible/ very hard to use, I don't know yet.

So has anyone seen any method like this? And if can come up with better setup moves for some cases, please let me know! I am interested in your thoughts about this method.

 

[Halqrius]

I doubt I'm the first to com up with this, but layer by layer but the layers are solved in 1x1x3 layers and those layers are solved in 1x1x1 layers. Due to the number of pieces on a cube, this method technically has 27 steps but a lot are naturally skipped.

Step 1: Literally just choose a corner and this step is done
Step 2: Form a 1x1x2 with your chosen corner and an edge
Step 3: Turn the 1x1x2 into a 1x1x3 with another corner
Step 4: Add an edge to the 1x1x3
Step 5: Add the centre to the 1x1x3 with edge
Step 6: 1x2x3
Step 7: A layer with a missing edge and a corner
Step 8: A layer missing a corner
Step 9: A layer
Step 10: Add an edge to your layer (note that the centres don't have to be solved
Step 11: Solve the centre
Step 12: Solve the edge on the opposite side of the centre you just solved
Step 13: This step should already be done
Step 14: I wanna make a joke about solving the core, but I can't think of a good one
Step 15: See step 13
Step 16: F2L minus an edge
Step 17: Solve the remaining centre of F2L
Step 18: And in only 17 steps, we have F2L done
Step 19: Solve a corner in the last layer
Step 20: Solve an edge next to the corner
Step 21: Solve a corner next to that edge
Step 22: Solve an edge next to the 1x1x3 you just made
Step 23: This step should hopefully already be finished
Step 24: At this point, a 1x2x3 will be solved on the top layer
Step 25: Solve one of the remaining corners
Step 26: Solve the remaining edge
Step 27: Solve the final corner

Pros
-6 steps are always skipped
-Many more steps are often skipped
-The first few steps can be solved in very few moves
-Many cubers don't need to learn any new algs

Cons
-many

 

[Aluminum]

When I solve 4x4, i basically do the centers intuitively. But one day I was solving a 4x4, got the white and yellow centers, partial white cross, and then two middle centers next to each other. Once I get to the last 2 centers, it's pretty hard, beacuse you have to not disturb the other centers. But then I thought, what if there was a way to just do an algorithm to solve those two centers? What if there was a way to recognize a case, then do an algorithm to solve those two centers? For example:

would be r U2 r' U2.
What do you think about it?
Would it speed up your solves?

 

[Luke Solves Cubes]

yes it would and for certain cases for the last two centers, there are algorithms that could let you solve them

 

[Christopher Mowla]

4x4x4's last two centers are relatively easy to resolve compared to larger cube sizes. I know that there is such a resource available (for more than a decade for sure, probably close to two decades) for the last two centers of 5x5x5. https://cube.garron.us/big_cubes/L2C/

You can just pay attention to the "corner" centers of those images to get algorithms for their corresponding 4x4x4 cases, but the algorithms are almost always going to be longer than if you found the shortest moves for the actual 4x4x4 case.

 

[Stock_Fish109]

is this a joke?
thats like
the only way you solve 4x4 centers

 

[Christopher Mowla]

To some people, "intuitive" means the use of 3-cycle commutators. So, he probably started with commutators and is learning how to solve them the common way (where it's the reverse order for most people).

 

[TipsterTrickster]

This is pretty much how I along with every top 4x4 solvers does l2c. It isn’t necessarily memorizing algs as all the cases are super intuitive, but rather over time you start recognizing the case and then just solving it without having to think.

 

[Thom S.]

really funny reduction ideas for 3x3
1. Reduce the 3x3 to a Cube in a Cube Pattern and apply the alg that solves the pattern to solve the cube
2. Reduce the 3x3 to a Cube in a Cube in a Cube Pattern and apply the alg that solves the pattern to solve the cube.

I mean, obviously funny(not haha funny), but

Have you tried that even ONCE?
Didn't we tell you that you don't just post every bad thing that crosses your mind here?

 

[PapaSmurf]

Has anyone ever seen a 3BLD method where you swap edges and corners at the same time?
In the last couple of days I came up with setup moves to PLLs for all the corners and edges.

I found that the setup moves are not as bad as I thought they would be. I made a spreadsheet with all possible combinations of 1 edge and 1 corner. Here's the link: https://docs.google.com/spreadsheets/d/10rt17l8auC-hStzhcCpKKyLxIEOC6OZJJG74DWAXgkU/edit?usp=sharing

I used buffers UBL and UB.
After you have done the corners (and the same amount of edges), you will be left with either 4 or 6 edges most of the time. You can solve these with any method you like, but it is easy to do with M2 because I used buffer UB. You can not get parity with this method.

The memo is very different and more difficult than normal memo. Because you need to remember 1 edge and 1 corner for each letter pair.
Maybe the memo will make this method impossible/ very hard to use, I don't know yet.

So has anyone seen any method like this? And if can come up with better setup moves for some cases, please let me know! I am interested in your thoughts about this method.

It's a cool idea, but the main problem is that comms are already fast and you're just making life more difficult for yourself in memo (as you pointed out). It's unfortunate because the idea is actually quite fun.

 

[IsThatA4x4]

I haven't seen many intuitive / semi-intuitive LSLL methods, and I thought they could be interesting. As long as EO is done, blocks can quite easily be built on the top. So, I tried to make a method out of it - I don't know how practical it actually would be, but it's an idea.

1. EO
2. Make 2 pairs on the top face (permuted correctly). This can also be done by building a square and then adding a corner.
3. Solve the last 3 edges and corners (~250 algs)

Recognition for step 3 (kinda bad)
Orientation of U layer corners
CP
EP

Examples (all of these built two pairs separately, but depending on the case it might be better to build a square)
Scramble: F U' F2 D' L2 F' L' F U2 L2 D F
F' U2 L' U L F // EO
U R U2 R' // Pair
U2 R U2 R' // Pair
R2 U2 R2 D' R U' R' D R2 U' R' U' R' U // Finish
28 STM

Scramble: D B2 U B2 U2 R2 D' F2 U F2 U R' B U2 B' U2 R' U2
F' U' L' U L F // EO
R U2 R' // Pair
U R U2 R' U2 R U R' // Pair
R' F2 R D' R' D F2 D' R D U // Finish
28 STM

Scramble: U R' F2 R F L F D2 L2 U2 L' B2 R B2 L' D2 L'
F' U2 F // EO
U2 R U2 R' // Pair
U2 R U R' U' F2 L' U L U L' U' L F2 // Worst possible second pair case (should make an alg)
U' R2 U2 R2 U2 F R D R2 D' R' F' U2 // Finish
34 STM

// Example with square + corner //
Scramble: F' L2 F2 R B2 R' F2 L2 U2 F2 R' F' L' R2 B' L U' R'
R' F R F' // EO
R U2 R' U R U' R' // Square
U2 R U R' // Corner
U R U' F2 R2 D R2 U R2 D' R U' R F2 R' U' // Finish (bad case)

I'm just putting this out there as a thing, it has some problems that make it not super viable, mainly the difficult recognition in step 3, however building blocks is RU gen regripless, quite ergonomic.

 

[IsThatA4x4]

I haven't seen many intuitive / semi-intuitive LSLL methods, and I thought they could be interesting. As long as EO is done, blocks can quite easily be built on the top. So, I tried to make a method out of it - I don't know how practical it actually would be, but it's an idea.

1. EO
2. Make 2 pairs on the top face (permuted correctly). This can also be done by building a square and then adding a corner.
3. Solve the last 3 edges and corners (~250 algs)

Recognition for step 3 (kinda bad)
Orientation of U layer corners
CP
EP

Examples (all of these built two pairs separately, but depending on the case it might be better to build a square)
Scramble: F U' F2 D' L2 F' L' F U2 L2 D F
F' U2 L' U L F // EO
U R U2 R' // Pair
U2 R U2 R' // Pair
R2 U2 R2 D' R U' R' D R2 U' R' U' R' U // Finish
28 STM

Scramble: D B2 U B2 U2 R2 D' F2 U F2 U R' B U2 B' U2 R' U2
F' U' L' U L F // EO
R U2 R' // Pair
U R U2 R' U2 R U R' // Pair
R' F2 R D' R' D F2 D' R D U // Finish
28 STM

Scramble: U R' F2 R F L F D2 L2 U2 L' B2 R B2 L' D2 L'
F' U2 F // EO
U2 R U2 R' // Pair
U2 R U R' U' F2 L' U L U L' U' L F2 // Worst possible second pair case (should make an alg)
U' R2 U2 R2 U2 F R D R2 D' R' F' U2 // Finish
34 STM

// Example with square + corner //
Scramble: F' L2 F2 R B2 R' F2 L2 U2 F2 R' F' L' R2 B' L U' R'
R' F R F' // EO
R U2 R' U R U' R' // Square
U2 R U R' // Corner
U R U' F2 R2 D R2 U R2 D' R U' R F2 R' U' // Finish (bad case)

I'm just putting this out there as a thing, it has some problems that make it not super viable, mainly the difficult recognition in step 3, however building blocks is RU gen regripless, quite ergonomic.

This could work too as a variant, probably better for CFOPers, I basically just combined steps 1 & 2.

• EOPair (or EOSquare)
• Pair (or corner if square)
• Finish

// Example //
Scramble: R2 B2 L2 D2 B' L2 B' L R' F' L' F R' F2 U'
U' r U R' U' M // EOPair (unintentional square)
R U R' U R U R' U2 // Pair
R U R U R2 D' R U R' D R2 U2 R2 // Finish
Edit: also interesting realisation for the final alg, you only need to look at the U layer, as 1 edge and 1 corner are not in the U layer, so are affected by pieces in the U-layer. So you can recognise the corner pattern, then probably the location of the U layer edges
Edit 2: There is actually more like 430 ish algs in the final step. I might work on a way to reduce this alg count.

// Major Edit - big change //
The reason for the huge amount of algs is because there are 5 possible configurations of two solved top layer pairs, leading to 5 algsets of ~85 algs each. This is not only impractical for being able to use the method, but one of the sets in particular has very bad cases. So, I decided that having a block with only 1 possible position would fare better for this method.
I have come up with some steps that should work, and the alg reduction is huge! There are three ways to go about it, I don't know which is better.

Variant A
- EOPair
- CPSquare (amount of algs is like ZBLS vs VHLS, you can have the pair and edge ready, then do it, or just do it)
- Finish (71 algs, position square at UBL)

Variant B
- EO
- CPPair
OR
- EOPair
- CP
OR even
- EOCP

THEN
- Finish (~170 algs) with the algset (variant B1)
OR
- Conjugated 2GLL (84 algs, harder recog) (variant B2)

Variant C
- EOPair
- Conjugated ZBLL (~430 algs I forgot how many)

I think variant A could be the best all round, so here's an example for it (I don't have CE with me right now so I cannot gen CP-based algs because the batch solver doesn't do that)
Examples

Spoiler: variant A

Scramble: R2 B2 D L2 D L2 D2 B2 R2 U' R B U B' R'
F' U F // EOPair
R2 U' L' U R' U' L R' // CPSquare (idrk algs for this)
R2 U R2 U' R2 U R2 U2 R2 U2 R2 U // Finish

 

[V Achyuthan]

This could work too as a variant, probably better for CFOPers, I basically just combined steps 1 & 2.

• EOPair (or EOSquare)
• Pair (or corner if square)
• Finish

// Example //
Scramble: R2 B2 L2 D2 B' L2 B' L R' F' L' F R' F2 U'
U' r U R' U' M // EOPair (unintentional square)
R U R' U R U R' U2 // Pair
R U R U R2 D' R U R' D R2 U2 R2 // Finish
Edit: also interesting realisation for the final alg, you only need to look at the U layer, as 1 edge and 1 corner are not in the U layer, so are affected by pieces in the U-layer. So you can recognise the corner pattern, then probably the location of the U layer edges
Edit 2: There is actually more like 430 ish algs in the final step. I might work on a way to reduce this alg count.

// Major Edit - big change //
The reason for the huge amount of algs is because there are 5 possible configurations of two solved top layer pairs, leading to 5 algsets of ~85 algs each. This is not only impractical for being able to use the method, but one of the sets in particular has very bad cases. So, I decided that having a block with only 1 possible position would fare better for this method.
I have come up with some steps that should work, and the alg reduction is huge! There are three ways to go about it, I don't know which is better.

Variant A
- EOPair
- CPSquare (amount of algs is like ZBLS vs VHLS, you can have the pair and edge ready, then do it, or just do it)
- Finish (71 algs, position square at UBL)

Variant B
- EO
- CPPair
OR
- EOPair
- CP
OR even
- EOCP

THEN
- Finish (~170 algs) with the algset (variant B1)
OR
- Conjugated 2GLL (84 algs, harder recog) (variant B2)

Variant C
- EOPair
- Conjugated ZBLL (~430 algs I forgot how many)

I think variant A could be the best all round, so here's an example for it (I don't have CE with me right now so I cannot gen CP-based algs because the batch solver doesn't do that)
Examples

Spoiler: variant A

Scramble: R2 B2 D L2 D L2 D2 B2 R2 U' R B U B' R'
F' U F // EOPair
R2 U' L' U R' U' L R' // CPSquare (idrk algs for this)
R2 U R2 U' R2 U R2 U2 R2 U2 R2 U // Finish

Well then I am gonna start generating algs for variant A or if they are already generated gonna start learning them.