2LLL methods

[Tigerninja]

Here's some mathematics for why CFCE is the easiest to learn

It all started with me counting skip probabilities. I couldn't count the probability of a CLL skip, but was able to calculate the ELL skip probability. I realized that the chance of skipping both ELL and CLL is equal to the chance of skipping LL. (1/96) * (1/x) = 1/15552. x = 1/162.

15552 prime factorized is 2^6 * 3^5. 96 is 2^5 * 3^1 and 162 is 2^1 * 3^4. This is true for every 2LLL method. Let's test with OLL and PLL. 216 = 2^3 * 3^3 and 72 = 2^3 * 3^2. The exponents always add up to 2^6 and 3^5, or 15552.

I started to think about which method has the least number of algs, which is closely related to the number of cases. The number of cases is also 1 / the probability of a skip. An example: There are 96 ELL cases and 162 CLL cases, which add up to 258. As earlier mentioned, 258 is the number of cases, not algorithms.

If we want the method with the least amounts of cases, we need to find the minimum value of 2^A * 3^B + 2^C * 3^D where A + C = 6 and B + D = 5. There are two solutions, 2^2 * 3^3 + 2^4 * 3^2 and 2^4 * 3^2 + 2^2 * 3^3. Both is equal 252, because they have the same relation as CFEC and CFEC. How many algs would that be? If we look at CFOP and CFCE, whose alg count we know and that are similar in cases, we get a quotient of about 3.66. 252/3.66 = 68.85. Of course, we can't calculate the number of cases without going through them all, but it's around 67-70, maybe.

The methods would have 108 and 144 cases for the two subsets. Using our quotient, that's about 30 and 40 algs. Probably recognition would literally be looking at a list of cases, doing an alg, then looking at another list of cases, and then doing another alg. That wouldn't be worth it, since we only save 1-4 algs compared to CLL/ELL, which has much better recognition.

(There can be many methods with the same number of cases, here they are referred to as one method.)

I wonder how these 2LLL methods would work...
Sorry, to 2 look the last layer with human recognition, you'll have to learn 71 algs.
Please correct me in case I've done anything wrong.

 

[Twisted101]

the chance of skipping both ELL and CLL is equal to the chance of skipping LL

what a shocker, considering that skipping CLL and ELL is skipping LL

 

[Tigerninja]

I was wrong!
Maybe...

I've found a 2LLL method that has the least number of cases. It has 252 cases, compared to CFCE at 258 and CFOP at 288.

The first step is corner orientation + permutation of one edge. After this you will most likely have an edge 3-cycle and a corner 3-cycle. All of this is solved with one algorithm.

34/48 times you will get two 3-cycles, and 47/48 times you will get at least one 3-cycle.

Regarding alg count, the current quotient estimate is 68.85. Though in the first step, if there's already an oriented edge it's only CO + some U move, so in the first step there'd be four of the same algs with different U moves afterwards.

Maybe CFCE isn't the easiest to learn...

It would be cool if this could be made a pure 3-cycle reduction, it could have a name like CF3C, which would make you sound very intelligent when you told people about your method.

 

[Tigerninja]

I was wrong!
Probably...

I've calculated the number of algs needed for the first step of the new method, it's 18. If our "goal" is 68 algs, we have 50 more to spend.
The new method is solving corner orientation and permuting one edge first, then solving the rest.

Here is a table about how many algs we can expect for the last step. It has 144 cases.

Name	Cases	Algs	Quotient	Algs for new method with this quotient
OLL	216	57	3.78	38.09
PLL	72	21	3.42	42.10
CLL	162	42	3.85	37.40
ELL	96	29	3.31	43.50

We see that in these boundaries, the worst case scenario is 43.5 algs. That'd mean the method would have 62 algs! But this gets better. Probably the bigger alg sets are more representative of our set, since it's pretty big. The best case scenario, from CLL, is 37 algs! This would lead to a method with 55 algs! I still haven't figured out a better way to get to know the number of algorithms without going through them individually, so it might take some time before I have the result.

If nothing goes really wrong, this will be the first 2LLL method with under 70 algorithms. Sadly I can't generate them.

 

[LBr]

You are massively overthinking this. I notice that CFCE interests you, just like it interested me a few years ago. In just a few minutes of thinking, I can find a 2lll method with just 61 algs. Basically just insert your last pair as such that you always orient at least 1 LL corners (this is not difficult either insert as normal or with U R U2 R’ or otherwise . This removes 10 CLLs from the H and Pi subset. Piece of p*ss to ‘invent’, so there are definitely methods out there. Also I stupidly forgot but OCLL PLL is just 28 algorithms. And if your goal was <70 with no influencing then maybe check out some other 1LLL subsets and see how many cases it takes to reduce to them.

 

[Deleted member 36445]

You are massively overthinking this. I notice that CFCE interests you, just like it interested me a few years ago. In just a few minutes of thinking, I can find a 2lll method with just 61 algs. Basically just insert your last pair as such that you always orient at least 1 LL corners (this is not difficult either insert as normal or with U R U2 R’ or otherwise . This removes 10 CLLs from the H and Pi subset. Piece of p*ss to ‘invent’, so there are definitely methods out there. Also I stupidly forgot but OCLL PLL is just 28 algorithms. And if your goal was <70 with no influencing then maybe check out some other 1LLL subsets and see how many cases it takes to reduce to them.

zzblah

Unorient all corners then zzll (only h and pi subset)

 

[bldcuber314]

I think the main issue is that alg count is one of the smallest differences as to what makes certain methods better. Although there are 10-20 more algs, OLL+PLL is very easy to recognise and fingertrick.

 

[Tigerninja]

I do not have any intent of replacing OLL+PLL, I'm just exploring the possibilities of different 2LLL methods. I think that it's interesting and thought that other people might think so too.

It's a good idea to look at 1LLL subsets that already exists, but most of them already has a reduction, and the number of algs is closely related to the number of cases, the method I have here has as few cases as possible. Also, unbalance in how much is solved generally increases case count.

I'm doing this purely for the fun, and I don't care if the method isn't good, because I had fun while exploring it and I've already learnt a lot.

 

[bldcuber314]

I do not have any intent of replacing OLL+PLL, I'm just exploring the possibilities of different 2LLL methods. I think that it's interesting and thought that other people might think so too.

It's a good idea to look at 1LLL subsets that already exists, but most of them already has a reduction, and the number of algs is closely related to the number of cases, the method I have here has as few cases as possible. Also, unbalance in how much is solved generally increases case count.

I'm doing this purely for the fun, and I don't care if the method isn't good, because I had fun while exploring it and I've already learnt a lot.

Sure(I had an exciting 5 minutes a few days ago when I was doing exactly this(kinda) and thought I found a new 2LLL which turned out to be CFCE so I can relate)

 

[Tigerninja]

I was wrong!
Which leads to me probably being right the first time...

The method I wrote about earlier, corner orientation and permutation of one edge as the first step, had 125 algs in the second step, and with 144 cases, that leads to a ratio of 1.125. That's bad.

I found another method with 75 algs. That's three less than CFOP but four more than CFCE. It's an R U reduction. The first step is CPEOLL and making sure you don't get a U-perm for EPLL. This could be seen as a variant of CPEOLL + 2GLL, that has 24 fewer algs. I believe that this is the R U reduction with the fewest number of algs, but I'd love to be wrong about that.
I've generated some algs for the second step with Batch Solver, the average is 14.53 moves in STM. I have not yet figured out how to generate algs for the first step with Batch Solver.

Probably CLL/ELL probably has the fewest number of algorithms due to its symmetry. I've found out that it has the fewest number of cases for an M U reduction method (which it is).

Spoiler: Why CFCE has the fewest cases for an M U reduction method and more prime factorization explanation

We're searching for a method with steps with 2^2 * 3^3 + 2^4 * 3^2 cases.
CP has 2 * 3 cases
EP has 2^2 * 3 cases
CO has 3^3 cases
EO has 2^3 cases

If we want an M U reduction, since the M slice can't touch the corners, we need both CO and CP from the beginning.
CP and CO gets us 2 * 3 * 3^3, or 2 * 3^4. Since this already has too many 3s, it can't get better.

I'm still searching for a method with fewer algs!

 

[Christopher Mowla]

If you want a method with the fewest algs, how's 18?

Here is a tool which illustrates how to apply such a set to solve the last layer. (Choose "Tempus 18" in the dropdown, put in an alg that just scrambles the last layer, and hit solve.)

This was originally brought up in this post.

 

[Tigerninja]

Wow, that's cool! Thank you for showing me this!

 

[Tigerninja]

I did it!
I found a 2LLL method that uses 67 algorithms.
Actually, CFCE does most of the heavy lifting.
Also, it's a stupid(ly creative) solution.

The first step is CLL + flipping the RF edge, and the second step is ELL + flipping the RF edge.

Step one has 43 algs, one more than the unmodified CLL. It's because you can always do a CLL alg and then flip RF + e.g. UR; as one algorithm. The last alg is for when CLL is already solved but the edge isn't flipped.

When we come to step two, there are either 1 or 3 unoriented edges. There are 12 cases with 1 edge and 12 with 3. That is 24 algorithms, 5 less than normal ELL.
43 algs + 24 algs = 67 algs.

Spoiler: This has the same skip chances as ELL/CLL

Except for that none of the steps can't be skipped.
What to do if you skip both steps

I've tried generating some algs, all of them are very bad. This is just for fun.
The flipped edge doesn't have to be the RF edge, some other edge would probably lead to better algorithms. (Two not-so-unthinkable candidates are LF and DF)

 

[Deleted member 36445]

I did it!
I found a 2LLL method that uses 66 algorithms.
Actually, CFCE does most of the job.
Also, it's a stupid(ly creative) solution.

The first step is CLL + flipping the RF edge, and the second step is ELL + flipping the RF edge.

Step one has 42 algs, like the unmodified CLL. It's because you can always do a CLL alg and then flip RF + e.g. UR; as one algorithm.

When we come to step two, there are either 1 or 3 unoriented edges. There are 12 cases with 1 edge and 12 with 3. That is 24 algorithms, 5 less than normal ELL.
42 algs + 24 algs = 66 algs.
This has the same skip chances as ELL/CLL.

I've tried generating some algs, all of them are very bad. This is just for fun.
The flipped edge doesn't have to be the RF edge, some other edge would probably lead to better algorithms. (Two not-so-unthinkable candidates are LF and DF)

very clever

thanks for contribuiting to the speedsolving community

 

[Twisted101]

I did it!
I found a 2LLL method that uses 66 algorithms.
Actually, CFCE does most of the heavy lifting.
Also, it's a stupid(ly creative) solution.

The first step is CLL + flipping the RF edge, and the second step is ELL + flipping the RF edge.

Step one has 42 algs, like the unmodified CLL. It's because you can always do a CLL alg and then flip RF + e.g. UR; as one algorithm.

When we come to step two, there are either 1 or 3 unoriented edges. There are 12 cases with 1 edge and 12 with 3. That is 24 algorithms, 5 less than normal ELL.
42 algs + 24 algs = 66 algs.

Spoiler: This has the same skip chances as ELL/CLL

Except for that none of the steps can't be skipped.
What to do if you skip both steps

I've tried generating some algs, all of them are very bad. This is just for fun.
The flipped edge doesn't have to be the RF edge, some other edge would probably lead to better algorithms. (Two not-so-unthinkable candidates are LF and DF)

I have some algs for ell with DF flipped. And this is rly cool, also the CLL+flipping step would have 43 algorithms, for the case where the corners are solved and the edge needs to flip

ELLs AND MORE

docs.google.com

 

[Tigerninja]

also the CLL+flipping step would have 43 algorithms, for the case where the corners are solved and the edge needs to flip

Yeah, I forgot that. Thanks for telling me. I'll edit the post.
It's actually a little humorous that I didn't think about that since I used it in the "What to do if you skip both steps" example solve.