• Welcome to the Speedsolving.com, home of the web's largest puzzle community!
    You are currently viewing our forum as a guest which gives you limited access to join discussions and access our other features.

    Registration is fast, simple and absolutely free so please, join our community of 30,000+ people from around the world today!

    If you are already a member, simply login to hide this message and begin participating in the community!

22LL - a last layer subset

Joined
Sep 9, 2009
Messages
2,010
Likes
4
Thread starter #1
Link: 22LL page

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

You can read more about it on my blog.

If you have any better algs, or see any errors, post them here or send me a message.

Example Solves:
Speedsolve:
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
U2 L R U R F B' D // cross
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
BLD:
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
 
Last edited:
Joined
Sep 9, 2009
Messages
2,010
Likes
4
Thread starter #3
IAB - y' U' R' U' R U R' F' R U R' U' R' F R2

I like these...I use a few already, but I could always use a few more tricks for last layer!
Thanks, that's a nice cancellation/cyclic shift. I've added it.
 
Joined
Sep 9, 2009
Messages
2,010
Likes
4
Thread starter #9
Can I see an example solve? Im a visual person...
Sure. (I made the speedsolve scramble using Cube Explorer, based on F2L from a qqtimer scramble and a random 22LL case):

Speedsolve:
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
U2 L R U R F B' D // cross
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
BLD:
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
Excuse my terribly inefficient CFOP...

It's not like ZBLL, where you use ZBF2L to orient edges; there's no extra step before 22LL to setup a case. You just do it whenever it comes up.

Being the noob I am...I really have no clue what that means...it's just an Old Pochman alg with an R cancellation...if that's what you said...then oops...
Cyclic shift of an algorithm is when you take moves from one side of an algorithm and moving them to the other. J perm is a cyclic shift of T perm, by moving R U R' F' from the end of T perm to the start. The alg you gave moves the U' R' U' from the end of J perm and takes it to the front.

ABI - M' U R U R' F' R U R' U' R' F R2 U' R' U2 M
EAE - B' U R' U' R' F R2 U' R' U' R U R' F' R B

Two more...just turned them into a J perm or a T perm...not sure if that's what we're looking for here...but it's fast
Originally I had that for ABI, but I still think there might be a direct alg that faster than both of them. That's a good EAE though, I'll add that one.
 
Last edited:
Joined
Jul 25, 2006
Messages
880
Likes
0
Location
0, 0
#14
I once considered this as a direct solve LL method. The first step being to solve two corners and two edges. I stopped when I realized that the first step has the same "problem" as CLL+1 and Snyder LL. Start mixing corners with edges in a direct solve and the two piece types' orientations and positions relative to each other create a large number of cases.

I didn't consider if the second step has potential for BLD.
 

y235

Member
Joined
Jan 29, 2011
Messages
321
Likes
1
Location
Israel
WCA
2011BROD01
YouTube
WalbiCatboots
#16
If using it in a solve, how do you recognize if this a 22LL case or not?
I think that start checking the cycles isn't good, because if it's not a 22LL case you just wasted a lot of time.
 
Joined
Oct 3, 2008
Messages
2,068
Likes
3
Location
Toronto (Canada)
WCA
2009HOLT01
YouTube
riffz
#20
But it can easily be. If reducing all other LL cases to 22LL takes only low-number-move algorithms(6-9) we should give it a try.
Just think about that. For every LL case you should solve "only" any 2 corners and 2 edges.
Awesome. So you'll have a LL system with terrible recognition and step 2/2 will require one more algorithm than simply OLL/PLL.
 
Top