Cube Commutators and Setup Moves: What X Y X' Y' Does

Cube commutators are move lists of the form X Y X' Y': do a move X, do a move Y, undo X, then undo Y. Cubers use them, and their cousin the setup move X Y X', to change a small part of a cube while the rest comes back to where it was. This guide explains both patterns in plain words, walks through two real move lists, and shows what happens when you try the same idea on a cube where every twist adds a tile.

If you want to try twists on a cube right away, Evolved 2048 puts the 2048 puzzle on a cube you twist and turn in your browser, so you can see for yourself which twists cancel and which do not.

What cube commutators are

Wikipedia's Rubik's Cube article says the puzzle "lends itself to the application of mathematical group theory", which has helped people find move lists, in particular those with a commutator structure, X Y X⁻¹ Y⁻¹. Here X and Y are moves or move lists, and X⁻¹ and Y⁻¹ are their inverses: the moves that undo them.

In cube notation an inverse is written with a prime. R turns the right face clockwise, and R' turns it anticlockwise, which undoes R. For a longer list you undo it by reading it backwards and flipping each move. The inverse of U R is R' U', not U' R'.

So a commutator has four parts:

• X: the first move or move list.
• Y: the second move or move list.
• X': the first one undone.
• Y': the second one undone.

If you have read our beginner's guide to cube notation, you already know every letter you need.

Why X Y X' Y' changes so little

Wikipedia's Commutator article says the commutator "gives an indication of the extent to which a certain binary operation fails to be commutative". In a group, the commutator of two elements equals the identity, the do-nothing element, if and only if the two elements commute: doing them in either order gives the same result.

On a cube, that has a direct meaning. Take U and D, the top and bottom faces. They turn different layers on the same axis, so U then D leaves the cube the same as D then U. Their commutator, U D U' D', brings the cube back to where it started: nothing changes.

Now take two faces that share pieces, such as F and R. Wikipedia's Rubik's Cube group article says the group is non-abelian, meaning not all cube moves commute: doing moves in a different order can give a different position. F and R both move the pieces on the edge between the front and the right face. Their commutator does not cancel, but much of the cube still returns, because X' and Y' undo the parts of X and Y that did not touch each other. What is left over is the measure of how much the two moves got in each other's way.

That is why cubers like them. The Rubik's Cube article notes that many move lists are designed to change only a small part of the cube without disturbing parts already solved, such as lists that cycle three corners without changing the rest of the puzzle, or flip a pair of edges and leave the others alone.

The setup move: X Y X'

The second pattern drops the last step. Wikipedia calls X Y X' a conjugate, and says speedcubers often call it a "setup move". The Commutator article gives the same shape in group terms: the conjugate of a by x is x⁻¹ a x.

The idea in plain words:

1. Set up (X): move the pieces you care about into a spot where a move list you already know will work.
2. Act (Y): run that known move list.
3. Undo the setup (X'): put everything the setup moved back where it came from.

The result is Y's effect, carried out somewhere else. If Y swaps two pieces on the top face, X U X' lets you swap two pieces that started elsewhere, as long as X brings them to the top first. You learn one move list and reuse it in many places.

A worked example: reading two real move lists

The Rubik's Cube article describes Philip Marshall's method, which uses only two memorised move lists. Both are commutators, and you can see it by grouping the letters.

The Edge Piece Series, F R' F' R. Split it into four single moves:

• X = F, turn the front face clockwise.
• Y = R', turn the right face anticlockwise.
• X' = F', undo the front turn.
• Y' = R, undo the right turn.

So F R' F' R is the commutator of F and R'. Because F and R share the front right edge, the four moves do not cancel, and what is left over is a small change near that edge.

The Corner Piece Series, U R U' L' U R' U' L. This one has eight moves, but it splits the same way once you treat a block of three as one move:

• X = U R U'. This is itself a setup move: turn the top, turn the right face, turn the top back.
• Y = L', the left face anticlockwise.
• X' = U R' U'. Read X backwards and flip each move.
• Y' = L, which undoes L'.

So the eight moves are a commutator whose first part is a conjugate. The article notes that this list is the same as the usual last layer corner move list. Try writing any move list you know as X Y X' Y' or X Y X': it is a quick way to see why it changes only a few pieces.

Commutators on a 2048 cube

Evolved 2048 is the 2048 puzzle on a cube you turn like a Rubik's cube: six faces of nine squares, 54 in all. You slide the front face so equal tiles merge, twist a row or column to carry tiles round from the other faces, and turn the whole cube to use its other sides.

Its twists look like face turns, and they have inverses on the keyboard: 1, 2 and 3 twist the top, middle and bottom row right, 4, 5 and 6 twist the left, middle and right column up, and Shift twists the other way. But the game's own rules change the maths. A twist adds no points, counts one move and adds a new tile. In a test on a set-up board, key 4 and then Shift and 4 took Moves to 2 and the tiles on the board from 4 to 6, with Score 0.

So a four-twist commutator costs 4 moves and lands 4 new tiles, and never returns the board to where it began. As our post on cube group theory explains, a twist and its reverse never cancel the way R and R' do.

The setup idea still works, minus its last step. The game's How to play box puts it this way: a twist carries a layer's tiles to the next face, so "bring a tile from the side next to its match on the front." In one test, a 16 sat on the front's middle left square and another 16 on the right face's top left square. Shift and 1 twisted the top row left, which put the right face's 16 on the front's top left square, above the other 16, with a new 2 on the front. Then Up merged them into a 32: Score 32, Moves 2.

That is X then Y with no X' at the end. On a puzzle cube you undo the setup to protect solved pieces. On a 2048 cube there is nothing to protect, and undoing the twist would cost another move and another tile. Whole-cube turns are the free part: Shift with an arrow key turns the cube, adds no tile and counts no move, so you can look round all six faces before you choose a twist. See turning the whole cube in 2048 for the keys.

Frequently asked questions

What is a commutator on a Rubik's cube?

It is a move list of the form X Y X' Y': a move, a second move, the first undone, then the second undone. If X and Y commute it changes nothing; if they share pieces it leaves a small change.

What is a setup move?

It is the conjugate X Y X'. You move pieces into place with X, run a known move list Y, then undo X, so Y's effect happens somewhere new.

Is F R' F' R a commutator?

Yes. It is X Y X' Y' with X as F and Y as R'. Wikipedia lists it as the Edge Piece Series in Philip Marshall's method.

Do commutators work in Evolved 2048?

The twists have inverses, but each twist counts a move and adds a new tile, so X Y X' Y' never brings the board back. The useful part is the setup: twist a tile next to its match, then slide to merge.

Get started

Commutators and setup moves are a way of thinking: move things into place, act, and know what each step costs. On a 2048 cube every twist is a step you keep, so turn the cube to look first, then twist only when it brings a tile next to its match.

Play Evolved 2048: it is free and plays in your browser on a computer or a phone.