• Welcome to the Speedsolving.com, home of the web's largest puzzle community!
    You are currently viewing our forum as a guest which gives you limited access to join discussions and access our other features.

    Registration is fast, simple and absolutely free so please, join our community of 40,000+ people from around the world today!

    If you are already a member, simply login to hide this message and begin participating in the community!

xyzzy

Member
Joined
Dec 24, 2015
Messages
2,550
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.
 
Last edited:

OreKehStrah

Member
Joined
May 24, 2019
Messages
856
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.
 

MJbaka

Member
Joined
Jun 3, 2021
Messages
162
Location
Idaho
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
 

MJbaka

Member
Joined
Jun 3, 2021
Messages
162
Location
Idaho
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
 
Joined
Aug 12, 2013
Messages
2,400
Location
Brazil
YouTube
Visit Channel
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)

1628269050868.png
 
Last edited:

xyzzy

Member
Joined
Dec 24, 2015
Messages
2,550
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

Member
Joined
May 13, 2020
Messages
192
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.

Member
Joined
Sep 26, 2017
Messages
664
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

Member
Joined
Jul 17, 2021
Messages
31
Location
Arkansas
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.
 
Last edited:

Thumbprint

Member
Joined
Jul 17, 2021
Messages
31
Location
Arkansas
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

Member
Joined
Jan 19, 2021
Messages
204
Location
Virginia
WCA
2021KLIN02
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

Member
Joined
Jul 17, 2021
Messages
31
Location
Arkansas
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.

Member
Joined
Sep 26, 2017
Messages
664
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

Member
Joined
Jul 17, 2021
Messages
31
Location
Arkansas
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.
 
Top