The New Method / Substep / Concept Idea Thread

[PapaSmurf]

Yesterday, I wrote a custom solver in JavaScript to find some algs for the CMLL with a missing edge set:

It let me make more state definitions than Cube Explorer, and that helped with finding shorter algs.

I set it to find all <RUF> algs up to about 10 moves, and it found over 60 working algs! Some of the algs are a bit hard to execute.

I also threw together a website showing the algs I found and the corresponding CMLL case (the position of the FR edge might not be visible in all cases).

Here's a link: http://cmlle-algs.surge.sh/

That's pretty cool. How efficient are all the algs, because it could be a possible extension.

 

[Skewbed]

That's pretty cool. How efficient are all the algs, because it could be a possible extension.

A lot of them are just taking out the corner and putting in a pair. Lots of stuff like F U F’ though.

 

[parkertrager]

i have actually created a Facebook group for this and we have gotten some algsets and methods worth trying out.

 

[Cubinwitdapizza]

Method for 4x4 incoming (or any big cubes for that matter). This is a Petrus version of 4x4. I dont use Petrus, do anyone can tell me if I did something wrong. Also this may not be as efficient as just doing redux and then Petrus.
1. Solve first two centers. This is like normal. You can solve them however you like or which ever ones you like.

2. Put two bottom color edges on the bottom center (these must be adjacent colors and also placed adjacent to each other) and then an edge that is the same colors as your d edge’s.

3. Solve last 4 centers like yau. The exact same no differences.

4. Put one of two options in the last slot on the down center.
1. Put another d color edge in or 2. Put an edge that has at least on color similar to your two down edges that have the down color.

5. 3-2-3 edge pairing (or any edge pairing for that matter).

6. Build the 2x2x2 (which it’s edges are already in the correct position) and then use your edge from step 4 to expand to 2x2x3.

7. Do Petrus style EO and fix parity if needed.

8. Finish F2L

9. COLL

10. EPLL + Parity.

I think Im going to call it 4trus like 4x4 and trus like in the end of Petrus.

let me know what everybody’s thought are on this. Also @PetrusQuber do you do 4x4?

 

[PapaSmurf]

I kinda get what you're saying. An example solve would be nice just to clarify.

 

[Cubinwitdapizza]

Ok
Scramble: U Fw2 U' D2 Rw2 F2 L' F' Uw2 D' L D' B2 Fw' R2 D2 L2 Uw Fw' Uw2 B2 R2 Rw' Uw B Rw F' B Fw L' U' L2 U L B L' D' Uw' R' F2

Rw U’ Rw2 F Rw’ F Rw L2 Uw2 y U Rw U2 Rw’ //F2C
y’ R L’ Uw L F’ y’ R U’ R’ Uw’ D2 R2 U R’ U’ y L’ U L Uw’ L // Two d color edges and the colored edge that has the same colors as those edges put on bottom like Yau
z’ x R Rw U’ Rw’ x’ R2 U’ r U’ r’ x’ R U’ Lw’ U’ Lw // L4C
z R2 Uw’ R U R’ Uw U2 R2 // I chose to put a non d colored edge in that has at least one color in relation to the d edges. You couldve put a d color edge there but the non d edge was easier to make.
y R U’ R’ Uw L U’ L’ U’ y L’ U L Uw L U’ L’ U2 R U’ R’ Uw’ y U’ y’ R U’ R’ y R U R’ F R’ F’ R Uw’ U2 L’ U L Uw’ R U R’ F R’ F’ R Uw // 3-2-3 edge pairing.
R B U’ R’ U2 L U’ L’ F’ U2 F’ R2 U F’ U’ F’ 3Dw’ // 2x2x3
U F’ U F2 U’ L’ U2 L U2 L’ U L U2 R U2 R’ U R U’ R’ // EO+F2L
U R U R’ U’ R’ F R2 U’ R’ U’ R U R’ F’ U r2 U2 r2 Uw2 r2 Uw2 U // PLL+Parity


ok I really hope I didn’t miscramble. If I did and this doesn’t work with the scramble then keep in mind you can just reverse everything and the go from there.
Also really the only thing that’s different is the first edges so that’s all that matters in this and the 2x2x3.

 

[CubeBlazer]

I solve 6x6 weirdly and I don't know if anyone else does it this way. SPOILER: I'm garbage and average mid-4s

Step 1: Redux Centers
Step 2: Pair and Insert Cross Edges
Step 3: Yau5 L8E(Pair all F2L Edges)
Step 4: F2L3+4
Step 5: (Deal with Edge/OLL Parity at the same time) / OLL
Step 6: PLL

 

[KAINOS]

New 4x4 method for ZZ/Petrus solvers, adapted from my 5x5 ZZ method from a while ago:

1. L/R Centers
2. 1x3x4 on L
3. Center bars
4. EOpair 5 edges with freeslice, not including DF and DB edges and place them on L/R
5. Finish reduction and solve EO2x2x3 - still uncertain about how to do this part, below is one way to do it:

5-1. 'Blockbuild' centers and EOLine minus 1 wing
5-2. L5W (Last 5 Wings) - done with commuators. You may get parity (=odd number of swaps) by 50/50 chance and this might be able to be avoided in the previous step.

6. Solve the rest - Petrus F2L, COLL then EPLL+Parity should be enough.

Spoiler: Example solve

Scramble: B2 U F2 L2 R2 D L2 B2 L2 B2 D2 R2 F' L' B D B D B' F L' Fw2 U R D' Fw2 D' L D L Fw2 L Fw B D' B2 L Uw Rw' Uw Fw2 Uw' Fw Rw2

x Lw' U Lw Uw' U' Lw2 Uw L2 Uw' L' x Uw' L2 Uw // L/R Centers (13/13)

x' R2 U Rw' D' x U' D Rw2 x' B' R2 3Rw' F
B Rw' M2 R U R2 B' // 1x3x4 (18/31)

3Rw' U' Rw' 3Rw' U l' U2 l U' 3Rw' U' Rw U' // Center bars (13/44)

Rw2 // GY
U R U l2 3Rw' // OB
U' R U l' // YO
U R U' 3Rw' U2 3Rw' Rw2 // YR
U' R' U' Rw2 // WO
R U R' U' // Finish step 4 (25/69)

3Rw2 Rw' U2 l' U2 3Rw U2 Rw2
U2 3Rw U2 3Rw' Rw U2 l' U2 3Rw' // step 5-1 (17/86)

D U R2 U' r U R2 U' r' D' // step 5-2 // (10/96)

R2 U' R U' R2 U R' U' R // F2L (9/105)
F' R U2 R' U2 R' F2 R U R U' R' F' // COLL (13/118)
M2 U M2 U M' U2 M2 U2 M' U // EPLL (10/128)

Looks like this ended up being a pretty lucky solve - the actual average movecount seems to be closer to 140-150.

 

[The Pocket Cuber]

I believe this method can be subset to solve Petrus (not a Petrus solver at all, so Petrus users I’d like your critique), than just COLL+EPLL and I think it could be beneficial.

1. 2x2x3 block like Petrus in the back
2. EO (same as Petrus)
3. Last 2 F2L pairs (therefore ignoring the last cross edge)
4. COLL+L5E (16 algs to solve the whole thing with L5E).

I believe this COULD (big maybe) be better than standard COLL + EPLL, but if any Petrus solvers think otherwise let me know. Ignoring the last cross edge could be beneficial in some situations and L5E recognition is just as good as EPLL. Don’t expect this to be a good method. Let me know what you guys think!

 

[Aerma]

I believe this method can be subset to solve Petrus (not a Petrus solver at all, so Petrus users I’d like your critique), than just COLL+EPLL and I think it could be beneficial.

1. 2x2x3 block like Petrus in the back
2. EO (same as Petrus)
3. Last 2 F2L pairs (therefore ignoring the last cross edge)
4. COLL+L5E (16 algs to solve the whole thing with L5E).

I believe this COULD (big maybe) be better than standard COLL + EPLL, but if any Petrus solvers think otherwise let me know. Ignoring the last cross edge could be beneficial in some situations and L5E recognition is just as good as EPLL. Don’t expect this to be a good method. Let me know what you guys think!

Ignoring the last cross move won't save many moves... it'll also require an extra rotation to bring it to the front before L5E. Also, while L5E's recognition isn't necessarily harder than EPLL, it's more move moves on average if I'm not mistaken.
The biggie, though, is that the best Petrus solvers would know full ZBLL, which is much better than L5E+COLL.

TL;DR: ignoring the cross edge gives very minor benefits, which don't make up for the fact that L5E is worse than EPLL, and ZBLL negates this variation entirely.
Sorry

 

[PapaSmurf]

Ok
Scramble: U Fw2 U' D2 Rw2 F2 L' F' Uw2 D' L D' B2 Fw' R2 D2 L2 Uw Fw' Uw2 B2 R2 Rw' Uw B Rw F' B Fw L' U' L2 U L B L' D' Uw' R' F2

Rw U’ Rw2 F Rw’ F Rw L2 Uw2 y U Rw U2 Rw’ //F2C
y’ R L’ Uw L F’ y’ R U’ R’ Uw’ D2 R2 U R’ U’ y L’ U L Uw’ L // Two d color edges and the colored edge that has the same colors as those edges put on bottom like Yau
z’ x R Rw U’ Rw’ x’ R2 U’ r U’ r’ x’ R U’ Lw’ U’ Lw // L4C
z R2 Uw’ R U R’ Uw U2 R2 // I chose to put a non d colored edge in that has at least one color in relation to the d edges. You couldve put a d color edge there but the non d edge was easier to make.
y R U’ R’ Uw L U’ L’ U’ y L’ U L Uw L U’ L’ U2 R U’ R’ Uw’ y U’ y’ R U’ R’ y R U R’ F R’ F’ R Uw’ U2 L’ U L Uw’ R U R’ F R’ F’ R Uw // 3-2-3 edge pairing.
R B U’ R’ U2 L U’ L’ F’ U2 F’ R2 U F’ U’ F’ 3Dw’ // 2x2x3
U F’ U F2 U’ L’ U2 L U2 L’ U L U2 R U2 R’ U R U’ R’ // EO+F2L
U R U R’ U’ R’ F R2 U’ R’ U’ R U R’ F’ U r2 U2 r2 Uw2 r2 Uw2 U // PLL+Parity


ok I really hope I didn’t miscramble. If I did and this doesn’t work with the scramble then keep in mind you can just reverse everything and the go from there.
Also really the only thing that’s different is the first edges so that’s all that matters in this and the 2x2x3.

I get what you mean now. The 3-2-3 edge pairing was a bit messed up, and I'd also recommend using alg.cubing.net for future example solves, just becasue it's easier and it automatically checks for you. This method seems pretty good. I don't think that it would be as good as yau, but it's certainly not a bad method.

New 4x4 method for ZZ/Petrus solvers, adapted from my 5x5 ZZ method from a while ago:

1. L/R Centers
2. 1x3x4 on L
3. Center bars
4. EOpair 5 edges with freeslice, not including DF and DB edges and place them on L/R
5. Finish reduction and solve EO2x2x3 - still uncertain about how to do this part, below is one way to do it:

5-1. 'Blockbuild' centers and EOLine minus 1 wing
5-2. L5W (Last 5 Wings) - done with commuators. You may get parity (=odd number of swaps) by 50/50 chance and this might be able to be avoided in the previous step.

6. Solve the rest - Petrus F2L, COLL then EPLL+Parity should be enough.

Spoiler: Example solve

Scramble: B2 U F2 L2 R2 D L2 B2 L2 B2 D2 R2 F' L' B D B D B' F L' Fw2 U R D' Fw2 D' L D L Fw2 L Fw B D' B2 L Uw Rw' Uw Fw2 Uw' Fw Rw2

x Lw' U Lw Uw' U' Lw2 Uw L2 Uw' L' x Uw' L2 Uw // L/R Centers (13/13)

x' R2 U Rw' D' x U' D Rw2 x' B' R2 3Rw' F
B Rw' M2 R U R2 B' // 1x3x4 (18/31)

3Rw' U' Rw' 3Rw' U l' U2 l U' 3Rw' U' Rw U' // Center bars (13/44)

Rw2 // GY
U R U l2 3Rw' // OB
U' R U l' // YO
U R U' 3Rw' U2 3Rw' Rw2 // YR
U' R' U' Rw2 // WO
R U R' U' // Finish step 4 (25/69)

3Rw2 Rw' U2 l' U2 3Rw U2 Rw2
U2 3Rw U2 3Rw' Rw U2 l' U2 3Rw' // step 5-1 (17/86)

D U R2 U' r U R2 U' r' D' // step 5-2 // (10/96)

R2 U' R U' R2 U R' U' R // F2L (9/105)
F' R U2 R' U2 R' F2 R U R U' R' F' // COLL (13/118)
M2 U M2 U M' U2 M2 U2 M' U // EPLL (10/128)

Looks like this ended up being a pretty lucky solve - the actual average movecount seems to be closer to 140-150.

With this method, I don't see how it would be beetter than LEOR on 4x4. This is my proposal for a method. F2C, Roux block (pretty much Meyer at this point). L4C, 3-2-3, EODFDB/EOStripe/EOLine (all of these are the same things) + parity, RB, COLL, EPLL+parity. If you don't know what LEOR is, check the page on the wiki here. I think it has potential and is more competitive than Meyer because of <rR(M)U> being better than <MU> on big cubes. Yes, I know that <MU> isn't bad at all. Also, the <RU> of RB is better than <Rr(M)U> of RB in Meyer.

 

[Pyjam]

I was off for a year. I didn't know there was a wiki page for Leor!
What is LEOR-b ?

 

[PapaSmurf]

LEOR-b is 2x2x2, FL pair, EODF, normal LEOR from here. EOMR is EOFB, DFDB, normal LEOR from here. I don't think that they're better than normal though.

 

[Cubinwitdapizza]

I get what you mean now. The 3-2-3 edge pairing was a bit messed up, and I'd also recommend using alg.cubing.net for future example solves, just becasue it's easier and it automatically checks for you. This method seems pretty good. I don't think that it would be as good as yau, but it's certainly not a bad method.

With this method, I don't see how it would be beetter than LEOR on 4x4. This is my proposal for a method. F2C, Roux block (pretty much Meyer at this point). L4C, 3-2-3, EODFDB/EOStripe/EOLine (all of these are the same things) + parity, RB, COLL, EPLL+parity. If you don't know what LEOR is, check the page on the wiki here. I think it has potential and is more competitive than Meyer because of <rR(M)U> being better than <MU> on big cubes. Yes, I know that <MU> isn't bad at all. Also, the <RU> of RB is better than <Rr(M)U> of RB in Meyer.

I would use alg.cubing.net but on my tablets keyboard for prime moves i usually use ‘ because the straight line is not a thing on my keyboard and alg.cubing doesn’t recognize ‘ as what a prime move is supposed to be, which is not on my keyboar.

 

[PetrusQuber]

So I was messing around with Petrus, and stumbled upon this...
1. 2x2x2 block
2. Heise style 2x2x1, or psuedoblock next to it
3. Pair on top of that creating a Roux 1x2x3
4. Insert last bottom layer edge. Swing the Roux pseudoblock down to create a F2L-1
5. OLL
6. PLL
Nice move count, around 45ish (just a few solves though)
Is there an appropriate thread for this to go into, because I can’t find one..,
I might do an example solve. Just posted this for fun!

 

[Pyjam]

Is there an appropriate thread for this to go into, because I can’t find one..,

Yes, 5th "Sticky threads", just above.
Please, post an example.

 

[GAN 356 X]

Sub-8 with this new method now!

 

[PetrusQuber]

I’m waiting for somebody to say:
Or you could just use Petrus

 

[PetrusQuber]

R U’ L2 F2 B’ D2 R D2 B2 L’ D F’ B U2 R’
y’ x’// inspection
L2 R U L U’ R B2 D’// bad 2x2x2 8 HTM, 8 HTM
R’ F2 R2 F2 R2 U F’// Psuedo block, wrong 2x2x1 7 HTM, 15 HTM
U’ R U2 R’ U2// Roux block complete 5 HTM, 20 HTM
B’ R F’ B// Edge insertion 4 HTM, 24 HTM
R’ U R U2 R’ U R// F2L pair 7 HTM, 31 HTM
y2 R U2 R2 U’ R2 U’ R2 U2 R// Chameleon Headlight 9 HTM, 40 HTM
y F2 U L R’ F2 L’ R U F2// U Perm 9 HTM, 49 HTM
U’// AUF 1 HTM, 50 HTM

Of course, there was a edge OLL skip, and an accidental COLl, but I believe this method could be optimised further with better block building at the start, D layer EO influencing and forced edge OLL skips.

 

[Cubinwitdapizza]

R U’ L2 F2 B’ D2 R D2 B2 L’ D F’ B U2 R’
y’ x’// inspection
L2 R U L U’ R B2 D’// bad 2x2x2 8 HTM, 8 HTM
R’ F2 R2 F2 R2 U F’// Psuedo block, wrong 2x2x1 7 HTM, 15 HTM
U’ R U2 R’ U2// Roux block complete 5 HTM, 20 HTM
B’ R F’ B// Edge insertion 4 HTM, 24 HTM
R’ U R U2 R’ U R// F2L pair 7 HTM, 31 HTM
y2 R U2 R2 U’ R2 U’ R2 U2 R// Chameleon Headlight 9 HTM, 40 HTM
y F2 U L R’ F2 L’ R U F2// U Perm 9 HTM, 49 HTM
U’// AUF 1 HTM, 50 HTM

Of course, there was a edge OLL skip, and an accidental COLl, but I believe this method could be optimised further with better block building at the start, D layer EO influencing and forced edge OLL skips.

I believe i understand this. Also, really cool method! I think what you could also do is instead of inserting edges and then do F2L pair you could just insert a pseudo pair or just insert the edge and then do tols.