Skip navigation

Square-1 Lookahead for Dummies

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