The New Method / Substep / Concept Idea Thread

[shadowslice e]

This is more or less PCMS isn't it?

R F2 D2 R' D2 L2 U2 R B2 U2 F2 U' B L' R2 F2 R' U2 R2 F

Or at least would this count as a solve using the method?
x2 U B U' r U' l'
U R U2 R
F R U' R' U R U2 R' U' R U R' U' F'
M2 U' M U M2
U M D' M D2 M' D' U'

 

[Hazel]

I've been thinking about a Roux/Waterman hybrid similar to WaterRoux:
1) Roux block on left
2) 2x2x1 block on right
3) corners
4) solve the rest of the edges as best you can (with a preference to solving D layer and left layer)
5) last 2-4 edges

Example
Scramble: D2 B2 L2 F' U2 F R2 U2 B2 D2 F D L2 U2 R F2 U' L' D'
z2 R D L' B U' D2 B2 //First block
L2 F D F2 R' F L2 //Second block
R L U L2 U R2 D2 R U' L //Corners
U2 M' U2 M2 U2 M' U2 (Ub perm) //"edges"
R B L F U F' L' B' R' U' //L3E

total: 52 (STM)
I haven't really generated any algs or anything so I haven't been able to use it in actual solves, but for somebody who's actually good at roux block building maybe it could be viable?

 

[LemonCuberIGuess]

This is more or less PCMS isn't it?

Sorta, you see F2BL is a method with 2 types, F2BOP and FEBO. F2BOP Uses CLL to solve corners and 2 look Last Layer, while FEBO uses EG and OLLCP. FEBO is faster than F2BOP, but harder to learn.

 

[KAINOS]

An idea for 'ZZ-for-5x5' thingy:

1. First 2 Centers: These are going to be L and R centers.
2. 'Bars-Redux': Instead of solving the remaining centers, reduce those into 1x1x3 bars like what would you see in the middle of Freeslice edge pairing. It's fine that the bars don't match with each other within Lw/Rw moves.
3. EOPair 8 Tredges: Same with Freeslice but do EO simultnaeously. Omit DF, DB ones and any other two.
4. 'MOLine': Orient remaining unpaired midges and place DF and DB in their correct spots.
5. 'EOLine': Solve centers and DF/DB wings using blockbuilding. You can think of it as ZZF2L (wings being corners, center bars being edges) but with <U2, D2, F2, B2, Lw, Rw> moves only.
6. Last 2 Edges: Algorithmic. (11? cases) Might be possible to do intuitively but I have no idea how to.
7. 3x3 Stage: ZZ!

It's probably just crappy, but felt like worth posting anyway.

 

[xyzzy]

An idea for 'ZZ-for-5x5' thingy:

1. First 2 Centers: These are gonna be L and R faces.
2. 'Bars': Instead of solving the remaining centers, you reduce those into 1x1x3 bars like what would you see in middle of Freeslice edge pairing. Yet it is fine that the bars don't match with each other within Lw/Rw moves.
3. EOPair 8 Edges: Same with Freeslice but do EO simultnaeously. Omit DF, DB and any other two.
4. 'MOLine': Orient remaining midges and place DF and DB in their right spots.
5. 'EOLine': Solve F/B (and U, of course) center bars and DF/DB wings using blockbuilding. Somewhat close to ZZF2L but uses <U2, D2, F2, B2, L, R, Lw, Rw>.
6. Last 2 Edges: Algorithmic. (11? cases) Might be possible to do intuitively but I have no idea how to.
7. 3x3 Stage: ZZ!

Interesting idea. I've thought about something like your step 2 before, but it's honestly hard to see how having the freedom to make unmatched bars can be of much use in L4C. In practice you'd just solve centres normally and skip the last few moves of L2C. Once you have unmatched bars though, it becomes super easy to flip an edge during freeslice: just do U2! (Note: R2 if you use E-slice edge pairing instead of M-slice.)

For step 4, you could probably use something like F R2 U R' U' F' for orienting midges two at a time, or maybe some edge comms. Step 5 doesn't look very efficient, but I might have to experiment with it more.

For step 6, I think the common parity algs already preserve EO on the L and R edges, which leaves the non-parity cases. The usual slice-flip-slice strategy will destroy EO, so here's some algs that preserve EO. (There aren't standard names for the 2+2-cycle cases, but hopefully you can figure out which alg is for which case.)

• 3-cycle: r2 D2 r U2 r' D2 r U2 r (+ mirrors and inverses)
• "opposite swap": r2 F2 U2 r2 U2 F2 r2 (same as the usual alg)
• "2-flip": r' F2 r2 U2 r' F2 r U2 r2 F2 r
• "swapped 2-flip": F2 r D2 r' F2 U2 F2 3r D2 3r' F2

 

[Sue Doenim]

Here's a method proposed be Critical Cubing, and helped in development by Teoidus. It's a Roux-ZB hybrid thing, and I think it's really promising. There is a link in the description to a document; I suggest you read through it. This is the idea:
1) FB
2) SB
3) Solve EO + place DF and DB
4) ZBLL
A few cool things I want to point out about this method: ZBLL recognition is significantly easier. Your CLL case can be recognized anytime after SB, as the M and U turns used in step 3 will not affect it. Then you can just trace your edges while finishing step 3, and in theory, have a pauseless recognition. Movecount is roughly equal, or even a little lower than in Roux.
I'd like to propose a couple of new ideas around it. Firstly, phasing during EODFDB. This probably wouldn't add too many moves on, would it? Secondly, with that idea laid down, what if you used this to allow you to recognize the ZBLL cases with or without phazing, then choose the more favorable one? That would be insane.

 

[JTay]

I've talked with Teoidus about this method some. I think it certainly has at least some potential, but I think the craziest thing theoretically possible with it would be to predict the ZZLL case before even solving the DFDB+EO+Phasing step, which I like to call HyperPhasing. If you were to make this step algorithmic and you knew exactly what each case did as far as edge permutation, you could determine which of the four ZZLL cases of each CMLL case you would get and go right into it with zero pauses. This would give a 1 look, 2 alg solution for the last 10 pieces and last 4 centers. This method would also give potential for a four look solve, with FB, Back Square, Last Pair, and the HyperPhase + ZZLL Prediction. Who knows how realistic this may be, but I found it to be interesting to think about.

 

[Đỗ Viên Rouxer]

i have come back with my Perry method:
*The step:
S1: Pblock (Perry block)
a) Fb
b) 2X2X2 in DBR+FR
S2: Po (Perry orient)
a) Orient corner (Poc)
b) Orient edge (Poe)
S3: Psq (Perry square): square on UBL
S4: Plce (Perry last corner-edge): Permutate last 3 edges and 4 corners.
*Algorithm and movecount:
S1:
a) intuitive, 7 moves
b) intuitive, 10 moves (R, U, M, r)
S2:
a) 23 alg, 7 moves
b) intuitive, 6 moves (M, U)
S3: intuitive, 8 moves (R, U, M, r)
S4: 68 algs, 14 moves (R, U, L, D)
Total: 91 algs, 52 moves

Some example solves:
1) B2 L' D2 F2 R' B2 D2 R' B2 U2 F2 D L' R F R' B U' F' U R'
z2 // inspection
L D2 B R' D2 B' D' F // Fb (8/8)
R r2 U R2 r U' r' U' r2 U R // 2X2+FR (11/19)
R U R' U R U2 R' // Poc (7/26)
M' U' M // POE (3/29)
U2 M U2 M' U M2 U M2 U' // Psq (9/38)
D R U' R U R' D R D' R D R2 D2 // Plce (13/51)

2) F R2 U' B2 D2 F2 R2 U F' R B2 D2 B2 D' B2 D' F2 U2 L2
z2 // inspection
B' L' B' U' F L' D2 // Fb (7/7)
M' U r2 U' r' U' R2 M' U2 r // 2X2+FR (10/17)
F' U2 L' U2 L F // Poc (6/23)
skip // Poe (0/23)
U M U2 M' U M2 U M2 // Psq (8/31)
U' R D2 R D R' D2 L D' R D R2 L' U // Plce (14/45)

3) L2 B R2 B U2 B R2 B U2 B' R' F D2 U2 F2 D' F2 L' D
z2 // inspection
U' F2 L2 F D B2 L2 // Fb (7/7)
U R U' R2 M U' r' U' r2 U R // 2X2+FR (11/18)
R U2 R2 U' R2 U' R2 U2 R // Poc (9/27)
M' U2 M U2 M' U' M // Poe (7/34)
r2 U R2 U R2 U2 r2 // Psq (7/41)
U2 L2 D' L2 U' L2 D L2 U' // Plce (9/50)

 

[Abram Lookadoo]

hello everyone. my name is abram lookadoo, and that is why i named it the Lookadoo method

(step inspection a) find a wat to build a 1x1x3 block (corner edge corner) and place it in DL as well as not create the diagonal corner permutation on top if solved 2 gen [R,U].

(step inspection b) after theoretically making the block, you theoretically put the block in DB and use only R[U,U2,U']R' M'[U,U2,U']M L'[U,U2,U']L r[U,U2,U']r' l'[U,U2,U']l (i will call this trigger style) to theoretically place the remaining bottom 2 corners permutation correctly, and find out witch 2 need to swap to complete the top layers permutation.

(step inspection c) find the two pieces on the still scrambled cube and find out witch two top pieces must swap for the top to be solved using trigger style, by knowing witch pieces swaps are congruent

yes inspection is crazy and not perfected

(step 1a) make the planned 1x1x3 block

(step 1 b) (this is easier than it seems) keep track of the two swapped pieces if you preform a U move, if you preform R,R2 or R' two new swapped pieces are formed due to all conditions (what two needs swaped) (what R move is used). now for the actual step, expand the 1x1x3 block into a 2x2x3 block while keeping track of the swap pieces and before the formation of the block permutate the corners (relative to the right side)

(step 1 c) preform a y rotation

(step 2 a) using trigger style place one f2l pair and influence the other pair

(step 2 b) using trigger style place the other pair

(step 2 c) place the final edge that goes into the first layer and orient all edges trigger style

(step 3) preform an 2gll algorithm 1/84 (not including skip)

so, that is my method. if anyone can provide a better style of inspection that would help.
I'm also interested about this methods move count (i calculated about 38 stm but I'm probably wrong)

 

[shadowslice e]

Spoiler

hello everyone. my name is abram lookadoo, and that is why i named it the Lookadoo method

(step inspection a) find a wat to build a 1x1x3 block (corner edge corner) and place it in DL as well as not create the diagonal corner permutation on top if solved 2 gen [R,U].

(step inspection b) after theoretically making the block, you theoretically put the block in DB and use only R[U,U2,U']R' M'[U,U2,U']M L'[U,U2,U']L r[U,U2,U']r' l'[U,U2,U']l (i will call this trigger style) to theoretically place the remaining bottom 2 corners permutation correctly, and find out witch 2 need to swap to complete the top layers permutation.

(step inspection c) find the two pieces on the still scrambled cube and find out witch two top pieces must swap for the top to be solved using trigger style, by knowing witch pieces swaps are congruent

yes inspection is crazy and not perfected

(step 1a) make the planned 1x1x3 block

(step 1 b) (this is easier than it seems) keep track of the two swapped pieces if you preform a U move, if you preform R,R2 or R' two new swapped pieces are formed due to all conditions (what two needs swaped) (what R move is used). now for the actual step, expand the 1x1x3 block into a 2x2x3 block while keeping track of the swap pieces and before the formation of the block permutate the corners (relative to the right side)

(step 1 c) preform a y rotation

(step 2 a) using trigger style place one f2l pair and influence the other pair

(step 2 b) using trigger style place the other pair

(step 2 c) place the final edge that goes into the first layer and orient all edges trigger style

(step 3) preform an 2gll algorithm 1/84 (not including skip)

so, that is my method. if anyone can provide a better style of inspection that would help.
I'm also interested about this methods move count (i calculated about 38 stm but I'm probably wrong)

This is essentially Briggs though with a less streamlined inspection and there are also a few things which I don't think would work:

(step inspection b) after theoretically making the block, you theoretically put the block in DB and use only R[U,U2,U']R' M'[U,U2,U']M L'[U,U2,U']L r[U,U2,U']r' l'[U,U2,U']l (i will call this trigger style) to theoretically place the remaining bottom 2 corners permutation correctly, and find out witch 2 need to swap to complete the top layers permutation.

This won't necessarily preserve the pieces that need to be swapped once the D corners have been placed.

(step 1 c) preform a y rotation

Personally I'm not a huge fan of fixed rotations built into a method. In addition, If you do "trigger style" in this state it will also not lead to a 2 gen LL.

(step 2 c) place the final edge that goes into the first layer and orient all edges trigger style

Why not just build it in at the same time as the two f2l pairs?

so, that is my method. if anyone can provide a better style of inspection that would help.

Have a look at Briggs/B2/the CPFB this @Teoidus came up with that I can't remember off the top of my head/ZZ-porky/ZZ-rainbow.

(i calculated about 38 stm but I'm probably wrong)

If you insist on solving in "trigger style" the movecount will most likely be around 50. If you don't, it will be closer to about 40-45 though this is assuming the methods actually works (which it doesn't in its current state due to breaking CP as indicated previously).

So CriticalCubing made up a Roux-ZZ hybrid type method called LLOB but (and I don't want to seem self-centered or anything) does anybody remember that DELToS (my old account I lost the passcode to) made this up a while before? I think I proposed it on the account too a little bit back. I have all the algs for inserting DF edge + EO here: https://docs.google.com/spreadsheets/d/1cCDVpuPzUXq_c2lItT3dBg0r2HscVXtT8ptqkD19c6I/edit?usp=sharing

and I originally called it Roux-MM (Miranda Manning), but I don't know if I specified the name

EDIT: I had a slightly different procedure for the method though, my version for L10E was CMLL, then DB while correcting centers, then DF + EO (what I called LE-OLL), then EPLL, but finishing with ZPLL seems ok too

Tbh, the thing he's come up with is essentially one variant of M-CELL which I actually have a lot of the algs genned for (or can at least find them in the case of L5E(OP)).

It's just that I've given up trying to call precedent nowadays on anything not related to SSC because when a more well known cuber comes up with something and posts about it, no one really takes notice of anyone saying they made something very similar of near identical a few months or a year earlier (eg Hexagonal Fransisco, ZZ-CT etc)

Not to diminish his or any other cubers work it's just frustrating that nowadays it's a pr game and who promotes stuff the most gets credit like ortega/varasano, Fridrich/CFOP.

 

[Abram Lookadoo]

the lookadoo method

the method does in fact work. if the corners are permutated to fit trigger style on the right side (witch is fairly easy to do), then trigger style will not change permutation of the corners. to get it to 2gll you orient the sides using M triggers, and the corners are already permutated. i have not found a way to solve f2l+eo with decent lookahead speed, without messing up corner permuation (F moves mess with the permutation with this style). this is nothing like B2. the simplified steps are 1. build a 1x1x3 block 2. expand to a 2x2x3 block+cp for trigger style on the right side 3. f2l+eo 4. 2gll. B2 is a corner permutation roux method.

the lookadoo method: a better inspection (attempt 2)

(inspection a) find out how to make a 1x1x3 block

(inspection b) find the two corners that will be on the bottom and which one is closer (1/30)

(inspection c) read where the other 4 corners will be counter clockwise (don't know why i chose counter clockwise) and find witch 2 needs to be swapped to match the corresponding permutation to the bottom corners

 

[shadowslice e]

the lookadoo method

the method does in fact work. if the corners are permutated to fit trigger style on the right side (witch is fairly easy to do), then trigger style will not change permutation of the corners. to get it to 2gll you orient the sides using M triggers, and the corners are already permutated. i have not found a way to solve f2l+eo with decent lookahead speed, without messing up corner permuation (F moves mess with the permutation with this style). this is nothing like Briggs. the simplified steps are 1. build a 1x1x3 block 2. expand to a 2x2x3 block+cp for trigger style on the right side 3. f2l+eo 4. 2gll. brigs is a corner permutation roux method.

It does work but only if you replace the pair each time before starting with the new one and only using 2 turn types at the same time. If that's what you mean it is different to what you indicated in the post. It also introduces needless inefficiencies

Also, you're thinking of B2. Briggs is 1x1x3+ CP, 2x2x3+EO, F2L, 2GLL.

 

[Abram Lookadoo]

the lookadoo method
comparison to briggs

in the briggs method you solve corner permutation relative to the front side (using R and U)
the lookadoo method solves corner permutation relative to the right side after solving the 2x2x3 block (turing the cube then using trigger style)
the lookadoo method solves edge orientation while finishing the first two layers
the lookadoo method uses trigger f2l

 

[shadowslice e]

the lookadoo method
comparison to briggs

in the briggs method you solve corner permutation relative to the front side (using R and U)
the lookadoo method solves corner permutation relative to the right side after solving the 2x2x3 block (turing the cube then using trigger style)

You don't solve CP relative to any side if you place DFR/DBR. It's solved no matter what orientation from then as long as the corners remain in seperate layers.

the lookadoo method solves edge orientation while finishing the first two layers

So does Briggs depending on the variant.

the lookadoo method uses trigger f2l

This is different but only in the way that CFOP would be different if you solved F2L using "trigger style

 

[Abram Lookadoo]

because you permiate the corners relative to the right side, it is likely impossible to solve using 2gen (R,U)
just try it mix it up using trigger style, turn the cube, and try to solve it 2gen.
this will prove that there is more than one direction to permiate corners.

you cannot solve f2l for cfop trigger style. the DF piece is not "empty". there is no way to flip sides.

the other points you provided, i cannot argue against

 

[Teoidus]

Okay, so if I read this correctly:

1x1x3
2x2x3 + reduce CP
y, "trigger style" solve two F2L pairs
L5EO and solve DF
2GLL?

Approximate movecount: 6 1x1x3 + 12 2x2x3&CP + 14 F2Lx2 (assuming 2 triggers per pair) + 9 L5EO&DF + 15 2GLL = 56 moves, with conservative estimate for trigger F2L pairs and 2x2x3&CP.

As @shadowslice e pointed out, I'm also not sure how "trigger style" preserves CP. Here's a quick counterexample:
Setup: R' U' R y
Solve: U r U r' (CP is not preserved)

Or do you mean there cannot be AUFs between triggers?
I'd have to take a closer look at the CP stuff if triggers truly preseve, but for now take a look at this:
Setup: R' U' R y
Solve: ...no good solution as far as I can see

Your description is a little hard to understand so I've included both possibilities, but it looks to me like:
If AUFs are allowed, CP isn't preserved.
If AUFs aren't allowed, I don't know if CP is preserved but some cases look like they'll be extremely inefficient.

Finally, it seems like for now you are trying to recognize and track CP by this trigger style--I recommend using 2GR's recognition system instead (and tracking/solving system as well, if they are applicable to your method)

It's just that I've given up trying to call precedent nowadays on anything not related to SSC because when a more well known cuber comes up with something and posts about it, no one really takes notice of anyone saying they made something very similar of near identical a few months or a year earlier (eg Hexagonal Fransisco, ZZ-CT etc)

Could you point out where Hexagonal/ZZ-CT were first proposed? I've heard of Roux-CFOP hybrid and some other things being reinvented hundreds of times (LLOB included) but thought those two were relatively original.

Not to diminish his or any other cubers work it's just frustrating that nowadays it's a pr game and who promotes stuff the most gets credit like ortega/varasano, Fridrich/CFOP.

I think part of the reason this is is that there's a silly precedent for putting your name on methods that you've invented. A name doesn't tell you anything about the method other than who got "first author" in its development; perhaps if method names were more about their steps than about their creators then people would be less motivated to push pr/exposure with their name on it and more motivated to develop good methods.

In a few months i will have no idea what "Roux-Miranda Manning" is but call it "Roux-EODF" or something and I'll know pretty much what it is right away. Same with this lookadoo method

 

[Abram Lookadoo]

the trigger style reduction method
(the lookadoo method)

permutation recognition and tracking (attempt 3)
and basic history

and yes, you can auf

the corner permutation is extremely confusing. the idea began when i created the idea of trigger style. i then tried to find a trigger algorithm that swaps corners, but there is no way to do that. so i thought, what happens if you preform an F move and solve it using trigger style. i found out that this causes the right two corners to swap. the method started with the block in the back. i didn't like the F move thing, so i decided to hold the block on the left so i used R moves instead. that is why we have to permiate it to the right side. that is why recognition is so difficult. you have to find out witch two on top need to swap (i acutely just found a better way to do this), then for each move you do the swap pieces change.

in this thing U means none swaps, R means the right top 2 swaps, D means that diagonals have to swap, and so on
this is what becomes what with each turn

----R----} ----U----} those things are arrows
UFLBU UUUUU
RRRRR RFLBR
DDDDD DDDDD this is why diagonal swaps are unwanted
{----R'---- {----U'---- you want to end on U when you finish the block

after this is is solvable trigger style

swap recognition

--F
14 the 6 corners and what i named them
23
--A

imagine solving the 1x1x3 block, then placing 1 in spot 1, if on bottom place A in spot 1, if both in bottom place F in spot 1, then read the names of the front two, this is the middle of this graph if permuation is correct
the left name in A spot, the top name in spot F
--- A +1 +2 +3 +4 +F
A Ee 32 F4 42 3F 23
1 42 Ee F3 4F 32 24
2 34 43 Ee AF F3 4A this is what it is if permutation is correct
3 F2 2F 4F Ee 2A A4 the top two that swap to give you the correct, is the swap pair
4 2F F2 A3 FA Ee 32
F 43 34 3A 24 A2 Ee

i had a lot of spacing difficulty there

and a question, would it be more useful to use trigger f2l+eo then 2gll, or trigger f2l then ollep?

 

[Teoidus]

Okay, I understand now:

1. 1x1x3 on LD
2. 2x2x3 + reduce CP to <B,U>
3. y rot, solve F2L pairs "trigger style" (CP is preserved wrt new <R,U>, previously <B,U>)
4. EO+DF
5. 2GLL

Your average movecount is still going to be fairly high (~55), so I'm not sure it's worth the trouble to fuss with CP in this manner.

As for F2L+EO then 2GLL, or F2L then OLLEP: F2L+EO then 2GLL will be ~12 + 9 + 15 = 36 moves, while F2L then OLLEP will be ~12 + 4 + 13? = 30 moves. OLLEP is a lot more algs though, ~57 * 12 = 694 vs the 84 2GLLs

 

[Teoidus]

Here's a method proposed be Critical Cubing, and helped in development by Teoidus. It's a Roux-ZB hybrid thing, and I think it's really promising. There is a link in the description to a document; I suggest you read through it. This is the idea:
1) FB
2) SB
3) Solve EO + place DF and DB
4) ZBLL
A few cool things I want to point out about this method: ZBLL recognition is significantly easier. Your CLL case can be recognized anytime after SB, as the M and U turns used in step 3 will not affect it. Then you can just trace your edges while finishing step 3, and in theory, have a pauseless recognition. Movecount is roughly equal, or even a little lower than in Roux.
I'd like to propose a couple of new ideas around it. Firstly, phasing during EODFDB. This probably wouldn't add too many moves on, would it? Secondly, with that idea laid down, what if you used this to allow you to recognize the ZBLL cases with or without phazing, then choose the more favorable one? That would be insane.

In my opinion, this is only worth it if you go full ZBLL. Solving EO+DFDB+Phasing is basically equivalent to solving LSE--at that point, you're better off using standard L10P (CMLL/LSE).

 

[Abram Lookadoo]

trigger style reduction method
(the lookadoo method)

advantages and disadvantages

advantages
solves more than half the cube in a decently small amount of moves (less than 20)
trigger F2L+eo can be incredibly fast if the solver has great look ahead due to it being completely made of triggers
has a relatively small 1LLL called 2gll (84 algs 13.15 average move count)
2gll algorithms can be preformed fast due to all the algorithms being 2 gen (R,U)

disadvantages
unbelievably hard to recognise the initial swap pair, so you'll have less time to lookahead
swap pair transformations are hard to keep track of if you are not used to it
if you don't have good lookahead trigger F2L will be very slow
you have to memorize 84 algorithms that consist of only R and U without getting them confused