# Optimal PLL - 288 cases



## cuBerBruce (Jan 22, 2009)

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).


```
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 (Jan 22, 2009)

Kieran said:


> 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 (Jan 22, 2009)

Kieran said:


> 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 (Jan 22, 2009)

Lucas Garron said:


> Kieran said:
> 
> 
> > And your reason for posting this is?
> ...



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.


```
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 (Jan 22, 2009)

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?


----------



## nitrocan (Jan 22, 2009)

AvGalen said:


> 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 (Jan 22, 2009)

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 (Jan 22, 2009)

AvGalen said:


> 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 (Jan 22, 2009)

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


----------



## abr71310 (Jan 22, 2009)

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 (Jan 22, 2009)

qqwref said:


> Kieran said:
> 
> 
> > And your reason for posting this is?
> ...



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 (Jan 22, 2009)

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 (Jan 23, 2009)

pjk said:


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



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.



pjk said:


> 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 (Jan 23, 2009)

jazzthief81 said:


> 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
> ...


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 (Jan 23, 2009)

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 (Jan 23, 2009)

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 (Jan 23, 2009)

AvGalen said:


> 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 (Jan 23, 2009)

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 (Jan 23, 2009)

AvGalen said:


> 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.



blade740 said:


> 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.


----------



## pjk (Jan 23, 2009)

cuBerBruce said:


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


Can you tell how you got 0.43 average?



cuBerBruce said:


> pjk said:
> 
> 
> > I'd be interested in seeing this done for the OLL as well.
> ...


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.



StefanPochmann said:


> AvGalen said:
> 
> 
> > 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)
> ...


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?


----------



## AvGalen (Jan 24, 2009)

Stefan's approach used optimal algs for the shortest pair. As you can see by the last pair (6.81) a normal pair takes about 7 moves, but if you can choose from 4 different pairs there is a very high chance that at least one of them can be done in less. That is why the numbers go up
5.03
5.40
5.80
6.81


----------



## cuBerBruce (Jan 24, 2009)

pjk said:


> cuBerBruce said:
> 
> 
> > pjk said:
> ...



To get the average number of moves, you simply add the lengths of the algs used for each case. Then divide by the number of cases. This, of course, assumes that the 288 PLL permutations are equally likely to occur, and that it is not influenced by some clever selection of what you do for OLL. Picking the shortest alg for each PLL (and the trivial skip case), the lengths sum up to 3228. Divide by 288 and you get approx. 11.21 (Helmstetter's number). Using my data for the alg lengths needed to completely solve each of the 288 cases with respect to the first two layers, the sum comes to 3353. Divide by 288 and you get 11.64. The difference is 125/288 or approximately 0.43. Since in both cases, the use of best case algs were being assumed (for example always using a 9-move H-Perm alg for H-Perm cases, plus AUF if necessary when solving with respect to first two layers), then the difference must be due to AUF moves. Of course you could use a 10-move alg for the canonical H-Perm case (L R U2 L' R' F' B' U2 F B, for example) instead of a 9-move alg plus an AUF. You technically reduce the number of AUF moves doing this, but you're not gaining anything in overall move count.




pjk said:


> cuBerBruce said:
> 
> 
> > pjk said:
> ...


Again, an AUF move does nothing for you at OLL time. It doesn't change the orientation of any pieces. In speedcubing, an AUF move might be used instead of a cube rotation to put the last layer at the correct angle for an alg you want to use, but for optimal FTM solving, you would just do a cube rotation, or translate the alg to compensate for the "wrong" angle. You seem to be suggesting something along the same lines as blade740, and I don't understand how you are expecting to gain something.



pjk said:


> StefanPochmann said:
> 
> 
> > AvGalen said:
> ...



Lars Vandenbergh's cross study page (http://www.cubezone.be/crossstudy.html) lists 5.81 for color-specific cross, and 4.81 for color neutral cross. So you would eliminate basically one more move using color neutral solving.


----------



## Zeroknight (Jan 25, 2009)

qqwref said:


> 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...


Hey, hey, hey, don't be too hasty with those generalizations. I would really like someone to teach me cube theory, but in an easy, understandable way, you know?


----------



## Stefan (Jan 28, 2009)

pjk said:


> StefanPochmann said:
> 
> 
> > AvGalen said:
> ...


No, it's from my diploma thesis:
http://www.stefan-pochmann.info/hume/hume_diploma_thesis.pdf
Page 32, the "CrossF2L" side of the "Greedy order" table. For more information about the meaning of the numbers, start reading at page 30. Basically it's the "standard way", like most of us solve F2L (fixed cross color, then always solving the easiest pair). And the data is experimental, average of 10000 solves, so it's quite accurate but not absolutely exact (which is why I'm 0.01 off for the cross compared to Lars' data).


----------

