The New Method / Substep / Concept Idea Thread

[2180161]

Idea for 3x3:

1. FB (1x2x3 block on L) Avg. moves: 10

2. Permute corners (R corners+ Y or J perm ) Avg. Moves: 13

3. solve a 2x2x3 using [R,Rw,M,U] Avg. Moves:7

4. EO using [R,U,Uw,M]but preserving F2L Avg. Moves- ?

5. F2L using [R,U] Avg. Moves-?

6. 2GLL Avg. Moves- 13?

I think this could be very good, because it has the many of the same steps of several methods combined, and it also has a fairly low move-count. (I believe anyway). It also has a good look-ahead, unless you decide to use CPLS instead of inserting the R corners and then doing CMLL, but...

So what do you guys think? Has a few algs to learn, but not any that you shouldn't already know. (i.e: H,Z,U,T,Y perms, and the 7 OCLL's)

Pros:

Spoiler

Fairly low move-count
Ergonomic (3-gen solve after step 2 and 2-gen after step 4)
Low alg count for a less advanced version

Cons:

Spoiler

High alg count for advanced version
EO detection can be difficult for beginners
Recognition for step 2 can be difficult
Colour neutrality can be difficult.

 

[TDM]

Idea for 3x3:

1. FB (1x2x3 block on L) Avg. moves: 10

2. Permute corners (R corners+ Y or J perm ) Avg. Moves: 13

3. solve a 2x2x3 using [R,Rw,M,U] Avg. Moves:7

4. EO using [R,U,Rw,M]but preserving F2L Avg. Moves- ?

5. F2L using [R,U] Avg. Moves-?

6. 2GLL Avg. Moves- 13?

This is Noah's CP block method 2.0 (or something like that, I can never remember the name exactly).

A few things though: firstly, FB should be less than 10 moves. However I personally think that since you're doing that in inspection, it would be better to combine it with ZZ-porky v2 to permute the corners while solving the block in about 10-12 moves in total. Steps 3 and 4 could maybe be combined - when doing this method, I usually solve DB, then EO, and then DF, though I'm sure there are better ways to do it.

(also, there's a typo in step 4: EO is done with RrU, not RuU).

 

[2180161]

This is Noah's CP block method 2.0 (or something like that, I can never remember the name exactly).

A few things though: firstly, FB should be less than 10 moves. However I personally think that since you're doing that in inspection, it would be better to combine it with ZZ-porky v2 to permute the corners while solving the block in about 10-12 moves in total. Steps 3 and 4 could maybe be combined - when doing this method, I usually solve DB, then EO, and then DF, though I'm sure there are better ways to do it.

(also, there's a typo in step 4: EO is done with RrU, not RuU).

No, I do EO with UuR. It is like 3-2-3 with Yau/Hoya, but with bad edges. Slice, insert bad edge, slice back.

 

[shadowslice e]

Idea for 3x3:

1. FB (1x2x3 block on L) Avg. moves: 10

2. Permute corners (R corners+ Y or J perm ) Avg. Moves: 13

3. solve a 2x2x3 using [R,Rw,M,U] Avg. Moves:7

4. EO using [R,U,Uw,M]but preserving F2L Avg. Moves- ?

5. F2L using [R,U] Avg. Moves-?

6. 2GLL Avg. Moves- 13?

I actually quite like this method but I would also like to make one small change: for steps 3 and 4, solve DB, orient, solve DF.

Also, you can permute the corners quite easily if you use something other than j or y perms that permutes but doesn't preserve orientation such as F (sexy) F' for adjacent swap and you can use another similar alg for opposite after you have permuted the two D corners.

So I would say

1) FB (8 moves)
2) Permute remaining corners (<10 moves)
3) orient edges and solve 2x2x3 (~10 moves?)
4) finish F2L (~10 moves?)
5) 2GLL (13 moves)

Total: ~51 moves?

But I think something would need to be done to improve the recognition because atm it's not very nice for at least 2 of the steps, lookahead is not great either and the efficiency could probably be better (maybe by doing steps 1-3 in a merged way such as
1) FB+ DB edge
2) permute corners
3) orient edges (L5E sort of way) and place FD.

 

[2180161]

I actually quite like this method but I would also like to make one small change: for steps 3 and 4, solve DB, orient, solve DF.

Also, you can permute the corners quite easily if you use something other than j or y perms that permutes but doesn't preserve orientation such as F (sexy) F' for adjacent swap and you can use another similar alg for opposite after you have permuted the two D corners.

So I would say

1) FB (8 moves)
2) Permute remaining corners (<10 moves)
3) orient edges and solve 2x2x3 (~10 moves?)
4) finish F2L (~10 moves?)
5) 2GLL (13 moves)

Total: ~51 moves?

But I think something would need to be done to improve the recognition because atm it's not very nice for at least 2 of the steps, lookahead is not great either and the efficiency could probably be better (maybe by doing steps 1-3 in a merged way such as
1) FB+ DB edge
2) permute corners
3) orient edges (L5E sort of way) and place FD.

I ended up doing an average of 12 and it was sub 30, and it was the first times I ever solved with it. I feel it has potential, if it were to be improved or would have less moves.
EDIT: an idea for that would be phasing while inserting the last edge to lower the 2GLL cases down a few.
Example solve:

Spoiler

Scramble:L' B' D2 U2 B D2 F' D2 R2 D2 U2 R' F' D B2 U2 F' U F L' F2
x y2//inspection

F' U B D' R' U F'//FB
U2 R L' U R2 U' x'//CP
U2 M' U2 M U' M U' M'//2x2x3
R' U R U2 F B' R F' B// EO
R2 U R2 U2 R U R U' R' U R U2 R' U R U2 R'// F2L with phasing
R' U' R U' R' U2 R U R' U' R U' R' U2 R'//2GLL

 

[shadowslice e]

I ended up doing an average of 12 and it was sub 30, and it was the first times I ever solved with it. I feel it has potential, if it were to be improved or would have less moves.
EDIT: an idea for that would be phasing while inserting the last edge to lower the 2GLL cases down a few.
Example solve:

Spoiler

Scramble:L' B' D2 U2 B D2 F' D2 R2 D2 U2 R' F' D B2 U2 F' U F L' F2
x y2//inspection

F' U B D' R' U F'//FB
U2 R L' U R2 U' x'//CP
U2 M' U2 M U' M U' M'//2x2x3
R' U R U2 F B' R F' B// EO
R2 U R2 U2 R U R U' R' U R U2 R' U R U2 R'// F2L with phasing
R' U' R U' R' U2 R U R' U' R U' R' U2 R'//2GLL

If you use partial corner control you will end up with 5 cases (ELL) (mostly U-perm) so I think the only barrier to this becoming a very nice method is the recognition for CP as the alg count can be reduced to 32 -or 30 ignoring mirrors (I think edited MGLS or WV would be best).

Alternatively, you could also insert a U layer piece when you finish the 2x2x3 to cause an L5E case which are shorter to my knowledge. Thus
1) FB + 1E (9 moves)
2) CP (10 moves)
3) orient edges + insert U piece to finish 2x2x3 (10 moves)
4a) Square (5 moves)
4b) MGLS/ WV etc (8 moves)
5) L5E (7 moves)

=49 moves?

also, 1LLL!

 

[mDiPalma]

No, I do EO with UuR. It is like 3-2-3 with Yau/Hoya, but with bad edges. Slice, insert bad edge, slice back.

pretty sure that will affect CP.

 

[shadowslice e]

If you use partial corner control you will end up with 5 cases (ELL) (mostly U-perm) so I think the only barrier to this becoming a very nice method is the recognition for CP as the alg count can be reduced to 32 -or 30 ignoring mirrors (I think edited MGLS or WV would be best).

Alternatively, you could also insert a U layer piece when you finish the 2x2x3 to cause an L5E case which are shorter to my knowledge. Thus
1) FB + 1E (9 moves)
2) CP (10 moves)
3) orient edges + insert U piece to finish 2x2x3 (10 moves)
4a) Square (5 moves)
4b) MGLS/ WV etc (8 moves)
5) L5E (7 moves)

=49 moves?

also, 1LLL!

Further modification/ correction stuff

1) FB+DB edge and DBR corner (any orientation) (10 moves)
2) CP (7 moves)
3) Orient edges+place U piece in FD. (L5E style is personal preference- 8 moves)
4) Finish F2L
4a) Square (5 moves)
4b) WV/MGLS etc (8 moves)
5) L5E (7 moves)

Total: 45 moves so I would say that <48 could confidently be the average with this method. However, step 2 is a fairly horrible step for recognition although you could go with the bars method which I will post about when I work out how to explain it properly.

If I were to name this I would probably say something like anti-tripod or tripod first due to the tripod being formed first.

Pros:
Decent lookahead overall, very good after step 2
Very ergonomic (3 gen then 2 gen)
Low movecount
Low algcount (~40)
No very complex steps

Cons
Mainly the horrible recog for step 2 otherwise not too much IMO.

 

[TDM]

No, I do EO with UuR. It is like 3-2-3 with Yau/Hoya, but with bad edges. Slice, insert bad edge, slice back.

RrU can orient four edges at a time, rather than two. It could be good to use a mixture of the two though, provided you keep things pseudo-2-gen.

I actually quite like this method but I would also like to make one small change: for steps 3 and 4, solve DB, orient, solve DF.

Also, you can permute the corners quite easily if you use something other than j or y perms that permutes but doesn't preserve orientation such as F (sexy) F' for adjacent swap and you can use another similar alg for opposite after you have permuted the two D corners.

I suggested that method for EO223 and a better CP method a few posts before

EDIT: an idea for that would be phasing while inserting the last edge to lower the 2GLL cases down a few.

Seen this a few times lately. Unphasing the edges is almost certainly better, thought I might make an except for an easy 2-gen WV case, since you don't want to stop yourself getting a LL skip!

pretty sure that will affect CP.

Not if he doesn't rotate, since U/E/Uw/R moves don't affect CP.

 

[mDiPalma]

Not if he doesn't rotate, since U/E/Uw/R moves don't affect CP.

he's doing u R U' R' u' to orient BR and UR. that surely changes the CP

and slice moves/rotations do affect CP, just not in the way ur thinking

 

[TDM]

he's doing u R U' R' u' to orient BR and UR. that surely changes the CP

and slice moves/rotations do affect CP, just not in the way ur thinking

Given that he's not rotating and treating two adjacent corners in DL as solved, his last layer will still be 2-gen provided he continues to only use R, Rw, U and Uw moves. The centres are treated as other pieces to solve, in the same way that edges are, and can essentially be ignored in this example.

 

[2180161]

he's doing u R U' R' u' to orient BR and UR. that surely changes the CP

and slice moves/rotations do affect CP, just not in the way ur thinking

Say you do the alg R2 U R2 U' R2 U R2 U'. It affects CP, but in relation to each other. So, the solve can still be done 2-gen after EO. Now, it does affect CO however, but that is not needed to worry about.

Given that he's not rotating and treating two adjacent corners in DL as solved, his last layer will still be 2-gen provided he continues to only use R, Rw, U and Uw moves. The centres are treated as other pieces to solve, in the same way that edges are, and can essentially be ignored in this example.

I don't really do Rw very often. Only if my last move was R', will I do that. Otherwise, I use M.


And if you do phase, you lower the alg count to 32 I believe, so you have a total alg count of ~35, which is less than many alg sets.

So move-count (I took the worst possible scenarios)
FB (9)
CP (7)
2x2x3 (6)
EO while preserving CP (8)
R,U F2L with LL phasing (15)
Reduced 2GLL (13)

Total move count: 58 (I probably have a high move count for my F2L, so someone else's will probably be better.)

Pros:
35 total algs
Decent movecount
Very ergonomic
1LLL
CP can have look-ahead into since FB should be done in inspection

Cons:
CP recognition can be a pain in the ***
Block-building can be difficult to get a hang of.
EO can be difficult to get a hang of
2GLL recognition isn't necessarily the greatest

 

[mDiPalma]

if u say that a Uw (D y) move doesn't affect [RU] CP, then u r saying that an L move doesn't affect [RU] CP, by translation. technically u r right, but u r discounting a rotation and a move that breaks the movegroup. that's fine, but u r lying 2 the world

also, using RUu to orient edges is literally the worst way to do it, without avoiding doing it. u can't cancel anything, and ur restricted in what pieces u can solve. even using M moves is better.

u r much better off doing a Petrus EO3x2x2 and porky v1 F2L, followed by RU LPELL. ull save ~10 moves, have less steps, and ur desk wont have dents in it from the amount of times u smashed ur forehead into it

also phasing is bad, here

 

[2180161]

I have revised it once again, and it is decent. Basically the same thing, except you orient edges, while placing DF and DB. This is done with RUMr

 

[shadowslice e]

I did some playing around and decided that it would be a good idea to combine this with my F2L method (FB+2x2x2) because you don't really need to affect the DBR corner after CP. Also, it means that you can intuitively 3-cycle or 2-swap the corners during CP which is much easier to recognise and you cut down on the maximum number of misoriented edges that are possible (it is easily possible to get 0,2 or 4 everytime). Lastly, you also save moves because you don't have to double up steps.

 

[2180161]

I did some playing around and decided that it would be a good idea to combine this with my F2L method (FB+2x2x2) because you don't really need to affect the DBR corner after CP. Also, it means that you can intuitively 3-cycle or 2-swap the corners during CP which is much easier to recognise and you cut down on the maximum number of misoriented edges that are possible (it is easily possible to get 0,2 or 4 everytime). Lastly, you also save moves because you don't have to double up steps.

Estimated move-count with this? about 45-50?

 

[shadowslice e]

Estimated move-count with this? about 45-50?

A bit higher but the CP can definately be done more efficiently. I did some number crunching and came up with this (note I do this method completely intuitively other than COLL/ WV thing
FB: 8
2x2x2: 8
CP: 10 (but the recog is horrible)
Eo: 6 (if you force good cases)
WVLSish cp preserving thing: 12
L5E: 7 .
Total: 51 moves

Or if you learn 2GLL:
FB: 8
2x2x2: 8
CP: 10
Eo+ DF: 6
LS: 5
2GLL: 13
Total: 50

the main problem ATM (other than horrible CP recog) is that it has too many small steps after SSF2L-2

 

[mDiPalma]

A bit higher but the CP can definately be done more efficiently. I did some number crunching and came up with this (note I do this method completely intuitively other than COLL/ WV thing
FB: 8
2x2x2: 8
CP: 10 (but the recog is horrible)
Eo: 6 (if you force good cases)
WVLSish cp preserving thing: 12
L5E: 7 .
Total: 51 moves

Or if you learn 2GLL:
FB: 8
2x2x2: 8
CP: 10
Eo+ DF: 6
LS: 5
2GLL: 13
Total: 50

the main problem ATM (other than horrible CP recog) is that it has too many small steps after SSF2L-2

do u guys brute force all the states, do you find the worst possible state, or are u just randomly speculating movecounts?

 

[shadowslice e]

do u guys brute force all the states, do you find the worst possible state, or are u just randomly speculating movecounts?

FB is anecdotal evidence. Certainly I can do it in ~9 and I know I have some weak points.
2x2x2 follows on in much the same way- I average ~9
CP, set up moves+ 3 cycle+ undo setup (it can actually be much lower as shown by NCPB2
Eo+DF: I got the statstic from L5E wiki plus a couple of set up moves. This is also if you force a good case (ie. 4 flip or 0 flip.
LS: this one I'm not entirely sure about but I know that it is <7 so I semi-arbitrarily pick 5 as I know ZZLS can have some very nice cases.
2GLL: wiki statistic
The WVLSCP thing is just from the cases that I generated because they came up while I was solving.

 

[2180161]

I have no Idea if this has been thought of, looked on the wiki and found nothing so here I go.
EOline
Left block
CP
reduce cube to ab3c case using only R,U
L3C
Not too sure about move-count, or if it would even be suitable for speedsolving.
Fairly certain about these movecounts below though
EOline: 7
Left block:?
CP:7
RU to ab3c:?
ab3c:8?

OR:
EOline:7
Left block:12
CP:7
1x2x2 in BDR:?
LPELL:7.4
L4C:11.73

The L4C is actually 2GLL H-case for every OCLL, and then pure OCLL's