The New Method / Substep / Concept Idea Thread

[LukasCubes]

Here’s a method idea but for 2x2

Step 1: Make a V on the bottom so just FRD is unsolved.

Step 2: Solve BLU corner and orient the missing FRD corner of the bottom layer. Around 10 algorithms for this step.

Step 3: Solve the oriented FRD corner and everything else in one algorithm. Should be 216 algorithms.

nice i like where this method is going. It is a subset of 1LLS which is 614 algs and a subset of VR which is 3684 algs.

 

[Skewbed]

How many algs are there for 1LLL with phasing? Would it be 4x OLLCP? That might be feasible.

 

[LukasCubes]

How many algs are there for 1LLL with phasing? Would it be 4x OLLCP? That might be feasible.

3915 algs for 1LLL, 3916 if you count the skip case

 

[PapaSmurf]

That's not 1LLL with phasing, that's 1LLL.

It'll be approximately 1/4 of 3915, so 978.75. Still in the range of 1000.

 

[Z1hc]

Thought of a method:
First step: EO and the line on the bottom like in zz.
Second step: Blockbuild but instead of solving normally you can solve it so you need to do an R,R’ or R2 to get it solved at the the end. Kind of like NMCLL. You do that for both sides.
last layer: I forgot what it was called but I’ll come and edit this later if I find it again. But you have to do 1 or 2 algorithms to put the Two side colors on the side. Here’s what I mean: L U’ R2 U R U’ R’ U L’ U’ R U R’ U’ R2 U. The two side colors are opposite so it’s easier to solve the cube.

last step just do L and R moves.

 

[OreKehStrah]

How many algs are there for 1LLL with phasing? Would it be 4x OLLCP? That might be feasible.

I'm not gonna lie, I've been toying with the idea of letting learning phased 1LLL be my end-game alg set to learn after ZB, and a few other ZZ/Petrus alg sets

 

[Cubing Forever]

last layer: I forgot what it was called

It's called NMLL(Non-Matching Last Layer)

 

[Athefre]

Yeah, it's NMLL. And that is actually why NMLL was developed. Non-matching blocks seemed interesting to use in ZZ, but there wasn't an easy to recognize LL method for non-matching blocks. So the idea was to find the L/R stickers since those stay consistent even when the left and right blocks don't match.

NMLL isn't the best LL method for speedsolving, but it is really interesting I think.

 

[Thom S.]

Yeah, it's NMLL. And that is actually why NMLL was developed. Non-matching blocks seemed interesting to use in ZZ, but there wasn't an easy to recognize LL method for non-matching blocks. So the idea was to find the L/R stickers since those stay consistent even when the left and right blocks don't match.

NMLL isn't the best LL method for speedsolving, but it is really interesting I think.

I actually used NMLL semi-regularly for a Month. Problem is, when you do one colour every time, you look at OLL and PLL only by one Colour. When you go to things like COLL, CMLL and OLLCP, you learn to look at the relationships that colours have (matching, adjacent, opposite) in order to recognise the case. When you do NMLL(with any of the big three) you can't go by that alone, you need to learn how every case needs the pieces to be moved.
So eventually you do thousands of solves and drills to learn a whole new recognition system and you save 7 moves on good cases.
My Opinion but I did seriously use it for CFOP, Roux (the most), ZZ and Petrus in order to have this conclusion.

 

[Cubing Forever]

NMLL isn't the best LL method for speedsolving, but it is really interesting I think.

It can be one of the best if not the best. Remember those variants I proposed in the method development discord server?

 

[Athefre]

I actually used NMLL semi-regularly for a Month. Problem is, when you do one colour every time, you look at OLL and PLL only by one Colour. When you go to things like COLL, CMLL and OLLCP, you learn to look at the relationships that colours have (matching, adjacent, opposite) in order to recognise the case. When you do NMLL(with any of the big three) you can't go by that alone, you need to learn how every case needs the pieces to be moved.
So eventually you do thousands of solves and drills to learn a whole new recognition system and you save 7 moves on good cases.
My Opinion but I did seriously use it for CFOP, Roux (the most), ZZ and Petrus in order to have this conclusion.

Do you have an example?

It can be one of the best if not the best. Remember those variants I proposed in the method development discord server?

Yeah, those are definitely cool. It would be nice to get everything into a doc for those variants so we can really compare.

 

[tsmosher]

• Step 1. Roux SB + 1 (any L.edge) - 8 moves

Yes, Roux SB first!

Any oriented L.edge is positioned in DL.

The DR edge here can be any oriented U/D non-L.edge (i.e., any U/D edge except DL or UL), giving you a lot more flexibility in how you build this block.

To be clear, you can use DL or UL as well, but this limits you down to only 1 possible FB to build in the next step (down from the usual 4 possibilities).

• Step 2. Roux FB - 15 moves

Insert two F2L pairs on the left, completing a (possibly non-matching) FB.

You have 2 options for your first F2L pair that will complete a square in dBR or dFR. This square can then be "swiveled" back and forth with L/L', giving you 2 options for the final F2L pair you insert.

• Step 3. NMCMLL/NMCDRLL - 11 moves

I struggle with the name for this step. (While thinking up a name, it occurred to me that there is no name for a set of CLL algorithms which have no regard for EO but only affect the U layer.)

The algs used here can disturb DB, DF, or DR. (DL will always be solved and should be preserved.)

The algs here needn't preserve EO. (In fact, the centers do not even have to be aligned yet.)

NMCMLL recognition is used here. (This recognition works well when the M slice centers are "off" as they often will be.)

• Step 4. L6E/L7E - 14 to 17 moves

Here is where it gets good.

• Step 4a. 2 Opp EO - 9 moves

I hate the name of this step, but I do like keeping names consistent. (This is the name used by shadowslice in his proposal of 42.)

First, perform EOLR/EOBF/EOdM. (In other words, resolve EO whilst influencing UL/UR, UB/UF, or DB/DF into DB/DF.)

EO alignment would be decided by the alignment of your (righthand) Roux SB. By the end of this sub-step, U/D centers would need to be on U/D or vice versa.

Next, perform the AMFs/AUFs necessary to solve DB/DF, UL/UR, or UB/UF. (i.e., Cancel into M2 + U/U' as in the end of Roux step 4b.)

UB/UF would be solved into their proper positions, but their triplets would be moved to ul/ur for now with U/U'.

DB/DF should not require any AMFs/AUFs unless they are solved in their opposite positions (fixed by cancelling into M2 U2 M2).

This leaves us with the M slice edges and DR. (Or, in the case of EOdM, the U layer edges and DR.)

• Step 4b. L4EP/L5EP - 5 to 8 moves

There are 3-4 possibilities for how to finish here:

If you have a proper Roux SB (i.e., DR is in DR), finish with EPLL (4 cases) if DB/DF are solved or L4EP (4 cases) if 2 U edges are solved. (L4EP is also commonly referred to as "Roux step 4c".) In this case, your solve would simply be a funky version of Roux.

If you do not have a proper Roux SB (i.e., DR is not solved):

If you solved DB/DF in (the previous) step 4a, finish with the L5EP-DR algorithm set (EPLL + 12 additional cases).

If you solved UL/UR or UB/UF in (the previous) step 4a, perform an x2/[r2] rotation, and finish with the RLSE-UO algorithm set (L4EP + 24 additional cases).

RLSE-UO recognition is identical because UL will be always be solved after rotating. Recognition is made slightly harder due to non-matching blocks though.

Note: if you don't mind the algs being <MD> (instead of <MU>) and the recognition being different (read: probably harder), you can avoid this x2/[r2] rotation entirely and solve L5EP using <MD> algs.

• Un-transform (AUF/ADF/ALF) - 2 moves

Total: 50 to 53 moves (+ x2/[r2] possibly)



Admittedly, ergonomics of this method are not ideal. Perhaps you could build everything as in Roux (with DL in Roux FB being flexible) then do a d2/y2/[u2] after F2B. However, in my opinion, this extra move/rotation seems unnecessary when you consider the fact that inserting 2 F2L pairs on the left would be completely ordinary in CFOP or ZZ.



Another CP-first idea I've toyed with but not listed here.

(Any slice move can be used at any point during the solve.)

• CP line (<RrUuFf>) - 5 moves
• 3QB (<RrUu>) - 7 moves
• EOdM (<RrU>), preserving belt edges - 11 moves
• F2L pair with last belt edge (<RU> only), completing belt - 7.5 moves
• CLS (<RU> only), solving L5C - 10 moves
• L5EP-DR - 8 moves

Total: ~49 moves STM

You will want to look ahead and find the last belt edge (probably also DB and/or DF) during 3QB to make EOdM one-lookable.

Also, orienting one additional edge (e.g., into DB as prescribed in YruRU) during 3QB would greatly reduce the case count for EOdM.

Some CLS algs would need reworking to conform to the <RU> move set.

Everything else should be pretty straightforward.



Roast me!

 

[LukasCubes]

I dont see much 2x2 in this

How about, this
1: Solve 2 Adjacent Corners and put them in DL kinda like a Mehta FB (~1.5 Moves)
2: Solve the last 2 corners of the first layer randomly using only R and U moves. (~2.5 Moves)
3: L6C in 1 look. (~9 Moves)


Pros:
1. Easy to 1 look because steps 1 and 2 can be done simutaniously
2. Low Movecount (same as EG)
3. Common to see entire step 1 skips
4. 5 Moves maximum is all it takes to get to the last step
5. Some algs are shorter (4-6 Moves with some algs)
6. All cases easy to recognize. CLL, Any TCLL, For Bottom 2, only 6 cases.

Cons:
Alot of algs
R and U moves arent the best moves on 2x2
3 steps instead of 2 like in CLL, EG, TCLL, VR, 1LLS, etc.

The movecounts are not counting cases with skips. Steps 1 and 2 are not rare to have skips on.

for L6C, there are 687 algs and are divided into 16 subsets (15 with 43 algs and 1 with 42 algs)

1. 42 CLL
2. 43 LEG-1
3. 43 TCLL+
4. 43 TCLL-
5. 43 BTCLL+
6. 43 BTCLL-
7. 43 TLEG+
8. 43 TLEG-
9. 43 tCLL
10. 43 tLEG-1
11. 43uCLL
12. 43 uLEG-1
13. 43 tuCLL
14. 43 tuLEG-1
15. 43 utCLL
16. 43 utLEG-1

some of these sets have bad names but some are good names.

after learning all algs, if you get lucky, you can user gods number method on here. This is just a start tho.

 

[PapaSmurf]

• Step 1. Roux SB + 1 (any L.edge) - 8 moves

Yes, Roux SB first!

Any oriented L.edge is positioned in DL.

The DR edge here can be any oriented U/D non-L.edge (i.e., any U/D edge except DL or UL), giving you a lot more flexibility in how you build this block.

To be clear, you can use DL or UL as well, but this limits you down to only 1 possible FB to build in the next step (down from the usual 4 possibilities).

• Step 2. Roux FB - 15 moves

Insert two F2L pairs on the left, completing a (possibly non-matching) FB.

You have 2 options for your first F2L pair that will complete a square in dBR or dFR. This square can then be "swiveled" back and forth with L/L', giving you 2 options for the final F2L pair you insert.

• Step 3. NMCMLL/NMCDRLL - 11 moves

I struggle with the name for this step. (While thinking up a name, it occurred to me that there is no name for a set of CLL algorithms which have no regard for EO but only affect the U layer.)

The algs used here can disturb DB, DF, or DR. (DL will always be solved and should be preserved.)

The algs here needn't preserve EO. (In fact, the centers do not even have to be aligned yet.)

NMCMLL recognition is used here. (This recognition works well when the M slice centers are "off" as they often will be.)

• Step 4. L6E/L7E - 14 to 17 moves

Here is where it gets good.

• Step 4a. 2 Opp EO - 9 moves

I hate the name of this step, but I do like keeping names consistent. (This is the name used by shadowslice in his proposal of 42.)

First, perform EOLR/EOBF/EOdM. (In other words, resolve EO whilst influencing UL/UR, UB/UF, or DB/DF into DB/DF.)

EO alignment would be decided by the alignment of your (righthand) Roux SB. By the end of this sub-step, U/D centers would need to be on U/D or vice versa.

Next, perform the AMFs/AUFs necessary to solve DB/DF, UL/UR, or UB/UF. (i.e., Cancel into M2 + U/U' as in the end of Roux step 4b.)

UB/UF would be solved into their proper positions, but their triplets would be moved to ul/ur for now with U/U'.

DB/DF should not require any AMFs/AUFs unless they are solved in their opposite positions (fixed by cancelling into M2 U2 M2).

This leaves us with the M slice edges and DR. (Or, in the case of EOdM, the U layer edges and DR.)

• Step 4b. L4EP/L5EP - 5 to 8 moves

There are 3-4 possibilities for how to finish here:

If you have a proper Roux SB (i.e., DR is in DR), finish with EPLL (4 cases) if DB/DF are solved or L4EP (4 cases) if 2 U edges are solved. (L4EP is also commonly referred to as "Roux step 4c".) In this case, your solve would simply be a funky version of Roux.

If you do not have a proper Roux SB (i.e., DR is not solved):

If you solved DB/DF in (the previous) step 4a, finish with the L5EP-DR algorithm set (EPLL + 12 additional cases).

If you solved UL/UR or UB/UF in (the previous) step 4a, perform an x2/[r2] rotation, and finish with the RLSE-UO algorithm set (L4EP + 24 additional cases).

RLSE-UO recognition is identical because UL will be always be solved after rotating. Recognition is made slightly harder due to non-matching blocks though.

Note: if you don't mind the algs being <MD> (instead of <MU>) and the recognition being different (read: probably harder), you can avoid this x2/[r2] rotation entirely and solve L5EP using <MD> algs.

• Un-transform (AUF/ADF/ALF) - 2 moves

Total: 50 to 53 moves (+ x2/[r2] possibly)



Admittedly, ergonomics of this method are not ideal. Perhaps you could build everything as in Roux (with DL in Roux FB being flexible) then do a d2/y2/[u2] after F2B. However, in my opinion, this extra move/rotation seems unnecessary when you consider the fact that inserting 2 F2L pairs on the left would be completely ordinary in CFOP or ZZ.



Another CP-first idea I've toyed with but not listed here.

(Any slice move can be used at any point during the solve.)

• CP line (<RrUuFf>) - 5 moves
• 3QB (<RrUu>) - 7 moves
• EOdM (<RrU>), preserving belt edges - 11 moves
• F2L pair with last belt edge (<RU> only), completing belt - 7.5 moves
• CLS (<RU> only), solving L5C - 10 moves
• L5EP-DR - 8 moves

Total: ~49 moves STM

You will want to look ahead and find the last belt edge (probably also DB and/or DF) during 3QB to make EOdM one-lookable.

Also, orienting one additional edge (e.g., into DB as prescribed in YruRU) during 3QB would greatly reduce the case count for EOdM.

Some CLS algs would need reworking to conform to the <RU> move set.

Everything else should be pretty straightforward.



Roast me!

This is essentially Roux in a different order, but adding in an extra edge for the sake of it. It's definitely not an improvement and is probably a hinderance as LSE and SB are already not that bad. It's less efficient than Roux too.

 

[tsmosher]

This is essentially Roux in a different order, but adding in an extra edge for the sake of it. It's definitely not an improvement and is probably a hinderance as LSE and SB are already not that bad. It's less efficient than Roux too.

I add the extra edge personally if it is hard to insert the proper DL edge. (e.g., It is located in FL or BL and would take 3+ moves to relocate.) This method was just me thinking of a way to make the edge I don't care about be the DR edge (for ergonomics and for certain alg sets such as CDRLL) instead of the DL edge.

I also like how you can plan the entire intuitive part of the solve in inspection if you are color neutral. FB+1 is essentially just a triplet, half belt, and an oriented Redge. (8-9 moves. EOCross or EO222 are harder than that.) F2L, CLL, and L7E can then be entirely algorithmic.

This is very much Roux though- with more freedom in how you build FB and SB.

Fair points though. Thanks for checking it out!

 

[CubetyCubes]

A new method! The EPCL method! (Pronounced ep-cle not ee-pee-see-el). EPCL is a type of columns first method designed to be weird but unique. It was supposed to be similar to Roux and ZZ but it ended up being similar to SSC(Shadowslice Snow Columns) instead. Also, this is more of a fun method rather than a speedsolving method because it’s pretty inefficient and stuff.
Number Of Algs: 58-60
I will add the stats when the method gets more developed.
The major 4 steps are:
EOCross (Edge Orientation cross)
Pairs
COLL (Corners of Last Layer)
L8E (Last 8 Edges)

Spoiler: EOCross

Orientate all the edges in the cube and make an unpermutated cross instead of a normal cross to lower movecount. A mixed cross is just a cross at the bottom but the center and edge colours don’t have to match. Just ZZ’s eoline without with a mixed cross.

Spoiler: Pairs

Make 4 corner edge pairs (f2l pairs) and solve them. This, like ZZ, is efficient because you don’t have to use F or B moves, making it rotation less. An option is to have the corners unoriented when you so, the pairs, then you solve the corners with one out of two algorithms. If you do this, remember that, if the corner and the pairs have one of the same colors (eg, white red blue corner paired with a green red edge), then make sure none of the colors match. If none of the colors match (eg, white red blue corner pair with green orange edge), make sure the opposite colors(blue/green, red/orange, white/yellow) are matching.

Spoiler: COLL

Just use the COLL algs and the d corner algs if unoriente..

Spoiler: L8E

Solve the remaining 8 edges by first, solving parity if needed(use M2 U2 M2), and then solving them with an algorithm (EZD Algs).

Spoiler: Algorithms

Algorithms:
L8E (EZD Algs)
H both layers: M2 U2 M2 y M2 U2 M2
Z Top H Bottom: M2 D' R2 (U D') M2 (U' D) L2 U M2
Ua Top H Bottom: (U) M2 D M' D M2 U' M2 D M D M2
Ub Top H Bottom: R2 (U' D) M2 D M' U2 M' U' M2 D2 L2
H Top Z Bottom: M2 U' L2 (U D') M2 (U' D) l2 U M2
Both Layer Z: M2 D' M2 (U D) M2 U' M2
Ua Top Z Bottom: M2 D M' U2 M' (U D') M2 U M2
Ub Top Z Bottom: M2 D' M' U2 M' (U' D) M2 U' M2
H Top Ua Bottom: (D) M2 U M' U M2 D' M2 U M U M2
Z Top Ua Bottom: M2 U M' D2 M' (U' D) M2 D M2
Ua Both Layers: M' (U' D) M2 D2 M' U' M' (U' D) M (U')
Ub top Ua Bottom: L2 (U' D) r2 U M2 U' l2 (U' D) L2H top Ub Bottom: M2 U2 M2 D' M2 U M' U2 M U' M2
Z Top Ub Bottom: M2 D' M2 (U D') M D2 M U' M2
Ua Top Ub Bottom: L2 (U' D) R2 U M2 U' L2 (U' D) L2
Ub both layers: M' (U' D) M2 U2 M' D M' (U' D) M (D)

D Layer Corner Algs (there’s a selection)
Adjacent Swap Alg list
R2 U F2 U' D' F2 D R2 (8stm*)
R2 U' R2 U2 F2 D' F2 D (8stm*)
R2 U' R2 D2 B2 D' B2 D' (8stm*)
R2 D R2 U' D' R2 U R2 (8stm*)
R2 D R2 D2 F2 U F2 D (8stm*)
R2 D' F2 U D F2 U' R2 (8stm*)
D B2 U' B2 U2 R2 D' R2 (8stm*)
D' F2 U' F2 D2 R2 D' R2 (8stm*)
D' F2 D F2 U2 R2 U R2 (8stm*)

Diagonal Swap Alg list
R2 F U2 M2 U2 F r2 (7stm*)
R2 F D2 M2 D2 F r2 (7stm*)
R2 F' U2 M2 U2 F' r2 (7stm*)
R2 F' D2 M2 D2 F' r2 (7stm*)
R2 B R2 E2 R2 B R2 (7stm*)
R2 B' R2 E2 R2 B' R2 (7stm*)
F2 R U2 S2 U2 R B2 f2 (7stm*)
F2 R D2 S2 D2 R B2 f2 (7stm*)

If you have any ideas or suggestions let me know!
Also if this method already exists then let me know.

 

[xyzzy]

What do you do if the pair edges are trapped in DF or DB? (DL and DR are also problematic, albeit a bit less so.)

Also you can probably find better CLL algs if you're only preserving pairs and EO, eg. F R2 U' R2 U R2 U R2 F'.

 

[hellocubers]

this has potential to be an actual speedsolving method.

 

[CubetyCubes]

What do you do if the pair edges are trapped in DF or DB? (DL and DR are also problematic, albeit a bit less so.)

Also you can probably find better CLL algs if you're only preserving pairs and EO, eg. F R2 U' R2 U R2 U R2 F'.

Oh yea! in that case I’m changing the EO to eocross and with a pseudo cross so it doesn’t take too much time. Also, yea I‘m gonna change the coll to cll.

 

[OreKehStrah]

This sounds very similar to a ZZ variant called ZZ-4c, but worse. That variant is actually quite good so I suggest taking a look at it, as it may be closer to what you were trying to achieve.