Centers Last (old)

(Disclaimer: I wrote this guide in June 2007, on twistypuzzles.com. Here it is, with just a few edits. I haven't changed up the method much if at all since then.)

This is a method for solving arbitrarily large cubes. I decided to make a topic because I want to keep a permanent reference for this method, and because I just recently improved it a bit and I thought I'd like to share that with you.

From personal experience, it becomes faster than the reduction method for cubes of a certain size or greater, but that size is determined by a lot of factors (such as how fast you can make slice moves and how good you are at finding pieces for reduction). Suffice it to say, though, that if I ever attempt a truly huge cube (say 40x40x40) I'm not going to use reduction. This method does use about 30-50% more moves than a reduction strategy for a given size of cube, though, and although you have better recognition you will need more physical endurance to be able to complete a cube with this strategy.

The basic method is just this:
1) Solve all of the edges and corners. They must be solved relative to the centers on an odd cube.
2) Solve all of the centers without disturbing the edges and corners (much).

There are a lot of subtleties, though. Each step has many different ways to complete it, and there are a lot of small (but very useful) shortcuts. Throughout this guide, I'm going to use the r* notation; what this means is, on an NxNxN cube, to do a clockwise turn on all R-side slices from the second slice to the floor(N/2)th slice. For example, on a 6x6x6 cube r*' would mean to turn the 2nd and 3rd R slices counterclockwise. This is useful for generalized algorithms.

My current step 1 is done by matching up pieces of edge groups. I'll mostly be using 3x3x3-like moves for this part, so think of everything as corners, edge groups, and center groups. Using only the outer layers, move an edge group with a lot of similar pieces to DF (but if you can't find one in 4-5 seconds don't bother), and choose a color pair of edges that you will place in that spot. Make sure to remember which color is on top. Now, looking at the R and L layers, find edge pieces which match that color pair and move them to UF or UB using R/U/L moves, then shoot them down to DF with the appropriate slice move. Once DF is completely grouped up, you can do something like R' L F to move it into the R or L layer; keep doing this, while never disturbing the previously grouped edge groups. When you have 7 of them, you will not be able to do this any more; then, move the M layer to the E layer (just do z), and group another edge group together using horizontal slices. You can use moves like RUR' to get the fifth unfinished edge group into E. When you are done, move the finished group into U or D. At this point, U and D should each have 4 finished edge groups. You can actually finish one more edge group in E quickly (remember, you can do things like R2 because centers are irrelevant) before you have to do moves like (vertical slice) R F' U R' F (vertical slice)' to finish off the remaining edges. Note that you can only be sure of solving 11 of 12 edges like this. Don't try to use last-two-tredges or parity algorithms yet, though.

When you have paired up at least 11 edges, it's time to solve the edges and corners into a cage. Do it like the 3x3x3 step. Make sure it's solved relative to the centers if you're doing an odd cube. Here is a trick: when you get to the orient step (OLL for Fridrich, step 3 for Petrus) it's very helpful if the last edge group, the one which will almost certainly have parities in it, is one of the edges you are going to orient. If you're not color neutral, you can force this easily: for example, I solve Fridrich with a yellow last layer, so I can simply pair up all of the edge groups which don't contain yellow first, which will ensure that my parity edge is in the last layer when I get to it. So fix all of the orientation parities at the same time, then do OLL, then fix the permutation parity if you need to, then do PLL. The permutation parity is very easy, by the way: just do r*2 U2 r*2 U2 r*2.

So edges and corners are all solved; now onto step 2. In this step, we use commutators to solve all of the centers. The goal is to solve one center completely, then the opposite center, and then any other center, an adjacent center, and the last two. But again, there are a lot of subtleties and tricks here. First of all, a lot of people tend to use commutators like r U' r' d r U r' d'. There's nothing wrong with that, but I much prefer commutators in the form of r U l' U' r' U l and r U' l' U r' U' l. These commutators are very fast to execute because all of the interior slices are on the same axis, and you can see what is going on by only looking at two faces (where the centers are coming from and where they are going), leaving you free to look for the next center on an adjacent face. You'll have to experiment with this algorithm to get a feel for it, but you should know a couple things: (a) you can vary the affected centers in the 3-cycle by varying which slices you use (and the r- and l-like slices don't even have to be the same depth, i.e. r U 3r U' r' U 3r works fine); (b) x-centers can only be solved by one of these, but others can be solved by both; (c) the first move of the commutator should move a center piece that you want to move to the U layer into a space in U that does not already have a U-color center in it; (d) it's possible to bring entire blocks up to U by using more than one slice in place of one (or both) of the component slices of the commutator, but the first move has to bring the block to a place in U that is mostly or fully unoccupied, and some blocks are simply too large to do this with; and (e) it's best to only use setup moves involving U and only try to solve one piece or block at a time, so that the edges and corners don't get further than an AUF away from solved.

Now that we've gone over the small-scale details, let's concentrate on the large-scale ones. When you're solving the first center, pieces can come from all five centers, but you will notice that bringing them from the opposite center is time-consuming for a couple of reasons, notably 180-degree turns and slow recognition. There is a solution, however: the move r* F2 r*' l*' F2 l* will swap the F and D centers, completely on an even cube and mostly on an odd cube, although it messes up some edges so you will have to undo it after you solve the U center. So one way you could do the first center group (say white) is to bring every white center cubie from one face into the white face, then swap that face's center group (which contains no white cubies now) with the center group opposite white, and finally just bring all of the white centers (from the center group that used to be on bottom) onto the white face before reswapping the two center groups. Personally I like to hold the target face on U, and then bring all the target center pieces on F and R into the target face before doing y2 and doing it again. Once you have the first center, the opposite center is the same, but this time every center piece you want to bring in will be in an adjacent face, which makes it a little easier.

Now, you have four centers left to do. Pick one and hold it on U, then transfer the target pieces from F to U, swap F and D, transfer the target pieces from F to U, swap F and D, do y2, transfer the target pieces from F to U. If you want to be fast, this should be mostly mechanical, as it's a lot of the same type of move done from more or less the same angle. Now pick an adjacent face and hold it on U, with the just-finished face on B. Transfer the target pieces from F to U, swap F and D, transfer, swap. Remember that if you do one swap, you must do a second one, because otherwise the edges will get messed up. Now hold the last two centers on F and U (the order is irrelevant) and finish the cube. You're done!

By the way, if you want to use this on cubes smaller than 6x6x6, there are a couple of key differences. Depending on how good you are at reduction, it may be faster for you to just hold the edges on the E layer and pair them up normally. If that works for you, do it. Also, on the smaller cubes, you shouldn't bother with swapping centers, because there are not enough centers to swap to make it worthwhile. If you want to reduce the number of centers you have to move from one face to an opposite one, you can try to find a face that has as many centers as possible on that face and the adjacent ones, and start solving there. But unless you are very slow at the centers part of reduction, this will probably be slower for you for small cubes, so I don't recommend it for the small ones.

Solving 4x4x4 and 5x5x5 Supercubes

Although the 4x4 and 5x5 supercubes look much more difficult and impressive than the standard ones (even experienced bigcubers will wonder how you can find pieces so quickly!), they aren't much harder than the normal cubes: all they take is a slightly different method. The following tips and tricks were all gotten through experience and practice. Note that I'm going to describe the reduction method below, for a couple reasons: I think it's the fastest known way to do supercubes (and normal cubes for that matter), I'm most familiar with it, and you're probably most familiar with it. So if you're not a reduction user, then sorry, the only advice I can give you is to go practice :)


Centers are the only part that's really different about supercubes, although they are not the only part that you have to solve differently. In a supercube, every center has to be solved into the correct spot - they're not interchangeable anymore. Thus, instead of just solving blocks of centers, you have to actually pay attention to what goes where.

In a 4x4, you only have x-centers, which have three colors in the standard Pochmann sticker design (which I really recommend, because just drawing arrows or cutting corners off the stickers makes it very hard to see what goes where). I always put 4x4 centers together by making two 1x2 blocks. This probably doesn't require any explanation at all, although you might find it helpful to know that if you pair up the two yellow centers across a red-yellow 'edge', the other stickers will be paired across an orange-yellow 'edge' (since orange is the opposite of yellow). This can make recognition and setup easier.

If you go to solve centers, you might notice that the last center doesn't automatically solve itself anymore. That should happen 5/6 of the time, but fortunately there are algorithms to fix this quickly. If you want to swap Ufr and Ufl, you can use this A-perm-like algorithm:
x r' U r' d2 r U' r' d2 r2
If you want to do a diagonal swap, on the other hand, the algorithm I currently use comes from the Square-1 and is as follows:
r2 U D r2 U r2 U D r2 U r2 U D r2.
So your centers should be solved and you can now start on the edges step.

In a 5x5, on the other hand, you have many different types of centers, and now the fixed center, although it cannot move, must be oriented along with the rest of them. Again I pretty much solve the centers with my normal method (1x3 blocks, with the first block containing the fixed center) although it takes a bit longer to find the exact pieces I am looking for. If you see any blocks already formed for the first center or two, that will be very helpful, so try to preserve them.

On 5x5 you still have last center problems, but since PLLs are hard to recognize and turning a fixed center (only) by 180 degrees is slow, I prefer the following method. First I solve a 2x3 block on the second to last center, and position it so I can do rUr'-type triggers without messing it up. Then I intuitively solve all of the T-centers on U and F. It's important to solve them relative to the fixed center (not just relative to each other). There is one other case here, that of parity, where you have two edges swapped. The quick solution is just this:
r U2 r U2 r U2 r U2 r.
That algorithm should do an opposite swap of edges on U (a Usl-Usr swap to be exact), so now you can be certain to be able to solve the edges only. Finally, I have six T-centers left; I do an F turn to set them up to a more convenient location, and then finish off the centers with U turns and the Niklas commutator (which has two forms):
r U l' U' r' U l
l' U' r U l U' r'.
Sometimes it is actually more convenient to just solve the F centers with this commutator, and then finish off U with an A perm (which does exactly what you think it does). If you get an E or an H, good luck, you might as well just do two As. The A perms (for 5x5) are:
x r' U r' d2 r U' r' d2 r2
x r2 d2 r U r' d2 r U' r.


If you got the Eastsheen supercubes, you might notice that your edges and corners have more colors than they need to. The extra colors don't affect anything (although sometimes they can make recognition for PLL a little easier, on 3x3), and after a couple of dozen solves you'll learn to ignore them.

For 4x4, you can do edges exactly as you would on a standard cube. There is no change at all no matter what method you use, so go full speed on this step.

For 5x5, if you use AvG or any other kind of 2-pair edges method, do whatever you normally do. You'll notice that you never get parity - this is because we fixed it during the centers step. Convenient, isn't it? If the T-centers are solved, you can never get parity on the wings. Anyway, if you use the freeslice/bigcubes method, the biggest difference is that during the first 8 edges you can't do half turns of the faces (F2/R2/B2/L2 if you solve in the E slice, for instance) unless the slices are all solved. Just making them parallel isn't enough, because that will actually slightly mess up two centers. You will also notice that, during the last 4 edges, you can't do the m U2 m' U2 algorithm, because that also messes up centers a bit. (If you really want to do it, you should do the inverse algorithm twice.) You should also be careful during the last 2 edges: if you solve this in one step, be very careful about whether your algorithm messes up centers or not, because some will and some won't. If your algorithm does mess up centers, you can always just fix the edges with the r [flip edge] r' algorithm, which is completely center-safe.


The final step on both 4x4 and 5x5 is to solve a supercube 3x3. You don't need to learn any new tricks for this, you just have to be more careful. When you're putting together the cross, make sure that the centers are all oriented the right way; since this takes so much more thought than a normal cross I do not at all expect you to do this in one look. Feel free to do it one or two edges at a time. Now, if the centers on the first two layers are correctly oriented, you are basically home free: almost all F2L algs will keep them solved (the only one I know of that messes them up is the 2-gen edge insert algorithm, but you can always use an alternate algorithm), and most OLL algs will keep them solved as well. Some PLL algs do, and for certain ones (U perm, for instance) it might be helpful to learn alternate algorithms that don't mess up the centers at all, since you have to spend extra time fixing it. Here's one possible alternate U perm:
F2 U (M' U2 M U2 M' U2 M) U F2.
If you do end up with a messed up center, you should twist both it and the U center, because the U center hasn't been fixed to a specific orientation yet anyway. The following (intuitive) algorithm will flip the front center clockwise and the left one counterclockwise (note that here M and E mean every slice together):
M' U M E M' U' M E'.

There are three parity algorithms that you should know. The first two are the standard 4x4 parity algorithms (so of course they only show up on even supercubes). For the orientation parity, you can still use the normal one although that will twist the R or L center by a quarter turn, so I strongly suggest that you use some kind of slice-turn-only parity. My favorite is this one:
2R U2 x 2R U2 2R U2 2R' U2 2L U2 2L' x' U2 2R U2 2R' U2 2R'.
For PLL parity, the normal algorithm will mess up centers pretty badly, so here is one that won't:
x' 2U' R F' U R' F 2U 2D F' R U' F R' 2D' x
Finally, at the very end on both 4x4 and 5x5 supercubes, half of the time the U center will be twisted by 180 degrees. There are two algorithms I use for this, either of which can be faster depending on the cube and your style:
(R L U2 R' L' U)2
(R' U' R U')5.

And with that, you know everything you need to solve the 4x4 and 5x5 supercubes every time. Good luck, and good times!


Advanced Counting: Burnside's Lemma

Sometimes the theory we have discussed so far is not enough to calculate the number of positions of a puzzle. Fortunately there is a theorem from group theory that will help us with this. It is called Burnside's Lemma (although he was not the first to discover or prove it):

Theorem: Suppose we have a finite set X, and a finite group G of permutations of X. For each element g in G write |Fix(g)| for the number of elements of X that are not changed by g, and write |G| for the number of elements of G. Then the number of orbits of X is equal to 1/|G| Σg∈G |Fix(g)|.

What does this mean, though? Well, when we are counting the number of positions of a puzzle, we want the number of positions regardless of orientation - you shouldn't be able to get from one position to another just by rotating the puzzle, but we also don't want to miss any. The way we do this is by setting X to the set of every possible position in every possible orientation and G the possible ways to rotate the cube. The number of elements in X is relatively easy to calculate (it's like finding the number of positions of a puzzle, except that you don't fix anything; for example the size of X for the 2x2 cube would be 8! 3^7), and the number of elements in G can mostly be looked up from a small table, since it is 12 for a puzzle with tetrahedral symmetry, 24 for puzzle with the symmetry of a cube or octahedron, and 60 for one with the symmetry of a dodecahedron or icosahedron. Now, the number of orbits is simply the number of positions of a puzzle regardless of orientation, which is exactly what we want - so as long as we can compute the Fix(g) values, we know exactly how many positions a puzzle has, even if the puzzle has repeated pieces.

One really important thing to notice is that, for any cycle in a permutation in G, every piece on the cycle has to look the same. This is pretty important because it tells us that if we have, say, three of each piece, it is impossible for g to fix any positions if g contains a 4-cycle (or bigger), because there are no sets of 4 of the same piece. Also, if g contains only 3-cycles, and the number of duplicate pieces in each set is not a multiple of 3, g cannot fix any positions.

I want to do two examples to show how this works. First I'll do the very simple example of a cube with three red faces and three blue faces which can be switched any way we want. We already saw that our basic approximation gave something like .83 when the actual answer was 2. Let's use Burnside's Lemma. The size of X is 6 choose 3 or 20, and the size of G is 24 because the puzzle is cubical. Let's calculate the |Fix(g)|'s: if g is the permutation that does nothing, 20 positions remain the same; if g is a rotation around a corner (there are 8 of these), 2 positions are fixed; if g is a 90-degree rotation around a face (there are 6 of these), there are no fixed positions; if g is a 180-degree rotation around a face (there are 3 of these), there are 4 fixed positions; and if g is a flip around an edge (there are 6 of these), there are no fixed positions. So the total number of positions is 1/24 (20 + 8*2 + 0 + 3*4 + 0) = 1/24 (48) = 2. It's exact!

Now let's do a very hard example: the (non-jumbled) Little Chop or 24-cube, which has 24 pieces, with 4 each of 6 colors and no orientation. The size of X is 24!/(4!^6) and the size of G is 24 again. Calculate the values of |Fix(g)|: if g does nothing, 24!/(4!^6) positions remain the same; if g rotates around a corner, we create 8 3-cycles so no positions can be fixed; if g is a 90-degree rotation around a face, there are 6 4-cycles so 6! positions are fixed; if g is a 180-degree rotation around a face, there are 12 2-cycles so 12!/(2!^6) positions are fixed; and if g is a flip around an edge, there are again 12 2-cycles so 12!/(2!^6) positions are fixed. The total number of positions is 1/24 (24!/(4!^6) + 6*6! + 3*12!/(2!^6) + 6*12!/(2!^6)), which works out to 135,277,941,853,080. We can't really verify this, but if we have done our calculations right it is the correct value. Note that with our basic computations, fixing one of the 4 pieces of a specific color, we would get an approximate value of 1/4 (23!/(3! * 4!^5)) = 135,277,939,046,250, which is pretty close (but not exact).