22LL Finished

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

Speedsolve « Show »

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 « Show »

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

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

 

SpeedSolving forum thread

New qqTimer Updates

Official update thread
My modified version
Official release

A few weeks ago in IRC, Lucas Garron was asking people to benchmark the Mark 2 scrambler, and one of the ‘tests’ was to generate 1000 3×3 scrambles. Because this was so fast (only about 30-40 seconds for 1000 near-optimal, random-state scrambles, or roughly 30-40ms each, including solver initialisation). I decided to see how difficult it would be to add this random-state 3×3 scrambler to qqTimer, with no prior experience in JavaScript.

It turned out to be fairly easy after Lucas told me about the “API” for Mark 2, so I decided to add some other things I thought qqTimer was missing, like adjustable scramble size (when I do BLD it’s hard to read scrambles because I can’t wear my glasses). I also added a blindfolded mode, which allows you to press the spacebar during the solve to mark the end of memorisation, and the memorisation time is added as a comment on the solve.

I posted this branch of qqTimer in the qqTimer thread on Speedsolving, and people posted about some of the bugs in it (I was adding onto a dev version of qqTimer that may or may not have been posted on the forums by qqwref, I don’t know), and I fixed all of the ones which were mentioned, and added more features. The last feature I added was the ability to have 5 separate sessions, instead of only one (which was a new feature in the dev version).  I made a few a lot of new bugs with the mean of N feature, and didn’t have time to fix those before qqwref sent me a message, asking if I were okay with him releasing what I’d worked on, with some newer stuff from him, including last layer scrambles and big cube scrambles with solved centres.

It’s still a bit buggy with Internet Explorer (because, well, it’s Internet Explorer. It’s not compatible with anything on the Internet), and Firefox (version 8 is slow with JavaScript and version 9 can’t even start the timer), but in the best browser (I’m talking about Google Chrome) it works great.

Introduction

I’ll be posting some BLD/cubing/whatever information here on this blog.

to-do:

  • Re-write my list of letter pairs for edges and corners, which will be in separate documents.
  • Update the collection of algorithms I have for 3-cycles (and learn some better algs I have written down)
  • Write algorithms for other buffers (eg UF, UB, ULB, URF)
  • Finish generating 3style algs for x-centres, using an Ulb buffer.
  • Finish generating all “22LL” cases (last layer cases consisting of only a 2-cycle of edges and a 2-cycle of corners. There are 60 cases, afaik)
  • Write out proper explanations of my memory and execution methods. They’re FAQs.

And I have to find the time to do all of this between Skyrim, Fallout 3, Minecraft, and cubing (and eventually university).