Permutation of Last Layer (PLL)

Printable Page (select "landscape" in page set-up)

Best time for executing 21 PLL's in a row: 45 ish, which isn't that fast. Watch Yu Nakajima do this in 36.72 seconds.

PLL, the last step of the Fridrich Method, permutes the last layer pieces without disturbing their orientation. There are 21 patterns including mirrors and inverses, much less than for OLL. However, each algorithm is longer than in OLL and often involve tricky finger-tricks. Go as fast as you possibly can on PLL. Your initial goal should be sub-2.5 sec for 1 execution (sub-10 for 4 consecutive executions) for each pattern.

Below you can find the algorithms I currently use, though I will probably end up changing a couple of these in the future as people discover better algorithms. Definitely check out other cubers' lists and find your best match. Since PLL is often where you can get personal with your finger-tricks, experiment with different ways performing even the same algorithm, for example by chunking into different substeps or by changing when to regrip. Keep in mind that, since this is the last step, you do not need to worry about whole cube turns and that you should also think about putting down the cube to stop the timer. (Which reminds me, the 100-meter dash analogy and why it's not unreasonable to use a StackMat: here, here, and here.)

Recognition and AUF

PLL recognition takes longer than for OLL recognition because we often need to adjust the U face (AUF) before we can determine the case. Rather than systematically matching the corners or the edges, I recommend using "blocks" to determine the case. I will use the keyboard numpad in to refer to the pieces (props to Timothy Wang for this idea) and use cycles to describe the permutation.

Two adjacent top-layer pieces are "connected" if they have the same color on the same side. Each permutation has a unique pattern of connected pieces that form "blocks." For example, (46)(39), the T permutation, has blocks 12 and 78. We match these blocks with the first two layers and apply the appropriate algorithm. Learning the blocks for each permutation often allows us to determine the correct permutation just from two adjacent sides. For instance, if you see the block 1236 (not connected to 9), the only possible case is: (79)(48). In some cases, we need more information. Say you see the block 236 (not connected to either 1 or 9) upon finishing OLL. There are three possible permutations: (19)(48), (179), and (197). We can distinguish between these patterns either by inspecting the blocks on one of the two remaining sides.

If there is only one block, consisting of a corner and an edge, it must be one of the four G permutations. We match this block to determine which of the four cases we are in. If there is no block at all, we must have (13)(79), and matching one edge (which automatically matches all the edges) shows us which corners needs to be switched.

Another advantage to this recognition method is that, often during OLL, we can already see blocks coming together. This allows us to predict the PLL case by slowing down slightly towards the end of PLL, thereby reducing the pause between the two last layer steps.

It is always possible to determine the permutation from just two adjacent sides. Take the same block 236. With (19)(48), the colors of 1 and 23 and those of 9 and 63 are opposite. For the three cycles, only one set is opposite and the other two have adjacent colors, on F or on R depending on the direction of the cycle. I personally do not use this more advanced recognition method.

Learning PLL

Start with two-step PLL, which is a subset of the complete PLL. There are two algorithms for corners (n3 and n15) and four for edges (n1, n2, n5, n6). Learn n4, the reflection of n3.

Of the algorithms above, n15, which is used to swap corners across a diagonal, takes the longest. For this reason, the next PLL cases to learn are the other cases with a diagonal corner swap: n7, n9, n20, n21.

From here, it's all preference. The intimidating G permutations are actually not any more difficult to recognize than the other cases. After matching the corner-edge block, use the method described in the comment for n16.

Algorithms

Codes	Prob.	Pattern	Algorithm	Comment
n1 U	1/18	Single: 1.64 Four: 6.16 (1.54)	R'UR'U'-R'U'-R'URUR2	Very easy. n1/n2 are the ones you most often encounter after COLL. For these easy cases, AUF / cube rotation becomes a pretty significant part of the time. Learn the mirror: RU'-RURURU'R'U'R2
n2 U	1/18	Single: 1.26 Four: 5.97 (1.49)	R2U'R'U'RURURU'R	Inverse of n1. See the comment for n1. Learn the mirror: R2URUR'U'R'U'R'UR'
n3 A	1/18	Single: 1.59 Four: ()	RB'R-F2-R'BR-F2R2	I'm starting to do this one with some tilt in the direction of y.
n4 A	1/18	Single: 1.95 Four: ()	L'BL'-F2LB'L'-F2L2	Mirror of #3. Much easier from another direction.
n5 Z	1/36	Single: 1.59 Four: 7.84 (1.96)	UR'U'RU'RURU'R'URUR2U'R'U	2-generator algorithm from Katsu. AUF to match the corners, then either this or its mirror, R'U'RU'RURU'R'URUR2U'R'U2 (the first U is moved to the end).
n6 H	1/72	Single: 1.39 Four: 5.89 (1.47)	M2UM2U2M2UM2	Since I'm not so comfortable doing Bob's M double trigger (middle then ring finger), I usually stick with Rw2R2' instead of M2. Alternatively you can use RwRB2R'wR'-B'wB'R2BwB. The second set of antislices can be performed using double triggers.
n7 E	1/36	Single: 1.72 Four: ()	xUR'U'LURU'-R2w'U'RULU'R'U	Credit: Lars Vandenbergh.
n8 T	1/18	Single: 1.31 Four: 6.59 (1.65)	RUR'U'R'FR2U'R'U'RUR'F'	Very easy. Either keep the left thumb on F the entire time and pull the last F' with the right thumb, or move the left thumb to D during the second to last move and do F' with the left index finger.
n9 V	1/18	Single: 1.90 Four: 8.22 (2.11)	R'UR'U'-B'DB'D'-B2R'B'RBR	A possibly better algorithm by Stefan: R'UR'D'w-R'F'R2U'R'UR'FRF. Keep left thumb on F center except at the hyphen, where you need to move it from L to F.
n10 F	1/18	Single: 2.15 Four: 10.76 (2.69	U'R'URU'R2-y'R'U'RU-BRB'R'B2	I probably need to change this algorithm.
n11 R	1/18	Single: 1.97 Four: 9.58 (2.39)	R'U2'-RU2'-R'FRUR'U'-R'F'R2U'	This used to be a pretty hard case, but this algorithm by Quinn Lewis makes it easy. Left thumb stays on F center the entire time. Double triggers for U2' help.
n12 R	1/18	Single: Four: ()	RU2'R'U2-LwU'L'wU'-RULwUL'wR'U	Mirror of n11.
n13 J	1/18	Single: 1.34 Four: 7.16 (1.79)	RU2'R'U'RU2'L'UR'U'L	I actually found this on my own, but I never used it until I saw it on Lars V's site. Double triggers for U2'.
n14 J	1/18	Single: 1.55 Four: ()	R'U2'RUR'U2'-LU'RUL'	Mirror of n13. Double triggers.
n15 Y	1/18	Single: 1.91 Four: 9.01 (2.25)	FRU'R'U'RUR'F'-RUR'U'R'FRF'	Made from two OLL algorithms. Keep the left thumb on F center except during F' at the end of the first part.
n16 G	1/18	Single: 1.93 Four: ()	RUR'y'R2U'wRU'R'UR'UwR2	About the four G permutations: Most cubers tell them apart by matching the 1x1x2 block with the first two layers and then looking at the non-U sticker of the edge that completes the 1x2x2 block on U that contains the 1x1x2 block. This color will either be opposite the one next to it or adjacent.
n17 G	1/18	Single: 2.53 Four: 8.80 (2.20)	R2'Uw'RU'RUR'-UwR2FwR'Fw'
n18 G	1/18	1.78 Single: 2.28 Four: 8.33 (2.08)	L'U'LyL2UwL'ULU'LU'wL2	Mirror of n16 (across FB). Maybe this can also be done after y2 and using R and U...?
n19 G	1/18	1.81 Single: Four: 8.38 (2.10)	R2Uw-R'UR'U'RU'w-R2'B'wRBw	From Yu Nakajima's amazing 21 PLL Excution video. Mirror of n17 (across RL).
n20 N	1/72	Single: Four: 8.77 (2.19)	R'UR'FRF'RU'-R'F'UF-RUR'U'R	Both N permutations are really troublesome. I used to use the mirror of n21 for this case. This algorithm is a modified from one by Stefan.
n21 N	1/72	Single: Four: 9.11 (2.28)	(LU'RU2L'UR')*2U'	I don't like this one so much.