> urticator.net

  About This Site
> Domains

> Games

  The Hive Cluster Is Under Attack!
  Some Memes for Oni
  4D Maze Game
  Attention in Myth
> Rubik's Cube

  Some Memes
> Primitives
  How I Solve It
  Pattern Index



Sequences like [x,U] that have a simple, well-defined effect on a limited number of edges or corners I think of as primitives. I'm not sure where I got the name, probably I saw it somewhere in connection with computer graphics. Primitives are sort of like atomic operations (although of course they can be divided into turns) and sort of like instructions in an instruction set (see Machine Language and Operations for some inspirational reading along those lines).

To put the last two subessays in perspective, commutators let us construct primitives (hard to find) from monoflips and so on (relatively easy to find) and conjugates let us make effective use of them. When we use a primitive we always have the same two external degrees of freedom available: choice of orientation and choice of conjugation value. Some primitives (commutators and others) also have an internal degree of freedom.

That said, here's an inventory of all the primitives I use. Caveat: this is very much a matter of taste! I've set the cube aside for years at a time, so the primitives I remember tend to be the ones that are easy to remember. I'm not trying to set any records, so speed isn't a big issue. And, I don't enjoy doing front and back turns. If you have a good memory (muscle memory) and the will to use it, there are faster primitives and even sets of primitives that you can learn.

1. Double Flip

The commutator [x,U] is a double flip, but it's just a fun example, not something I actually use. The sequence x has the same style as some of the later sequences in [SS], and in fact x-1 appears there, though it's not used in a commutator.

My favorite double flip right now is the commutator based on David Seal's original monoflip. I picked it up while I was working on these essays.


Note that the hot seat is in the upper right. If you're left-handed you'll probably want to use the mirror image.

2. Quadruple Flip

I'm not sure where I learned the quadruple flip (Uα)4. It appears in [WW] in a different orientation (and reflected), but I'm sure I knew it long before I read that. I did like to try repeating things to see what would happen, so it's possible I discovered it that way. In any case, here's the peculiar arrangement it produces.

Although it's a peculiar arrangement, it's not a bad one. You can conjugate the sequence by R2D-1B2 to flip a whole face or by BLB-1 to flip a whole slice, or you can interlock three copies to flip all the edges on the cube. Why you'd want to do that, I don't know; it's not pretty.

The quadruple flip isn't a primitive in the atomic sense since it can be built up from two double flips, but it's a nice instruction to have in your instruction set. Conversely, if you follow a quadruple flip with the mirror image (U-1α)4, you get a double flip. I'm pretty sure I did double flips that way for many years.

3. Edge Swap

The edge swap (U2α2)2 (on the left) is tremendously useful.

It's super-fast, and you can easily conjugate it to accomplish almost any swap. Just to give you the idea, you can conjugate by γ2D or ε2B to swap in different ways on a single face, or by RεB±1 to get effects that are useful for making patterns.

The edge swap (U2R2)3 (on the right) is also handy sometimes.

I'm calling these sequences swaps, but as you can see they're really double swaps. Single swaps are impossible by a parity argument that you can find in [WW] or [MT].

4. Edge Cycle

I'm calling these sequences cycles, and they are. To be precise, they're 3-cycles, cyclic permutations of three pieces. Other cycle lengths occur in theory but not in practice.

My favorite edge cycle, that I've used for as long as I can remember, has the form xUjxUkxU-j-kx, where x = RL-1 F2 LR-1. The way it works is, the first x “picks up” the upper front edge, the Uj turns the upper face to wherever you want that piece to go, the second x puts that piece down and picks up the next one, and so on. It's not especially fast, but it's easy to remember and to control. In other words, you don't have to puzzle over what effect it's going to have, you just pick things up and put them down where you want them. The sequence x has the same style as some of the later sequences in [SS], but I'm pretty sure that the edge cycle is my own invention.

One thing that's remarkable about that edge cycle is that it has two integer parameters rather than the usual zero or one. (I'll still say it only has one internal degree of freedom, though, because the degrees of freedom we're talking about are more than just integers.) There's a way to understand that, it turns out. Since the sequence x is self-inverse, we can rewrite the edge cycle as [x,Uj][x,Uj+k]-1, so the reason it has two parameters is that it contains two commutators! What's more, each of the commutators is itself a cycle that includes the upper and lower front edges. The sequence x isn't a true monoswap because it swaps the upper and lower front edges, not two edges on the upper face, but the principle is very similar.

The sequence xD2 is also a cycle, a very fast one. That exact sequence appears in [SS], and a reoriented version appears in [CG]. Let me write it out in a more convenient orientation, along with its inverse.

RL-1 U2 LR-1 F2
F2 RL-1 U2 LR-1

If we reorient as we go, we can rewrite it as βF2αF2; that form appears in [WW], where it's attributed to Kati Fried.

I've been giving the fast cycle a try, but I have to admit I don't love it. The turns are fast, which is great, but the overall process feels slow because I always have to stop and think about which sequence to use. Also, almost all the cycles I want to perform are on a single face, so I always have to conjugate by R2D-1.

5. Double Twist

Just as we can flip edges, we can also twist corners, either two corners in opposite directions or three in the same direction. Here's the sequence I use for two corners, which twists the upper right front corner clockwise and the diagonally opposite corner counterclockwise.

(R-1D2R B-1U2B)2

It's a great sequence, fast and easy to conjugate. When I use it, I reorient in the middle of the sequence so that the second half becomes R-1U2R. I learned it from [CG], where among other things it says the following.

This string, or something very like it, is said to have been discovered by Rubik himself …

That sounds so much like science fiction! Discovered by Rubik himself at the dawn of history, before the fall of the empire!

There are also double twist primitives constructed from monotwists, but I don't like them.

6. Triple Twist

Triple twists are definitely a weak point for me. They come up all the time when I'm solving the cube and making certain patterns, but I don't know any good triple twist primitives, I just always do two double twists instead. The only such primitive in all my books is this one from [CG], which twists three corners counterclockwise.


I find it both hard to remember and awkward to execute, but it does take only 14 turns compared to 28 for two double flips. (Each double flip takes 12 turns to execute and 2 to conjugate.)

Actually, the triple twist primitives derived from the monotwists in [WW] aren't bad. The clockwise monotwist x = (RF-1R-1F)2 satisfies x3 = 1, so it can be used not just in commutator form to make a double twist but also in the form xUjxUkxU-j-k to make a triple twist. The triple twist takes 27 turns, but it's appealingly repetitive and controllable, and to twist counterclockwise you just replace x with the counterclockwise monotwist x-1.

7. Corner Swap

Here's a nice monoswap that I invented a few years ago when I finally grokked commutators. Watch the upper right corners and see how it works!

x = R-1D-1R B-1D2B R-1DR

I always reorient in the middle of the sequence so that the second term becomes R-1D2R. In any case, once we have x we can form the commutator [x,U2] to get the real swap primitive. It's a double swap; single swaps are impossible here too. One noteworthy feature of the sequence x is that it's self-inverse, so you don't have to know it backwards and forwards, just forwards.

If you don't mind the corners getting twisted, you can use this monoswap from [WW] instead. It feels a lot faster.

R-1D-1 R2D2R2 DR

I've reoriented (and reflected) the sequence, and as a result you can see how closely related it is to mine.

8. Corner Cycle

If we use U±1 instead of U2 in the previous commutator, the monoswaps overlap and produce a cycle. It's pretty easy to control the direction by thinking about which piece needs to move two spaces. Of course, you can use the monoswap from [WW] instead if you don't mind the corners getting twisted.

9. Edge-Corner Swap

The reason it's impossible to do single swaps of edges or corners is that swaps are odd permutations and the total permutation of the pieces is always even. But, is it possible to do single swaps of edges and corners together? More generally, is it possible to produce odd permutations of edges and corners? Sure! In fact it's very easy. A quarter turn is equivalent to two 4-cycles, one of edges and one of corners, and 4-cycles are odd permutations, Q.E.D. What about single swaps of edges and corners? I've never seen a primitive that does that, but then it's not something that comes up much, and it's easy enough to do a quarter turn and then fix up the rest with other primitives (a corner swap and a conjugated edge swap).

10. Center Patterns

Since our notation includes slice moves, it's meaningful to talk about primitives that act on center pieces, and in fact there are two of them. They're simple and well known, and with them you can reach any possible state of the center pieces from any other in one step. However, they also happen to make pretty patterns, so I'd like to save the details for the later subessay about that.

* * *

If you try to solve a cube that has pictures on the faces, you'll soon discover that in addition to all the other ways it can be messed up, it can have twisted center pieces. I had a chance to play with one recently, and was very pleased with myself and my theory of cubes when in just a few minutes I was able to come up with a nice flexible primitive to fix that, the commutator [x,εj] based on the center monotwist x = αUkβ. But, later, when I reviewed the discussion of center twists in [CG], I found good news and bad news. My primitive is better than any of theirs, but it's not enough—you also need one like their (URLU2L-1R-1)2 that applies a 180-degree twist to a single center piece.

* * *

Unbelievable! After using my favorite edge cycle for, oh, thirty years, I just learned something new about it. You can use the sequence x = RL-1 F2 LR-1 to perform swaps as well as cycles … i.e., any even permutation of upper edges! You just pick things up and put them down where you want them, and it all works out. That's a great operation to have available if you're just learning to solve the cube.



  See Also


@ November (2012)
o July (2013)
o December (2015)