ZZ-CT Thread

[Teoidus]

What's horrible about it?

 

[CubingGenius]

please dont do this cpls is horrible

It's very good for OH. And you can also look at ZZ-orbit if you want.

 

[Shiv3r]

It's very good for OH. And you can also look at ZZ-orbit if you want.

isn't ZZ-orbit phasing + CP so you get a phased subset of 2GLL?

 

[Teoidus]

Nah ZZ-orbit is just one guy's random way of "solving" the missing link

Here's the original post: https://www.speedsolving.com/forum/threads/at-last-zz-d-method-has-been-completed.34994/

It's literally just CPLS but with a pair instead of with FR in slot

 

[Shiv3r]

Nah ZZ-orbit is just one guy's random way of "solving" the missing link

Here's the original post: https://www.speedsolving.com/forum/threads/at-last-zz-d-method-has-been-completed.34994/

It's literally just CPLS but with a pair instead of with FR in slot

ok. when I first thought of CPLS, I thought immediately of a method where you permuted corners while inserting the last pair, but I realized what it really was a little while ago. I think that CPLs was originally supposed to be an alternative to CLS for MGLS, which may actually be decent.

 

[MethodNeutral]

While we're discussing variants that do CP before LL, I use a method for OH where you do CP after your first block, leaving you with a 2-gen second block and 2GLL. Does anyone know what this is called?


Sent from my iPhone using Tapatalk

 

[Teoidus]

ZZ-d

 

[Shiv3r]

While we're discussing variants that do CP before LL, I use a method for OH where you do CP after your first block, leaving you with a 2-gen second block and 2GLL. Does anyone know what this is called?


Sent from my iPhone using Tapatalk

Depends on how you do it. If you do it as a step right after your first block idk how you do it you r god please teach us. If you so it while while inserting last FB pair, it's probably ZZ-porky V1 or V2, which are each "missing links" for ZZ-d. ZZ-porky2 is what I use for ZZ-D, and it definitely has OH potential, I don't know why more people don't use it.

 

[mDiPalma]

It's not really content for this thread, but I've used all the ZZ-d variants extensively (at least 500 solves on each, >1000 on a few), and I will attest that CPLS, ZZ-Orbit (as well as the R U R' inserts), "Freestyle Porky" v1 (using any adjacent U layer corners AUF'd to UL), and "Half-Porky" v1 (putting a single D corner in D and using CPLS recog and shorter algs to solve CP) are the the most promising variants. Other methods just take too long at recognize or aren't efficient enough. Maybe you could plan a 3x2x2+cp in inspection and then use slice moves to orient the edges, but that's just too hard for me.

I know those two last ones weren't methods truly proposed by Porkynator, but they are derivatives of his work.

And I wouldn't say that these ZZ-d variants have better OH potential than regular COLL/EPLL. Both of these approaches have similar proportions of <RU> to <URDLF>. You are just sacrificing recognition to move the L/D/F moves earlier in the solve, while getting only a slight movecount advantage, if any at all.

 

[MethodNeutral]

Depends on how you do it. If you do it as a step right after your first block idk how you do it you r god please teach us.

I complete my left block then do CP. The way I do it is I place the remaining D-layer corners in the D-layer (can be swapped, orientation doesn't matter) then recognize permutation. The algs are just an AUF and either L' U R U' L or L' U R2 U' L. I can go more in depth on recognition if you want.

 

[gyroninja]

I made a visualization of the TSLE algs on my website. You can find it in this thread.

It's kind of interesting how you can see the bias of algs that are good / I like personally. (The chart is heavily biased on the left side) It's also the first time I've worked with LaTeX before.

 

[lillod]

Cool! I just finished my project as well. It's ttll-trainer.us. This was my first time working in HTML and Javascript. I was inspired by the EGtrainer site and decided to replicate it to aid my learning of TTLL. The main feature over the qqtimer scrambler is that you can constrain the set(s) that will be generated. Hopefully, someone can find it useful.

 

[mDiPalma]

@4Chan

i threw together a custom input file for ZZ-CT in HARCS. it finds stepwise optimal solutions to eoline/lb/rs+tsle/ttll in that order.

you can shift it to use your preferred orientation. it also doesn't use any of your tsle/ttll algorithms, but it generates optimal RUD solutions each time - you can load your own algs if you want.

Spoiler: custom.txt

step eoline
movegroup 1
prunedepth 5
searchdepth 5
epmask 0x00000000f0f0
eomask 0xffffffffffff
cpmask 0x00000000
comask 0x00000000
cnmask 0xfff

step lb
movegroup 5
prunedepth 6
searchdepth 6
epmask 0x0000f00ff0ff
eomask 0xffffffffffff
cpmask 0x0000f00f
comask 0x0000f00f
cnmask 0xfff

step rs+tsle
movegroup 4
prunedepth 7
searchdepth 7
epmask 0x0000ffffffff
eomask 0xffffffffffff
cpmask 0x0000ff0f
comask 0xffffffff
cnmask 0xfff

step ttll
movegroup 4
prunedepth 8
searchdepth 9
epmask 0xffffffffffff
eomask 0xffffffffffff
cpmask 0xffffffff
comask 0xffffffff
cnmask 0xfff

all eoline lb rs+tsle ttll

here are the first 5 solves that it generated:

38 htm
44 htm
39 htm
39 htm
39 htm

that's a pretty good movecount - only slightly worse than stepwise optimal ZZ-a , and I'm sure there is something valuable to be learned concerning how it optimally solves rs+tsle.

 

[4Chan]

@4Chan

i threw together a custom input file for ZZ-CT in HARCS. it finds stepwise optimal solutions to eoline/lb/rs+tsle/ttll in that order.

you can shift it to use your preferred orientation. it also doesn't use any of your tsle/ttll algorithms, but it generates optimal RUD solutions each time - you can load your own algs if you want.

Spoiler: custom.txt

step eoline
movegroup 1
prunedepth 5
searchdepth 5
epmask 0x00000000f0f0
eomask 0xffffffffffff
cpmask 0x00000000
comask 0x00000000
cnmask 0xfff

step lb
movegroup 5
prunedepth 6
searchdepth 6
epmask 0x0000f00ff0ff
eomask 0xffffffffffff
cpmask 0x0000f00f
comask 0x0000f00f
cnmask 0xfff

step rs+tsle
movegroup 4
prunedepth 7
searchdepth 7
epmask 0x0000ffffffff
eomask 0xffffffffffff
cpmask 0x0000ff0f
comask 0xffffffff
cnmask 0xfff

step ttll
movegroup 4
prunedepth 8
searchdepth 9
epmask 0xffffffffffff
eomask 0xffffffffffff
cpmask 0xffffffff
comask 0xffffffff
cnmask 0xfff

all eoline lb rs+tsle ttll

here are the first 5 solves that it generated:

38 htm
44 htm
39 htm
39 htm
39 htm

that's a pretty good movecount - only slightly worse than stepwise optimal ZZ-a , and I'm sure there is something valuable to be learned concerning how it optimally solves rs+tsle.

Have you tried slot neutral? I wonder what the difference would be.
ColourfulPockets has some degree of neutrality when he uses ZZ-CT

EDIT: I read into HARCS, and I see you specify steps, so asking for slot neutral sounds not so straightforward, oops.

 

[gyroninja]

Cool! I just finished my project as well. It's ttll-trainer.us. This was my first time working in HTML and Javascript. I was inspired by the EGtrainer site and decided to replicate it to aid my learning of TTLL. The main feature over the qqtimer scrambler is that you can constrain the set(s) that will be generated. Hopefully, someone can find it useful.

Nice. My timer can also do that but it's a little more complicated (it doesn't have nice check boxes for everything)

Have you tried slot neutral? I wonder what the difference would be.
ColourfulPockets has some degree of neutrality when he uses ZZ-CT

EDIT: I read into HARCS, and I see you specify steps, so asking for slot neutral sounds not so straightforward, oops.

Wouldn't the move count be like the same over all possible starting states due to symmetry? (I've also used slot neutral tsle since nats and it's not too hard since it's just triggers)

 

[mDiPalma]

Wouldn't the move count be like the same over all possible starting states due to symmetry? (I've also used slot neutral tsle since nats and it's not too hard since it's just triggers)

it would be slightly less because it could pick the shortest between lb first or rb first and which square to solve along with tsle. but that is an evaluation a human will not be able to make in a speedsolve.

i just thought it was interesting that you could solve rs+tsle in ~11 htm <RU> on average

 

[gyroninja]

it would be slightly less because it could pick the shortest between lb first or rb first and which square to solve along with tsle. but that is an evaluation a human will not be able to make in a speedsolve.

i just thought it was interesting that you could solve rs+tsle in ~11 htm <RU> on average

11 HTM sounds about right. If you take a look at the chart I made of the algs from my website you'll notice that the majority of the chart is made of three triggers.

(3 triggers * 3 move each) + 3 AUF (one before each trigger) = 12 HTM

If you didn't know most of the tsle algs on my site are qtm move optimal.

EDIT: whoops, didn't notice you said it also did the block

 

[4Chan]

Interesting, but a shame.
If only a human could do rb+tsle that low. ):

 

[lillod]

Has anyone thought of Roux-CT? All you would need to do is tsle during second block and a loose subset of ttll for cmll. Since the edge of tsle isn't necessarily oriented and could be in DF or DB, there would be a lot more cases if you wanted to do it in one look. But if you immediately inserted the edge to DF, you could do change the corner orientation without needing to juggle where the edge is. The goal is to get the corner orientation to match a 1 trigger tsle. This should be able to be done with one trigger. Then you insert the edge back into the top layer with an M' or M2 and do one trigger to solve tsle. After writing this I realize that it is essentially making them all a 4 trigger case that alternate between <M,U> and <R,U> but 1. It's pretty intuitive even compared to normal tsle 2. it can be mirrored to the back slot and would only be 48 cases after the edge is taken out and 3. there's lot of tricks you can do to make cases mor efficient eg. you could insert the edge right away to reduce it to a 2 trigger tsle case.
Then ttll is simple you just generate some algs that disregard eo and the M slice but solve the corner permutation. You could also generate a few more that swap DBR with UBL without needing to do an ADF at the beginning and end. The result is raising the skip chance of cmll from 1/162 to 1/30 and making the recognition of cmll easier.
If anyone has a better idea to do tsle during SB let me know.

 

[4Chan]

Has anyone thought of Roux-CT? All you would need to do is tsle during second block and a loose subset of ttll for cmll. Since the edge of tsle isn't necessarily oriented and could be in DF or DB, there would be a lot more cases if you wanted to do it in one look. But if you immediately inserted the edge to DF, you could do change the corner orientation without needing to juggle where the edge is. The goal is to get the corner orientation to match a 1 trigger tsle. This should be able to be done with one trigger. Then you insert the edge back into the top layer with an M' or M2 and do one trigger to solve tsle. After writing this I realize that it is essentially making them all a 4 trigger case that alternate between <M,U> and <R,U> but 1. It's pretty intuitive even compared to normal tsle 2. it can be mirrored to the back slot and would only be 48 cases after the edge is taken out and 3. there's lot of tricks you can do to make cases mor efficient eg. you could insert the edge right away to reduce it to a 2 trigger tsle case.
Then ttll is simple you just generate some algs that disregard eo and the M slice but solve the corner permutation. You could also generate a few more that swap DBR with UBL without needing to do an ADF at the beginning and end. The result is raising the skip chance of cmll from 1/162 to 1/30 and making the recognition of cmll easier.
If anyone has a better idea to do tsle during SB let me know.

Creative thinking is always great

I think it's not as good as normal roux, because it's the same amount of steps as doing the slot, and then the CMLL.
):