The New Method / Substep / Concept Idea Thread

[deadmanlsh]

A post just to add to the list of redundant last layer methods.
I decided to generate full sets of algorithms simply because I like the U-layer edge 3-cycles a lot. Like a lot.

Without further ado, allow me to present to you another way of doing the last layer.

Step 0.5:
COLS. Since EO is unnecessary, I found better algorithms for some cases. Of worthy note is the availability of sledgehammers. In case you don't know what COLS is, it's basically WVLS without necessarily preserving the edge orientation, so I'm calling it COLS here.

Step 1:
CP1E. Stands for Corner Permutation and 1 Edge. Exactly as it sounds. There are 3 possible sets of situations, with 8 cases for each.
First, there is the solved set, where the corners are correctly permuted. ELL would solve the cube, but for the sake of consistency, I added algorithms to fit CP1E.

Next, there is the adjacent swap set, where 2 adjacent corners are swapped (if you haven't realised). My method of doing this step would be to place the bar of solved corners at the left, then recognising where the sticker that belongs to UL is. Just look for two identical colours adjacent to each other and the piece with the same colour as those. Recognition should be pretty easy.

Finally, there is the diagonal swap set. Just look for the edge piece with the colour which is identical to the LUF sticker.

Step 2:
L3E. This is the step the whole method was created for. Solve the last 3 edges with an algorithm. 6 algorithms to learn. All of them are superb except maybe the adjacent 2-flip. I love using them in solves.

It's a 2.5-look method. L3E is ridiculously fast, so I would say it isn't that much of a loss speed-wise. You only need to look at 3 stickers at most for CP1E, so recognition should be quite fast. It shouldn't be too hard to decide where the edge piece is when it isn't visible by elimination. You can also just track the edge sticker during COLS (It's like 1 piece, even during algorithms it should be quite easy. It's nothing compared to seeing the first 3 pairs during inspection).

A total of 27 + 23 + 6 = 56 algorithms are required. A lot of them are really short or very obviously related to other algorithms, so you won't really have to learn that many algorithms in reality. Also, for those who just want to try out the method for fun (a.k.a. most of you all), just use set-up moves and PLLs for CP1E to indulge in L3E in all its glory. For those who don't know WVLS, use standard OCLL or other such sets that fulfill the purposes of COLS in a less efficient way.

Algorithms:
Below are the algorithms. For those with B moves, it's really supposed to be done as though you are doing a rotation, but not quite, so figure out the finger trick yourself if possible.
*I have since edited the post. So don't be surprised if you don't find any B moves.

Some of the algorithms may seem really bad, so if you have any suggestions, please drop a reply.

For some cases, I just put "WVLS", "Y Perm" or other such simplifications. I may edit them in the future (or I may not), but for now just look for resources online (PLLs are literally everywhere) or try to figure it out yourself (it won't take much effort, really).

For COLS, refer to algdb.net for the numbering (since you need them for those cases identical to WVLS anyway).

By variants I mean inverses and mirrors of a particular algorithm.

COLS:
1: WVLS
2: WVLS
3: U F' U F R U' R'
4: y Lw' U' L U M
5: U2 F2 L F L' F
6: R' U' F U R U' F'
7: WVLS
8: WVLS
9: WVLS
10: WVLS
11: R' F R2 U R' U' F'
12: WVLS
13:
U2 F R' F' R U' R U' R'
R' F R2 U' R' F' L' U L
14:
WVLS
U2 R' F R F' R U2 R'
15: R' F R F'
16:
U Lw R U' R' U F' Lw'
U2 F R' F' R2 U2 R'
17: WVLS
18: WVLS
19: y U F R U' R' F'
20:
U2 F' U F U' R U2 R'
U2 R U' Lw U' R' U F' R' x
21:
U F' U F U R U2 R'
U F' U L' U2 L U F
22: U' F' U' F (U' R U' R')
23: U2 R Dw' R U' R' F'
24:
(U2 R' F R F')2
R' F R U2 y' R' U' R U' R'
U2 R' U' R U' R' U2 F R F'
25:
WVLS
U2 F2 L F L2 U' L U F
26:
WVLS
U' F' U' F U2 R' F R F'
27: WVLS

CP1E-Solved
//Solve to UL
UL: U4
LU: ((M' U)3 M')2 U2
UF: R2 U R U (R' U' R' U' R') U R' (U Perm)
UB: R2 U' R' U' (R U R U R) U' R (U Perm)
UR: R U' (R U R U R) U' R' U' R2 (Inverse of UF)
FU: (M U M') U2 (M U M')
BU: (M' U' M) U2 (M' U' M)
RU: (U') (R U R' U') M' (U R U' Rw) (U)

CP1E-Adj
//Bar at UL
UL: R U R' F' R U R' U' R' F R2 U' R' (U') (J Perm)
LU:
(U') R' U' R' F' U' F U R2 U2 R' U' R
R' U R U2 R2 U' F' U F R U R (U)
UF: (U2) R2 F2 L F L' F2 R F' R (U')
UB: (U2) Lw R U2 L' U' L U2 R' U Lw' (U)
UR: (R U R' U' R' F R2) U' R' U' R U R' F' (T Perm)
FU: (U') F2 U F L F L2 U L2 F L' F'
BU: F L F' L2 U' L2 F' L' F' U' F2 (U)
RU: (U') Lw U' R U2 L' U L U2 R' Lw' (U2)

CP1E-Diag
//With respect to LUF sticker.
UL: L U F' U2 R' U L' U' R U2 Rw U Rw'
LU:
R' F' U2 F U' R U R2 F R F' U2 R (U')
(U) R' U2 F R' F' R2 U' R' U F' U2 F R
UF: R U' L U' R' U L' U2 F' U F R U' R'
UB: F R U' R' U' R U R' F' (R U R' U' R' F R F') (Y Perm)
UR: (U2) F U' F' U' L2 D' Lw U Lw' D L2
FU: R U R' F' U' F U2 L U' R U L' U R'
BU: R F R' F' R U R' F' U' F R2 U' R2 (U2)
RU: (U) R U' R2 F R F' R U' y R U2 R' F'

L3E:
U Perms
(R U R' U') M' (U R U' Rw') and its variants. It's just sexy M' inverse sexy M with a combined move. Non-optimal, but fast.
(M' U' M) U2 (M' U' M) and its variants. the 7-mover.
Pure Flips:
Opposite (UF, UB being the only case) - (M' U)3 M' U2 (M' U)3 M'
Adjacent - R U R' U' Rw' U2 R U R U' R2 U2 Rw and its variants (or just do U moves to set up).

Recognition for 3-cycles with 2 flipped-edges (use the oriented piece to decide the angle to perform the algorithms):
If the flipped pieces are adjacent,
-If the U-layer stickers are opposite colours, the case is the inverse of [sexy, M'].
-If the U-layer stickers are adjacent colours, the case is the 7-mover.
If the flipped pieces are opposite,
-The case is [sexy, M']. The piece at the front will go to the right (UF to RU to BU), so use that for calibration.

 

[Chenkar]

A post just to add to the list of redundant last layer methods.
I decided to generate full sets of algorithms simply because I like the U-layer edge 3-cycles a lot. Like a lot.

Without further ado, allow me to present to you another way of doing the last layer.

Step 0.5:
COLS. Since EO is unnecessary, I found better algorithms for some cases. Of worthy note is the availability of sledgehammers. In case you don't know what COLS is, it's basically WVLS without necessarily preserving the edge orientation, so I'm calling it COLS here.

Step 1:
CP1E. Stands for Corner Permutation and 1 Edge. Exactly as it sounds. There are 3 possible sets of situations, with 8 cases for each.
First, there is the solved set, where the corners are correctly permuted. ELL would solve the cube, but for the sake of consistency, I added algorithms to fit CP1E.

Next, there is the adjacent swap set, where 2 adjacent corners are swapped (if you haven't realised). My method of doing this step would be to place the bar of solved corners at the left, then recognising where the sticker that belongs to UL is. Just look for two identical colours adjacent to each other and the piece with the same colour as those. Recognition should be pretty easy.

Finally, there is the diagonal swap set. Just look for the edge piece with the colour which is identical to the LUF sticker.

Step 2:
L3E. This is the step the whole method was created for. Solve the last 3 edges with an algorithm. 6 algorithms to learn. All of them are superb except maybe the adjacent 2-flip. I love using them in solves.

It's a 2.5-look method. L3E is ridiculously fast, so I would say it isn't that much of a loss speed-wise. You only need to look at 3 stickers at most for CP1E, so recognition should be quite fast. It shouldn't be too hard to decide where the edge piece is when it isn't visible by elimination. You can also just track the edge sticker during COLS (It's like 1 piece, even during algorithms it should be quite easy. It's nothing compared to seeing the first 3 pairs during inspection).

A total of 27 + 23 + 6 = 56 algorithms are required. A lot of them are really short or very obviously related to other algorithms, so you won't really have to learn that many algorithms in reality. Also, for those who just want to try out the method for fun (a.k.a. most of you all), just use set-up moves and PLLs for CP1E to indulge in L3E in all its glory. For those who don't know WVLS, use standard OCLL or other such sets that fulfill the purposes of COLS in a less efficient way.

Algorithms:
Below are the algorithms. For those with B moves, it's really supposed to be done as though you are doing a rotation, but not quite, so figure out the finger trick yourself if possible.

Some of the algorithms may seem really bad, so if you have any suggestions, please drop a reply.

For some cases, I just put "WVLS", "Y Perm" or other such simplifications. I may edit them in the future (or I may not), but for now just look for resources online (PLLs are literally everywhere) or try to figure it out yourself (it won't take much effort, really).

For COLS, refer to algdb.net for the numbering (since you need them for those cases identical to WVLS anyway).

By variants I mean inverses and mirrors of a particular algorithm.

COLS:
1: WVLS
2: WVLS
3: U F' U F R U' R'
4: y Lw' U' L U M
5: U2 F2 L F L' F
6: R' U' F U R U' F'
7: WVLS
8: WVLS
9: WVLS
10: WVLS
11: R' F R2 U R' U' F'
12: WVLS
13:
U2 F R' F' R U' R U' R'
R' F R2 U' R' F' L' U L
14:
WVLS
U2 R' F R F' R U2 R'
15: R' F R F'
16:
U Lw R U' R' U F' Lw'
U2 F R' F' R2 U2 R'
17: WVLS
18: WVLS
19: y U F R U' R' F'
20:
U2 F' U F U' R U2 R'
U2 R U' Lw U' R' U F' R' x
21:
U F' U F U R U2 R'
U F' U L' U2 L U F
22: U' F' U' F (U' R U' R')
23: U2 R Dw' R U' R' F'
24:
(U2 R' F R F')2
R' F R U2 y' R' U' R U' R'
U2 R' U' R U' R' U2 F R F'
25:
WVLS
U2 F2 L F L2 U' L U F
26:
WVLS
U' F' U' F U2 R' F R F'
27: WVLS

CP1E-Solved
//Solve to UL
LU: ((M' U)3 M')2 U2
UF: U Perm
UB: U Perm
UR: U Perm
FU: (M U M') U2 (M U M')
BU: (M' U' M) U2 (M' U' M)
RU: U' (R U R' U') M' (U R U' Rw) U

CP1E-Adj
//Bar at UL
LU:
U' R' U' R' F' U' F U R2 U2 R' U' R
R' U R U2 R2 U' F' U F R U R U

UF: (U2) R2 F2 L F L' F2 R F' R U'
UB: (U2) Lw R U2 L' U' L U2 R' U Lw' U
UR: T Perm
FU: U' F2 U F L F L2 U L2 F L' F'
BU: F L F' L2 U' L2 F' L' F' U' F2 U
RU: (U') Lw U' R U2 L' U L U2 R' Lw' U2

CP1E-Diag
//With respect to UFL corner
LU:
R' F' U2 F U' R U R2 F R F' U2 R U'
U R' U2 F R' F' R2 U' R' U F' U2 F R

UF: R U' L U' R' U L' U2 F' U F R U' R'
UB: Y Perm
UR: U2 F U' F' U' L2 D' R B R' D L2
FU: R U R' F' U' F U2 L U' R U L' U R'
BU: R F R' F' R U R' F' U' F R2 U' R2 U2
RU: U R U' R2 F R F' R U' y R U2 R' F'

L3E:
U Perms
(R U R' U') M' (U R U' Rw') and its variants. It's just sexy M' inverse sexy M with a combined move. Non-optimal, but fast.
(M' U' M) U2 (M' U' M) and its variants. the 7-mover.
Pure Flips:
Opposite (UF, UB being the only case) - (M' U)3 M' U2 (M' U)3 M'
Adjacent - R U R' U' Rw' U2 R U R U' R2 U2 Rw and its variants (or just do U moves to set up).

Recognition for 3-cycles with 2 flipped-edges (use the oriented piece to decide the angle to perform the algorithms):
If the flipped pieces are adjacent,
-If the U-layer stickers are opposite colours, the case is the inverse of [sexy, M'].
-If the U-layer stickers are adjacent colours, the case is the 7-mover.
If the flipped pieces are opposite,
-The case is [sexy, M']. The piece at the front will go to the right (UF to RU to BU), so use that for calibration.

This doesn't seen at all redundant... I really like how it flows, imma pring out the algs later today. Thanks!

 

[Antonie faz fan]

there's way more cases than that

4 [corner permutation]
4 [center permutation]
2^5 [edge orientation]
6! [edge permutation]
1/2 [parity]

184320 cases

well you could just learn the 40 algs for the corners and have 2 steps, it takes 1 move to solve the centers and recognizing the case then is way easier and shouldn't edge permution be 5! cuz the last 2 edges cant be in any place they want.
'

 

[GuRoux]

well you could just learn the 40 algs for the corners and have 2 steps, it takes 1 move to solve the centers and recognizing the case then is way easier and shouldn't edge permution be 5! cuz the last 2 edges cant be in any place they want.
'

this is basically lse cases, the corners are already solved, just need auf. i guess you can divide by 16 because pre auf in the M and U layers. i think is is 6!/2 rather than 5!.

 

[tseitsei]

well you could just learn the 40 algs for the corners and have 2 steps, it takes 1 move to solve the centers and recognizing the case then is way easier and shouldn't edge permution be 5! cuz the last 2 edges cant be in any place they want.
'

What are you talking about

The corners are already solved here. 4 corner permutations are just NO-AUF, U-AUF, U'-AUF and U2-AUF. But as others have said you can divide by 16 because you can fix M and U layers correctly while/after CMLL...

Also it's not 5! because 5! is not the same as 6!/2
First edge can be in any of the 6 possible locations. Second can be in any of the remaining 5 locations so 6*5
And so on until you only have the second last edge left. That can only be in one of the remaining 2 places because of parity so you get 6*5*4*3*1=6!/2

 

[jjone fiffier]

For some time, I´ve been thinking about a new square-1 method.
Unfortunatelly I don´t know anything about generating algs, so I obviously don´t know, how many of them there would be.

The method has 6 steps:
1. Making the cube square (use any method)
2. Solving a Roux block either on DR or DL (totally intuitively)
3. Solving the other block
4. Inserting the last two edges whilst orienting the U-layer corners
5. EPLL
6. Fix the middle layer

Step 4 is, where it becomes tricky. Currently I do this in two steps, bring one corner down using (0,-1)/(1,1)/(-1,0) wich is very easy. To bring the second one down i hold the edge and its correct location on DR and UR and do (1,0)/(0,-3)/(0,-3)/(-1,-1)/(1,4)/(0,3)/. Then only the LL corners and edges are left.

Please tell me, where i can generate square-1 algs.

 

[stoic]

I'm not sure if either of the programs here are of use?
Also, you don't need to know how to generate algs to work out how many you need.
Good luck with your method.

 

[DGraciaRubik]

For some time, I´ve been thinking about a new square-1 method.
Unfortunatelly I don´t know anything about generating algs, so I obviously don´t know, how many of them there would be.

The method has 6 steps:
1. Making the cube square (use any method)
2. Solving a Roux block either on DR or DL (totally intuitively)
3. Solving the other block
4. Inserting the last two edge.

I don't get the orienting corners step after doing the two D roux blocks, shouldn't the corners be already oriented, and they only need permutation then. If so, this is similar to screw/roux method and is already in use by some speed square-1 solvers.
BTW, the step 4 seems kinda weird and difficult. What I do when I solve using the Roux method is:
1.Square
2.Roux Blocks (DR, DL)
3.Permute corners of the top layer
4.Orienting edges
5.L6E in two steps or one if i know the case.

 

[2180161]

Alright this is for 3x3.
Eoline
Solve your first layer
COLL because it maintains EO
Cycle your edges until f2l is solved (maximum # of edges to be cycled: 4)
EPLL

 

[lerenard]

Alright this is for 3x3.
Eoline
Solve your first layer
COLL because it maintains EO
Cycle your edges until f2l is solved (maximum # of edges to be cycled: 4)
EPLL

OR this:

EOLine
Solve f2l efficiently using block building
COLL+EPLL/ZBLL/phasing + ZZLL/etc.

This way you use fewer moves, less algs, and can do everything faster.

Oh wait that's just zz.

An idea I use in my roux solves:
This probably has been thought of by someone else but whatever.
Once you have EO done, you don't have to solve L and R edges, you can solve F and B or the two D edges, whichever is easier. At this point the last four edges can be cycled as in normal roux.
scramble: U' M' U2 M' U M U2 M'

In this case we see that the F and B edges can be easily paired with M U2 M'. At this point I just try to get both U edges on the same face and it usually just solves the cube. In this case you would use U' to join up the DB edge to its centers and I see the R color on the DF edge and so I know it's the UR edge and the other U edge is at UB so I would get them on the same face with M U2 M and U to finish.
I hope the example was clear. This would probably be slower for most fast roux people simply because they are hard wired at this point to just look for UL and UR and doing otherwise would just require too much thought even if it required a few less moves. I plan to start off solving this way so that it will be just as fast if I ever do get fast with roux (my pb is like 36 ATM... But I can build really good first blocks, sometimes just 6 moves)

 

[GuRoux]

OR this:

EOLine
Solve f2l efficiently using block building
COLL+EPLL/ZBLL/phasing + ZZLL/etc.

This way you use fewer moves, less algs, and can do everything faster.

Oh wait that's just zz.

An idea I use in my roux solves:
This probably has been thought of by someone else but whatever.
Once you have EO done, you don't have to solve L and R edges, you can solve F and B or the two D edges, whichever is easier. At this point the last four edges can be cycled as in normal roux.
scramble: U' M' U2 M' U M U2 M'

In this case we see that the F and B edges can be easily paired with M U2 M'. At this point I just try to get both U edges on the same face and it usually just solves the cube. In this case you would use U' to join up the DB edge to its centers and I see the R color on the DF edge and so I know it's the UR edge and the other U edge is at UB so I would get them on the same face with M U2 M and U to finish.
I hope the example was clear. This would probably be slower for most fast roux people simply because they are hard wired at this point to just look for UL and UR and doing otherwise would just require too much thought even if it required a few less moves. I plan to start off solving this way so that it will be just as fast if I ever do get fast with roux (my pb is like 36 ATM... But I can build really good first blocks, sometimes just 6 moves)

some rouxers use this. but it is often hard to recognize because you have to identify both the colors of the edge.

 

[lerenard]

some rouxers use this. but it is often hard to recognize because you have to identify both the colors of the edge.

I didn't think about that. I'm totally color neutral with roux, so I generally just ending up tracking two opposite edges I happen to see during EO and only about half the time are they UR and UL.

It's cool to know people actually find an idea I came up with useful, even if they already thought of it.

Another thing I do sometimes on normal solves with f2l: if the corner of the last slot is already done and edges are oriented (they usually are for me) I do coll and then I solve edges using an EPLL alg with a setup move. I only do this with slow solves though because it takes more effort to think about how to do it... It's probably not practical for speed solves.

 

[Smiles]

some rouxers use this. but it is often hard to recognize because you have to identify both the colors of the edge.

sometimes i mess up my L/R colours during lse and accidentally insert F/B so i do this anyway lol its not bad but recognition is a pain. i never intentionally do it though.

 

[jjone fiffier]

Alright, I'll try that, thanks!

 

[mark49152]

Probably a question rather than an idea, but, do any CFOP solvers try to find cross solutions that make good the F2L edges? For avoidance of rotations later? I'm not talking about adding several moves or an extra step; I just mean choosing a slightly different cross solution that might be 1-2 moves longer but that leaves no bad edges.

 

[CheesecakeCuber]

Probably a question rather than an idea, but, do any CFOP solvers try to find cross solutions that make good the F2L edges? For avoidance of rotations later? I'm not talking about adding several moves or an extra step; I just mean choosing a slightly different cross solution that might be 1-2 moves longer but that leaves no bad edges.

Isn't that just like an EO cross adopted from ZZ?

 

[mDiPalma]

Probably a question rather than an idea, but, do any CFOP solvers try to find cross solutions that make good the F2L edges? For avoidance of rotations later? I'm not talking about adding several moves or an extra step; I just mean choosing a slightly different cross solution that might be 1-2 moves longer but that leaves no bad edges.

that would be really hard for CN solvers.

most CFOPers have no idea what "edge orientation" even means until they get to the Last Layer. let alone at the beginning of the solve, let alone in ANY orientation.

 

[Bindedsa]

that would be really hard for CN solvers.

most CFOPers have no idea what "edge orientation" even means until they get to the Last Layer. let alone at the beginning of the solve, let alone in ANY orientation.

I doubt that, but even if that's true he did say "any". I pay attention to EO throughout my solve and solve pairs differently to avoid future rotations/worse LL, just not during cross.

 

[tseitsei]

that would be really hard for CN solvers.

most CFOPers have no idea what "edge orientation" even means until they get to the Last Layer. let alone at the beginning of the solve, let alone in ANY orientation.

I think very many CFOPers know what EO means... Of course newer solvers who don't know that many tricks don't necessarily know this but at least most of the experienced solvers definitely should know this.

I don't think about EO during my speedsolves (I don't really practise normal 3x3 event that seriously so haven't learned it), except for occasional sledge insert to avoid dot OLLs, but I certainly know what EO is and how it works and how affect it...

 

[Smiles]

Probably a question rather than an idea, but, do any CFOP solvers try to find cross solutions that make good the F2L edges? For avoidance of rotations later? I'm not talking about adding several moves or an extra step; I just mean choosing a slightly different cross solution that might be 1-2 moves longer but that leaves no bad edges.

nope just cross solutions to make an easy first pair. just because an edge is oriented doesn't always mean it'll make a nice case. for example if the corresponding corner is inserted in the diagonal slot from where it should be, cross colour facing down. i'd rather just rotate or do F moves sometimes.