*Link: 22LL page*

I finally got around to finishing the 22LL page. I started it a long time ago, but stopped after filling out the A set and the E set (minus EBD and EBE). I was very recently sent two PMs on SpeedSolving about 22LL, so I decided to put in the tables and pictures for the rest of the cases, and I changed the page layout the match the rest of my pages. I was soon sent algs for all 12 R set cases by Robert Yau, so I added those in, and I also added in the I and D set cases which were easy setups to PLL. Today I generated the last 10 or so algorithms, and finished the list. There are still some cases which I’m not *totally* happy with. Cases such as AAI where the algorithm is followed by (?) indicate that I think there’s a better algorithm, but I don’t have it. (In the case of AAI, I *know *that there is a better algorithm, but every time I ask Kirjava for it, I forget to write it down)

## What is 22LL?

22LL is a subset of last layer algorithms. Each case consists of a 2-cycle of corners and a 2-cycle of edges. So, some PLLs such as T perm are 22LL cases. Z perm is **not** a 22LL case because while it has 2 2-cycles, they are both edge cycles.

## How many cases are in 22LL?

22LL is only 56 cases. There are 5 sets, based on the corner 2-cycle, each of which represents a separate CLL case. The A and D sets contain adjacent and diagonal corner swap PLLs, respectively. The A set contains T, J, L, F, and both R perms, and the D set contains Y, V, and both N perms. The D set contains less algorithms than the other 4 sets because there were 4 cases which were reducible by AUF, which I didn’t notice until I made the case pictures for them. Additionally, there is no F set ( for the 2-cycle (UBR LUF) ) because it is identical to the I set with a U2 AUF.

## Why make 22LL?

Originally, I planned to learn how to solve each 2×2-cycle for (UBR x) (DF y), where x is an edge and y is a corner, by using setups to PLLs or ZBLLs. I soon realised that it would be much simpler if I allowed edges to be unoriented. For this purpose, the entirety of 22LL would not be used. Rather, a slightly different setup would be used to reach a better 22LL case. For example, (UBR ULB)(DF UR). M’ setup could be used to reach ABI, or F2 setup could be used to reach ABC, which is a much better case (ABC is right R perm).

I also suspect that if 22LL is used by people for blindsolving, setups would be a lot simpler if the edge and corner buffers are adjacent. For example, URF and UF buffers. In my case, UBR and DF, this makes setups very awkward, although I can start by doing M2 to set DF next to UBR.

But I digress, 22LL is also a useful LL subset for speedsolving. Recognition is simple (only 5 CLL cases, and half of the pieces are solved) and the case number is low. In the past when I’ve seen 22LL cases I’ve thought to myself “that looked like a really simple LL case, why don’t I know how to solve it in 1 look?”

## Example solves

U’ B’ R’ D B R’ D2 B2 L’ F U’ F2 U B2 D F2 U2 L2 U L2 D’ F2

z2 y // inspection

U’ R’ U’ R // F2L #1

U’ R U’ R’ U’ L’ U’ L // F2L #2

R U’ R’ U y’ R’ U’ R // F2L #3

y’ R U2 R’ // F2L #4

U F U R’ U’ R D’ R2 U R’ U’ R2 D F’ U’ // 22LL

F’ R’ D’ L D’ F’ R’ L B D F2 U R2 U2 L2 U B2 F2 D2 F’

y // memo

// corners

D L’ U2 L D’ L’ U2 L // UBR->LDB->FDL

R’ U2 R’ D’ R U2 R’ D R2 // UBR->URF->ULB

y’ R2 D2 R U2 R’ D2 R U2 R y // UBR->RBD->RFU

U2 L D’ L’ U2 L D L’ // UBR->ULF->RDF

// edges

U2 M’ U L U’ M U L’ U // DF->BU->LB

M U2 M U M’ U2 M’ U’ // DF->UF->UR

R2 u M’ U L U’ M U L’ U’ u’ R2 // DF->RD->FL

z L’ U M’ U’ L U M U’ z’ // DF->DL->LU

(M2) R2 U R U R’ U’ R2 F’ U F R’ F’ U’ F R2 U’ R2 (M2) // 22LL parity

z2 M’ U M’ U M’ U2 M U M U M U2 // flip edges