The New Method / Substep / Concept Idea Thread

[BenChristman1]

I just said solve F2L, not do 3/4 of cross then F2L. I average easily sub-20 with this method because I know most L5eop cases and only about 100 ZBLL (rough estimate).

So is it FreeFOP-type F2L, or do you want to make a 3/4 cross? It’s one or the other, there’s no other options.

 

[xyzzy]

Also flipped edges is a lot easier to have two sided PLL recog for than having to do twisty recog for ZB.

Even better, you can literally recognise the S/AS anti-ZBLLs without even looking at the sides. The top face is enough to uniquely identify the case.

(Not that that would be a good recognition method… or would it?)

Anti-ZBLL algs overall seem a lot worse than ZBLL.

Yeah but you have to consider how few people have worked on the algs.

My 2 cents: the dot 1LLLs really do seem inherently worse than ZBLL on average.

Dot LL algs with certain move restrictions have a strict lower limit to the number of non-⟨R,U⟩ moves:
(i) (for RUFB algs) four F/B turns in QTM (e.g. R' F' U2 F2 U R U' R' F' U2 R)
(ii) (for RrU algs) four Rw turns in QTM (e.g. R' U2 r U' r' U2 r U r' U2 R)
(iii) (for RUFLD algs) if not four F quarter turns, an F/F' pair with at least two L or D moves (e.g. L F R U2 R' U2 R U2 R' F' L')

While F, B and Rw moves flip four edges at once, two of those four will always be in locations that can't be touched by ⟨R,U⟩ moves, so using only one F/F' pair, B/B' pair, or Rw/Rw' pair can at best flip two last layer edges. S moves invalidate this argument (only the DL edge is immobile under ⟨R,U⟩ moves; example of a two-S-move dot 1LLL is S R' U' R U R U R U' R' S'), but they also can't affect corner permutation, so there's a limit to how useful they are.

Normal ZBLL has a smaller lower bound: it's well-known that every ZBLL can be solved in RUL, RUF, and RUD with at most two non-⟨R,U⟩ moves. In practice, a lot of the actual ZBLL algs we use have more than the bare minimum, but that's at least a choice we can make when it comes to normal ZBLL. Anti-ZBLL forces you to use more non-⟨R,U⟩ moves.

Dot 1LLL also excludes all of the very short last layer cases because the shortest dot 1LLL is 11 moves (in FTM and I think STM as well). You don't get 3-cycle corner comms, 3-cycle block comms (e.g. sexysledge), or sexy setups (e.g. fruruf, Sune); you do get U2-setups, but they're limited to only solved CP and diag CP (e.g. R' U2 r U' r' U2 r U r' U2 R and r' D R2 U R' U2 R U' R2 D' r).

Edit: Forgot to mention: there are also U setups, which do cover the adj CP cases, e.g. R U' R2 B2 D' r U r' D B2 R2 U R', so that weakens my above point a bit. These algs still are not very good, though; if I'm not mistaken, the example I just gave is optimal for this type of alg (6 setup moves, i.e. 13 moves total).

(Except for the RrU alg, which I think I learnt from AlgDb, all dot last layer algs mentioned here were ones I genned by myself. Not entirely talking out of my butt!)

But wouldn't that have terrible algs, seeing as dot cases are already bad enough?

(Continuing from my above point.) But the dot OLLs are fine, because you still get to cherrypick the best alg out of 72 dot 1LLLs. Even if 71 of them are garbage, as long as one isn't, you can use that as your OLL alg.

 

[LukasCubes]

So is it FreeFOP-type F2L, or do you want to make a 3/4 cross? It’s one or the other, there’s no other options.

Block build F2L

 

[OreKehStrah]

Even better, you can literally recognise the S/AS anti-ZBLLs without even looking at the sides. The top face is enough to uniquely identify the case.

(Not that that would be a good recognition method… or would it?)



My 2 cents: the dot 1LLLs really do seem inherently worse than ZBLL on average.

Dot LL algs with certain move restrictions have a strict lower limit to the number of non-⟨R,U⟩ moves:
(i) (for RUFB algs) four F/B turns in QTM (e.g. R' F' U2 F2 U R U' R' F' U2 R)
(ii) (for RrU algs) four Rw turns in QTM (e.g. R' U2 r U' r' U2 r U r' U2 R)
(iii) (for RUFLD algs) if not four F quarter turns, an F/F' pair with at least two L or D moves (e.g. L F R U2 R' U2 R U2 R' F' L')

While F, B and Rw moves flip four edges at once, two of those four will always be in locations that can't be touched by ⟨R,U⟩ moves, so using only one F/F' pair, B/B' pair, or Rw/Rw' pair can at best flip two last layer edges. S moves invalidate this argument (only the DL edge is immobile under ⟨R,U⟩ moves; example of a two-S-move dot 1LLL is S R' U' R U R U R U' R' S'), but they also can't affect corner permutation, so there's a limit to how useful they are.

Normal ZBLL has a smaller lower bound: it's well-known that every ZBLL can be solved in RUL, RUF, and RUD with at most two non-⟨R,U⟩ moves. In practice, a lot of the actual ZBLL algs we use have more than the bare minimum, but that's at least a choice we can make when it comes to normal ZBLL. Anti-ZBLL forces you to use more non-⟨R,U⟩ moves.

Dot 1LLL also excludes all of the very short last layer cases because the shortest dot 1LLL is 11 moves (in FTM and I think STM as well). You don't get 3-cycle corner comms, 3-cycle block comms (e.g. sexysledge), or sexy setups (e.g. fruruf, Sune); you do get U2-setups, but they're limited to only solved CP and diag CP (e.g. R' U2 r U' r' U2 r U r' U2 R and r' D R2 U R' U2 R U' R2 D' r).

(Except for the RrU alg, which I think I learnt from AlgDb, all dot last layer algs mentioned here were ones I genned by myself. Not entirely talking out of my butt!)


(Continuing from my above point.) But the dot OLLs are fine, because you still get to cherrypick the best alg out of 72 dot 1LLLs. Even if 71 of them are garbage, as long as one isn't, you can use that as your OLL alg.

I didn’t even think about the sunes stuff. That’s cool. The only dot 1LLL cases in interested in is XLL which is the corners oriented family of 1LLL since I think it could be a cool extension for CFCE.

 

[GodCubing]

Nothing beats OLL+PLL or EO+ZBLL

CLL+1 is 1 lookable with less algs than zbll, and lower movecount and L3E is like the best alg set to grace the earth with its presence

 

[EvanCuber]

I have an idea for the 2x2.
1. Solve three corners + CP
2. 2 gen WV to solve PLL and OLL while solving the last corner to the side

 

[Cubing Forever]

I have an idea for the 2x2.
1. Solve three corners + CP
2. 2 gen WV to solve PLL and OLL while solving the last corner to the side

I don't think that's 1-lookable

 

[EvanCuber]

I have two ideas for the three by three that are extensions to CFOP. Here is the first one
Flipped Edge PLL
1. Solve Cross
2. Solve F2L but solve one edge flipped
3. OLL
4. Solve Flipped Edge and PLL using one of twenty one algorithms
I like the idea for this method because if you get a flipped edge case in F2l and have a solved corner it is really annoying and takes a lot of extra time. A really big advantage to this is you can set up your last F2L pair to one of four F2L pairs and then basic insert, because two of them will give you a flipped edge. Here is my second idea which does not have a name.
1. Solve cross, but solve the cross pieces in any orientation you want (minimizes longest cross solution to six moves and 4 move crosses on average)
2. F2L, but you don't have solve the corners correctly, so you can pair them up with any edge, giving you a large variety of choices for F2L pairs, (I believe it is 16).
3. OLL+Parity(if there is a Parity between U and D layers, also 114 algorithms, or 57 if you do M2 U2 M2 and then OLL algorithm)
4. PUDL (Permute U and D layers using one of 441 algorithms

 

[Deleted member 36445]

I have two ideas for the three by three that are extensions to CFOP. Here is the first one
Flipped Edge PLL
1. Solve Cross
2. Solve F2L but solve one edge flipped
3. OLL
4. Solve Flipped Edge and PLL using one of twenty one algorithms
I like the idea for this method because if you get a flipped edge case in F2l and have a solved corner it is really annoying and takes a lot of extra time. A really big advantage to this is you can set up your last F2L pair to one of four F2L pairs and then basic insert, because two of them will give you a flipped edge. Here is my second idea which does not have a name.
1. Solve cross, but solve the cross pieces in any orientation you want (minimizes longest cross solution to six moves and 4 move crosses on average)
2. F2L, but you don't have solve the corners correctly, so you can pair them up with any edge, giving you a large variety of choices for F2L pairs, (I believe it is 16).
3. OLL+Parity(if there is a Parity between U and D layers, also 114 algorithms, or 57 if you do M2 U2 M2 and then OLL algorithm)
4. PUDL (Permute U and D layers using one of 441 algorithms

or you could use actual cfop with 0 extra algs to learn

for flipped edge f2l pair I use intuitive EOLS or you can make use of the empty slots with fast sledge hammer + insert triggers

I won't say anything about the second idea with 441 extra algs (You can learn zbll instead)

 

[xyzzy]

Flipped Edge PLL
1. Solve Cross
2. Solve F2L but solve one edge flipped
3. OLL
4. Solve Flipped Edge and PLL using one of twenty one algorithms
I like the idea for this method because if you get a flipped edge case in F2l and have a solved corner it is really annoying and takes a lot of extra time. A really big advantage to this is you can set up your last F2L pair to one of four F2L pairs and then basic insert, because two of them will give you a flipped edge. Here is my second idea which does not have a name.

There are actually 72 cases for PLL + flipped edge. (Fix the location of the flipped edge, then you have 4!^2/2 = 288 ways of permuting the pieces. There are exactly four post-AUFs for each case, so divide by 4 to get 72 cases.) Probably most of the algs are bad, although there's this cool Ja perm: R' F R F' R' U2 R2 U R2 U R

You can also solve OLL together with the flipped edge instead (54 algs). (CubeRoot has the algs.)

I think it's better to just learn an F2L alg for this case and remember which edge(s) it flips, so you can solve last layer EO simultaneously (or at least avoid dot OLL). Forcing flipped-edge is silly because the algs all seem to suck, and if you don't force it, it's rare enough that you might have difficulty remembering the correct alg to use (out of 54 for OLS-FE, or out of 72 for PLL-FE) when you do encounter it.

1. Solve cross, but solve the cross pieces in any orientation you want (minimizes longest cross solution to six moves and 4 move crosses on average)
2. F2L, but you don't have solve the corners correctly, so you can pair them up with any edge, giving you a large variety of choices for F2L pairs, (I believe it is 16).
3. OLL+Parity(if there is a Parity between U and D layers, also 114 algorithms, or 57 if you do M2 U2 M2 and then OLL algorithm)
4. PUDL (Permute U and D layers using one of 441 algorithms

Interesting.

I think this is not worth it if you just solve F2L like normal CFOP pairs, because you're not really exploiting all the freedom you have. You can freely pseudoslot since bottom layer permutation is irrelevant (it's not even "pseudo" in this case!). The reduced number of cases might also make multislotting viable. Or you could even directly blockbuild your F2L this way.

At first I thought OLL+parity recognition would be hell, then I realised you could just recognise parity on the D face (as if you're checking for PLL parity). Recognition probably still is bad, though. (Maybe speed-optimal algs will end up swapping the two DR corners to fix parity, or something like that.)

My wild speculation is that PBL algs probably suck. Doesn't matter whether you fix parity or not; my guess is most of them are bad regardless, except for the ones with one layer fully solved (i.e. PLL and upside-down PLL). I'd assume someone has tried generating PBL algs before, given that the belt method keeps getting reinvented.

 

[GodCubing]

I have an idea for the 2x2.
1. Solve three corners + CP
2. 2 gen WV to solve PLL and OLL while solving the last corner to the side

https://www.speedsolving.com/threads/2x2x2-ru-group-method.79803/#post-1420486 already a thing. I thought of the same thing then found this. Well actually I thought up variant E exactly

 

[GodCubing]

I have two ideas for the three by three that are extensions to CFOP. Here is the first one
Flipped Edge PLL
1. Solve Cross
2. Solve F2L but solve one edge flipped
3. OLL
4. Solve Flipped Edge and PLL using one of twenty one algorithms
I like the idea for this method because if you get a flipped edge case in F2l and have a solved corner it is really annoying and takes a lot of extra time. A really big advantage to this is you can set up your last F2L pair to one of four F2L pairs and then basic insert, because two of them will give you a flipped edge. Here is my second idea which does not have a name.
1. Solve cross, but solve the cross pieces in any orientation you want (minimizes longest cross solution to six moves and 4 move crosses on average)
2. F2L, but you don't have solve the corners correctly, so you can pair them up with any edge, giving you a large variety of choices for F2L pairs, (I believe it is 16).
3. OLL+Parity(if there is a Parity between U and D layers, also 114 algorithms, or 57 if you do M2 U2 M2 and then OLL algorithm)
4. PUDL (Permute U and D layers using one of 441 algorithms

Great ideas, but check if the algs are good and for the second one how about just matching random e layer edges and d layer corners so there is no OLL parity

 

[Thom S.]

I like the idea for this method because if you get a flipped edge case in F2l and have a solved corner it is really annoying and takes a lot of extra time.

R2' U2' F R2 F' U2' R' U R'
Regripless and fairly fast

 

[Thumbprint]

Pretty bad method idea: What if you solved cross, did f2l, but paired any edge piece with any corner piece(making sure that the edge is oriented properly of course), did OLL on top, deal with parity by spamming u-perms until there are only two opposite edges in the wrong place, fix them by doing R2 U2 R2 U2 R2 U2, and then solved the e-slice intuitively.

 

[Thumbprint]

Pretty bad method idea: What if you solved cross, did f2l, but paired any edge piece with any corner piece(making sure that the edge is oriented properly of course), did OLL on top, deal with parity by spamming u-perms until there are only two opposite edges in the wrong place, fix them by doing R2 U2 R2 U2 R2 U2, and then solved the m-slice intuitively.

I also forgot to mention that the only pro to this method is that its slightly more efficient than cfop in f2l since you can pair up any corner and edge, but it's very confusing and all the parity at the end completely cancels out any time saves that could be made during f2l. This method, though, shall be called CPFOP (cross, pseudo-f2l, oll, pll)

 

[PiKeeper]

Pretty bad method idea: What if you solved cross, did f2l, but paired any edge piece with any corner piece(making sure that the edge is oriented properly of course), did OLL on top, deal with parity by spamming u-perms until there are only two opposite edges in the wrong place, fix them by doing R2 U2 R2 U2 R2 U2, and then solved the e-slice intuitively.

That sounds like a worse version of pseudoslotting.

 

[Thumbprint]

That sounds like a worse version of pseudoslotting.

I know what pseudoslotting is, but don't have a very good understand of it, so correct me if I'm wrong about anything. I don't think its like pseudo slotting because you aren't really setting anything up or doing multiple pairs at once like pseudo-slotting. Again, I don't really have a good understanding of pseudo slotting so I could just be rambling on about something completely different that it, but I don't think it's like pseudo-slotting.

 

[Thom S.]

Pretty bad method idea: What if you solved cross, did f2l, but paired any edge piece with any corner piece(making sure that the edge is oriented properly of course), did OLL on top, deal with parity by spamming u-perms until there are only two opposite edges in the wrong place, fix them by doing R2 U2 R2 U2 R2 U2, and then solved the e-slice intuitively.

This is one of the ideas pretty much everyone has and it pops up in this thread often.
You don't have any advantages as even bad F2L cases are more efficient than additional PLLs.
I'm sure if you get mire familiar with F2L you will see how bad this is.

 

[Thumbprint]

This is one of the ideas pretty much everyone has and it pops up in this thread often.
You don't have any advantages as even bad F2L cases are more efficient than additional PLLs.
I'm sure if you get mire familiar with F2L you will see how bad this is.

Yep that sounds about right. I came up with that "method" after just messing around with the cube for a couple minutes so its not exactly surprising that someone else came up with it already. And you're absolutely right about it being garbage. I average like more than twice as slow with it than cfop and roux. I just wrote it down because I hadn't heard of anything else similar, that was my bad.

 

[EvanCuber]

Kind of a weird idea, but what if you just did ZZ but also did CP while building EO cross thus reducing the last layer to 84 cases so you can PLL skip every time with 84 algorithms