# Finding the best 2-look ZBLL method

## What should we find 2-look methods for?

• Total voters
21

#### Etotheipi

##### Member
I've had this idea, starting from when I started trying out ZZ. I want to try to make a program (With help ofc) that crunches through every possible 2-look ZBLL method (Or would it be 2-look EO LL method, correct me on my terminology) to find the best one. So it would test methods like OCLL-->PLL, COLL-->EPLL, and weirder things like 1x2x2-->L5P. I don't have the programming expertise to do this, so it'd be great if people could share tips and pieces of code that would help. The main thing that we would need is an alg generator that can link directly to python code so we can automate it, but also notation for substeps, and other things.

#### brododragon

##### Member
I've had this idea, starting from when I started trying out ZZ. I want to try to make a program (With help ofc) that crunches through every possible 2-look ZBLL method (Or would it be 2-look EO LL method, correct me on my terminology) to find the best one. So it would test methods like OCLL-->PLL, COLL-->EPLL, and weirder things like 1x2x2-->L5P. I don't have the programming expertise to do this, so it'd be great if people could share tips and pieces of code that would help. The main thing that we would need is an alg generator that can link directly to python code so we can automate it, but also notation for substeps, and other things.
What does the program consider the "best"?

#### Etotheipi

##### Member
What does the program consider the "best"?
I was thinking we run all the algs in a set through Jperms alg formula (This part would need a piece of code to find regrips and such), and average it for the sets total score. We'd need a human to review the bots choices though, and all the sets algs would be stored in text files so we can find the second best if the first has problems the bot couldnt see, unless that results in like 100 gigabytes of memory.

#### brododragon

##### Member
I was thinking we run all the algs in a set through Jperms alg formula (This part would need a piece of code to find regrips and such), and average it for the sets total score. We'd need a human to review the bots choices though, and all the sets algs would be stored in text files so we can find the second best if the first has problems the bot couldnt see, unless that results in like 100 gigabytes of memory.
The hard part of that comes with your fingerticks, because everyone does them a bit differenty.

#### BenChristman1

##### Member
I was thinking we run all the algs in a set through Jperms alg formula
How are you planning on finding these algs, and how many algs would there be in this alg set?

#### brododragon

##### Member
How are you planning on finding these algs, and how many algs would there be in this alg set?
I think they're going to use there Python thing they're creating, and, the amount of algs depends on the two looks.

#### xyzzy

##### Member
"Nonstandard" 2-look ZBLL methods are fun to experiment with, but I don't think it's something that's seriously worth pursuing. OCLL/PLL and COLL/EPLL are already Pareto-optimal among the standard 2-look methods (the others are EP/L4C, CP/2GLL, OCELL/CPLL and one more without a name (EP+CP/CO) and they all suck), and trying to do anything fancy usually involves making recognition worse. (Fwiw one of my very first posts on this forum was a nonstandard 2-look ZBLL method.)

I'm not saying you shouldn't try, but this is a project you should be taking on with the expectation that you won't find anything groundbreaking. (Which is totally fine! It would still be a learning experience.)
---
As for how you'd actually go about writing such a program… You can grab ZBLL algs from your favourite source (I'm really not up to date here, but I assume Tao Yu's trainer links to the best ZBLL algs?) so you can completely skip the step of finding algs to use, unless you also want your program to look for alternative algs, in which case you can pull those off of Birdflu.

You could define the substeps based on which states you want to be able to directly solve in the second look; e.g. for square/L5P, that's just saying that there must be a solved square. Once you have this, you can make a program to search for sets of algs that will bring any ZBLL case into one of the directly-solvable states. The algorithm I used for this when I last tried something similar was just dumb brute force:
Code:
while coverage isn't perfect:
choose a random ZBLL alg that improves coverage
add it to the list

#### RedstoneTim

##### Member
I was thinking we run all the algs in a set through Jperms alg formula (This part would need a piece of code to find regrips and such), and average it for the sets total score. We'd need a human to review the bots choices though, and all the sets algs would be stored in text files so we can find the second best if the first has problems the bot couldnt see, unless that results in like 100 gigabytes of memory.
As xyzzy said, ZBLL is a limited set, so we don't need to generate any algorithms.
There's actually the possibility of getting someone who knows full ZBLL and letting them do an ao5 with all of the algs to get a score of how fast each alg is. The main issue with that is obviously that there aren't a lot of people who know full ZBLL and most of them probably don't have the time for that.
In that case, one could use a Python program called AlgExplorer, which assigns algorithms scores based on data from actual solves. However, the creator doesn't seem to be active anymore and I'm not sure how much effort it would be to make the code work as a library (i.e. how hardcoded it is).

#### y235

##### Member
I was thinking we run all the algs in a set through Jperms alg formula (This part would need a piece of code to find regrips and such), and average it for the sets total score. We'd need a human to review the bots choices though, and all the sets algs would be stored in text files so we can find the second best if the first has problems the bot couldnt see, unless that results in like 100 gigabytes of memory.
What is Jperm's alg formula?

Sent from my COR-L29 using Tapatalk

##### Member
What is Jperm's alg formula?

Sent from my COR-L29 using Tapatalk
JPerm made an alg efficiency calculator, so using the texts available from his excel sheet, you could calculate how much efficient that alg is or which alg is better by comparing the efficiency.
So basically, you use the excel sheet to refer to see if the alg has any regrip, efficiency or its generator.

#### RedstoneTim

##### Member
JPerm made an alg efficiency calculator, so using the texts available from his excel sheet, you could calculate how much efficient that alg is or which alg is better by comparing the efficiency.
So basically, you use the excel sheet to refer to see if the alg has any regrip, efficiency or its generator.
That's not entirely true. Efficiency usually refers to how many moves solving specific pieces takes. E.g. if you solve Roux FB in 8 moves on average, that is more efficient than 14 moves.
J Perm's formula assigns any given algorithm a specific score to determine how quickly an algorithm can be executed, not how efficient it is. That score should in theory be proportional to the time it takes to execute the alg, so if your Aa is twice as fast as your Na, the score of Na should be two times higher than the one of Aa. (Basically the lower your score, the less time it takes.)
The main issue with that is that it's not 100% accurate (e.g. J Perm can do both Aa and Ub in 0.54s, but their scores are 10.5 and 13.0, respectively) and that the sheet doesn't do all the work for you. You also need to tell it how many hard regrips the alg contains and how often your fingers overwork.
For more information, you should watch his first video, his second video explaining how he got the results and the actual excel sheet itself.

##### Member
That's not entirely true. Efficiency usually refers to how many moves solving specific pieces takes. E.g. if you solve Roux FB in 8 moves on average, that is more efficient than 14 moves.
J Perm's formula assigns any given algorithm a specific score to determine how quickly an algorithm can be executed, not how efficient it is. That score should in theory be proportional to the time it takes to execute the alg, so if your Aa is twice as fast as your Na, the score of Na should be two times higher than the one of Aa. (Basically the lower your score, the less time it takes.)
The main issue with that is that it's not 100% accurate (e.g. J Perm can do both Aa and Ub in 0.54s, but their scores are 10.5 and 13.0, respectively) and that the sheet doesn't do all the work for you. You also need to tell it how many hard regrips the alg contains and how often your fingers overwork.
For more information, you should watch his first video, his second video explaining how he got the results and the actual excel sheet itself.
I'm just giving an overview of the sheet.

#### mukerflap

##### Member
Cardan reduction is interesting, and fish and chips

#### Etotheipi

##### Member
Ok, @xyzzy said that non-standard 2-look ZBLL methods probably aren't worth exploring seriously, so do you people think we should try and find 2 look LL methods, which would have an expanded search and probably better methods than OLL PLL, or should we still try 2-look ZBLL. I do like the idea of searching for last layer methods, so if 2-look ZBLL methods are less useful, I still want to try something else.

#### brododragon

##### Member
Ok, @xyzzy said that non-standard 2-look ZBLL methods probably aren't worth exploring seriously, so do you people think we should try and find 2 look LL methods, which would have an expanded search and probably better methods than OLL PLL, or should we still try 2-look ZBLL. I do like the idea of searching for last layer methods, so if 2-look ZBLL methods are less useful, I still want to try something else.

#### brododragon

##### Member
I suppose, should I make a poll?
Sure. Churn out as many ideas for different things as possible (another is Roux SB LS + CMLL) and put them on a poll.

#### Etotheipi

##### Member
Sure. Churn out as many ideas for different things as possible (another is Roux SB LS + CMLL) and put them on a poll.
Ok then,=P

#### dudefaceguy

##### Member
Ok, @xyzzy said that non-standard 2-look ZBLL methods probably aren't worth exploring seriously, so do you people think we should try and find 2 look LL methods, which would have an expanded search and probably better methods than OLL PLL, or should we still try 2-look ZBLL. I do like the idea of searching for last layer methods, so if 2-look ZBLL methods are less useful, I still want to try something else.
One of the cool things about ZZ is that there are so many different variants. It seems to be a method set that attracts nerds who like to try new things.

Many of these things are worth exploring even if they don't lead to more optimal solutions for the world's top cubers. I'm principally interested in learning intuitive methods, and there are many opportunities here regarding ZZ methods. I like to see how far I can get without learning algorithms. So far I like doing corner permutation, corner orientation, then edge permutation. These can all be done with commutators and a few very intuitive algs that I don't even have to memorize as algs. I may see if I can work out ZZ-d intuitively in order to reduce this to 2 looks and 1 or 2 algs.

My point is, we should absolutely look for cool new 2 look solutions, even if the fastest ones have already been found. Because it's fun. A computer may not be able to find the most fun solution, however.

#### Etotheipi

##### Member
One of the cool things about ZZ is that there are so many different variants. It seems to be a method set that attracts nerds who like to try new things.

Many of these things are worth exploring even if they don't lead to more optimal solutions for the world's top cubers. I'm principally interested in learning intuitive methods, and there are many opportunities here regarding ZZ methods. I like to see how far I can get without learning algorithms. So far I like doing corner permutation, corner orientation, then edge permutation. These can all be done with commutators and a few very intuitive algs that I don't even have to memorize as algs. I may see if I can work out ZZ-d intuitively in order to reduce this to 2 looks and 1 or 2 algs.

My point is, we should absolutely look for cool new 2 look solutions, even if the fastest ones have already been found. Because it's fun. A computer may not be able to find the most fun solution, however.
Yes, that is true, but since as you said, computers can't find the funnest solutions, and the point of this project was to find algsets using computers, computers don't have much they can do I guess in the 2-look ZBLL area.