The New Method / Substep / Concept Idea Thread

[genericcuber666]

I think that with some pre-edgepairing magic like in Yau/Meyer/Hoya, Z4 can be a big competitor to the other 4x4 methods.
Here's my proposal(just a rough idea, if you have suggestions please contribute them):
1.2 opposite centers on L/R
2.orient 4 edges, put 3 on the L side(FR, DR, BR, and DL)
3.solve last 4 centers
4.pair the line edges
5.rest of Z4 edgepairing and solving

pros:
-no rotations after 2 opposite centers
-only RUL moves for ZZF2L after edgepairing
-with parity-included EPLL, permutation parity is directly solved, therefore no extra parity step
cons:
-step 2 can be hard to wrap your head around
-See Z4 for Lookahead and other problems

how do you like it?

seems really nice but could you also do something like yau then for l8e do z4 or is that inefficeint i dont know much about z4 though so feel free to just ignore that . also all these new advances in zz are so cool.

 

[Shiv3r]

seems really nice but could you also do something like yau then for l8e do z4 or is that inefficeint i dont know much about z4 though so feel free to just ignore that . also all these new advances in zz are so cool.

EOline is much more efficient to do, and the blockbuilding is much freer and smoother feeling when the rest of the cross is isn't place already.

 

[Teoidus]

Don't think there's a good way to EOPair as efficiently as 3-2-3

 

[JustinTimeCuber]

Based off of CubeRoll's method but modified.
Step 1: 1x2x3 block
Intuitive mostly, hold it on the bottom left like Roux.
Step 2: CURL (Corners of the U and R Layers)
Solve the rest of the corners and the 2 remaining E-layer edges at FR and BR. Also mostly intuitive.
Step 3: L7EM: Last 7 edges, M layer. 1st part of 2-look L7E. Once this step is complete, the M layer will be completely solved.
Step 4: L7ES: Last 7 edges, S layer. 2nd part of 2-look L7E. Same algs as step 3, except not all can occur.

Step 3 and 4 can be combined once I generate all the algs (72).

Algs:
FD>FU>BU>FD: R F R U R F R U
FD>BU>FU>FD: R U R F R U R F
FU>BU>BU, FD>BD>FD: M U M U
FU>BD>FU, BU>FD>BU: U M U x' U M U
Parity fix for M slice*: R F R F R F

*There're probably better ways to solve the M slice when there is parity, which I'll generate soon. Parity is just when there is a 4-cycle or a 2-swap instead of a 3-cycle or two 2-swaps.

 

[GuRoux]

i feel like trying to solve f2b with only double turns => cmll skip => LSE(4b4c), seems better.
i think you can easily average sub 20 moves, probably with more practice sub 15 moves.
in terms of time, sub 5 shouldn't be too hard.

 

[AlphaSheep]

The reason I really don't like Z4 is that you only do chain pairing 50% of the time. Otherwise its just beginner edge pairing with EO added in. Because of that, its about 50% more moves than 3-2-3. That's a lot of extra moves. If you just do normal 3-2-3, EO takes only around 6 moves. If you can push good edges to the back, then EO after pairing can typically be done in 4 moves, and recognition is almost instant since all the bad edges are on U and F. That's why I like a Hoya-like approach, because pushing good edges to the back can be done without interrupting the flow of the solve.

 

[shadowslice e]

Is this for speed or fun? Because I'm pretty sure recog and ergonomics are going to suck.

 

[JustinTimeCuber]

i feel like trying to solve f2b with only double turns => cmll skip => LSE(4b4c), seems better.
i think you can easily average sub 20 moves, probably with more practice sub 15 moves.
in terms of time, sub 5 shouldn't be too hard.

when you get to the second block, you can get all but the DF edge intuitively, that's why the CURL step is so easy. Then, it's a matter of 2 algs, first solving the M slice, then rotating and solving the E slice.

Is this for speed or fun? Because I'm pretty sure recog and ergonomics are going to suck.

Ideally there would be more algorithms, but with more algorithms the recognition might be tricky, but I don't think it would be that much of a problem, although I wouldn't know because I haven't tried. Anyway, here's an example solve:

R U R D R B F D B L U F L F D L B F D B R U D B L //scramble
y' x' R U B //FB
R U R U R U //CURL
r F R F R F x2 R F R U R F R U //L7EM
y x R F R U R F R U //L7ES

 

[sqAree]

Anyway, here's an example solve:

R U R D R B F D B L U F L F D L B F D B R U D B L //scramble
y' x' R U B //FB
R U R U R U //CURL
r F R F R F x2 R F R U R F R U //L7EM
y x R F R U R F R U //L7ES

It's not working for me.

Also, in CURL step we have to solve not only all the remaining corners but also SB?

EDIT: Nvm, it does work. Everything clear now.

 

[JustinTimeCuber]

It's not working for me.

Also, in CURL step we have to solve not only all the remaining corners but also SB?

EDIT: Nvm, it does work. Everything clear now.

CURL is solving all the remaining corners and the RF and RB edges, the DR edge is probably not solved. (1/3 chance that it is solved, but it doesn't matter

 

[GuRoux]

the example solve has so many moves, i think sub 15 is possible with what i said. using tricks like psuedo blocks is also often helpful.

 

[JustinTimeCuber]

I made a kewl random-state scrambler
https://repl.it/DkkQ/0
Most scrambles are around 10 moves, but there's a 6 move minimum

 

[efattah]

Normally I believe CFOP-ZBLL is the fastest method (even though I don't use it), and I still think it is a tad better than ZZ-CT... but I have recently imagined a Roux variant which could possibly take the crown. I call it the Roux-M variant. I got the idea from Marc Waterman's long forgotten trick.

When Waterman would solve the last four corners with CLL, he created CLL algorithm variants where he injected M or M' moves in the middle of the CLL algorithm. This allowed him to solve at least 1 edge piece during the CLL algorithm (as injecting M/M' into a corners algorithms has no effect on the corners themselves).

Here is the Roux-M variant:
1. Build two blocks as normal
2. Ready for CLL
3. Instead of doing CLL, adjust the M slice to fix the centers so you can identify L6E orientation (must use the color of the center only, to ID edge orientation, since corners are still unsolved)
4. Execute one of (approximately) 336 MCLL algorithms to simultaneously solve the 4 corners and orient the last 6 edges
5. Finish permuting the last 6 edges as normal

Of the 336 MCLL algorithms, OLLCP is a subset. So if you already know OLLCP, then you already know 216 of the 336 MCLL algorithms, although technically you might find *slightly* faster algs if you fully generate the MCLL set since OLLCP keeps the first two layers untouched while MCLL can swap the lower edges on the M slice.

Advantages:
- Significantly fewer moves than Roux. You won't save much on the cases where edge orientation required a 3-move algorithm, but in the 'bad' cases like the 6-flip you save tons of moves, as the MCLL algorithm will never be more than about 3 moves longer than the associated CLL algorithm, and in some cases it is 0 moves longer since you can replace R/R' with r/r', or L/L' with l/l' which moves the M slice without adding any extra moves.
- Eliminates a look. Normally CLL is one look, then edge orientation is another look. By combining them together, with practice, you can identify them together.
- Greater chance for fast singles. With Roux the chance of L6E skip is essentially zero. With Roux-M you add a small but possible chance of an L6E skip after the MCLL algorithm, allowing for the occasional extremely fast single (like ZZ-CT also gives a good chance of lucky singles)



Eric Fattah
BC, Canada

 

[Teoidus]

This is essentially Pinky Pie, but with more algorithms and (arguably) slightly less efficient.

With pinky pie, you build the two blocks, then force UL UR on D or UF UB on D. You don't care about where the centers are. You then detect EO for the centers based on whatever center sticker ended up on U, then use OLLCP to orient L4E and solve the corners. This leaves an ~8 move LSE.

 

[efattah]

I'm not sure I agree. How can Pinky Pie be more efficient if you have to use several moves to put UL/UR into D, especially when you have to make sure that they are placed in an oriented position? That whole step is skipped in Roux-M.

Eric Fattah
BC, Canada

 

[Teoidus]

It is usually quite easy to place either UL UR or UF UB. This would take like 4 moves max by itself, and oftentimes you can cancel 1-2 of these moves into the end of your SB solution.

I wouldn't think of it as solely a setup for OLLCP as it serves another purpose of already placing ULUR or UFUB in an advantageous position for the next step. This saves more than I think you take into consideration.

If you're not convinced, we can look at movecount breakdowns after F2B like this:
Pinkie Pie:
Force ULUR/UFUB (0-3 STM)
OLLCP (~11 STM)
LSE - solve ULUR or UFUB (2-3 STM)
LSE - 4c (0-6 STM)
= ~13-23 STM

Your proposal:
MCLL (~11 STM, will assume since OLLCP is a pretty big subset of it)
LSE - ULUR or UFUB (0-6 STM)
LSE - 4c - (0-6 STM)
= ~11-23 STM

So I'd say you get a little bit more variance with MCLL but I wouldn't call it any more or less efficient. (This makes Pinkie Pie the better choice, since you've got less algs)

Another issue with solving EO like you suggest (and also with Pinkie Pie really) is that it's actually less efficient sometimes to go for the EO skip than to go for, say, a 4flip that you can solve EO + ULUR in 3-4 moves.

If you just look at standard Roux with a streamlined EOLR step (which is not amazingly difficult):
CMLL (~9 STM)
LSE - EOLR (~0-9 STM)
LSE - 4c (~0-5 STM)
= ~9-25 STM

You're obviously almost never going to get that 9 STM L10P, but notice how the movecounts are relatively similar. This is because EO is ultimately just not the best step to force skips out of--influencing it is great, but a large alg set is better spent on other things. A sufficiently advanced LSE will often generate near-optimal <M,U> solutions.

As far as improving on Roux goes, I think blocks are a better place to start. Often speedsolve solutions are nowhere near as efficient as they can be; an alg set/approach that regularly generates sub-20 STM block solutions would be very nice to have.

 

[cornercutproductions]

My new method (Roux ZZ style variant)

Step 1 basically eo line but you hold the two solved edges on the right and left rather than front and back then make sure that only top and bottom layer edges are in the front and back positions.

Step 2 solve f2l using only R,U,L

Step 3 do cmll but mainly use colls to keep the orientation of the edges

Step 4 solve the remaining 6 edges using m,u keep in mind that the six edges will be oriented

 

[GuRoux]

My new method (Roux ZZ style variant)

Step 1 basically eo line but you hold the two solved edges on the right and left rather than front and back then make sure that only top and bottom layer edges are in the front and back positions.

Step 2 solve f2l using only R,U,L

Step 3 do cmll but mainly use colls to keep the orientation of the edges

Step 4 solve the remaining 6 edges using m,u keep in mind that the six edges will be oriented

you can try it, but this tends to be significantly less efficient than regular roux.

 

[Teoidus]

ZZ has R/L regrips, Roux has R,r regrips. To avoid that, reduces to <R,U,D> and then <R,U> and then <M,U>. Nice and ergonomic and less algs than CMLL for LS CO, though CP recog still sucks

EOLine on Left (6-8 STM)

FB + CP (~7 STM)

SB + LS (~15 STM)

4b + 4c (5-11 STM)

33-41 STM

 

[GuRoux]

ZZ has R/L regrips, Roux has R,r regrips. To avoid that, reduces to <R,U,D> and then <R,U> and then <M,U>. Nice and ergonomic and less algs than CMLL for LS CO, though CP recog still sucks

EOLine on Left (6-8 STM)

FB + CP (~7 STM)

SB + LS (~15 STM)

4b + 4c (5-11 STM)

33-41 STM

looks interesting. what does LS stand for? can you write an example solve?