# The New Method / Substep / Concept Idea Thread

#### obelisk477

##### Member
Thank you very much, I've seen CFCE listed under methods but never taken the time to look into it. Also, I'm new to the forums, so if I have a question about a method (NMLL), where would I put it? I don't even know what it stands for because all of the entries I've found on it are very short.
You would post it here generally, or in the ZZ or Roux help for NMLL specifically. NMLL stands for non-matching last layer, and I recently answered a question about it here, posts 610 through 612 on that page

#### Sion

##### Member
I was thinking for Hawaii 4-O if it would be efficient to pair all the dedges, and then fix the last two centers of the 4x4 using an orientation preserving alg.

#### xyzzy

##### Member
I was thinking for Hawaii 4-O if it would be efficient to pair all the dedges, and then fix the last two centers of the 4x4 using an orientation preserving alg.
Can you provide an example solve? I'm guessing you'd do centres using commutators (as in the cage method), which isn't too bad on its own, but combining this with an awkward edge pairing stage would suck.

In fact, it looks like you're practically forced to have awkward stages of some sort once you have 3×3×4+columns solved. Dealing with edges is pretty weird when you're this restricted. You have nice stuff like a seven-move parity fix (destroys centres), but it's also hard to intuitively solve edges regardless of whether you have to preserve centres because the "M' U M"-like triggers are all 5-cycles. Solving centres is very easy and fast if you don't have to preserve edges, but if you do, it becomes a lot slower.

#### Sion

##### Member
Can you provide an example solve? I'm guessing you'd do centres using commutators (as in the cage method), which isn't too bad on its own, but combining this with an awkward edge pairing stage would suck.

In fact, it looks like you're practically forced to have awkward stages of some sort once you have 3×3×4+columns solved. Dealing with edges is pretty weird when you're this restricted. You have nice stuff like a seven-move parity fix (destroys centres), but it's also hard to intuitively solve edges regardless of whether you have to preserve centres because the "M' U M"-like triggers are all 5-cycles. Solving centres is very easy and fast if you don't have to preserve edges, but if you do, it becomes a lot slower.
Thought of the same. Instead, I decided to reduce L10E into L5E via Redux after solving centers. This is different from OBLBL, as it leads to L5EOP, which is a bit faster than OLL/ PLL. It's how I finally solved 4x4 completely, although my redux skills need serious work.

#### Shiv3r

##### Member
lol guys, originally I tried this out as a joke, but:

7 FB
5-6 <r,R,U> to solve 2x2x3
5 EO
12-13 F2L + phasing
14 ZZLL
= 43-45 STM

Here's the reddit post where I first pitch this to oyoat because I assume he'd be most familiar with how fast Petrus-related things can go. I also link to data I've collected to get these movecount estimates that I've given above.

This fixes the bad fingertricks/lookahead in the 2x2x3 step of Petrus (since it's <r,R,U> now and you can easily track where the two edges are going in inspection). Given that PDF is able to one-look FB + SBsquare pretty often, I wouldn't be surprised if people could be able to one-look the entire 2x2x3.
I came up with this kinda thing a while back, but my problem with petrus was how EO isn't too nice-- it takes a few seconds to orient all the pieces.(its ok on OBLBL tho...)
-FB
-Orient 3 edges on R layer and place on DR, FR, and RB
-Roux 4a+place DF/DB edges(about as hard as EOLR, which can be done pretty quickly and fluidly) -- problem is that you may need to use r moves to solve sometimes if the DF/DB edges are on the R layer
-rotationless Petrus F2L + LL

#### Shiv3r

##### Member
Could be good. Main issue with beginners' methods is getting beginners to choose them over LBL
What about HF-beginner? It would be a really nice for beginners to not just transition over to CFOP. because of the L5EO stage, you get the basic LSE 4a step down, and learn some basic EOline.

#### Teoidus

##### Member
Yeah, I saw your post on that while back. It's less efficient to do EO that way though. Overall the EO step in petrus just seems a little awkward and I think ZZ had the right idea moving it to the front of the solve

#### Shiv3r

##### Member
Yeah, I saw your post on that while back. It's less efficient to do EO that way though. Overall the EO step in petrus just seems a little awkward and I think ZZ had the right idea moving it to the front of the solve
Yeah, but for a rotationless petrus it isn't too bad.
One thing I am doing: I use OBLBL as my main method for 5x5. Why? because it takes the best parts of petrus, and EO isn't too bad. Also, I hate building centers.

#### UKL

##### Member
I've been experimenting with this for only a few days now, but here goes nothing.

If you've ever looked closely at what Winter Variation actually does, it basically orients all the corner of the top layer. So I've been thinking about combining this with Roux. So the way the method would go would be:

1. First block
2. Second block
3. Winter Variation
4. Permute last layer corners
5. LSE
Using this would also decrease the alg count from 42 CMLL cases to 29 cases (27 WV and 2 perms).

So what do you guys think, would this help in decreasing times (or other benefits). Any problems with this?

P.S. - Suggest any edits or corrections if there's a mistake

#### Cale S

##### Member
This would only skip CMLL 1/6 of the time, and another 1/6 of the time you're giving yourself the worst CMLL case. Adj swap isn't that good of a case either

WV is also pretty inefficient for some cases, especially when you force yourself to use it all the time (if you set up to an R U R' insert you have to do an extra R U2 R' or R U' R'), and it's very inefficient for roux

If you want to decrease the alg count, you could do CP during last pair, which would be 6 cases for the last pair and then only 7 for CMLL

#### Elo13

##### Member
If you want to decrease the alg count, you could do CP during last pair, which would be 6 cases for the last pair and then only 7 for CMLL
Or you can do CP during FB.

#### TDM

##### Member
Yeah, the oriented corners cases aren't very good - but actually, neither are a lot of the solved CP cases (U, L, T are all bad). Combining both is good, but then the algs can be long if you want to preserve the pair (and also remain pseudo-2-gen). A few people have also taken a look at inserting just the corner and solving CO, an then doing something like FR+EO+setup ULUR, but it's far less efficient than standard Roux.

There have been lots of attempts to get this to work but I don't think skipping CMLL is the future of Roux, unfortunately. Influencing EO/EP during CMLL is far easier and will probably save you more time. Though, learning the difference between sledge, R U' R' and R U2 R' could be good to influence better COs.

#### Sue Doenim

##### Member
I was looking into the B2 method and I really liked it. I do however realize that CPFB is not, and may never be, feasible for speedsolving. Still, I like the idea of forcing an arrow case for EO. I've thought of a couple different ways to do it, which will be called A and B method. Starting at F2B-1, the steps are:
A
1) Make sure 1 D layer edge is oriented and one is not.
2) Use a 0-flip or 4-flip VHLS case.
3) Solve corners with COLL.
B
1) Make sure 1 D layer edge is oriented and one is not.
2) Insert final F2L pair
3) Use a COLL or CLLEF case to force arrow case.
Both of these could work; B is probably better than A.

##### Member
I was looking into the B2 method and I really liked it. I do however realize that CPFB is not, and may never be, feasible for speedsolving. Still, I like the idea of forcing an arrow case for EO. I've thought of a couple different ways to do it, which will be called A and B method. Starting at F2B-1, the steps are:
A
1) Make sure 1 D layer edge is oriented and one is not.
2) Use a 0-flip or 4-flip VHLS case.
3) Solve corners with COLL.
B
1) Make sure 1 D layer edge is oriented and one is not.
2) Insert final F2L pair
3) Use a COLL or CLLEF case to force arrow case.
Both of these could work; B is probably better than A.
I think what most people do (at least what I do) is sort of a simplification of pinkie pie where you have a few (usually 2 though I don't think there are many who actually learn them on purpose but rather just have picked them up over the years) algs for each CMLL which flip or exchange different pieces each time and that can be used to influence EO so that you always get a reasonably nice case and never get any of the really horrible ones like 6-flips. It's nice because you don't have to make sure you have certain pieces in D or anywhere really and it is the same speed as normal CMLL (more or less depending on your lookahead. With my lookahead (which I consider to be reasonable to bad for where I should be), you take no extra time and save a few moves in LSE most of the time).

#### Teoidus

##### Member
Wait guys, you don't have to BLD trace

Let's just assume we've got a permutation of corners on R and U faces. We can of course solve DRF and DRB <R,U> leaving a permutation of LL corners on U that we could use to detect a CP fix (aka what people do with COLL or porky style recog), but we can also simulate this solving in inspection with swaps. If we solve DRF and DRB with pure swaps, there's at most 1 extra "correction" swap that we have to do s.t. the 3 swaps performed together form a valid 2-gen permutation (essentially using the property of 2gen group to simulate the <R,U> moves needed to solve DRF and DRB while shortcutting all the tracking you'd need to do so). Then we can much more quickly figure out where our LL pieces would be w.r.t each other than if we had directly tracked what the LL would look like by imagining DRF and DRB solved w/ <R,U>.

So given any permutation of 6 corners we can imagine what the LL would look like if we 2gen solved DRF and DRB by imagining these swaps being done. And then looking at the resulting permutation of LL corners to figure out the key swap

Now this is easy to generalize to 7 corners--whenever we hit the DLF piece, we just pretend it's whatever piece is current at DLF (simulating a swap to solve DLF). Now without any BLD tracing we can extract a key swap, and we can easily express this key swap in a standard form that lets it be easily tracked.

#### Shiv3r

##### Member
Wait guys, you don't have to BLD trace

Let's just assume we've got a permutation of corners on R and U faces. We can of course solve DRF and DRB <R,U> leaving a permutation of LL corners on U that we could use to detect a CP fix (aka what people do with COLL or porky style recog), but we can also simulate this solving in inspection with swaps. If we solve DRF and DRB with pure swaps, there's at most 1 extra "correction" swap that we have to do s.t. the 3 swaps performed together form a valid 2-gen permutation (essentially using the property of 2gen group to simulate the <R,U> moves needed to solve DRF and DRB while shortcutting all the tracking you'd need to do so). Then we can much more quickly figure out where our LL pieces would be w.r.t each other than if we had directly tracked what the LL would look like by imagining DRF and DRB solved w/ <R,U>.

So given any permutation of 6 corners we can imagine what the LL would look like if we 2gen solved DRF and DRB by imagining these swaps being done. And then looking at the resulting permutation of LL corners to figure out the key swap

Now this is easy to generalize to 7 corners--whenever we hit the DLF piece, we just pretend it's whatever piece is current at DLF (simulating a swap to solve DLF). Now without any BLD tracing we can extract a key swap, and we can easily express this key swap in a standard form that lets it be easily tracked.
So we only need to simulate 3 swaps? Im game, I just tried it and it works! Waaay easier than the other way you proposed, thanks!

#### Teoidus

##### Member
Here's a table of the correction swaps you need to ensure that every triplet of swaps is actually a valid 2gen permutation.

Basically first you pretend that DLF is solved by pure swap.

Now you take the swap you need to solve DRB and look at the corresponding row in the table. Now take the swap you need to solve DRF after you've done the previous swap to solve DRB and look at the corresponding column in the table. Read out a "correction" swap. Now when you determine what your LL ends up looking like after the two swaps to solve DRB and DRF, you can figure out what swap you need to reduce the corners to 2gen by combining the permutation of the LL corners with this "correction" swap. So if your correction swap is diagU and you find that your LL corners end up needing a diagU swap after you use two swaps to solve DRB and DRF, then your correction swap cancels with the LL corner swap, telling you that the corners are already solvable 2gen

#### Shiv3r

##### Member
Hey guys, remember that rotationless petrus variant you proposed a while back? Well, Just did an Ao5(I'm calling it Pootris)
Pootris average of 5:
Generated By csTimer on 2017-1-9
avg of 5: 21.81

Time List:
1. (16.59[pootris]) U' R2 B2 D B2 R2 D B2 D' L2 U2 L R2 B' D2 B2 R' F U' L' F
2. 22.18[pootris] F2 D L2 U' R2 U' R2 D2 R2 F2 D2 L' R' B D' R' B L2 U B' U
3. 22.62[pootris] B R2 D' L2 B2 D L2 U' F2 D' R2 L U B' D2 B' R B L
4. 20.62[pootris] B2 F2 D' R2 D L2 U2 F2 D' L2 D L F D' U2 L F' U2 F R' U'
5. (25.87[pootris]) B2 R' B' D B' R2 F R' B2 U' F2 U2 L B2 D2 L2 D2 R B2 R2 B2

Method overview(again -- how I do it)
Roux block, while tracing DF/DB(poot block Here!)
solve DF/DB and centers, while predicting EO
solveEO(I do 2 at a time, with F Rx F', maybe I should do some more efficient EOing...)
Finish F2L
LL(I do COLL-EPLL)

Last edited:

#### Metallic Silver

##### Member
OLL skip or VLS and OLL with EG on skewb would be helpful.
Instead of just EG, you can do EG and orient all top side at once. (EGOLL) This will get rid of L5C and first layer helpful.
If OLL skip is possible for skewb, it will get rid of advanced sarah cases and L5C. It will leave off L4C or L3C. (VLS)

downside is that i cant work on my ksolve program, my stupid command prompt is too advanced and frustrating