Permutation of Last Layer (PLL)

Click here for a printable page.

PLL is the last step in the Fridrich Method. It has 21 different patterns including mirrors and inverses, a tiny number compared to that of OLL. However, each algorithm used is long and often requires swift hand movements. On PLL, you should go as fast as you possibly can. Your goal should be sub-2.5 sec for 1 (sub-10 for 4 consecutive excutions) for each pattern. Because this is the last step, you do not need to worry about whole cube turn. PLL is often where you can get personal with your FSC's. People will have different ways of doing the same algorithm. The ones listed here are the ones that I currently use. I may change much of these in the future, and you should definitely try to personalize them, making it the best for you. PLL is also where you can get back the time you lost on F2L. You may want to memorize different algorithms for each direction of the pattern to minimize whole cube turns.

These are the algorithms I currently use for PLL. I have provided two codes for each pattern: JSCC and Fridrich (letter). Many thanks to Josef Jelinek for his wonderful Java Cube Applet.

I've given credit whenever possible to where I originally found the algorithm. Remember: these are just the ones I use. Try as many algorithms as you can and find your perfect match. Here is a list of pages with PLL algorithms.

Best time for excuting 21 PLL's in a row: 49.45.

Recognition

Recognition for PLL may take you a while to master but should not be a problem once you have used the alogorithms long enough. Recognition for this step is much more difficult than that of OLL because, unlike in OLL, in PLL you need to AUF before you can see which pieces need to be permuted. One approach would be to match up two of either corners or edges. Wile this may be easier for a starter, having to recognize a four-cycle of whatever you did not fix (corners or edges) is quite difficult. For this reason, I use a "block" approach for reconigition of PLL.

First, definitions to speed up the talk: call two adjacent pieces "connected" if they have the same color on the same side. Each permutation pattern has a unique pattern of connected pieces that form a "block." I will refer to the number pad of the keyboard for ease of discussion. For example, you would recognize the permutation (46)(39), the T permutation, by the blocks formed by 12 and 78; match these up with AUF and you are ready to apply whatever algorithm you are using. Once you know what blocks are formed for each permutation, you can easily determine the permutation you have through a process of elimination. For instance, if you see the block 1236 (but not 9), there is only one possible pattern: (79)(48). It is not always the case that you can decide the pattern after an initial inspection of two sides. Say you see the block 236 (but not 1 or 9) upon finishing OLL. There are three possible permutations: (19)(48), (179), and (197), and you would need look at either the L or B face to decide on a pattern. This method is the hardest with the four G permutations, in which case you only have one block consisting of a corner and an edge. Conversely, if you only see this small block, it is one of the four G permutations; you can decide which one of the four by the direction of the block (either 74 or 78 after AUF) and by on which face in relation to the block exists two corners of the same color (1 and 3 on F or 3 and 9 on R). If you do not see any block at all, you have the permutation (13)(79); if this is the case, match one edge (which automatically matches all the other edges) and then determine which corners need to be swapped. While all of this may feel unnatural upon first using it, rest assured that you will be doing it without even thinking with practice.

Here are some basics of another recognition approach used by top cubers: it is always possible to determine which pattern you have just by looking at two adjacent sides (and so eliminating the need for any AUF). Take the same block 236 (but not 1 or 9). If you have the permutation (19)(48), the colors of 1 and 23 and those of 9 and 63 are opposite, while if you have a 3-cycle of corners, only one set is opposite and the other two have adjacent colors, on F or on R depending on the direction of the cycle.

More discussion on this topic

Props to Timothy Wong for his numpad notation.

The good stuff

Codes	Pattern	Algorithm	How It's Done	Comment
n1 U	Single: 1.64 Four: 6.16 (1.54)	R'UR'U'-R'U'-R'URUR2		Very easy. This and n2 are the ones you most often encounter after COLL. For blindfold cubing, I still like to use the other variation: R2UFB'R2F'BUR2.
n2 U	Single: 1.26 Four: 5.97 (1.49)	R2U'R'U'RURURU'R		Fastest excution time.
n3 A	Single: 1.59 Four: ()	RB'R-F2-R'BR-F2R2		This is for me the easiest pattern for PLL.
n4 A	Single: 1.95 Four: ()	L'BL'-F2LB'L'-F2L2		Mirror of #3. Should also be very easy.
n5 Z	Single: 1.84 Four: 8.32 (2.08)	UR'U'RU'RU R U'R'U RU-R2 U'R'U		Old algs: LR'U2'D2LR'DL2R2'D'wM2', x'F-RU'R'U-DR'D-U'-R'UR-D2, RURB'R'BU'R'-FwRUR'U'F'w (OLL #46->#44). This 2-generator algorithm is from Katsu.
n6 H	Single: 1.61 Four: 6.96 (1.74)	M2UM2U2M2UM2		Alternative: RwRB2R'wR'-B'F'U2BF. Slices are done as Rw then R.
n7 E	Single: 1.72 Four: ()	xUR'U'LURU'-R2w'U'RULU'R'U		Credit: Lars Vandenbergh. Much better the old one: RBLB'R'-FB-RF'L'FR'-F'B'.
n8 T	Single: 1.52 Four: 7.00 (1.75)	RUR'U'R'FR2U'R'U'RUR'F'		With the suggestion of Stefan Pochmann, I switched to this new one from the inverse, F-RU'R'URU-R2F'- RURU'R'. This new one is much nicer. The thumb stays on the bottom left blocks of F the entire time. The last F' is pulled with left thumb.
n9 V	Single: 1.90 Four: ()	R'UR'U'-B'DB'D'-B2R'B'RBR		Long but easy, as long as you don't POP. Here's an alternate algorithm by Leyan Lo: L'URU'LUL'UR'U'LU2RU2 R'
n10 F	Single: 2.15 Four: 10.76 (2.69) video (fast)	U'R'URU'R2-y'R'U'RU-BRB'R'B2		This is a pretty slow algorithm. I need to practice more.
n11 R	Single: 1.97 Four: 9.58 (2.39)	R'U2-RU2'-R'FRUR'U'-R'F'R2U'		Credit: Quinn Lewis
n12 R	Single: Four: ()	RU2'R'U2-LwU'L'wU'-RULwUL'wR'U		Leyan's
n13 J	Single: 1.68 Four: 7.16 (1.79)	RU2R'U'RU2L'UR'U'L		This one I actually found but didn't use for a long time. I switched to this one after seeing it on Lars' site, but only much later did I realize that I had discovered it previously! Here's my old one: B2LUL'B2-LwB'LwUR2
n14 J	Single: Four: ()	R'U2RUR'U2LU'RUL'		Mirror of above.
n15 Y	Single: 1.91 Four: 9.01 (2.25)	FRU'R'U'RUR'F'-RUR'U'R'FRF'		Alternative: B'R'URB'-U'w-BRBR'F2wUR2.
n16 G	Single: 1.93 Four: ()	RUR'y'R2U'wRU'R'UR'UwR2
n17 G	Single: 2.53 Four: ()	R'L'U2RLy'RU'LU2R'UL'U2
n18 G	Single: 2.28 Four: ()	L'U'LyL2UwL'ULU'LU'wL2
n19 G	Single: Four: ()	x'zDwDR2D'wD'z'U'wRU'R2DR'UR2
n20 N	Single: 2.70 Four: ()	[R'UL'U2RU'L]x2U
n21 N	Single: Four: ()	[LU'RU2L'UR']x2U'

These are some very good pages with PLL algorithms. Try as many algorithms as you can to find your perfect match :D