(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.
(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.)
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!
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).
The Cv puzzles were some of the first simple twisty puzzles to be developed. One in particular, the Skewb, is probably the puzzle with the most distinct shape modifications. These puzzles are related to the Tv and Of puzzles.
The Cf puzzles are very simple to describe: they are just the very well-known 2x2x2 and 3x3x3 cube. There are, of course, much more efficient methods than those described here.
These puzzles are tetrahedral with edge turns. Puzzles Te3 and Te4 in this series have extra moves if you remove the restriction that they must be tetrahedral, since in fact they can be considered as shape modifications of the 3x3x3 and 2x2x2 Rubik's Cube.
These puzzles are tetrahedral with vertex turns. Because the tetrahedron is the unique regular polyhedron to have a face opposite a vertex, all face-turning tetrahedral puzzles can also be considered to be vertex-turning, and for simplicity's sake they will thus fall under the Tv classification.
There are a lot of twisty puzzles out there, and they can be categorized in a multitude of ways. This project, the TPCP, is an attempt to categorize all of the most basic twisty puzzles into a list, ideally giving each one an identification code, an image, the gelatinbrain number or common name if applicable, a list of the types of pieces and their orbits, and a basic solution. I do not expect to complete all of it but I hope to get a good chunk of it done.
The most basic twisty puzzles, as I define them, satisfy the following characteristics:
- They are based around a regular polyhedron.
- There is exactly one type of axis around which turns can be made.
- All possible turn axes are represented, and they all have the same depth. Thus the puzzle is symmetrical and remains mathematically unchanged under a rotation.
- Each face of the solved puzzle has one unique solid color and the goal is to bring the puzzle into a state where each face has one solid color.
- After any turn, the puzzle is still in a regular-polyhedral form.
The foundation for the TPCP is very mathematical. Each puzzle belongs to one type, which is described by a capital letter denoting the polyhedron (T, C, O, D, and I for tetrahedron, cube, octahedron, dodecahedron, and icosahedron, respectively) and a lowercase letter denoting the type of axis (f, e, and v for face, edge, and vertex turns, respectively). Thus for example the 3x3x3 cube belongs to type Cf. Within the types, each puzzle gets a natural number, starting with puzzle 1 for the shallowest cut and increasing for deeper cuts. Puzzles with different-depth cuts which function in the same way are considered to be the same. Even trivial puzzles will be considered, except for puzzles with a cut depth of 0 where turns do not move any pieces and thus no scrambling at all is possible. In this case the 3x3x3 cube would be Cf1.
For standardization of images I have chosen to use an image size given by the downloaded Gelatinbrain applet: 312x312 pixels. Of course I have used the lossless .png format so the images should not take too much time to load. Images for puzzles which are not represented in the downloadable applet have been created by me.
Note that in this project if a set of pieces is described as "trivial" the pieces cannot be permuted relative to each other but do have an orientation.
Although it is not addressed in this project, it is possible to use this categorization system to create types for higher-order puzzles (which I call compound types), and I may investigate some of these series in the future. The type of, for example, a dodecahedral puzzle with two types of edge turn and one type of vertex turns would be Deev, and the Super-X would belong to type Cfv. Although the numbers within the types cannot be as unambiguous as in the TPCP puzzles, we can still assign each puzzle in a compound type a number, with the expectation that someone wishing to do research in this topic would look up a puzzle's number in an online list.
With that said, let's start to classify some of the types.
No theory in this article, it's just a proposal I've been thinking of but don't have the skills to program. I've never seen this in practice, but it was an idea I had a while ago and which I'm sure a lot of other people have had independently. It ought to be written up, though...
The thing that inspired this was the realization that people look to the unofficial world record (UWR) pages on speedcubing.com as a reference, but that many fast people don't post their times at all, so they are clearly not representative. I've often heard the excuse that the official times are the only times that matter, but the fact is that most events and puzzles do not have any official counterpart and the only way to compare times on them is through an unofficial list of this sort.
It seems to me that this would solve this problem, plus many additional ones which I'll talk about later. The basic idea is to have a forum where users enter their unofficial personal best times. The times would then be organized in a list in their profile, and there would also be a UWR section which would automatically sort and display the times that users have submitted. Ideally it would be very easy to submit times, so that people would grow used to submitting new PBs as often as they post in Accomplishment threads. A timer could also be added, and then users' single and rolling average-of-12 times could even be automatically updated when they finish a session. From a database point of view it would be a relatively simple addition to the forum system. The way I would do it would be to take a working forum and then add the databases of records and categories; then we would just have to make a way to submit records, display them in people's profiles, and display them in the UWR format. Other additions such as timers or a compare-users function would just involve different ways of interacting with this system.
This doesn't sound like that much of an improvement over a forum like speedsolving.com, but it would solve a lot of problems. There wouldn't be many problems with fake times (like there apparently are on the UWR list) because the mods could simply delete or ban the offending account. Signatures wouldn't need to contain people's best times because they would be easily found in the user's profile. Nothing would have to be manually updated on the unofficial record list, so whenever someone updated their time or e-mail the list would update, and you'd never have duplicate entries. Similarly it would be easy to add new events: you could allow people to create their own events, with certain restrictions, and perhaps show all events with at least two people in them. Since the UWR list and forums would be on the same website, it would be a lot easier to compare people, and you could even have a function which takes two users and compares all of their personal records automatically. You'd also end up with an account for everyone who wants to be on the unofficial list, which means that the community could be more organized than ever; it wouldn't be much of a problem to make different forum sections for people from different countries or people who speak different languages, and perhaps eventually everyone could be using the same website as their speedcubing community (rather than having speedsolving.com for most English-speaking people and then a bunch of other separate websites for various other languages or countries). This would also be a very convenient centralized place for people to talk about their records, since it would all be on one site.
The question is, though, should everyone move from speedsolving or wherever to use this? I kind of think that we should agree on some kind of website that would satisfy all of our needs as a community for the next few years. Cubing is definitely not dying down; in fact it is picking up faster and faster, and I think it's about time we become very organized with the community. Speedsolving is a pretty good forum but it has a big problem with posting times: people can't really display much of their accomplishments because of small signatures, so you have to already know who people are in order to figure out who's amazingly fast. In fact some of the faster people I know don't even know what their best times are, which seems kind of odd given that so many other people want to know that. This tells me that more organization is needed. There's also a problem of lots of smaller, regional cubing forums; this means that the community isn't all in one place, so it can be tricky to find someone who isn't on speedsolving, and if something is posted in one place it won't necessarily reach everyone. So I figure we could use this kind of certainty.
The last thing I think I should say is that, once we are sure we have a forum that will satisfy everything we want, moving to it won't be that hard. Initially you will have people using the old and new system concurrently, but eventually the old system will just become an archive of past cubing discussions. This seems to be the eventual fate of the speedcubing Yahoo group, which was replaced by speedsolving because the Yahoo group message system is much less convenient and organized than the forum system. I am pretty sure that, if a community website can be made which is clearly superior to the existing community forums, we will eventually have everyone in the new website, and it will be much easier to share records and ideas. It will definitely take a while to program and perfect this, but I think that if we use lookahead we can see that it will be well worth it in the long run.
I wrote this on 3/30/08.
The goal of this article is to determine the number of positions of various twisty polyhedra. I will first show an algorithmic theory where we can find the number of positions in well-behaved twisty polyhedra (that is, puzzles which are symmetrical and have no move constraints based on the position) without difficulty, and then use it to find the number of positions in a few infinite families of theoretical twisty polyhedra, and a few examples of how to modify this theory for trickier puzzles.
Theory of Positions
Before we start determining the number of positions of a puzzle we must fix the orientation somehow. This is necessary since simply turning a puzzle around without doing moves on it will not change its position. The normal way to do this is to fix one specific piece, or a set of pieces which are fixed relative to one another. If this is impossible we can divide the number of positions we calculate later by the number of possible positions of a solved puzzle (most usually 12 for a puzzle with tetrahedral symmetry, 24 for a puzzle with cubical or octahedral symmetry, or 60 for a puzzle with icosahedral or dodecahedral symmetry) but it is not certain that this will give us the correct result. Note, however, that if we have a few choices for what piece to fix, you will get the same answer no matter which piece you choose.
After this the first step to finding the number of positions of a twisty puzzle is to determine the orbits. An orbit is the set of positions that a given non-fixed piece can be in, and orbits containing the same positions are considered the same. In a 3x3x3 cube we will typically fix the orientation by forcing the centers to be in specific places; then there are two orbits, one for the 12 edges and one for the 8 centers. Note that there can be more than one orbit containing similar-looking pieces; for example on the 3x3x3 square group (where only half turns can be used) there are in fact three edge orbits and two corner orbits.
In general we will proceed by finding the number of positions in each orbit and multiplying them together. Because of parity concerns, the best way to do this is to order the orbits in some way and consider them one by one, assuming that while considering one orbit all pieces in the previously considered orbits are solved. This way, when two orbits have the same parity, we see that one does not obey a parity constraint and the other does, so we correctly divide by 2 only once.
So how many positions are in a single orbit? This is generally an easy problem, as it can be directly calculated with a little casework. First we consider the permutations. If there are n pieces, we start with n!; if there are n pieces each of k types, as in the centers of a higher-order Rubik's Cube, we start with (nk)!/n!^k. If the pieces of the orbit have to obey a (permutation) parity constraint then we divide by 2; note that this is only possible in the first type because if we have indistinguishable pieces we can always make a 2-cycle of same-colored pieces to cancel out a wrong parity. Next we consider the orientation of the pieces. If the pieces cannot be oriented differently when they are in a given position we do not have to consider orientation and we can just multiply by 1. Otherwise, if we let k be the number of possible orientations one piece can have if it is a given position and n be the number of pieces then we should multiply by k^n. If the pieces of the orbit obey an orientation parity, we divide by its order, which is generally 2 or 3 but can be higher.
Let's work through an example to illustrate the technique: the 3x3x3 cube. As I already mentioned, if we fix the orientation by fixing the centers' positions, we have two orbits: edges and corners. First we'll consider edges: there are 12 pieces (12!) with no parity (since corners are unknown), and each has an orientation of order 2 (2^12) with an orientation parity (/2), so the total number of possibilities here is 12! * 2^11. Then we consider corners: there are 8 pieces (8!) with parity (/2, since edges are fixed), and each has an orientation of order 3 (3^8) with an orientation parity (/3), so the total number of possibilties is 8!/2 * 3^7. Thus the total number of positions is (12! * 2^11)(8!/2 * 3^7) = 43252003274489856000, as I'm sure you already know.
Number of Positions of Infinite Families of Twisty Polyhedra
The most important concept here is that of layers. It is difficult to put into words, but the number of layers of a puzzle is basically the number of parallel, twistable slices (not counting slices on the opposite side of the puzzle's center). Puzzles with one layer include the 2x2x2, 3x3x3, Megaminx, and Dino Cube; puzzles with two layers include the 4x4x4, 5x5x5, Gigaminx, and Lattice Cube. A family of puzzles is basically a set of puzzles that function similarly (have the same axes, the same fixed pieces, the same shape, and so on), but which differ in the number of layers, a constant which I will call n throughout the rest of the article. I don't count 'trivial tips' (twistable elements of a puzzle which do not affect any other elements, are not affected by any other elements, and can always be solved in one move) as layers, because they do not share any pieces with the rest of the puzzle; thus, although most families only have twistable puzzles for n >= 1, there are some families where the case for n = 0 has more than 1 possibility.
There are many families of puzzles; however, most families have only had one puzzle constructed or even considered, and there are other families (such as stacked pucks and 2x2x(2n+1) cuboids) where adding one layer simply multiplies the number of combinations by a fixed amount. In this article I will only consider the number of combinations for families of which at least two puzzles have been constructed or designed. Of course, these are the most popular families to consider. All numbers I give have been calculated using the formula given here.
Odd NxNxN Cubes: Just like the 3x3x3, we will hold the centers constant. Then our orbits are: 12 edges with 2 orientations each (12! * 2^11), 8 corners with 3 orientations each (8!/2 * 3^7), n-1 orbits of 24 edge wings ((24!)^(n-1)), and n^2-n different orbits of 24 centers, all of which are made up of 4 pieces each of 6 types ((24!/4!^6)^(n^2-n)). Thus the total number of positions is 12! * 8! * 24!^(n^2-1) * 4!^(-6n^2+6n) * 2^10 * 3^7. For this family the existing puzzles are n=1 (3x3x3, with 4.325 * 10^19 positions), n=2 (5x5x5, with 2.829 * 10^74 positions), and n=3 (7x7x7, with 1.950 * 10^160 positions).
Odd NxNxN Supercubes: This is like the odd NxNxN cubes, except that there are much more parities since the center pieces have no duplicates, and also the centers have orientation. Again keep the centers fixed, then the orbits are 6 centers with 4 orientations each (1 * 4^6), 12 edges with 2 orientations each (12!/2 * 2^11), 8 corners with 3 orientations each (8!/2 * 3^7), n-1 orbits of 24 edge wings ((24!)^(n-1)), and n^2-n orbits of 24 centers ((24!/2)^(n^2-n)). So the total number of positions is 12! * 8! * 2^(-n^2+n+21) * 3^7 * 24!^(n^2-1). The puzzles that have been made so far are n=1 (3x3x3 Supercube, with 8.858 * 10^22 positions) and n=2 (5x5x5 Supercube, with 5.289 * 10^93 positions).
Even NxNxN Cubes: We can't hold centers constant, because there are no centers, but if we fix one specific corner we will always be guaranteed a fixed orientation. So our orbits are: 7 corners with 3 orientations each (7! * 3^6), n-1 orbits of 24 edge wings ((24!)^(n-1)), and n^2-2n+1 orbits of 24 centers, each of 4 pieces in 6 colors ((24!/4!^6)^(n^2-2n+1)). The total number of positions here is 7! * 24!^(n^2-n) * 4!^(-6n^2+12n-6) * 3^6. The puzzles in this family that have been constructed are n=1 (2x2x2, with 3.674 * 10^6 positions), n=2 (4x4x4, with 7.401 * 10^45 positions), and n=3 (6x6x6, with 1.572 * 10^116 positions).
Even NxNxN Supercubes: This is very much like the odd NxNxN supercubes. Keep a corner fixed, and our orbits become 7 corners with 3 orientations each (7! * 3^6), n-1 orbits of 24 edge wings ((24!)^(n-1)), and n^2-2n+1 orbits of 24 centers, all with parity ((24!/2)^(n^2-2n+1)). So the total number of positions is 7! * 24!^(n^2-n) * 3^6 * 2^(-n^2+2n-1). The existing puzzles are n=1 (2x2x2, with 3.674 * 10^6 positions) and n=2 (4x4x4 Supercube, with 7.072 * 10^53 positions).
Megaminx Family: These puzzles work just like the odd NxNxN cubes, except with larger numbers of pieces in each orbit. However, in these puzzles all turns create 5-cycles, so every orbit has a permutation parity. There are 30 edges with 2 orientations each (30!/2 * 2^29), 20 corners with 3 orientations each (20!/2 * 3^19), n-1 orbits of 60 edge wings ((60!/2)^(n-1)), and n^2-n orbits of 60 centers, in 12 colors of 5 pieces each ((60!/5!^12)^(n^2-n)). So the total number of positions is 30! * 20! * 60!^(n^2-1) * 5!^(-12n^2+12n) * 2^(28-n) * 3^19. The existing puzzles are n=1 (Megaminx, with 1.007 * 10^68 positions) and n=2 (Gigaminx, with 3.648 * 10^263 positions).
Pyraminx Family: These puzzles are slightly more tricky to calculate since some of them have middle centers (where there are only 4 pieces instead of 12) and some do not. I am not including the trivial tips in the calculation because they are not an inherent part of the puzzle, but of course to put them back in we can just multiply by 3^4. In this puzzle we are keeping the corners in the same position, although their orientation can change. Note that, just as in the Megaminx family, all turns create even permutations, so every orbit has permutation parity. In this family our orbits are 4 corners with 3 orientations each (1 * 3^4), 6 middle edges with 2 orientations each (6!/2 * 2^5), n-1 orbits of 12 edge wings ((12!/2)^(n-1)), a total of floor((n-1)^2/3) orbits of 12 centers, in 3 centers for each of 4 colors ((12!/3!^4)^(floor((n-1)^2/3))), and ((n-1)^2 mod 3) orbits of 4 centers ((4!/2)^((n-1)^2 mod 3)). Thus the number of positions is 6! * 2^(5-n-((n-1)^2 mod 3)) * 3^4 * 12!^(n-1+floor((n-1)^2/3)) * 3!^(-4floor((n-1)^2/3)) * 4!^((n-1)^2 mod 3). The existing puzzles are n=1 (Tetraminx, with 9.331 * 10^5 positions), n=1 with tips (Pyraminx, with 7.558 * 10^7 positions), and n=2 with tips (Master Pyraminx, with 2.172 * 10^17 positions).
Magic Octahedron Family:This family works just like the Pyraminx family, but now there are parities involved with some of the edges since a turn creates edge 4-cycles. Again, we want to fix the corners, and we're not going to fix the tips. The orbits are 6 corners with 4 orientations each (1 * 4^6), n-1 sets of 24 edge wings ((24!)^(n-1)), one orbit of middle edges (12!/2 * 2^11), a total of floor((n-1)^2/3) orbits of 24 centers, 3 each in 8 colors ((24!/3!^8)^(floor((n-1)^2/3)), and ((n-1)^2 mod 3) orbits of 8 centers ((8!/2)^((n-1)^2 mod 3)). So the number of positions is 2^(22-((n-1)^2 mod 3)) * 24!^(n-1+floor((n-1)^2/3)) * 12! * 3!^(-8floor((n-1)^2/3)) * 8!^((n-1)^2 mod 3). The existing puzzles are n=1 (Magic Jewel, with 2.009 * 10^15 positions), n=1 with tips (Magic Octahedron, with 8.229 * 10^18 positions), and n=2 with tips (Master Octahedron, with 1.029 * 10^47 positions).
Trajber's Octahedron Family: Although the Trajber's Octahedron functions in an analogous way to an odd NxNxN cube, the pieces are colored differently, which means that a different method is required when solving it, and it has a different number of positions. Thus it makes sense to consider it a separate puzzle. Note that octahedra made from even NxNxN cubes are entirely different, in that they have many solutions and no piece has multiple stickers. We will hold the corners constant, although allowing them to rotate. Thus our orbits are 6 corners with 4 orientations each (1 * 4^6), 12 middle edges with two orientations each (12!/2 * 2^11), n-1 orbits of 24 edge wings ((24!)^(n-1)), n^2-n outer center orbits, with 3 pieces each of 8 colors ((24!/3!^8)^(n^2-n)), and 8 inner centers (8!/2). Thus the total number of positions is 12! * 8! * 2^21 * 24!^(n^2-1) * 3!^(-8n^2+8n). The existing puzzles are n=1 (Trajber's Octahedron, with 4.050 * 10^19 positions) and n=2 (5x5x5 Trajber's Octahedron, with 3.429 * 10^78 positions).
Dino Cube Family: This is an interesting set of puzzles to think about, although it is easy to solve, since you basically just have a large number of orbits that are all solved like a dino cube. Note that a true n-layer Dino Cube will have 2n(n+1) stickers on each face, and also has two solutions - if you solve it to a mirrored color scheme you will not encounter any problems. This doesn't change the number of combinations, but it does make the puzzle slightly 'easier'. There are n(n+1)/2 orbits on this puzzle, each of which must have an even permutation because all turns create 3-cycles, and no pieces have orientation since they are in a given orientation whenever they are in a given position. We will fix one piece in the centermost orbit (11!/2) and then keep the other ones free ((12!/2)^((n^2+n)/2-1)), so the total number of positions is 11! * 12!^((n^2+n-2)/2) * 2^((-n^2-n)/2). The existing puzzles are n=1 (Dino Cube, with 1.996 * 10^7 positions) and n=2 (Lattice Cube, with 1.145 * 10^24 positions).
Number of Positions of Some Other Interesting Twisty Polyhedra
We can use these techniques for basically any twisty polyhedron, but in some specific cases we need to use a trick to find the correct answer, because if we are not careful we will miss an important detail about the puzzle. I'll illustrate each one with a puzzle. I will make a large table with the number of positions for each of a number of existing puzzles in another article, so if you are interested in the number of positions of a specific puzzle that isn't mentioned here it should be on that list.
Siamese Cube: The Siamese Cube is composed of two separate puzzles which do not share pieces. Since they are the same, you can find the number of positions by finding the number of positions for one of those puzzles and squaring it. Fix the block and the number of positions is ((24)(120 * 3^5)(11!/2 * 2^10))^2 or 2.046 * 10^32.
Helicopter Cube: The tricky thing about this cube is that (in its non-jumbleable form) it actually has four orbits of centers, which each contains one center of each color, and at least one orbit can have an odd permutation as long as the permutation of all of the orbits combined is even (since each turn flips parity on two orbits but doesn't change the overall parity). So if we fix a corner the number of positions ends up as (7! * 3^6)(6!)(6!)(6!)(6!/2) or 4.937 * 10^17.
Alexander's Star: In the standard coloring scheme each piece has a duplicate. So we want to choose one pair of pieces and fix one. There are two identical pieces, though, so we can fix each position exactly two ways, so we have to divide the result by 2. But note that there still may be positions which look the same in more than one of these states (which we assume to be different), which would mean that the result we calculate is actually too small. Generally there are a very small number of these, not enough to influence the calculated result if we write it scientific notation, but it is important to realize that if we wrote out the number in full it would almost certainly be incorrect. The number of positions is approximately (29*(28!/2!^14) * 2^28)/2 or 7.243 * 10^34.
Here is another way to look at this phenomenon: consider a "puzzle" with six tiles arranged like the faces of a cube, where you can switch any two tiles at any time. Suppose we color these tiles so there are three red ones and three blue ones. Now intuition tells us there are exactly 2 positions; our calculation, on the other hand, says that we can fix one of them in a specific orientation and get (5!/(2!*3!))/3*4 = 120/144 or 0.833... positions. Of course this is a contrived result, with many more identical positions than a real puzzle would have, but it does show how the calculated number is too small.
Group theory is a branch of theoretical mathematics that can be used to describe the way the functioning of the Rubik's Cube and various related puzzles. Although pure group theory can get extremely complicated (there is one proof, a classification of what are known as simple groups, which took an estimated tens of thousands of pages in its first incarnation) there are several simple applications of group theory to twisty puzzles.
First, we should explain what a group is. A group is nothing more than a set of elements and some binary operation on those elements; so we could make a group out of the set of integers and the operation +. Generally people describe a group just as the set of elements, since the operation is usually obvious from context. A group also has to satisfy several properties:
- Closure: Whenever we apply the operation to two elements in our group, the result is an element in the group.
- Associativity: If a, b, and c are in the group, and * is our operation, then (a * b) * c and a * (b * c) are always the same thing. This means that we can write things like a * b * c * a * c without needing large numbers of parentheses, which is very convenient.
- Identity: There is some identity element, so that if we apply the operation to the identity element and any element a the result will just be a again.
- Inverse: Every element has an inverse in the group, so that if you apply the operation to the element and its inverse it becomes the identity.
This is a pretty abstract concept, but fortunately it isn't too difficult to use. Basically, each puzzle has one group, with the elements being the puzzle's possible positions. Our operation is composition. Basically, suppose we have two elements in the group, A and B. Then A * B is what you get when you take the moves you would use to reach B from a solved cube, and apply them to A instead of a solved cube. This is a very simple and useful operation for several reasons. First, the identity is the solved state, which is easy to work with. Second, if we define a set of basic moves (for example F, R, U, B, L, and D, and their inverses, for a 3x3x3) we can get to every position from the identity using some sequence of these moves, which means that every element in the group can be written as some sequence like F * B * L inverse * D * D, and we can even describe positions by the way that they can be written like this. Third, the inverse of a position is also easy to find: group theory tells us that the inverse of A * B * ... * Z is Z inverse * .... * B inverse * A inverse. Since the inverse of basic moves are basic moves, we can very easily find the inverse of a certain position by just switching the order of the basic moves that bring you to that position and then inverting each one of them. Note that the inverse of the inverse of any position P is just P again.
By the way, since the operation * is always implied, we often write a series of moves in what is called multiplicative notation, where we write the separate moves next to each other without a *, and use exponents (like in algebra) to indicate doing something multiple times or inverting it. This means that we would write something like F B L^-1 D^2 instead of F * B * L inverse * D * D. This is the origin of our modern notational system, which has been simplified so that the inverse sign (which normally looks like a superscript "-1") is changed to a ' and the square sign (a superscript "2") is changed to a normal 2. I believe it was David Singmaster who created the modern Rubik's Cube notation this way. As for my notation system, it works just like this, but includes many more basic moves so that sequences of moves can be written more succinctly.
Along with the concept of a group comes the idea of a subgroup. A subgroup is what you get when you find a normal group and create another group with the same operation but only some of the elements. Because puzzle groups are only finitely large, it turns out that all you need to check to make sure a subgroup is valid is closure, so it's easy to find subgroups. Note that a subgroup always has to contain the identity (solved state). Since we always use the same operation, you can think of a subgroup as basically describing a sub-puzzle of a normal puzzle. A few interesting subgroups of the 3x3x3 are:
- The "two-generator" subgroup, all positions which can be solved using only R and U turns;
- The orientation-only subgroup, positions where all pieces are in place, but can have any orientation;
- The half turn subgroup or square group, positions that can be solved using only 180-degree turns.
The concept of a subgroup is closely tied in with the idea of a generator. A generator for a group is a set of moves or algorithms in that group, so that you can reach any position in the group only using moves or algorithms from that set (or their inverses). * For a given set of moves, there is always some group that is generated by them, that is, some group that contains exactly the positions that you can reach using those moves (in some order and doing them as many times as you want). For any set of moves, say the set R, U, and F2, we write the group generated by them as <R,U,F2>. One particularly famous generated group is a subgroup which we have already discussed: the subgroup of 3x3x3 positions which can be solved using only R and U turns. This is known as the 2-generator group, since it is <R,U>, the group generated by moves of two adjacent faces. Playing with generators can create a lot of new and interesting challenges out of a normally non-challenging puzzle.
Another useful result of group theory is the use of so-called "cycle notation". Imagine a group where, instead of a normal puzzle, you have a bunch of pieces labeled 1 through n, and you can put them in any order (permutation) you want. We can still use the composition operation for this group, and it works a lot like the puzzle groups we have looked at. The question is: how do we represent objects in this group? What we will do is represent a permutation by following where pieces go. Give each piece a spot, labeled 1 through n, which represents its original location; so we can write down a permutation by writing the list of numbers we see, following the locations from 1 to n. So if we have five pieces and the permutation leaves them looking like "3 4 2 1 5" we can use this to represent the permutation. There is a better way, though: instead of just looking at each piece, follow where pieces are actually sent. In this case, the piece that was at position 1 is now at position 4; the piece at position 4 is now at position 2; the piece at position 2 is now at position 3; and the piece at position 3 is now at position 1. We can encode all of this information by writing (1 4 2 3). This is what we call a cycle, and we can imagine making this permutation by simultaneously moving all of the pieces in it to the location where it will go. More specifically this is a 4-cycle, because it has 4 elements. Now what about the piece at position 5? It's still there, and although we could write this as a 1-cycle we usually do not, because that piece doesn't have to move at all. This is really useful, because (1 4 2 3) is a valid permutation for ANY number of pieces, as long as you have at least 4 of them! If we have more than one cycle at the same time, we can write them by writing them next to each other. So if 1 goes to 2 and 2 goes to 1, and 3 goes to 4 and 4 goes to 3, we will write this as (1 2)(3 4).
We call a cycle with n elements an n-cycle. In puzzles we usually consider permutations on the pieces of the puzzle. Because of some more complicated math that will be discussed later, the basic unit that you can use to solve puzzles is the 3-cycle, which moves three pieces around. You may already know a few 3-cycles of pieces on the 3x3x3. Permutations of the pieces, however, is very important in the study of how to solve puzzles, as well as integral to blindfold solving.
There are two last useful mathematical terms which are very useful to understand cubing. They are conjugation and commutation. In conjugation you take two move sequences, which we will call X and Y, and then you make the sequence X Y X^-1. The interesting thing about this is that we end up with the same cycles as in Y, just with different pieces being moved around. You can use this to make other algorithms out of a given one, because the pieces that are moved in the conjugated algorithm are actually the pieces that X puts in the spots Y moves around. Commutation is similar: for two move sequences X and Y the commutator is X Y X^-1 Y^-1. In theory this can make many of the cube's possible patterns, but in practice we mostly use commutators to create nice 3-cycle maneuvers, or to flip/twist two pieces on a puzzle. The way it works is this: have X be a single turn, and then choose Y so that it modifies just one piece on the layer. If Y flips or twists the piece, you will end up with one piece in X's layer flipped/twisted and another flipped/twisted the same amount in the opposite direction. If Y replaces the piece with some piece from another layer, you will end up with a 3-cycle. The really useful thing about commutators is that if you understand them well enough you can literally make up commutators quickly while you are solving a puzzle, and do any 3-cycle you want in just a few seconds.
Well, those are most of the group theory topics you are likely to see. I've tried to explain them simply, but if you don't understand you can look them up on Wikipedia or look for a topic on the speedsolving.com forum. Again, good luck!
There are a lot of terms in the theory of cubing that won't be at all understandable to outsiders, or even that are used in a different way in cubing than in the outside world. I'm going to define some of them; since I have an imperfect memory this list is not complete, but just a list of some things which I think are commonly or easily misunderstood and which I'd like to explain.
Algorithm: This just means a sequence of moves, whether it is made up on the spot or memorized beforehand. The common abbreviation is "alg". Typically it is a sequence that accomplishes something specific (such as solving part of a cube), but people sometimes talk about scrambling algs. A way to solve a specific puzzle is not an algorithm, but a method (see below). Some methods have many algorithms to memorize, and some require less or no memorization.
Bandaged: A puzzle is bandaged if some of its pieces are connected to what would normally be adjacent pieces in a way that restricts the movement of the puzzle depending on where those pieces are, which often increases the puzzle's difficulty. A bandaging is a way of connecting pieces together to make a bandaged puzzle.
Blindfold Solving: This is a way of solving a puzzle by memorizing the positions of all of its pieces, then putting on a blindfold and solving the whole puzzle without looking at it. The typical abbreviation for blindfold or a blindfold solve is BLD. There are really two types of BLD: solving all of the pieces like a speedsolve, and tracking where they go while you memorize, then memorizing what moves to do; or solving a few pieces at a time while not affecting the others, so you can memorize where each piece is supposed to go, which is often easier.
Block: This can either mean a group of adjacent layers on one axis, or a cuboidal set of pieces. A block turn is a turn of some group of adjacent layers. Block building is a type of intuitive step of a method where you assemble a block of pieces.
Center: Any piece which belongs to only one face. Some puzzles have a lot of these on each face, in many different types. Since they have only one color, though, if a puzzle is not a supercube (see below) they can often be interchanged with each other without making the puzzle unsolved. Centers typically do not have orientation, except sometimes on a supercube.
Corner: Any piece which belongs to more than two faces. Corners usually have from two to five possible orientations. Note that trivial tips (see below) are generally not considered corners, though, since they don't affect other pieces and are thus not really part of the puzzle.
Cube: Although formally this means a cubical puzzle, the Rubik's Cube is so popular that people will often casually refer to any twisty puzzle as a cube.
Cuber: Anyone who is interested in solving the Rubik's Cube or other twisty puzzles. If they are also interested in solving as fast as they can, they are a speedcuber.
Edge: Any piece which belongs to two faces. Edges usually have two possible orientations.
Face: One face of the puzzle. A face is solved when all of its stickers match (on a normally-colored cube this would mean they were all the same color). However, solving a face on many puzzles (such as 3x3x3) is useless, since it might still be necessary to permute the pieces on that face in order to solve the puzzle; it is much better to solve in terms of layers or blocks.
God's Algorithm: In general this term means a method to always solve a puzzle in the fewest possible number of moves. However, it can be used in a few different ways: sometimes it means a way to find this solution for any given scramble (or a list of solutions for every scramble), sometimes it means a solution for a given position, and sometimes it is used to mean the maximum number of moves that an optimal solution for a scramble can take.
Intuitive: A step is intuitive if you solve it by figuring out what moves to do during the solve, rather than by using algorithms you know (which is called an 'algorithmic' step). Typically people think of commutators as intuitive, since you don't memorize the moves that are in them, but instead learn the concept. Intuitive steps in a method are good because they require less memorization, take fewer moves, and are generally more fun to execute, but it does take more practice to be fast at them.
Lucky: A solve is lucky if one or more of the steps in the method is skipped; solves can be very easy without being lucky. Note that if a solver uses a different algorithm than normal to deliberately skip a step in their method, most people would say that does not make the solve lucky.
Method: A method is a predetermined way of solving a puzzle in a series of steps. Typically methods are named after their creator(s) or the steps themselves. A method created by Stefan Pochmann might be referred to as the Pochmann method, Pochmann, or even poch; abbreviations are common if the name is long. For example, there is a family of methods called Corners First (CF) because the first step or first few steps solve the corners of the puzzle without regard to other pieces.
Metric: A specific and well-defined way to count the length of an algorithm or a puzzle solution. The most common metrics are htm or ftm (half turn or face turn metric, where every move of one face, or block containing a 1st slice, is counted as one turn), stm or btm (slice turn or block turn metric, where every move of one face, block, or slice is counted as one turn; some would say stm does not count blocks as one move but as separate slices), and qtm (like htm, except that only turns of the smallest valid angle increment (90 degrees on 3x3x3, for example) are counted as one move, and larger turns may be more than one move).
Orbit: This is the set of all pieces that can be moved to a specific location on the puzzle without rotating the puzzle. Sometimes there is more than one orbit of pieces that look the same.
Orientation: The way that a piece is positioned, independent of where it is on the puzzle; you can define a 'correct' orientation for each piece and location. On a Rubik's Cube, for instance, corners have three possible orientations. When you do moves to give a set of pieces the correct orientation, you are orienting them (not orientating). Pieces with the wrong orientation are typically said to be flipped (in the case of edges) or twisted (in the case of corners and centers) and algorithms to solve them are thus called flippers or twisters.
Parity: As I'll discuss later, pieces can normally be solved in cycles of three pieces, but if pieces cannot be solved like this then there is a (permutation) parity. There can also be orientation parities, if only one piece in an orbit is wrongly oriented, but these do not occur on all puzzles. The algorithm to fix any parity without disturbing other pieces is typically very long.
Permutation: Where a piece is on the puzzle, independent of the way it is positioned; if a piece is in the correct permutation it might still be misoriented (twisted or flipped). When you do moves to give a set of pieces the correct permutation, you are permuting them (not permutating).
Slice: One of the layers on an axis, not counting the outermost layer. A slice turn (or sometimes just slice) is a turn of one of these layers only.
Supercube: A puzzle where some or all pieces are marked so that the position and orientation of every piece must be correct for the puzzle to be solved.
Trivial tip: A piece on the puzzle which can always be brought to its solved position in one move without disturbing any other pieces; they are called trivial because they are so easy to solve that they are often not even mentioned in methods. They are also known as tips. A pyraminx has four of these.
Twisty puzzle: Basically a sequential move puzzle where the goal is to turn various parts of it until it reaches one of its solved states. A pretty good list can be found at the twistypuzzles.com website. These are often simply referred to as puzzles, or even cubes.
In this post I'll describe my generalized notation for twisty puzzles. I might stray from this notation at times but I think this does a pretty decent job of describing moves for puzzles. There are a few levels of notation built on each other, and although it might seem overcomplicated most applications of this (such as writing down specific algorithms) only use simple features of it: for example, the well-known Sune algorithm for the 3x3x3 is still written R U R' U R U2 R'.
Not all of this will necessary make sense or seem useful to you now. However, if I use some notation that you are not familiar with, it would be helpful to come back to this post as a reference.
First you give each face of your puzzle a letter (or more than one if you are careful about it). Fortunately, for algorithms on dodecahedral and icosahedral puzzles, you usually don't have to label all of the faces. The standard naming for cubical puzzles, which you have probably seen before if you are into speedsolving, is to call the faces U (for the upper face), D (for the down face), F (for the front face), B (for the back face), R (for the right face), and L (for the left face). Typically if you see three faces in a shot of a cube they are assumed to be U, F, and R. I'll assume that you know what faces I am using when I talk about cubical puzzles, but if I am discussing a different puzzle I'll probably describe how I am naming faces or at least make it so that you can determine the meanings from context.
Now you can label the axes that you turn pieces around. There are three types of axes: faces, edges, and corners. Check out the puzzles at gelatinbrain if you aren't entirely sure what this means; the most common puzzles with various axes are the Rubik's Cube (face), Bevel/Helicopter Cube (edge), and Pyraminx (corner). Face axes are labeled by their face, edge axes are labeled by the two faces they touch, and corner axes are labeled by the three faces they touch; the face's names can be in any order, but they should not have spaces between them. This means that if you see an axis label (say UF on a 3x3x3) you should be able to quickly determine what type of axis it belongs to, so this notation can still handle puzzles with more than one type of notation.
Finally, we get to the turns themselves. Turns are all around an axis, so you should modify the following basic types of turns based on the axis. For the examples I'll use the axis UR. We're going to suppose there is more than one slice around the axis (like in big cubes) for the purpose of the notation. Label the slices with integers starting at 1 for the outermost slice and ascending as you move deeper into the puzzle. There are five types of moves; all moves are clockwise turns as seen from a vantage point outside the puzzle.
- 3UR is a clockwise turn around the UR axis, turning the 3rd slice only (a slice turn). If the number is 1 (1UR) then it is allowed to just omit the 1, since this is a very common type of move.
- 3ur is a clockwise turn around the UR axis, turning all slices up to the 3rd slice (a block turn). If the number is 2 (2ur) then it is allowed to omit the 2, since this is the smallest block turn that can't be just written as a slice, and is also very common.
- 2-4ur is a clockwise turn around the UR axis, turning slices from the 2nd to the 4th (a block turn). This isn't a common type of move, but it's useful for writing patterns in block turn metric.
- *ur is a clockwise turn around the UR axis, turning basically half of the slices on the UR axis (and its opposite axis) rounded down. On a 4x4x4 or 5x5x5 cube this would be 2 slices; on a 6x6x6 or 7x7x7 it would be 3. Note that since it is lowercase it should be a block turn. This is useful for writing algorithms in a more general form.
- cUR is a clockwise cube rotation around the UR axis. Note that it's unambiguous because having lowercase and uppercase letters together is unique. Observe that sometimes we might need cube rotations around axes that you can't turn; for example on a 3x3x3 cube sometimes a rotation like cURF is useful.
Separate moves should always be written with spaces separating them. A group of moves can be enclosed with parentheses (i.e. ( and )). You can modify a move or a group of moves by putting a number after it (to indicate it is to be done that many times) or a ' (to indicate that its inverse is to be performed instead). Thus combinations such as 3UR' and r2 are possible. If we want to use both of these, either R2' or R'2 is acceptable, but personally I will tend to use R2' because I like it more.
Rarely, in generalized patterns or commutators, variables are needed to show that any slice or any amount of turn can be used. Typically any letters that are not in use to describe axes are acceptable. As in the notation we have already seen, if a variable is placed before the axis name (such as nr) it describes a slice number, and if a variable is placed after (such as Rx) it describes a number of times a turn should be done.
Finally, I'd like to say that it's true that this notation differs a bit from the conventional notation, especially when it comes to large NxNxN puzzles (bigcubes, that is), but I think that it is better generalizable to other puzzles and more consistent than the standard notation. Moves such as (rm') or Rw, as written in standard notation, are difficult to expand to different puzzles and often unwieldy. I hope my notation is reasonable enough to be understood by most visitors here.
This is a blog about twisty puzzles themselves. I aim to explain the way they work and the way they are solved so that the reader should eventually gain a deep understanding of the way these puzzles work, a thing which is sadly lacking in many of today's speedcubers. I also hope to put some of the methods I use or have discovered on here. Some of the material here might be original research and some may not; it's safe to assume that I've created anything that I explicitly credit to me, but I don't necessarily claim authorship of all that I write here.
The first couple posts will probably concern themselves with the mathematics of the cube, to get a feel for why things work as they do. Although I'm considering majoring in Math I'm not going to be too formal or theoretical, so anyone with an early high school understanding of mathematics (or better) should be fine. Then after that I'll start to go into the more interesting stuff, or perhaps some more complicated mathematics. Don't think of this as a kind of textbook where every section builds on the one before it: the material in these opening sections should be enough to understand all or most of the rest. If you are confused about something you can always ask me, or the friendly folks on speedsolving.com.
So what's with this name "Notes on Twisty Puzzles"? It is based off of the title of an early Rubik's Cube treatise by David Singmaster which he called "Notes on Rubik's Magic Cube" and which was a great leap ahead in understanding how the standard 3x3x3 cube works. Despite not having read his books about the Cube I do recommend that you read them if you have a chance, as I've heard they are excellent.
Finally, all opinions expressed herein, and all writing, are mine unless stated otherwise. Opinions can and do change, so if you have a problem with anything here feel free to tell me about it.
Have fun, and good luck!