## Category Archives: Uncategorized

This site is the official source of information from the world renowned Rubik’s Cube speedsolver Andrew Nelson.  I’d like to thank you for stopping by.  It’s currently a work in progress – I’ve just imported the posts from my old site to get things started.  But there’s definitely good stuff to be found, so look around!

First and foremost, I assume you are using a Vandenbergh-type method. If not, gtfo.

There are 5 steps in a basic Square-1 solve: Cubeshape, CO, EO, CP, and EP. I’ve never really had much luck looking ahead from Cubeshape, except for a few basic shapes. So that leaves 3 places you can look ahead to the next step of the solve: CO->EO, EO->CP, and CP->EP. CO to EO is the hardest to explain, and I won’t try to go into it here. This is more of a skill that you build gradually, kind of like cubeshape.

The EO-CP gap is fairly straightforward. Once you determine which EO algorithm you have, it’s quite trivial to look at the CP during the first move of the algorithm (or while you’re adjusting the U/D faces beforehand). The trick is, you must know what your EO algs do to CP. I know some people use only EO algs that preserve CP, which makes this pretty easy. Most algorithms for Opp/Opp and Adj/Adj leave CP alone. So does my alg for 3/3 swap (1,0/3,0/3,0/-1,-1/-3,0/-3,0/). It turns out, the only EO I use that doesn’t affect CP is my single swap (0,-1/-3,0/4,1/-4,-1/3,0), which performs an N/J permutation on the corners. Keep in mind, these are just my algs. You don’t need to switch to my algs: just figure out what yours do.

The CP-EP gap is where it gets interesting. Recognizing CP is great, but it’s only cutting down on recognition time, not making the solve any better. Once you get to EP, though, you can not only recognize instantly, but in fact force good EPs much of the time. In fact, this method is four times as likely to give an EP skip, and a great deal more likely to give an easy EP algorithm (adj/adj or opp/opp) and all with ZERO ALGS LEARNED.

Every CP algorithm is essentially a 2×2 Ortega case. That is, they all do combinations of J and N permutations. Each corner stays attached to one of the edges next to it, forming a corner-edge block. But beyond that, all of these algorithms can be performed after a (1,0), (0,-1), or (1,-1), which doesn’t affect the corner permutation, but switches to the mirrored J/N perms. The way I think of it is preserving blocks. Talk is cheap so let’s look at a few examples:

First of all, let’s take a look at the J/J corner permutation. The algorithm I use for this case is /-3,0/3,3/0,-3/. If your puzzle comes up like this, you can just perform that algorithm as-is:

But what if it looks like this:

The first move of that J/J algorithm goes and messes up the blocks on U. Instead, what you’ll want to do is line up the blocks so they won’t be broken. Try adjusting the U face by 1 move, then performing the algorithm. Thus, 1,0/-3,0/3,3/0,-3/. Similarly, if the D blocks would be messed up, misalign by (0,-1) first. That means there are a total of 4 ways an algorithm can be performed: no misalignment, (1,0), (0,-1), and (1,-1).

So that’s all well and good when you get J perms, but how does it affect my lookahead? Well, the number of blocks you preserve just so happens to be the same as the number of solved edges in your EP! That means that if you get a G or R perm, it’s obvious that you can only preserve one block, so you’ll end up with a U-perm. If you have an A, V, Y, or T, there are two possible blocks, but you can still only preserve one of them. It gets even better for double parity cases: These will all either preserve 2 blocks, or no blocks, which helps you tell if you’re going to get a nice adjacent/opposite case, or a (generally worse) O/W. From there, it’s fairly simple to figure out which is which (I list them over at http://crunchatize.me/ if you’re lazy).

There’s one parity case, though, that’s absolutely MAGIC: the P permutation.

(The one on the left is P. The easiest way to recognize it is to look for a CEC block and an ECE block (or what would be a 1×3 block and 2×2 block on a 3×3).)

This one can go to either opposite OR adjacent, depending on how it is aligned. In the case above, performing the J/J algorithm without any misalignment will lead to an adjacent-opposite algorithm (since I already know that the bottom permutation goes to opposite). If I misalign by (1,0), it gives me an opposite-opposite instead. Similarly, if you know you’re going to have an O on D, you’ll force an opposite, and if you’ll have a W on D, force an adjacent (since the O/opp and W/adj CP algs are much better than O/adj and W/opp).

There’s another case that works similarly: I’ve been calling it C.

This one will go into either W or O depending on how it is aligned. This is a bit harder to recognize, but it can help you avoid those worst EPs. I’ll leave the specifics as an exercise for the reader.

There’s also a bit more possible as far as forcing good Us (opposite U permutations rather than parallel). I’ve gone into detail about that at the Speedsolving forum, so I won’t talk about it here. I also didn’t go over tracing EP through CP Parity, but that’s fairly similar to seeing CP through EO, just learn what your algs do.

I hope this is helpful to someone. If you have any questions, please don’t hesitate to ask!

No explanation, just a new notation and the minimal alg list needed to learn square-1.

Notation:
R = Move the right half of the puzzle 180 degrees (clockwise)
u = move the U slice clockwise one “notch” Could be either (1,0) or (2,0) by old notation depending on what piece is to the right of the U notch.
u2 = move the U slice clockwise 2 “notches” Only used if there are 2 edges to he right of the U notch.
U = move the U slice clockwise 90 degrees. (3,0) in old notation
u4 = (4,0) in old notation
u5 = (5,0) in old notation
U2 = 180 degrees, (6,0)

Method:
Cubeshape: R u d’ R’ U’ d4′ R u2′ D R u’ d’ R U’ R
M2: u R u’ d’ R’
single EO: d’ R U’ R’ u4 d R u4′ d’ R’ U R
J/J: R U’ R’ U D R D’ R’
N/J: R U R’ U’ R U R’ U’ R
Opp/opp: u R u’ d’ R’ U2 R u d R’
Pure parity: R U’ R’ D R D’ R’ D R u R’ d R u’ R’ u4 R d2′ R’ d2 R u4′ d R U R’
Flip E Slice: R U2′ R U2′ R

I recognize PLL with a combination of “Blocks” and “Bars” A block is two or three connected pieces, like so:

A bar is a set of connected corners. I’ve put bars in red wherever possible. The term “bar” is taken from 2×2 PBL recognition, so a bar may or may not include the edge in between the corners. (If it does, it’s also a 1×3 block):

You can tell the permutation of a layer (and its parity) by comparing blocks and bars in most cases. I’ve included some lookahead information for square-1 permutation, but the recognition part applies equally to 4×4 PLL. Listed is which EP case each permutation goes to with a proper Vandenbergh solution, and then information on 1-look permutation if it applies.
The E/X/Q cases are difficult to recognize with this technique, so I’ve added some notes to the end of the page detailing how I recognize these cases.

 Permutation Recognition Corner Permutation Resulting EP 1-look Permutation No parity: U + J = U J 1 J Z + J = Z N/A H + J = H N 1 N A + J = U J 2 J T + J = U J 4 J Ga + J = U N J Gb + J = U J N J + J = Solved J or J J or J N or N J R + J = U N/A F + J = U N/A Y + N = U J 5 J V + N = U N/A N + N = Solved N or J 6 J E + N = Z N/A Parity: Opp Edges + Solved = Opp N/A Adj Edges + Solved = Adj N/A O + Solved = O N/A W + Solved = W N/A Opp Corners + N = Opp N/A Adj Corners + J = Adj N/A K + J = Adj N/A P + J = Opp or Adj N/A B + J = Adj N/A D + J = Opp N/A C + J = W or O N/A M + J = W N/A S + N = Adj N/A X + N = O N/A Q + N = O N/A

Notes on E/X/Q:
These are definitely the hardest to distinguish. The trick is to look at two edges, and the corner between them, and apply the 3-color rule. If there are 3 colors, that means EP is correct, so you have an E-perm. If there are 2 colors, you have an X, and if there are 4 colors, you have a Q.

 E X Q