# Optimal PLL - 288 cases

#### cuBerBruce

##### Member
I would have to think someone has done this before, but I have run all the non-trivial isomorphically distinct PLL cases in Cube Explorer to come up with the real optimal PLL move counts for all 288 PLL cases. I summarize the results below, total cases and broken down by the standard 14 PLL cases (including PLL skip case).

Code:
Optimal PLL (FTM) - All 288 cases

Moves  All  Skip   A    E    F    G    H    J    N    R    T    U    V    Y    Z
-----  ---  ----   -    -    -    -    -    -    -    -    -    -    -    -    -
0f*     1    1
1f*     3    3
9f*    18         8                   2                        8
10f*    82        24                   2   24              8   24
11f*    16                                  8              8
12f*    40                       32                                            8
13f*    84                  12   32              4   24                  12
14f*    40              4    4                   4    8             16    4
15f*     4              4
---   --   --   --   --   --   --   --   --   --   --   --   --   --   --
Total  288    4   32    8   16   64    4   32    8   32   16   32   16   16    8
This works out to an average of approximately 11.642 moves. Note that Helmstetter's site (http://www.ai.univ-paris8.fr/~bh/cube/) gives an average of 11.21 moves. Why is his figure lower? Because Helmstetter only uses the best case within each PLL category, and doesn't compensate for the fact that a given alg will require an "AUF" 75% of the time. That means his average should be as much as 11.96 to properly account for AUFs. By considering optimal algs for each of the "AUF" cases, the real average comes down to 11.64.

(Note: Because of certain symmetrical PLL's, properly using the proper angle or mirror for an alg can reduce the AUF percentage slightly, so I would say that the 11.96 figure that I stated is slightly too high, but would still be higher than 11.64.)

#### Lucas Garron

##### Member
And your reason for posting this is?
You don't have a question, you just felt like posting seemingly pointless information to claim that some-one else was wrong?
No, he felt like posting some original research to improve the work that has been done before.

(Seriously, we finally get a post that's serious cube math instead of noob-talk, and someone still complains?)

Bruce: Planning to upload a .txt with a table of the algs?

#### qqwref

##### Member
And your reason for posting this is?
You don't have a question, you just felt like posting seemingly pointless information to claim that some-one else was wrong?
Kieran's signature said:
..A child of the new generation..
I always knew the "new generation" of cubers was the generation who just wanted to solve the cube fast without wanting to understand it. This guy's posting original cubing research on the forum, and your criticism is that it's not a question so you don't understand why he would have posted it? Go back to posting comments on Youtube, your level of intelligence fits in much better there...

Bruce: This is really cool stuff, and it seems like it could be very useful for fewest moves if you could reduce the number of algs to learn. For instance, which cases have the property that there is a small set of most-optimal algorithms, and the others are just one of those algorithms + AUF?

[By the way, for any mods/admins (i.e. PJK) reading this: please make a Theory subforum!]

#### cuBerBruce

##### Member
And your reason for posting this is?
You don't have a question, you just felt like posting seemingly pointless information to claim that some-one else was wrong?
No, he felt like posting some original research to improve the work that has been done before.

(Seriously, we finally get a post that's serious cube math instead of noob-talk, and someone still complains?)

Bruce: Planning to upload a .txt with a table of the algs?
No, as far as my post trying to claim someone else was wrong. Helmstetter's analysis didn't separate each "AUF" case, so it's not surprising to me that the average he gives doesn't count AUF moves. I just figured someone would claim my result must be off, claiming Helmstetter's number, so I explained the difference up front.

As for Lucas's request, since the Cube Explorer maneuver file is fairly short, I'll just inline it here. You can load it into Cube Explorer, and generate additional algs for each case.

Code:
R2 F2 R' B' R F2 R' B R'  (9f*)
R2 F2 R' B' R F2 R' B R' U  (10f*)
R2 F2 R' B' R F2 R' B R' U'  (10f*)
R2 F2 R' B' R F2 R' B R' U2  (10f*)
L U' R D2 R' U L' R U' L D2 L' U R'  (14f*)
R2 U F2 U2 F2 R2 U F2 U F2 U2 R2 U' R2 U'  (15f*)
R2 U F2 U2 F2 R2 U F2 U F2 U2 R2 U' R2  (14f*)
F2 L2 B' F2 U B' R2 F D' B R2 B F' U'  (14f*)
F2 L2 B' F2 U B' R2 F D' B R2 B F'  (13f*)
L F' R U2 L' B L' R2 D2 R2 B' L R'  (13f*)
R2 F2 D B2 D' B2 U B2 U' B2 F2 R2 U  (13f*)
F2 D B2 D L2 B D F' D2 B D' F'  (12f*)
R2 F2 D B2 D' B2 U B2 U' B2 F2 R2  (12f*)
R2 F2 D B2 D' B2 U B2 U' B2 F2 R2 U'  (13f*)
F2 L2 R2 U R2 D' F2 D F2 U' L2 F2 U'  (13f*)
F2 L2 R2 U R2 D' F2 D F2 U' L2 F2  (12f*)
R D L' D2 R D' L' F2 D' L2 D' R2  (12f*)
F2 L2 R2 U R2 D' F2 D F2 U' L2 F2 U  (13f*)
L2 B2 F2 R2 D L2 B2 F2 R2 U'  (10f*)
L2 B2 F2 R2 D L2 B2 F2 R2  (9f*)
L2 B2 F2 R2 D' L2 B2 F2 R2 U'  (10f*)
B2 L U L' B2 R D' R D R2  (10f*)
L R U2 R' U' R U2 L' U R'  (10f*)
B U' F U2 B' U B U2 B' F'  (10f*)
B2 L2 U L2 D' B2 D B2 U' B2 U'  (11f*)
R2 F2 U2 F2 U F2 R2 U2 R2 U F2 U2 R2 U'  (14f*)
R U' R2 F2 U' R F2 R' U F2 R2 U R'  (13f*)
R' U2 R U2 R' F R U R' U' R' F' R2 U'  (14f*)
R' U2 R U2 R' F R U R' U' R' F' R2  (13f*)
L U' B U L2 D2 R F R' D2 L U' B'  (13f*)
L' B2 R2 D' R D R B2 L U2 R U' R'  (13f*)
R2 D B2 U' B2 R2 D' F2 U F2 U'  (11f*)
R2 D B2 U' B2 R2 D' F2 U F2  (10f*)
R2 D' F2 U F2 R2 D B2 U' B2 U'  (11f*)
R2 U B' F R2 B F' U R2  (9f*)
R2 U B' F R2 B F' U R2 U  (10f*)
R2 U B' F R2 B F' U R2 U'  (10f*)
R2 U B' F R2 B F' U R2 U2  (10f*)
R D2 F2 D R' D' F2 U2 L' U' L D2 U' R'  (14f*)
F2 U R2 D2 L2 B2 D L2 D R2 U2 F2 U' F2  (14f*)
F U F2 L F2 U' F' L2 B' U B L2 U2 L'  (14f*)
F' U' F R2 B' D B U B2 D' B2 U' R2  (13f*)
F2 U' F2 U' F2 U2 L' B' L F2 L' B L  (13f*)
F' L' F R2 F' L F U2 R2 U R2 U R2 U'  (14f*)
B2 F2 U' L2 R2 D L R' D2 U2 L R'  (12f*)
F' L F L' R' F L R' F L' F' R2  (12f*)
L2 R2 D L2 R2 U L2 B2 L2 R2 F2 R2  (12f*)

#### AvGalen

##### Premium Member
I like cube theory, but could you maybe explain in simple english what "non-trivial isomorphically distinct PLL cases" mean? As there are only 21 PLL's I would expect there to be 21*4 + 3 = 91 distinct PLL cases. What don't I understand?

N

#### nitrocan

##### Guest
I like cube theory, but could you maybe explain in simple english what "non-trivial isomorphically distinct PLL cases" mean? As there are only 21 PLL's I would expect there to be 21*4 + 3 = 91 distinct PLL cases. What don't I understand?
I think that 21 PLL's are the ones that you can set up with AUF of the cube.
You know how in Katsu's website, there's another diagram of the G permutation.

and 21 * 4 + 3 = 87

#### jazzthief81

##### Premium Member
There are 72 PLL's if you consider all starting orientations:

- H, the two N's and the solved case have only one starting orientation since they're completely symmetric
- Z and E have two starting orientations
- the remaining 16 cases have 4 starting orientations

4*1+2*2+16*4=4+4+64=72

After the PLL you can have 4 AUF's (U/U'/U2/nothing).

72*4=288

Another way is to look at it like this:

- four edges can be permuted in 4!=24 ways
- four corners can be permuted in 4!=24 ways
- because the parity of edges and corners must be the same, only half of the cases are possible

24*24/2=288

#### cuBerBruce

##### Member
I like cube theory, but could you maybe explain in simple english what "non-trivial isomorphically distinct PLL cases" mean? As there are only 21 PLL's I would expect there to be 21*4 + 3 = 91 distinct PLL cases. What don't I understand?
Trivial cases: solved, U, U', U2
isomorphically distinct: This means I ignored cases that are symmetrically equivalent to each other. Cube Explorer will tell you if a pattern you're entering from the Facelet Editor is isormorphic to one that's already in the main window.

Lars already explained the 288.
Symmetry (including mirror cases) reduce significantly the number of cases. So the total number of cases that I actually needed to examine with Cube Explorer was less than your 21*4. (The standard 21 PLL cases count mirrors as separate cases.)

#### JLarsen

##### Premium Member
Wow, intense stuff, here, just a bit over my head to be honest, but I think I get the general purpose.

#### abr71310

##### Member
I couldn't agree more -- new research is always interesting!!

Now to find the optimal move count for FULL FRIDRICH (lol, not accounting for OLL/PLL skips).... *thinks about it*.

Love the research mate, seeing as I only know about 16/288 PLLs (finally started learning random orientation PLL), this is some nice facts and figures!

May I use these facts and figures in my Data Management presentation for the Fridrich method??

#### fanwuq

##### Member
And your reason for posting this is?
You don't have a question, you just felt like posting seemingly pointless information to claim that some-one else was wrong?
Kieran's signature said:
..A child of the new generation..
I always knew the "new generation" of cubers was the generation who just wanted to solve the cube fast without wanting to understand it. This guy's posting original cubing research on the forum, and your criticism is that it's not a question so you don't understand why he would have posted it? Go back to posting comments on Youtube, your level of intelligence fits in much better there...

Bruce: This is really cool stuff, and it seems like it could be very useful for fewest moves if you could reduce the number of algs to learn. For instance, which cases have the property that there is a small set of most-optimal algorithms, and the others are just one of those algorithms + AUF?

[By the way, for any mods/admins (i.e. PJK) reading this: please make a Theory subforum!]
I completely agree with QQwref. This is the kind of stuff that I actually want to see.
There should be a theory subforum. I don't understand why so many people consider getting fast times more fun than getting efficient solves... so much that they even feel move count analysis is pointless?
I don't know if I'd use PLL much for FMC, but this is definitely interesting.

#### pjk

##### Administrator
Staff member
I've never seen this study before (or Helmstetter's), but I've always wondered what the optimal PLL movecount was.

Helmstetter only uses the best case within each PLL category
So his move count was only off due to the fact that he didn't take into account the 25% chance of a correct PLL (without "AUF")?

I'd be interested in seeing this done for the OLL as well.

#### cuBerBruce

##### Member
I've never seen this study before (or Helmstetter's), but I've always wondered what the optimal PLL movecount was.

Helmstetter only uses the best case within each PLL category
So his move count was only off due to the fact that he didn't take into account the 25% chance of a correct PLL (without "AUF")?
Yes, in other words, Helmstetter's number is correct if you consider AUF (to align last layer with first two layers) to be a separate step from PLL, and you do the PLL part optimally. What additional fraction of a move would need to be added to account for AUF depends on your assumptions, but my data indicates at least 0.43 of a move on average is required.

I'd be interested in seeing this done for the OLL as well.
AUF is not necessary for OLL, so I think Helmstetter's site has the raw data for this, and I would presume the correct average. It does not seem to a have a summary table of number of cases for each alg length, though. I note that Helmstetter's site treats mirrors (and inverses, when applicable) as the same cases, so the number of cases he has for PLL and OLL are less than the usual numbers given. (I also note that OLL cases do not have inverse cases. This is because OLL algs are free to permute the pieces around, so inverses of algs for the same OLL case do not in general have the same OLL effect.)

#### AvGalen

##### Premium Member
There are 72 PLL's if you consider all starting orientations:

- H, the two N's and the solved case have only one starting orientation since they're completely symmetric
- Z and E have two starting orientations
- the remaining 16 cases have 4 starting orientations

4*1+2*2+16*4=4+4+64=72

After the PLL you can have 4 AUF's (U/U'/U2/nothing).

72*4=288

Another way is to look at it like this:

- four edges can be permuted in 4!=24 ways
- four corners can be permuted in 4!=24 ways
- because the parity of edges and corners must be the same, only half of the cases are possible

24*24/2=288
Thanks for the explanation Lars (and sorry about the 21*4+3 =91, that was wrong on so many levels).

As most of you know I like translating theory into practice. In this case 288 would be the amount of algs you would need to learn if you wanted to be able to

* Solve every PLL optimally
* From every angle
* Without a need for AUF-ing (before or after)

I am wondering how many of those algs would actually start or end with a U-move (some, like U, U', U2 and A-Perm+AUF obviously do)

#### Kieran

##### Member
He explained how many would end or begin with a U-move..? Well as I read it he said that there is 288 cases of which 75% of them require a AUF, meaning that 216 of the cases would start or end with a U, and presumably more because some of the 21 PLLs at the moment begin with U-moves.

You will have to forgive me for the first comment on that page that was fairly deleted, but when I first read it, I didn't take it in and thought why is he posting this, he hasn't asked any questions or asked about discussion, but I understand what he was saying. As for those quoting my signature, it has nothing to do with cubing.. Just simply a cliché phrase at my school, and as for me being involved only with speedcubing and not understanding the cube, 'tis quite the contrary: I only go for understanding the cube, and cubing gets rather boring after you can solve it easily.. Hence I have every size of the cube now. Thanks for judging some-one through a computer screen on the merit of a sentence? xD

This is actually interesting: I have a question though, was wondering does this mean that the average move count for a traditional Fridrich is wrong as you have just proved that the average for the PLL was wrong?

Sorry.

#### AvGalen

##### Premium Member
Well as I read it he said that there is 288 cases of which 75% of them require a AUF, meaning that 216 of the cases would start or end with a U, and presumably more because some of the 21 PLLs at the moment begin with U-moves.

75% of them (roughly) require an AUF to become a "normal" PLL. that doesn't mean that the optimal solution to the Un-AUF-version has to begin or end with a -move!

And none of the PLL's I know begin with a -move. I only know a 2-gen Z-PLL that ends with a U2, but that isn't an optimal alg

And there isn't really an exact consensus about the average move count for a traditional Fridrich solve. Each seperate case could be calculated (should come done to approximately 5+4*7+12+13 = 58) but by doing a different cross or a different first slot the next step can be dramatically influenced. I once proved this at Danish Open where I did a "worst-cross-case"-Fridrichstyle-solution. Within an hour I found a solution that had
8 move cross (maximum)
4 * 3 or 4 move pairs (almost minimum)
6 move OLL (minimum)
9 move PLL (minimum)

#### Stefan

##### Member
And there isn't really an exact consensus about the average move count for a traditional Fridrich solve. Each seperate case could be calculated (should come done to approximately 5+4*7+12+13 = 58)
Less approximately, using my data for F2L, Bernard's for OLL and Bruce's for PLL, we get for using optimal algs:
5.82 + 5.03 + 5.40 + 5.80 + 6.81 + 9.22 + 11.64 = 49.72

#### blade740

##### Mack Daddy
I wonder, though: If you calculate with the AUF during OLL, does it save a fraction of a move (by allowing you to use Helmstetter's number for PLL)?

#### cuBerBruce

##### Member
Well as I read it he said that there is 288 cases of which 75% of them require a AUF, meaning that 216 of the cases would start or end with a U, and presumably more because some of the 21 PLLs at the moment begin with U-moves.

75% of them (roughly) require an AUF to become a "normal" PLL. that doesn't mean that the optimal solution to the Un-AUF-version has to begin or end with a -move!

And none of the PLL's I know begin with a -move. I only know a 2-gen Z-PLL that ends with a U2, but that isn't an optimal alg

The 75% comes from the simple fact that if you apply a PLL alg without any regard to how the other two layers are oriented, you have only a 25% chance that the first two layers will have the proper orientation to line up with the solved (relative to itself) last layer. I will go into detail below about what cases you need algs for below, to solve PLL optimally for FTM.

On Helmstetter's site, some PLL algs start with a U layer turn, but that is just to make the alg correspond with the diagrammed PLL case. He parenthesizes such a U move and doesn't count that move when he counts the length of the algorithm.

I am looking at this issue (optimal PLL) mainly from the perspective of fewest moves solving, where face-turn metric is generally used (as is the case for WCA competitions) and 1-move difference can be significant in the results of a competition. If you learn an alg, you should be able to calculate its mirror or inverse. (You don't really have to do this "in your head" during fewest moves solving because you have paper and pen.) So I won't count mirrors/inverses as separate algs to be learned.

For each PLL "letter case," I will consider four "AUF" cases. Most PLLs have a standard "canonical" case, and other AUF cases differ by a U layer move. (There may be differences of opinion as far the "angle" for the canonical cases, but that isn't relevant to this discussion.) Some of the "letter cases" have mirror cases, and G-Perm has both mirror and inverse combinations that are generally labelled as separate cases. Some sites might refer to these as "Ja" and "Jb" for the J-perm cases, etc. Think of the four "AUF" cases as applying to each of Ja and Jb separately.

A-Perm: 1 alg. The typical 9-move algorithm is optimal for the canonical case. Other cases can simply use AUF (with the same alg).

E-Perm: 2 algs. Algs for the canonical case (double corner swap) and U2 AUF case are needed.

F-Perm: 2 algs. The canonical case is a corner swap and an edge swap. An alg and its mirror are needed for the quarter-turn AUF cases, and one alg for the U2 AUF case. A separate alg is not needed for the canonical case.

G-Perm: 2 algs. Algs are needed for the case where the 2x1x1 block is in the correct position, and the case that's a U2 turn from that case.

H-Perm: 1 alg. The canonical case is usually the double edge swap case. An alg and its mirror are needed for the cases that are a quarter-turn from that case. Separate algs are not needed for the canonical case and the "X-Perm" case.

J-Perm: 2 algs. An alg is needed for the canonical case (an edge swap and a corner swap), and one alg and its mirror for the cases that are a quarter-turn AUF from that.

N-Perm: 1 alg. The canonical case is either of the two cases of an edge swap and a corner swap. One alg (applied from two angles) is needed for the cases that are a quarter-turn AUF from either of choice of canonical case.

R-Perm: 3 algs. The canonical case swaps two corners and two edges. Algs are needed for the three other cases.

T-Perm: 1 alg. The canonical case swaps two corners and two edges. One alg and its mirror are needed for the non-canonical cases.

U-Perm: 1 alg. The "Allan" algorithm (or mirror) is optimal for the canonical case. Other cases can simply use AUF.

V-Perm: 3 algs. The canonical case is a corner swap and an edge swap. An alg is needed for each AUF case, except the two cases a quarter-turn away from the canonical case can be solved with one alg and an appropriately applied mirror.

Y-Perm: 2 algs. An alg is needed for the canonical case (a corner swap and an edge swap), and an alg and its mirror is needed for the cases of a quarter-turn AUF from the canonical case.

Z-Perm: 3 algs. The canonical case is a double edge swap. Similar to V-Perm, each case requires an alg except the cases a quarter-turn AUF from the canonical case can use one alg and its mirror.

I wonder, though: If you calculate with the AUF during OLL, does it save a fraction of a move (by allowing you to use Helmstetter's number for PLL)?
I'm not sure what you mean. You might sometimes be able to apply an OLL from more than one angle, or apply a mirror alg instead of unmirrored alg. That might get you a better PLL altogether, not merely eliminate an AUF. You could also learn multiple (unrelated) OLL algs for the same case that permute pieces differently, giving you different PLLs. This may be considered a more advanced method or method variation when you look at influencing PLL with the choice of OLL alg.

Last edited:

#### pjk

##### Administrator
Staff member
I've never seen this study before (or Helmstetter's), but I've always wondered what the optimal PLL movecount was.

Helmstetter only uses the best case within each PLL category
So his move count was only off due to the fact that he didn't take into account the 25% chance of a correct PLL (without "AUF")?
Yes, in other words, Helmstetter's number is correct if you consider AUF (to align last layer with first two layers) to be a separate step from PLL, and you do the PLL part optimally. What additional fraction of a move would need to be added to account for AUF depends on your assumptions, but my data indicates at least 0.43 of a move on average is required.
Can you tell how you got 0.43 average?

I'd be interested in seeing this done for the OLL as well.
AUF is not necessary for OLL, so I think Helmstetter's site has the raw data for this, and I would presume the correct average. It does not seem to a have a summary table of number of cases for each alg length, though. I note that Helmstetter's site treats mirrors (and inverses, when applicable) as the same cases, so the number of cases he has for PLL and OLL are less than the usual numbers given. (I also note that OLL cases do not have inverse cases. This is because OLL algs are free to permute the pieces around, so inverses of algs for the same OLL case do not in general have the same OLL effect.)
As far as a "AUF" being necessary or not for OLL: wouldn't that actually affect the overall move average? If you can position an OLL in a fashion that, when executed, creates a greater "chance" of having more pieces into the correct location, wouldn't that decrease the "chance" of needing to AUF during PLL? Perhaps this has something to do with where you got 0.43.

And there isn't really an exact consensus about the average move count for a traditional Fridrich solve. Each seperate case could be calculated (should come done to approximately 5+4*7+12+13 = 58)
Less approximately, using my data for F2L, Bernard's for OLL and Bruce's for PLL, we get for using optimal algs:
5.82 + 5.03 + 5.40 + 5.80 + 6.81 + 9.22 + 11.64 = 49.72
Stefan, I don't think I ever saw the complete study and/or details to this. Was this the study where you looked at various members example solves? If so, perhaps you could study the F2L by using optimal solutions to each CE pair case. Is the 5.82 for the cross the average optimal move count for color neutrality, if not, where did you get 5.82?

Last edited:
Similar threads