The New Method / Substep / Concept Idea Thread

[ribbon method]

Yea it's a Hawaiian Kociemba variant that's already been thought of, probably not very good but decent tho

Whats hawaiian koceiemba

 

[TheSlykrCubr]

Whats hawaiian koceiemba

It's an obscure method that's actually pretty good, but too many algorithms

 

[Username: Username:]

Whats hawaiian koceiemba

it's a method where you make a pEOArrow and solve HKF2L (since the DF edge is unsolved you can do many F2L tricks) then solve the last layer's orientation + the DF edge's orientation in one algs, then solve HKPLL, PLL + DF edge

 

[TheSlykrCubr]

pEOArrow, HKF2L, HKOLL, HKPLL

 

[Devagio]

Been fiddling with an idea. Let the bashing begin. If it survives, I'll gen the algs for example solves for further scrutiny.

Philosophy and motivation:
Algorithmic methods are doing fairly well compared to block building methods, and for good reason. TPS on the new hardware has shot up and it makes sense to make best use of it. A method with a bearable number of algorithms, yet highly algorithmically reliant and with good recognition has the potential to beat a good deal of methods. A means to achieve that is to have 3 algorithmic steps (compared to 2 for CFOP for example); while ensuring that those algorithms do indeed tackle a large set of cases (2LLL CFOP handles ~15k cases).
Orientation steps are almost always recognition friendly as long as they involve one (or two) top colour (like TSLE is decent for recog, OLL is pretty good, etc. but LEOR EO is hard) Permutation steps are good for recognition if a single glance at a cube, and registering 4-5 stickers at most can uniquely identify each case (like 2 sided PLL recognition system if good, ZBLL recognition on the other hand is hard, so is 4x4 PLL).
Cube symmetries can play a huge role in reducing number of algorithms while getting tons of cases solved (There are 72 PLL cases, but symmetry reduces it to 22 (21+1)). These symmetries can be exploited much better once we think about it.

Based on these primers and a bit of work, there seems to be one very promising end to a solve using 3 algorithms:
Suppose a 2x2x3 is solved on DL; FR and BR edges are solved; and the remaining 5 edges are oriented (i.e. white/yellow facing up/down say).
Alg-1: orients 6 corners. This will be a short <R,U> alg; and surprisingly, there are very few cases thanks to the freedom of U layer and the S slice symmetry. Also, R2 setups cut this down much further. There are 23 + (4 x 8) + (2 x 8) = 71 cases, though only 39 algorithms excluding mirrors. If we consider R2 setups, this number goes below 30.
Alg-2: Permutes 6 corners. These will be <R,U,D> algs (<R2,U,D> is enough, but algs may get lengthy); and again surprisingly, there are very few cases thanks to the same freedom and symmetry. There are 5 + (4 x 6) + 18 = 47 cases, though only 29 algorithms excluding mirrors. 2 sided recognition is possible here.
Alg-3: L5EP, <M,U> gen 16 short algs very simple to recognise during the previous alg.

This 3 alg system, which without any reduction has 71+47+16 = 134 algs (CFOP has 78 excluding F2L) can reduce the cube state from a possible 6! * 5! * 3^5 / 2 = 10M cases! This is 700 times more than 15k of CFOP, instead of an expected sqrt(15k)~120. Basically, this algorithm system is better per algorithm required compared to 2LLL, plus has comparable to better recognition; and looking at the movesets potentially better and shorter algs.

Now to the hard part:
How do we achieve " a 2x2x3 is solved on DL; FR and BR edges are solved; and the remaining 5 edges are oriented"?

Two premises about this.
Firstly, blockbuilding is probably the best thing that can be done with the inspection time in terms of reducing the number of cubestates. A roux block does this slightly better than a petrus block, which is better than a cross; all solving the same number of pieces (counting centres, since roux centres aren't fixed).
Second, there is a reason CFOP is as successful as it is, and that is the symmetry in F2L. We can choose to do whichever F2L pair we please, and we can do these in any order. This is very good for a step that is neither algorithmic, nor block building; because we can simply do whatever we see first. Finally, we can use only the last pair to influence LL.

This gives us a beautiful way to achieve the above mentioned cubestate. A roux block can be done in inspection, and then each of the 4 edges UF, UB, DF and DB can be placed between corresponding centres in any order convenient; while influencing EO. Follow this with a rotation and you have your required cubestate! The best part is, this central "belt" doesn't have to align with FB, because at the end of the solve, we can do an AUF with an ADF and will be done.
The EO condition in the belt can be relaxed in a more advanced version of the method, where one can learn all L5E algs (roughly 200 cases, ~60 algs excluding mirrors and setups).


Summing it all up:

Intermediate version:
Step 1: FB (~6 moves)
Step 2: EO-Belt (~16 moves) <r,R,U>
Step 3: 6COLL (~13 moves) <R,U>
Step 4: 6CPLL (~12 moves) <R,U,D>
Step 5: L5EP (~13 moves) <M,U>
Avg ~ 60 moves

Advanced version:
Step 1: FB (~6 moves)
Step 2: Belt (~9 moves) <r,R,U>
Step 3: 6COLL (~13 moves) <R,U>
Step 4: 6CPLL (~12 moves) <R,U,D>
Step 5: L5E (~15 moves) <M,U>
Avg ~ 55 moves

Promising a higher TPS than CFOP, this should be pretty good. Let me know.

 

[ribbon method]

Been fiddling with an idea. Let the bashing begin. If it survives, I'll gen the algs for example solves for further scrutiny.

Philosophy and motivation:
Algorithmic methods are doing fairly well compared to block building methods, and for good reason. TPS on the new hardware has shot up and it makes sense to make best use of it. A method with a bearable number of algorithms, yet highly algorithmically reliant and with good recognition has the potential to beat a good deal of methods. A means to achieve that is to have 3 algorithmic steps (compared to 2 for CFOP for example); while ensuring that those algorithms do indeed tackle a large set of cases (2LLL CFOP handles ~15k cases).
Orientation steps are almost always recognition friendly as long as they involve one (or two) top colour (like TSLE is decent for recog, OLL is pretty good, etc. but LEOR EO is hard) Permutation steps are good for recognition if a single glance at a cube, and registering 4-5 stickers at most can uniquely identify each case (like 2 sided PLL recognition system if good, ZBLL recognition on the other hand is hard, so is 4x4 PLL).
Cube symmetries can play a huge role in reducing number of algorithms while getting tons of cases solved (There are 72 PLL cases, but symmetry reduces it to 22 (21+1)). These symmetries can be exploited much better once we think about it.

Based on these primers and a bit of work, there seems to be one very promising end to a solve using 3 algorithms:
Suppose a 2x2x3 is solved on DL; FR and BR edges are solved; and the remaining 5 edges are oriented (i.e. white/yellow facing up/down say).
Alg-1: orients 6 corners. This will be a short <R,U> alg; and surprisingly, there are very few cases thanks to the freedom of U layer and the S slice symmetry. Also, R2 setups cut this down much further. There are 23 + (4 x 8) + (2 x 8) = 71 cases, though only 39 algorithms excluding mirrors. If we consider R2 setups, this number goes below 30.
Alg-2: Permutes 6 corners. These will be <R,U,D> algs (<R2,U,D> is enough, but algs may get lengthy); and again surprisingly, there are very few cases thanks to the same freedom and symmetry. There are 5 + (4 x 6) + 18 = 47 cases, though only 29 algorithms excluding mirrors. 2 sided recognition is possible here.
Alg-3: L5EP, <M,U> gen 16 short algs very simple to recognise during the previous alg.

This 3 alg system, which without any reduction has 71+47+16 = 134 algs (CFOP has 78 excluding F2L) can reduce the cube state from a possible 6! * 5! * 3^5 / 2 = 10M cases! This is 700 times more than 15k of CFOP, instead of an expected sqrt(15k)~120. Basically, this algorithm system is better per algorithm required compared to 2LLL, plus has comparable to better recognition; and looking at the movesets potentially better and shorter algs.

Now to the hard part:
How do we achieve " a 2x2x3 is solved on DL; FR and BR edges are solved; and the remaining 5 edges are oriented"?

Two premises about this.
Firstly, blockbuilding is probably the best thing that can be done with the inspection time in terms of reducing the number of cubestates. A roux block does this slightly better than a petrus block, which is better than a cross; all solving the same number of pieces (counting centres, since roux centres aren't fixed).
Second, there is a reason CFOP is as successful as it is, and that is the symmetry in F2L. We can choose to do whichever F2L pair we please, and we can do these in any order. This is very good for a step that is neither algorithmic, nor block building; because we can simply do whatever we see first. Finally, we can use only the last pair to influence LL.

This gives us a beautiful way to achieve the above mentioned cubestate. A roux block can be done in inspection, and then each of the 4 edges UF, UB, DF and DB can be placed between corresponding centres in any order convenient; while influencing EO. Follow this with a rotation and you have your required cubestate! The best part is, this central "belt" doesn't have to align with FB, because at the end of the solve, we can do an AUF with an ADF and will be done.
The EO condition in the belt can be relaxed in a more advanced version of the method, where one can learn all L5E algs (roughly 200 cases, ~60 algs excluding mirrors and setups).


Summing it all up:

Intermediate version:
Step 1: FB (~6 moves)
Step 2: EO-Belt (~14 moves) <r,R,U>
Step 3: 6COLL (~13 moves) <R,U>
Step 4: 6CPLL (~12 moves) <R,U,D>
Step 5: L5E (~15 moves) <M,U>
Avg ~ 60 moves

Advanced version:
Step 1: FB (~6 moves)
Step 2: Belt (~9 moves) <r,R,U>
Step 3: 6COLL (~13 moves) <R,U>
Step 4: 6CPLL (~12 moves) <R,U,D>
Step 5: L5E (~15 moves) <M,U>
Avg ~ 55 moves

Promising a higher TPS than CFOP, this should be pretty good. Let me know.

Why does eo belt make more move count

 

[CyoobietheCuber]

Been fiddling with an idea. Let the bashing begin. If it survives, I'll gen the algs for example solves for further scrutiny.

Philosophy and motivation:
Algorithmic methods are doing fairly well compared to block building methods, and for good reason. TPS on the new hardware has shot up and it makes sense to make best use of it. A method with a bearable number of algorithms, yet highly algorithmically reliant and with good recognition has the potential to beat a good deal of methods. A means to achieve that is to have 3 algorithmic steps (compared to 2 for CFOP for example); while ensuring that those algorithms do indeed tackle a large set of cases (2LLL CFOP handles ~15k cases).
Orientation steps are almost always recognition friendly as long as they involve one (or two) top colour (like TSLE is decent for recog, OLL is pretty good, etc. but LEOR EO is hard) Permutation steps are good for recognition if a single glance at a cube, and registering 4-5 stickers at most can uniquely identify each case (like 2 sided PLL recognition system if good, ZBLL recognition on the other hand is hard, so is 4x4 PLL).
Cube symmetries can play a huge role in reducing number of algorithms while getting tons of cases solved (There are 72 PLL cases, but symmetry reduces it to 22 (21+1)). These symmetries can be exploited much better once we think about it.

Based on these primers and a bit of work, there seems to be one very promising end to a solve using 3 algorithms:
Suppose a 2x2x3 is solved on DL; FR and BR edges are solved; and the remaining 5 edges are oriented (i.e. white/yellow facing up/down say).
Alg-1: orients 6 corners. This will be a short <R,U> alg; and surprisingly, there are very few cases thanks to the freedom of U layer and the S slice symmetry. Also, R2 setups cut this down much further. There are 23 + (4 x 8) + (2 x 8) = 71 cases, though only 39 algorithms excluding mirrors. If we consider R2 setups, this number goes below 30.
Alg-2: Permutes 6 corners. These will be <R,U,D> algs (<R2,U,D> is enough, but algs may get lengthy); and again surprisingly, there are very few cases thanks to the same freedom and symmetry. There are 5 + (4 x 6) + 18 = 47 cases, though only 29 algorithms excluding mirrors. 2 sided recognition is possible here.
Alg-3: L5EP, <M,U> gen 16 short algs very simple to recognise during the previous alg.

This 3 alg system, which without any reduction has 71+47+16 = 134 algs (CFOP has 78 excluding F2L) can reduce the cube state from a possible 6! * 5! * 3^5 / 2 = 10M cases! This is 700 times more than 15k of CFOP, instead of an expected sqrt(15k)~120. Basically, this algorithm system is better per algorithm required compared to 2LLL, plus has comparable to better recognition; and looking at the movesets potentially better and shorter algs.

Now to the hard part:
How do we achieve " a 2x2x3 is solved on DL; FR and BR edges are solved; and the remaining 5 edges are oriented"?

Two premises about this.
Firstly, blockbuilding is probably the best thing that can be done with the inspection time in terms of reducing the number of cubestates. A roux block does this slightly better than a petrus block, which is better than a cross; all solving the same number of pieces (counting centres, since roux centres aren't fixed).
Second, there is a reason CFOP is as successful as it is, and that is the symmetry in F2L. We can choose to do whichever F2L pair we please, and we can do these in any order. This is very good for a step that is neither algorithmic, nor block building; because we can simply do whatever we see first. Finally, we can use only the last pair to influence LL.

This gives us a beautiful way to achieve the above mentioned cubestate. A roux block can be done in inspection, and then each of the 4 edges UF, UB, DF and DB can be placed between corresponding centres in any order convenient; while influencing EO. Follow this with a rotation and you have your required cubestate! The best part is, this central "belt" doesn't have to align with FB, because at the end of the solve, we can do an AUF with an ADF and will be done.
The EO condition in the belt can be relaxed in a more advanced version of the method, where one can learn all L5E algs (roughly 200 cases, ~60 algs excluding mirrors and setups).


Summing it all up:

Intermediate version:
Step 1: FB (~6 moves)
Step 2: EO-Belt (~14 moves) <r,R,U>
Step 3: 6COLL (~13 moves) <R,U>
Step 4: 6CPLL (~12 moves) <R,U,D>
Step 5: L5E (~15 moves) <M,U>
Avg ~ 60 moves

Advanced version:
Step 1: FB (~6 moves)
Step 2: Belt (~9 moves) <r,R,U>
Step 3: 6COLL (~13 moves) <R,U>
Step 4: 6CPLL (~12 moves) <R,U,D>
Step 5: L5E (~15 moves) <M,U>
Avg ~ 55 moves

Promising a higher TPS than CFOP, this should be pretty good. Let me know.

Sounds nice!

Why does eo belt make more move count

Solve a cross, then solve EO-Cross. Which one took more moves?

 

[TerryD]

Been fiddling with an idea. Let the bashing begin. If it survives, I'll gen the algs for example solves for further scrutiny.

Philosophy and motivation:
Algorithmic methods are doing fairly well compared to block building methods, and for good reason. TPS on the new hardware has shot up and it makes sense to make best use of it. A method with a bearable number of algorithms, yet highly algorithmically reliant and with good recognition has the potential to beat a good deal of methods. A means to achieve that is to have 3 algorithmic steps (compared to 2 for CFOP for example); while ensuring that those algorithms do indeed tackle a large set of cases (2LLL CFOP handles ~15k cases).
Orientation steps are almost always recognition friendly as long as they involve one (or two) top colour (like TSLE is decent for recog, OLL is pretty good, etc. but LEOR EO is hard) Permutation steps are good for recognition if a single glance at a cube, and registering 4-5 stickers at most can uniquely identify each case (like 2 sided PLL recognition system if good, ZBLL recognition on the other hand is hard, so is 4x4 PLL).
Cube symmetries can play a huge role in reducing number of algorithms while getting tons of cases solved (There are 72 PLL cases, but symmetry reduces it to 22 (21+1)). These symmetries can be exploited much better once we think about it.

Based on these primers and a bit of work, there seems to be one very promising end to a solve using 3 algorithms:
Suppose a 2x2x3 is solved on DL; FR and BR edges are solved; and the remaining 5 edges are oriented (i.e. white/yellow facing up/down say).
Alg-1: orients 6 corners. This will be a short <R,U> alg; and surprisingly, there are very few cases thanks to the freedom of U layer and the S slice symmetry. Also, R2 setups cut this down much further. There are 23 + (4 x 8) + (2 x 8) = 71 cases, though only 39 algorithms excluding mirrors. If we consider R2 setups, this number goes below 30.
Alg-2: Permutes 6 corners. These will be <R,U,D> algs (<R2,U,D> is enough, but algs may get lengthy); and again surprisingly, there are very few cases thanks to the same freedom and symmetry. There are 5 + (4 x 6) + 18 = 47 cases, though only 29 algorithms excluding mirrors. 2 sided recognition is possible here.
Alg-3: L5EP, <M,U> gen 16 short algs very simple to recognise during the previous alg.

This 3 alg system, which without any reduction has 71+47+16 = 134 algs (CFOP has 78 excluding F2L) can reduce the cube state from a possible 6! * 5! * 3^5 / 2 = 10M cases! This is 700 times more than 15k of CFOP, instead of an expected sqrt(15k)~120. Basically, this algorithm system is better per algorithm required compared to 2LLL, plus has comparable to better recognition; and looking at the movesets potentially better and shorter algs.

Now to the hard part:
How do we achieve " a 2x2x3 is solved on DL; FR and BR edges are solved; and the remaining 5 edges are oriented"?

Two premises about this.
Firstly, blockbuilding is probably the best thing that can be done with the inspection time in terms of reducing the number of cubestates. A roux block does this slightly better than a petrus block, which is better than a cross; all solving the same number of pieces (counting centres, since roux centres aren't fixed).
Second, there is a reason CFOP is as successful as it is, and that is the symmetry in F2L. We can choose to do whichever F2L pair we please, and we can do these in any order. This is very good for a step that is neither algorithmic, nor block building; because we can simply do whatever we see first. Finally, we can use only the last pair to influence LL.

This gives us a beautiful way to achieve the above mentioned cubestate. A roux block can be done in inspection, and then each of the 4 edges UF, UB, DF and DB can be placed between corresponding centres in any order convenient; while influencing EO. Follow this with a rotation and you have your required cubestate! The best part is, this central "belt" doesn't have to align with FB, because at the end of the solve, we can do an AUF with an ADF and will be done.
The EO condition in the belt can be relaxed in a more advanced version of the method, where one can learn all L5E algs (roughly 200 cases, ~60 algs excluding mirrors and setups).


Summing it all up:

Intermediate version:
Step 1: FB (~6 moves)
Step 2: EO-Belt (~16 moves) <r,R,U>
Step 3: 6COLL (~13 moves) <R,U>
Step 4: 6CPLL (~12 moves) <R,U,D>
Step 5: L5EP (~13 moves) <M,U>
Avg ~ 60 moves

Advanced version:
Step 1: FB (~6 moves)
Step 2: Belt (~9 moves) <r,R,U>
Step 3: 6COLL (~13 moves) <R,U>
Step 4: 6CPLL (~12 moves) <R,U,D>
Step 5: L5E (~15 moves) <M,U>
Avg ~ 55 moves

Promising a higher TPS than CFOP, this should be pretty good. Let me know.

Very interesting method, seems like ergonomics and algs would be pretty good. I think L5E takes less moves though. Are you going to generate algorithms for this?

 

[CyoobietheCuber]

I tried a solve this is what I got, not correct moveset though:

Scramble: F' L' U2 B' R2 U2 R2 D2 R2 B L2 B' U2 F2 D F' U R' D2 R' F

y'
R' S U2 R2 r' u' r' U r2 //2x2x3
U2 R2 F R F' R2 U' R // Belt
R2 U' R U2 R2 U' R2 U' R2 U2 R // CO
U R2 U' D' F2 l' R' F R F' R U2 r' U L // CP
U2 M' U M' U' M' U2 M U' M2 U2 D // L5E

EDIT: Tell me if I did something wrong.

 

[PapaSmurf]

That's something similar to what I proposed a while back: 2x2x3, solve 6 corners somehow, DR+BR, L5E. On the subject of L5E, I'm pretty sure FR+LL L5E is better than DF, although that could be wrong. These type of methods (2x2x3 first) could be pretty good, but there has been almost no exploration, so if you put the work in to figure it out, that would be very useful. I do think that ideally the method would average 50 or fewer moves too, but that's not as important.

 

[Devagio]

Very interesting method, seems like ergonomics and algs would be pretty good. I think L5E takes less moves though. Are you going to generate algorithms for this?

Not sure about L5E, couldn’t find anything about it being done in one look; guessed 15 because that’s typical L6E length, and there’s no reason L5E would be better. It would be much faster though due to 1-looking.
So far not much downsides to the methods have been claimed, so I guess I will gen a few algs for the sake of example solves in a while.

I tried a solve this is what I got, not correct moveset though:

Scramble: F' L' U2 B' R2 U2 R2 D2 R2 B L2 B' U2 F2 D F' U R' D2 R' F

y'
R' S U2 R2 r' u' r' U r2 //2x2x3
U2 R2 F R F' R2 U' R // Belt
R2 U' R U2 R2 U' R2 U' R2 U2 R // CO
U R2 U' D' F2 l' R' F R F' R U2 r' U L // CP
U2 M' U M' U' M' U2 M U' M2 U2 D // L5E

EDIT: Tell me if I did something wrong.

The start of the solve is done differently to what I proposed. I did think of doing it this way, but the symmetry in a vertical belt and the difficulty in planning an entire 2x2x3 in inspection made the choice easy.
I’ll post an example solve in a while, check it out then.

EDIT: might make a separate thread for this and call it CFOP-breaker XD

 

[Username: Username:]

Been fiddling with an idea. Let the bashing begin. If it survives, I'll gen the algs for example solves for further scrutiny.

Philosophy and motivation:
Algorithmic methods are doing fairly well compared to block building methods, and for good reason. TPS on the new hardware has shot up and it makes sense to make best use of it. A method with a bearable number of algorithms, yet highly algorithmically reliant and with good recognition has the potential to beat a good deal of methods. A means to achieve that is to have 3 algorithmic steps (compared to 2 for CFOP for example); while ensuring that those algorithms do indeed tackle a large set of cases (2LLL CFOP handles ~15k cases).
Orientation steps are almost always recognition friendly as long as they involve one (or two) top colour (like TSLE is decent for recog, OLL is pretty good, etc. but LEOR EO is hard) Permutation steps are good for recognition if a single glance at a cube, and registering 4-5 stickers at most can uniquely identify each case (like 2 sided PLL recognition system if good, ZBLL recognition on the other hand is hard, so is 4x4 PLL).
Cube symmetries can play a huge role in reducing number of algorithms while getting tons of cases solved (There are 72 PLL cases, but symmetry reduces it to 22 (21+1)). These symmetries can be exploited much better once we think about it.

Based on these primers and a bit of work, there seems to be one very promising end to a solve using 3 algorithms:
Suppose a 2x2x3 is solved on DL; FR and BR edges are solved; and the remaining 5 edges are oriented (i.e. white/yellow facing up/down say).
Alg-1: orients 6 corners. This will be a short <R,U> alg; and surprisingly, there are very few cases thanks to the freedom of U layer and the S slice symmetry. Also, R2 setups cut this down much further. There are 23 + (4 x 8) + (2 x 8) = 71 cases, though only 39 algorithms excluding mirrors. If we consider R2 setups, this number goes below 30.
Alg-2: Permutes 6 corners. These will be <R,U,D> algs (<R2,U,D> is enough, but algs may get lengthy); and again surprisingly, there are very few cases thanks to the same freedom and symmetry. There are 5 + (4 x 6) + 18 = 47 cases, though only 29 algorithms excluding mirrors. 2 sided recognition is possible here.
Alg-3: L5EP, <M,U> gen 16 short algs very simple to recognise during the previous alg.

This 3 alg system, which without any reduction has 71+47+16 = 134 algs (CFOP has 78 excluding F2L) can reduce the cube state from a possible 6! * 5! * 3^5 / 2 = 10M cases! This is 700 times more than 15k of CFOP, instead of an expected sqrt(15k)~120. Basically, this algorithm system is better per algorithm required compared to 2LLL, plus has comparable to better recognition; and looking at the movesets potentially better and shorter algs.

Now to the hard part:
How do we achieve " a 2x2x3 is solved on DL; FR and BR edges are solved; and the remaining 5 edges are oriented"?

Two premises about this.
Firstly, blockbuilding is probably the best thing that can be done with the inspection time in terms of reducing the number of cubestates. A roux block does this slightly better than a petrus block, which is better than a cross; all solving the same number of pieces (counting centres, since roux centres aren't fixed).
Second, there is a reason CFOP is as successful as it is, and that is the symmetry in F2L. We can choose to do whichever F2L pair we please, and we can do these in any order. This is very good for a step that is neither algorithmic, nor block building; because we can simply do whatever we see first. Finally, we can use only the last pair to influence LL.

This gives us a beautiful way to achieve the above mentioned cubestate. A roux block can be done in inspection, and then each of the 4 edges UF, UB, DF and DB can be placed between corresponding centres in any order convenient; while influencing EO. Follow this with a rotation and you have your required cubestate! The best part is, this central "belt" doesn't have to align with FB, because at the end of the solve, we can do an AUF with an ADF and will be done.
The EO condition in the belt can be relaxed in a more advanced version of the method, where one can learn all L5E algs (roughly 200 cases, ~60 algs excluding mirrors and setups).


Summing it all up:

Intermediate version:
Step 1: FB (~6 moves)
Step 2: EO-Belt (~16 moves) <r,R,U>
Step 3: 6COLL (~13 moves) <R,U>
Step 4: 6CPLL (~12 moves) <R,U,D>
Step 5: L5EP (~13 moves) <M,U>
Avg ~ 60 moves

Advanced version:
Step 1: FB (~6 moves)
Step 2: Belt (~9 moves) <r,R,U>
Step 3: 6COLL (~13 moves) <R,U>
Step 4: 6CPLL (~12 moves) <R,U,D>
Step 5: L5E (~15 moves) <M,U>
Avg ~ 55 moves

Promising a higher TPS than CFOP, this should be pretty good. Let me know.

I don't really understand how L5E is MU

Promising a higher TPS than CFOP, this should be pretty good. Let me know.

This is quite a bold claim, CFOP's main pro is TPS and I don't really know but isn't like FB's TPS lower than cross? belt looks like an ok step but L5E is SUD gen, so I don't see the higher TPS.

 

[Devagio]

I don't really understand how L5E is MU

If L6E is MU gen, L5E by default is too. Well technically its SU gen, but a D' will fix that.

This is quite a bold claim, CFOP's main pro is TPS and I don't really know but isn't like FB's TPS lower than cross? belt looks like an ok step but L5E is SUD gen, so I don't see the higher TPS

FB and cross should be at worst similar TPS, belt is higher TPS than F2L since you don’t have to track 2 pieces or rotate, and a higher percentage of the solve is algorithms; which in all makes a higher TPS objectively certain.

 

[TheSlykrCubr]

something that just popped into my head

1) EO+ F2L pair on TR of B layer

2) Expand to a column

3) Solve 2 blocks, so it looks like roux

4) LSE

5) L3C

 

[Devagio]

Made a slight modification to the start to save a rotation, which also happened to help lookahead by reducing blindspots. However, rRU turning had to be traded for RUu turning during belt.
Here is an example solve:

Scramble: B L' U F' L' R2 D' B F' U B U' L R2 U2 F2 B2 L' D2 U2 F' B R2 L B

y2 // inspection
F U2 B' L F B2 // FB
u R u R' u R2 u' R' U2 R // Belt
U R' U' R U2 R' U' R // 6CO
R2 U2 R2 U'D' R2 U R2 U' R2 D R2 D' // 6CP
M' U M U2 M' U M' U M2 U' M' U2 M' U2 M2 // L5E
U'D' // Adjusting faces

This solve was 50 execution turn metric, and i tried a few solves which averaged around 50 moves. Since the method is algorthmic, this number should hold even for speedsolves; which means this method may be more efficient CFOP during speedsolves despite having higher TPS!

I believe I will need assistance in generating the 6CP algs. Also, critique please.

 

[ribbon method]

What are you guys gonna call this method

 

[I'm A Cuber]

EDIT: might make a separate thread for this and call it CFOP-breaker XD

What are you guys gonna call this method

YCFop
Edit: no actually it’s called quadrangular Francisco but a little better

 

[Devagio]

What are you guys gonna call this method

Not sure yet, probably something along the lines of "665" (6CO, 6CP, L5E; because that's what the method aims to achieve), also just short of evil XD
For now, putting solves on example solves thread; and making a separate thread in a while because I do intend to work on it.

 

[ribbon method]

Do a detail walk through vid

 

[LukasCubes]

The EO Method is a new method in which hopefully many people uses in the future.

Proposer: Lukas Herrell
Proposed: 2020
Alt Names: ZZ-LH
Varients: ZZ,, ZZ-CT, ZB
No. of Steps: 4 or 5 depending on LL
No. of Algs: 2-493
No. of Moves: (~50 ZBLL) (~60 OLL+PLL)
Purposes: Speedsolving, FMC, OH, Feet Solving

Steps:
1. EO (Edge Orientation)
2. The Line (Solve DF an DB Edges)
3: ZZ-F2L
4: OLL (7 Cases)
5: PLL (21 Cases)
(4 and 5 can be combined for ZBLL which has 493 Cases)

Pros: No Rotations, Reduced Move set, Ease of Learning
Cons: Weird Alg Ergonomics, +2 cubie for F2L, Swithing between L an R Moves

Well that was painful to write but that's the EO method for yall. Goodbye!