# The New Method / Substep / Concept Idea Thread

#### Oatch

##### Member
I randomly created this "method" when I was high on multiple medicine when I had the flu. I just thought of it and tried it out.
The idea of building F2L except for 2 cross edges, then inserting them with <M, U> and then doing last layer has been suggested before, with different methods for reaching this cube state and dealing with LL afterwards. To reiterate what most people think about this idea: it's pretty inefficient to insert the cross edges with M and U moves and then carrying on, it's probably better to use LSE at that point.

A more promising idea that I was playing around with at one point that follows a similar vein of thinking is to insert two U-layer edges into the DF and DB positions, like what you have done, but to specifically place the UL and UR edges instead. Simultaneously, edges are oriented while you place the edges, so you essentially make a pseudo-EOLine. Then you blockbuild the left and right blocks as normal. Once you get to LL, perform COLL and then you reach a cube state where you've skipped 4a of Roux LSE and setup to finish 4b extremely quickly because the corresponding edges are already setup at the bottom and are only an M2 away from being solved (+ maybe an AUF). Then all that remains is 4c which can usually be done quite with less moves than EPLL. The movecount should be quite a bit lower than your suggested variant. Again, I'll just emphasise that what I've suggested is nothing groundbreaking and has definitely been considered before, but I thought you may be interested in it.

##### Member
the final method I'm proposing (SBOPP)(squares-block-orient+phase-pll)

1) solve an edge piece in DB

2) solve the two 2x2x1 blocks in BLD and BRD

3) solve the first two layers using intuition while locating and tracking the edge phasing for the next step

4 26/27) solve oll and phase the edges using 1/163 algorithms
4 1/27) if you get an co skip use 1/155 algorithms to solve ll

5) solve pepll (phased-edge-pll) using 1/9 (1/24 skip)

example solve
R' L' F' U B U' F L' F R B U L D' F U R L R D' U' L' B L' F B

1) B2
2a) L2 U F R x' U' R' U x R2
2b) L2 F' (U2 D') L (D U') L'
3a) F' U2 l' U2 l F'
3b) U' L' U L U2 y' R U R'
4) U2 F R U R' U' R U' R' U R U R' F'
5) 1/24 skip

#### Thom S.

##### Member
the final method I'm proposing (SBOPP)(squares-block-orient+phase-pll)

1) solve an edge piece in DB

2) solve the two 2x2x1 blocks in BLD and BRD

3) solve the first two layers using intuition while locating and tracking the edge phasing for the next step

4 26/27) solve oll and phase the edges using 1/163 algorithms
4 1/27) if you get an co skip use 1/155 algorithms to solve ll

5) solve pepll (phased-edge-pll) using 1/9 (1/24 skip)

example solve
R' L' F' U B U' F L' F R B U L D' F U R L R D' U' L' B L' F B

1) B2
2a) L2 U F R x' U' R' U x R2
2b) L2 F' (U2 D') L (D U') L'
3a) F' U2 l' U2 l F'
3b) U' L' U L U2 y' R U R'
4) U2 F R U R' U' R U' R' U R U R' F'
5) 1/24 skip
Last Layer doesn't seem that bad, just without a straight advantage. But your First Two Layers - The Phrase
Or you could just use Petrus
couldn't fit more. Effectively the only difference is the missing EO Part.

Also, why your last Proposal? Did you have some aggreement to make like 13 Methods and then leave or did you just give up?

##### Member
Last Layer doesn't seem that bad, just without a straight advantage. But your First Two Layers - The Phrase
Or you could just use Petrus
couldn't fit more. Effectively the only difference is the missing EO Part.

Also, why your last Proposal? Did you have some aggreement to make like 13 Methods and then leave or did you just give up?
this method is based on all the research i have learned, and i believe it has enough efficiency, lookahead and tps with a small enough alg count to be the fastest method i can make. so all i have to do is get good at the method and learn the algorithms.

#### architmahale

##### Member
The idea of building F2L except for 2 cross edges, then inserting them with <M, U> and then doing last layer has been suggested before, with different methods for reaching this cube state and dealing with LL afterwards. To reiterate what most people think about this idea: it's pretty inefficient to insert the cross edges with M and U moves and then carrying on, it's probably better to use LSE at that point.

A more promising idea that I was playing around with at one point that follows a similar vein of thinking is to insert two U-layer edges into the DF and DB positions, like what you have done, but to specifically place the UL and UR edges instead. Simultaneously, edges are oriented while you place the edges, so you essentially make a pseudo-EOLine. Then you blockbuild the left and right blocks as normal. Once you get to LL, perform COLL and then you reach a cube state where you've skipped 4a of Roux LSE and setup to finish 4b extremely quickly because the corresponding edges are already setup at the bottom and are only an M2 away from being solved (+ maybe an AUF). Then all that remains is 4c which can usually be done quite with less moves than EPLL. The movecount should be quite a bit lower than your suggested variant. Again, I'll just emphasise that what I've suggested is nothing groundbreaking and has definitely been considered before, but I thought you may be interested in it.
Thank you! So whatever I've been doing is extremely inefficient? Got it. Also hello fellow Pink Floyd fan.

#### Sue Doenim

##### Member
The idea of building F2L except for 2 cross edges, then inserting them with <M, U> and then doing last layer has been suggested before, with different methods for reaching this cube state and dealing with LL afterwards. To reiterate what most people think about this idea: it's pretty inefficient to insert the cross edges with M and U moves and then carrying on, it's probably better to use LSE at that point.

A more promising idea that I was playing around with at one point that follows a similar vein of thinking is to insert two U-layer edges into the DF and DB positions, like what you have done, but to specifically place the UL and UR edges instead. Simultaneously, edges are oriented while you place the edges, so you essentially make a pseudo-EOLine. Then you blockbuild the left and right blocks as normal. Once you get to LL, perform COLL and then you reach a cube state where you've skipped 4a of Roux LSE and setup to finish 4b extremely quickly because the corresponding edges are already setup at the bottom and are only an M2 away from being solved (+ maybe an AUF). Then all that remains is 4c which can usually be done quite with less moves than EPLL. The movecount should be quite a bit lower than your suggested variant. Again, I'll just emphasise that what I've suggested is nothing groundbreaking and has definitely been considered before, but I thought you may be interested in it.
That's ZZ 4C. It's not a new method, but it's definitely viable. I like it.

#### PapaSmurf

##### Member
the final method I'm proposing (SBOPP)(squares-block-orient+phase-pll)

1) solve an edge piece in DB

2) solve the two 2x2x1 blocks in BLD and BRD

3) solve the first two layers using intuition while locating and tracking the edge phasing for the next step

4 26/27) solve oll and phase the edges using 1/163 algorithms
4 1/27) if you get an co skip use 1/155 algorithms to solve ll

5) solve pepll (phased-edge-pll) using 1/9 (1/24 skip)

example solve
R' L' F' U B U' F L' F R B U L D' F U R L R D' U' L' B L' F B

1) B2
2a) L2 U F R x' U' R' U x R2
2b) L2 F' (U2 D') L (D U') L'
3a) F' U2 l' U2 l F'
3b) U' L' U L U2 y' R U R'
4) U2 F R U R' U' R U' R' U R U R' F'
5) 1/24 skip
2 things:
This one is obviously from a zz user, but couldn't you do eo and that edge piece (so a half line) and then blocks will be <RULF2>, or you could just use petrus, then for ll, if you want to phase, just use zz-b, or you could go full out and use zz-a.
For last layer, you can't depend on skips every 1/24 solves. That's like me saying "I use COLL so that I get a 1/12 pll skip every time!", but I don't. It's because a really fast epll is faster than a g-perm, and I don't like g-perms.

Also, with your example solve, without that skip you'd be getting at least 55 moves, probably more in a speedsolve from inneficiencies during F2L.

But I like the idea of half EOline for Petrus. I have no idea how well it would work though.

##### Member
2 things:
This one is obviously from a zz user, but couldn't you do eo and that edge piece (so a half line) and then blocks will be <RULF2>, or you could just use petrus, then for ll, if you want to phase, just use zz-b, or you could go full out and use zz-a.
For last layer, you can't depend on skips every 1/24 solves. That's like me saying "I use COLL so that I get a 1/12 pll skip every time!", but I don't. It's because a really fast epll is faster than a g-perm, and I don't like g-perms.

Also, with your example solve, without that skip you'd be getting at least 55 moves, probably more in a speedsolve from inneficiencies during F2L.

But I like the idea of half EOline for Petrus. I have no idea how well it would work though.
the reason i don't use eo is so i have more ways to make the squares. this barely reduces the movecount, but more importantly, increases useful finger tricks

for last layer many of the oll cases can be mirrored or right front inverted to get a different case with the same speed. the question is does it take much more recognition? also 1/24 is better than 1/72.

the ll was the hardest part to get to feel right in this method, but you could orient the edges while finishing the last block and finish with zbll if you want.

I'm not going to use petrus, I'm using SBOPP.

#### Neuro

##### Member
(SBOPP)(squares-block-orient+phase-pll)

1) solve an edge piece in DB

2) solve the two 2x2x1 blocks in BLD and BRD

3) solve the first two layers using intuition while locating and tracking the edge phasing for the next step

4 26/27) solve oll and phase the edges using 1/163 algorithms
4 1/27) if you get an co skip use 1/155 algorithms to solve ll

5) solve pepll (phased-edge-pll) using 1/9 (1/24 skip)
I see little reason to use this.

The 1st 2 steps are Ok but not great. Maybe doing 3/4 Cross (even pseudo) and inserting pairs would be better. Also, free blockbuilding 2x2x3 in the back garners same result with more room for flexibility.

Intuitive F2L isn't bad in the 3rd step but fingertricks won't be too great.

Why not do phasing EO+ZZLL? You'd have only 7 EO+Phasing algs and ZZLL is 169 cases; significantly less than what you'd be using. Sure, there aren't as many skips, but the algs are easier to recognize and are already fairly well optimized (ZZLL at least.) You could even just use EO+Last pair, COLL, and EPLL. Just 45 algs (assuming intuitive EO+LP) with a higher skip chance and incredible algs.

Perhaps something like this

1: 1x2x3
2: Finish Cross (Steps 1 and 2 is one approach to 2x2x3+Last Cross edge, allow variation)

3: F2L (CFOP-y, fast and intuitive but allows variations and tracking) EO or track phasing depending on LL variant
4: LL (however you want, depends on how you do F2L (COLL/EPLL, EO+Phasing/ZZLL, OLL/PLL, EO+ZBLL, lots of room)

##### Member
I see little reason to use this.

The 1st 2 steps are Ok but not great. Maybe doing 3/4 Cross (even pseudo) and inserting pairs would be better. Also, free blockbuilding 2x2x3 in the back garners same result with more room for flexibility.

Intuitive F2L isn't bad in the 3rd step but fingertricks won't be too great.

Why not do phasing EO+ZZLL? You'd have only 7 EO+Phasing algs and ZZLL is 169 cases; significantly less than what you'd be using. Sure, there aren't as many skips, but the algs are easier to recognize and are already fairly well optimized (ZZLL at least.) You could even just use EO+Last pair, COLL, and EPLL. Just 45 algs (assuming intuitive EO+LP) with a higher skip chance and incredible algs.

Perhaps something like this

1: 1x2x3
2: Finish Cross (Steps 1 and 2 is one approach to 2x2x3+Last Cross edge, allow variation)

3: F2L (CFOP-y, fast and intuitive but allows variations and tracking) EO or track phasing depending on LL variant
4: LL (however you want, depends on how you do F2L (COLL/EPLL, EO+Phasing/ZZLL, OLL/PLL, EO+ZBLL, lots of room)
the first step is made inflexible so it is easier to one look the back block with being able to locate other pieces for the next step. i honestly don't see why you think building a 3/4 cross will be better than the way I'm doing it.

the finger tricks are actually good for the third step

the reason i do not use eo+phasing→zzll is that an algoithm is better if it has less exact things it could do. lets use oll as an example. oll as we know it is good, but pure oll is bad, because you can no longer mess up the permutation.

about alg optimization, every fastest algorithm (except i dont trust the ell algs) to solve every case can be found at
http://birdflu.lar5.com/?pos=____&list=algs

#### Noa

##### Member
Original post
I've thought about a way to do LL + LS quite quickly. My idea is to orient and permute the corners while inserting LS, then there's 4 OLLs you can get from there(one of them being OLL solved completely). Then use ELL to orient and permute the LL edges. That would be LS, OLL and PLL solved in 2 algorithms.

I just can't find a method that orients and permutes the corners while inserting LS. If anyboody know of such methods please tell me.

It would also be great if somebody could teach me how you find all the possible cases. E.g. how would you go about finding all the possible cases for PLL.
This is if there isn't any method out there that meets my requirements, I will maybe be able to make it myself.

2nd post
I have done some work and I am pretty sure, that for a method that orients and permutes the LL corners while inserting LS, while egnoring LL edges, there wil be 324 unique cases. I haven't done the math, since i don't know how, therefore I am not sure if there is only 324 cases. If anyone could do the math i would really appreciate it.

I did this by using Cube Explorer and making it figure out a lot of generators for cases where the LS corner and edge are paired up and in LL right about the slot they're supposed to go in to. I let it go on to find about 130.000 generators, out of those 130.000 there were 324 unique cases. But I'm still not sure if there are more.

I think, but I'm not sure that i am the first to do this method, I was thinking of calling it HVLS(Hansen Vejlø Last Slot((Hansen for the guy whom helped me make this method and Vejlø for myself)). An alternative name would be COPLS(Corners Permutation and Orientation Last Slot), OPCLS(Orientation and Permutation of Corners Last Slot) or CLLLS(Corners Last Layer Last Slot).
If I'm not the first to come up with this, please feel free to correct me, i will gladly credit him/her.

I will be learning these 324 algorithms over this and next year(I'm not that fast a learning algorithms, so it'll take a while), if there is found more cases I will certainly learn those as well. I hope this will become a replacement for the normal LS + OLL + PLL, though the Alg. count is quite high.
Bump.

#### Neuro

##### Member
Technically this idea has been done in form of WVCP; where you have all edges oriented and you solve the corners+LS in 1 look. However, you have naming rights b/c yours doesn't preserve EO. There are 27 CO states from (U) R U' R' insert, and 6 possible CP states, so you get 27*6=162 algs. However, it's generally agreed that the recognition takes too long and algs are usually bad (at least in WVCP.) I think it could work, but CP recog is very difficult to do quickly w/o a constant orientation in my experience; not to mention having to see the CO at the same time. Long recog time and (potentially) bad algs.

It's not a bad idea, but w/o a LOT of practice it's not very viable IMO. However, what you may try doing is using this as an opportunity to learn a subset of 1LLL. This is purely an idea, no idea the feasibility here. Perhaps insert using no-EO Winter Variation, and use the subset of 1LLL where all corners are oriented? Less algs than ZBLL and easier to recognize Maybe with speed-optimized algs it could be fast?

#### Noa

##### Member
Technically this idea has been done in form of WVCP; where you have all edges oriented and you solve the corners+LS in 1 look. However, you have naming rights b/c yours doesn't preserve EO. There are 27 CO states from (U) R U' R' insert, and 6 possible CP states, so you get 27*6=162 algs. However, it's generally agreed that the recognition takes too long and algs are usually bad (at least in WVCP.) I think it could work, but CP recog is very difficult to do quickly w/o a constant orientation in my experience; not to mention having to see the CO at the same time. Long recog time and (potentially) bad algs.

It's not a bad idea, but w/o a LOT of practice it's not very viable IMO. However, what you may try doing is using this as an opportunity to learn a subset of 1LLL. This is purely an idea, no idea the feasibility here. Perhaps insert using no-EO Winter Variation, and use the subset of 1LLL where all corners are oriented? Less algs than ZBLL and easier to recognize Maybe with speed-optimized algs it could be fast?
I think you a right when saying the recognition will take long, but this can become better with (Possibly a lot) practice. At least i hope so. Maybe i can come up with some super fast recognition metod, who knows.

I'm also hoping the algs will be better, since i don't perserve EO, but i'm not sure in any way, I don't have much experience in method making, so I'll just have to try it out and so how well it works. Thank you for your opinion on the matter.

#### Terence Tan

##### Member
I don't know if this is new or not
(keep in mind that this is not for speedsolving) - R3-T

1) build a 1x2x3 in the D layer

2) solve the E slice with the empty face

3) EO

4) CO

5) complete F2L (1x1x3)with R2,U moves

6) PLL

Last edited:

#### 1001010101001

##### Member
This method is pretty wierd, probably a substep of Petrus. Basically Petrus + L5E
1. 2x2x3 block in DB
2. Bar in LF + EO
3. Last 5 corners + RF edge
4. L5E

#### Thom S.

##### Member
I don't know if this is new or not
(keep in mind that this is not for speedsolving)

1) build a 1x2x3 in the D layer

2) solve the E slice with the empty face

3) EO

4) CO

5) complete F2L

6) PLL
Solving the full E Layer maked the whole method bad for everything. EO algorithms could be much shorter if only half of the layer is solved. Don't know what CO does for you as you destroy it later. May I ask you why you want to do this?
Either you destroy your solved Edges or you use Commutators. Both is inefficient.

#### Sue Doenim

##### Member
I don't know if this is new or not
(keep in mind that this is not for speedsolving)

1) build a 1x2x3 in the D layer

2) solve the E slice with the empty face

3) EO

4) CO

5) complete F2L

6) PLL
This looks a lot like Hexagonal Francisco, which is not a bad method.

#### Aerma

This looks a lot like Hexagonal Francisco, which is not a bad method.
I used HF for as a main method for a little while, and I think if one takes the time to learn full CLS really well, it can be really good

#### xyzzy

##### Member
the reason i do not use eo+phasing→zzll is that an algoithm is better if it has less exact things it could do. lets use oll as an example. oll as we know it is good, but pure oll is bad, because you can no longer mess up the permutation.
Saying this while proposing a method that triples the chances of getting F perms and N perms (compared to plain OLL + PLL) is extremely galaxy-brain.

Why not do phasing EO+ZZLL? You'd have only 7 EO+Phasing algs and ZZLL is 169 cases; significantly less than what you'd be using. Sure, there aren't as many skips
EO + phasing / ZZLL has a 1/24 skip chance, so it's actually exactly as many skips as OLL + phasing / phased PLL.

#### Terence Tan

##### Member
Solving the full E Layer maked the whole method bad for everything. EO algorithms could be much shorter if only half of the layer is solved. Don't know what CO does for you as you destroy it later. May I ask you why you want to do this?
Either you destroy your solved Edges or you use Commutators. Both is inefficient.
Orient the corners using OCLL's
then solve the remaining of F2L with R2,U moves

Because the E slice is solved there can only be 0, 2 or 4 misoriented edges

4 misoriented -arrow
example -(D) M' U M (D') or S moves

2 misoriented - other alg