Gallagher 1

Sean Gallagher

Professor Ray Mest

Sr. Seminar, MAT 492

May 2011

The Rubik’s Cube and its Group Theory Applications

When the Rubik’s Cube was invented in 1974, it took the world by surprise. When the

idea was first thought up by Ernő Rubik, he may not have known how big the puzzle was

eventually going to be. The Rubik’s Cube has sold over 350 million copies, making it the best

selling puzzle of all time; it is considered by many to be the best selling toy in history. A few

years after its release in the market, nearly every child in every household owned the puzzle. It

has even made its way into the Oxford English Dictionary.

Introduction

The Rubik’s Cube is unlike any other puzzle. It has many distinct and unique features

that allow it to stand out among many other puzzles. A few key features that Ernő Rubik

pointed out himself are:

1) The cube (all of its pieces and all of its parts) stays together when being solved. Many

other puzzles that require moving parts have separating pieces.

Gallagher 2

2) Several pieces move at once, in contrast to other puzzles that may only move one piece

at a time.

3) Most pieces of the cube have what is called “orientation.” This means that not only

does each piece have a correct “positioning,” but each piece has a correct orientation as

well. In other words, a single piece could be placed in the correct spot but could be

flipped (colorwise) the wrong way. Rubik says that the only other puzzles that have this

quality are assembly puzzles, which are very, very different types of puzzles as

compared to the Rubik’s Cube (viii).

4) The three-dimensionality of the cube is a unique characteristic trait. Three-dimensional

moving-piece puzzles are very rare. In Rubik’s eyes, this is a very important feature

(viii).

5) The cubicality of the cube. Simply put, the cube is a very satisfying shape to handle. It is

the most basic three-dimensional shape. On a cube it is easy to make specified turns

because everything is symmetrical and everything lines up nicely (Rubik viii)

6) The colors of the cube. It has great aesthetic appeal; some other puzzles lose their

appeal. Rubik put much thought into the colors of his puzzle. At first, he wished to

make opposite sides of the cube complementary colors. Later, he realized that he

wanted a white side to “brighten” the effect of the cube. So what he ended up doing

was separating colors on opposite sides by a factor of yellow. For example: yellow-

white, red-orange, and blue-green (Rubik viii).

7) The mechanism of the cube. This may be the most remarkable aspect of the puzzle.

When Ernő Rubik first proposed the idea of the Rubik’s Cube, people laughed at him and

Gallagher 3

said that the puzzle was impossible to physically make. He ended up developing an

amazing core mechanism that fit together with each individual piece and allowed the

puzzle to exist.

8) The complexity of the cube. For such a simple looking puzzle, the complexity of the

cube is remarkable.

9) The mathematics of the cube. That is what this paper focused on. The Rubik’s Cube is a

great example of permutation groups and group theory.

10) The educational value of the cube. The ability to increase three-dimensional abilities of

children and adults.

Ernő Rubik first formulated the idea of the physical Rubik’s Cube in 1974 (Rubik 17). This

was when he thought up the final design and realized that it was actually possible for the cube

to be made. The cube is said to have been originally created for the purpose of illustrating

spatial moves. The cube became more than an illustration; it became a game with great

marketing possibilities. So in 1975 Rubik applied for a patent for the cube and began looking

for a mass manufacturer. Politechnika Cooperative eventually took the job (Rubik 17). The

Rubik’s Cube was put on the Hungarian market in 1977. It gained much self-propelled

popularity without too much advertisement. In 1980, over one million cubes were sold in

Hungary alone (Rubik 17).

In 1978, the Rubik’s Cube won a BNV prize at the International Budapest Fair (Rubik 17). In

1979, it won an award from the Hungarian Ministry for Cultural Affairs. In 1980, it won the

“Toy of the Year 1980” award in England, along with many other awards in other countries such

Gallagher 4

as Germany and France. In 1981, the cube became included in the collection of design and

architecture for the New York Museum of Modern Art (Rubik 17).

Over 60 books have been published about the Rubik’s Cube (Rubik 17). The popularity of

the puzzle is enormous. There are dedicated fans and “cubers” around the world who spend

hours every day solving this amazing toy. There is even a term called “cubology,” with a big

focus on in depth analyses of the cube. Now let’s begin to get into the notation and

mathematics of the cube.

Notation

Let’s talk about the description and notation of the Rubik’s Cube. The original cube is a

3x3 cube puzzle made up of what appears to be 27 individual cubes. We will call each

individual cube piece a cubelet. If you dismantle the cube, you will see that the center cubelet

does not actually exist. In the center of all the cubelets is a core, rotating mechanism. This

mechanism attaches all six of the center face cubelets together. All of the other cubes interlock

with each other and are able to rotate in many different directions. The Rubik’s Cube as a

whole contains three basic types of cubelets. The first type is called a corner piece. There are

eight corner pieces on the cube, each of them at the eight different corners. These cubelets

have three different colors to them, considering they link a total of three sides. Each corner

piece can thus be oriented in three different ways. You can think of this by taking a starting

orientation of one of these cubelets and then rotating it clockwise. Rotating the cubelet

Gallagher 5

clockwise three times will bring you back to the original orientation. The second type is called

an edge piece. There are 12 edge pieces on the cube, each of which surround the centers and

lie between the corner pieces. These cubelets link only two sides and they have two different

colors. Therefore, there are only two possible orientations for any given edge piece at any of

the specified 12 spots. The third type is called a center piece. There are six center pieces, each

obviously at the center of each of the six faces of the cube. These cubelets can never change

position with respect to another center cubelet. This is impossible because all six of the center

pieces are directly attached to the core mechanism on the inside of the cube. Considering a

center piece only consists of one color, it has only one possible orientation.

Say we set one corner cubelet into a designated spot on the cube; let’s call this spot a

cubicle. That leaves seven remaining cubicles for the seven remaining corner cubelets.

Following this pattern we have 8! possible positions for the corner pieces (“Group Theory” 10).

Using this same logic, there are 12! possible positions for the edge pieces. Since each corner

piece in its own cubicle can be oriented three ways, there are 3⁸ possible orientations for the

corner pieces. Following the same logic, there are 212 possible orientations for the edge pieces.

Therefore, there are 8!12!38212 possible configurations of the Rubik’s Cube (“Group Theory”

10)! This number is about 5.19 x 1020, or 519 quintillion! This number is a theoretical number

because not all of these configurations can actually be reached from a solved Rubik’s Cube.

There are some moves that just can’t be done. One example is flipping the orientation of just

one edge piece. The only way to reach all of these configurations would be to physically

dismantle the cube and put it back together, altering certain cubelets. In the Rubik’s Cube, only

Gallagher 6

12 of the edge piece configurations match up with the original configuration of the cube. Only

13

of the corner piece configurations match up with the original configuration of the cube. Only 12

of the total possible configurations of the entire cube match up with the original configuration

of the cube. This claim can be shown by a specific theorem for the Rubik’s Cube:

Theorem: The total twist parity of the Rubik’s Cube cannot be changed (“Rubik’s Cube”).

To show this theorem, it’s important to understand a few more configurations that

cannot be obtained from twisting a solved cube. 1) As mentioned earlier, it is impossible to flip

the orientation of just one edge cubelet. 2) It is impossible to flip the orientation of just one

corner cubelet. 3) There is no process of moves that exchanges only two edge cubelets or two

corner cubelets (“Rubik’s Cube”). If we analyze each of these three smaller theorems, we find

out the following. Let’s say that we dismantle the cube and then put it back together; we will

obviously have choices on how we to reassemble the cube. For the first theorem there are two

possible choices: either flip the orientation of one edge cubelet or do not flip it. For the second

theorem there are three possible choices: the corner cubelet remains in its original orientation,

it is rotated once in the clockwise direction, or it is rotated once in the counterclockwise

direction. This is easy to see because each corner cubelet has three colors, allowing for three

possible orientations in its cubicle. For the third theorem there are two possible choices:

exchange two cubelets or do not exchange them. Therefore there are 2 x 2 x 3 = 12

independent ways of reassembling the cube. Only one of these 12 has the same parity of a

solvable cube (“Rubik’s Cube”).

Gallagher 7

So it has been proven that 1 in 12 possible theoretical configurations can actually be

obtained from a solved Rubik’s Cube. Therefore, we take our theoretical number of 8!12!38212

and divide it by 12 to get 4.3252 x 1019 , or 43 quintillion, possible attainable configurations

(“Group Theory” 10)!

Now for the notation of the Rubik’s Cube. It is important when solving the cube that

specific faces are targeted. This is crucial because certain twists of the cube will need to be

done to certain faces. If we set the cube down on a flat surface, there are six different faces

that can be twisted. The face on top will be called “U” for “Up.” The face on the bottom,

touching the flat surface, will be called “D” for “Down.” The faces on the left and right will be

called “L” for “Left” and “R” for “Right,” respectively. The face that we are looking at is called

“F” for “Front.” The face that is facing away from us will be called “B” for “Back.” Here is a

diagram:

F

Front

R

Right

DDown

Gallagher 8

This diagram illustrates the different faces of the Rubik’s Cube (“Mathematics of the

Rubik’s Cube” 1). Sometimes a specific cubelet may want to be addressed. Let’s say we are

looking at the F face and want to discuss the corner cubelet in the top right. This cubelet would

be called the “ufr” or “up, front, right” cubelet.

Now to discuss what it means to make a twist of one of the faces. To make a 90°

clockwise turn of the Front face is just denoted by “F.” This simply means to look at the F face

and twist it one quarter turn to the right (clockwise). The move “R” would mean to temporarily

look at the R face and make a 90° twist clockwise as well. This notation applies for all six faces

U

Up

L

Left

B

Back

Gallagher 9

of the cube. The move “F’” (the tic after the F) means to rotate the F face 90°

counterclockwise. Therefore, the move FFR’R would mean F twist clockwise, F twist clockwise,

R twist counterclockwise, R twist clockwise. These sequences of moves, such as FFR’R, are

called algorithms. An algorithm simply means a sequence of specific moves designed to reach a

specific goal. The goal in the case of the Rubik’s Cube is usually to position or orientate a

specified number of cubelets. Solving the Rubik’s Cube involves executing an algorithm(s) to

restore the cube to its original state. One much asked question is “What is the minimal number

of twists to restore the cube from any mixed up state?” The answer to this question has been

referred to as “God’s Number” (“Mathematics of the Rubik’s Cube” 3). It has been proven to be

as low as 22. This means that from any mixed up state, the cube can be solved in 22 moves or

less!

Groups

First let’s define what a group is. A group, denoted by ¿, is a set G, closed under a binary

operation ¿ , such that the following axioms are satisfied:

1) For all a, b, c ∈ G, we have

(a ¿ b) ¿ c = a ¿ (b ¿ c). Associativity of ¿

2) There is an element e in G such that for all x ∈ G,

e ¿ x = x ¿ e = x. Identity element e for ¿

3) Corresponding to each a ∈ G, there is an element a’ in G such that

a ¿a’ = a’ ¿ a = e. Inverse a’ of a (Fraleigh 37-38)

Gallagher 10

Note: A binary operation ¿ is a mapping from S x S into S (Fraleigh 20). (ex. +, /, …)

Now let’s prove that any sequence of moves performed on the Rubik’s Cube is a group.

Proof: To show this, we must show it satisfies the definition of a group as well as all three

axioms. If our group is ¿ on the Rubik’s Cube, then G and ¿ must first be defined. The set G on

the Rubik’s Cube is the set of all possible moves or sequence of moves. The binary operation ¿

is defined as M1 ¿ M2 where M1 is a move performed, followed by the execution of M2, where M2

is another move (“Group Theory” 11). It also must be shown that the set of moves is closed

under the binary operation. This is quite easy to see. If M1 is a move, and M2 is also a move,

then obviously M1 ¿ M2 is a move. Now that the set and binary operation are defined, let’s

prove the three axioms:

1) Associativity. It is important to note that a move can be defined by the change in the

configuration of the cube that it causes. So if we perform a move M1 on a cubelet, the

move puts the cubelet into another position M1(cubelet), that is the end result of the

move performed on the given cubelet. If a move M2 is then performed after M1, it puts

the cubelet into the position M2(M1(cubelet)), which equals (M1 ¿ M2)(cubelet) (“Group

Theory” 11).

For associativity, we want to show that [(M1 ¿ M2) ¿ M3](cubelet) = [M1 ¿ (M2 ¿ M3)]

(cubelet).

Gallagher 11

From what we proved above, [(M1 ¿ M2) ¿ M3](cubelet) = M3[(M1 ¿ M2)(cubelet)] =

M3[M2(M1(cubelet))].

Similarly, [M1 ¿ (M2 ¿ M3)](cubelet) = (M2 ¿ M3)[ M1(cubelet)] = M3[M2(M1(cubelet))].

Therefore, [(M1 ¿ M2) ¿ M3](cubelet) = [M1 ¿ (M2 ¿ M3)](cubelet), and ¿ is associative

(“Group Theory” 11).

2) Identity. Let e be the “do nothing move.” The “do nothing move” is defined as the

move where you do nothing to the cube. So the move M1 ¿ e = e ¿ M1 means to perform

the move M1 followed by the “do nothing move,” or do nothing to the cube (vice versa

for the other way around). This is obviously the same as performing just the M1 move.

Therefore, there is an identity element for all sequences of moves in the cube (“Group

Theory” 11).

3) Inverse. For any sequence of moves M1 you perform, you can exactly reverse the

moves. Let’s call this reverse of moves M1’. So for any given configuration state that the

cube is in, if you perform M1 and then perform M1’, you are right back to the

configuration state where you started. This would be the same as performing the “do

nothing move.” So we can see that M1 ¿ M1’ = e. Therefore, there is an inverse for all

sequences of moves in the cube (“Group Theory” 11).

Therefore, any sequence of moves performed on the Rubik’s Cube, ¿, is a group. ∎

Gallagher 12

Definition: The order of an element g in a subgroup is defined as m, such that gᵐ = e, the

identity (“Mathematics of the Rubik’s Cube” 9).

The order of an element can also determine the size of the subgroup that element

generates. We can use these ideas of order and generators to help us understand move

sequences of the Rubik’s Cube. For example: what is the order of a certain move? In other

words, how many times must that move be executed in order for the cube to be returned to its

original state, or the identity? Notice how if you perform the move FF twice to a solved cube,

the cube returns back to its solved form. FF becomes a generator of order 2.

Subgroups

Now that we know that any sequence of moves is a group, let’s further discuss some

subgroups of the cube. Since any sequence of moves can be of any length, the number of

different sequences is limitless. This is why discussing specific and limited subgroups is a

practical thought.

The F Subgroup

This subgroup is very simple and consists of all the possible configurations of the cube

that can be obtained from twisting only the F face. This subgroup contains only four elements:

the identity, the result from performing the move F, the result from FF, the result from F’.

Performing the move F four times brings the cube back to its original state (“Cube Groups”).

F = {e ,F ,FF ,F ' }

Gallagher 13

This is an example of a Cayley graph for the subgroup generated by F. A Cayley graph

allows us to gain insight into the structure of a subgroup (“Mathematics of the Rubik’s Cube”

12). Each g ϵ G, the subgroup, is a vertex:

Suppose that we wanted to draw the Cayley graph for the subgroup generated by U. It

would look exactly the same as the Cayley graph for F. If two groups have the same Cayley

graph, they essentially have the same structure and are called isomorphic (“Mathematics of the

Rubik’s Cube” 13). In the Rubik’s Cube, two isomorphic groups will have the same order and

same effect on the cube. For example, executing the algorithm FFRR is the same as turning the

entire cube to the right (so now you’re looking at the previous L face) and executing RRBB.

The Slice Squared Subgroup

Gallagher 14

This subgroup consists of all the possible configurations of the cube that can be

obtained from the following: RRLL, UUDD, FFBB. The subgroup gets its name from the fact that

performing either one of these moves is equivalent to twisting a center “slice” 180°. RRLL can

also be written as R2L2, hence the “squared” part. Let’s let X = R2L2, Y = U2D2, and Z = F2B2.

Notice that this subgroup is abelian. Performing XY gives the exact same result as performing

YX. Also notice that performing XYZ results in a “checkerboard” pattern for the cube. Since the

slice squared subgroup is abelian and each element is its own inverse, it can be represented by

the Cayley Table below:

Cayley Table of the SLICE

SQUARED Subgroup

The Slice Subgroup

E X Y Z XY XZ YZ XYZ

E E X Y Z XY XZ YZ XYZ

X X E XY XZ Y Z XYZ YZ

Y Y XY E YZ X XYZ Z XZ

Z Z XZ YZ E XYZ X Y XY

XY XY Y X XYZ E YZ XZ Z

XZ XZ Z XYZ X YZ E XY Y

YZ YZ XYZ Z Y XZ XY E X

XYZ XYZ YZ XZ XY Z Y X E

Gallagher 15

This subgroup is larger than any of the subgroups mentioned so far, but it is easy

enough to understand without too much difficulty. It consists of all the moves: RL’, UD’, and

FB’. It is called the “Slice Subgroup” because doing any of the above moves has the exact same

result as simply moving a middle “slice” (“Cube Groups”). This subgroup contains much

symmetry on each side, no matter what slice moves are performed. On each face of the cube,

all four corner piece facelets will always be the same color. Also, opposing edge piece facelets

will be the same color. The pattern would look similar to the following:

One unique pattern that can be obtained from the slice subgroup moves LR’BF’UD’LR’ is

often called “dots.” It is called this because every face of the cube has a different color center

facelet like so:

Gallagher 16

The Slice Subgroup contains the Slice Squared group as a subgroup. As shown earlier in

the table, the Slice Squared subgroup has order 8. There is a theorem called Lagrange’s

Theorem. Let’s define Lagrange’s Theorem:

Let H be a subgroup of a finite group G. Then the order of H is a divisor of the order of G

(Fraleigh 100).

Therefore, the order of the Slice Squared subgroup (8) must divide the order of the Slice

subgroup evenly. Suppose someone claimed that the order of the Slice subgroup was 108. This

person would be incorrect because 8 does not divide evenly into 108.

The (F ² R ² ) Subgroup

This is a cyclic subgroup that consists of the moves FFRR repeatedly. If we perform FFRR

6 times in a row, we will have the cube back in its starting configuration. This shows that the

subgroup is cyclic with order 6 and is generated by <FFRR>. The subgroup is also abelian of

order 6.

This subgroup has many practical uses and processes, many of which can be used when

physically solving the cube. Performing FFRR 3 times swaps exactly four cubelets: the uf, df, ur,

and dr cubelets. So when solving the cube, these cubelets can easily be swapped by twisting

only two faces. Let’s define a few terms before proceeding.

Gallagher 17

Definition: Let H be a subgroup of a group G. The subset aH = {ah | h ϵ H} of G is the left coset

of H containing a, while Ha is the right coset of H containing a (Fraleigh 97).

Definition: gxg⁻¹ is defined as a conjugation of x by g (Fraleigh 141).

We are able to create cosets of the (F²R²) subgroup now. If we perform any move

before performing FFRR, then the configuration that remains is not an element from the (F²R²)

subgroup. Rather, it is an element from one of its left cosets. If we perform a move after

performing FFRR, then the configuration that remains is also not an element from the

subgroup. Similarly, it is an element from one of its right cosets. These ideas can be elaborated

on and can create very important and useful techniques for cubing.

We have defined that multiplying a subgroup on the left by an element creates a left

coset. Similarly, multiplying a subgroup on the right by an element creates a right coset. Also,

multiplying something on the left and right by an element and its inverse, respectively, creates

a conjugate. Let’s look at some properties of conjugates:

(a * b * a⁻¹) * (a * c * a⁻¹) = a * b * (a⁻¹ * a) * c * a⁻¹ = a * (b * c) * a⁻¹

This property shows that conjugates by a are closed under the group operation (“Cube

Groups”).

(a * e * a⁻¹) = e

This property shows that the identity e is a conjugate by a (“Cube Groups”).

Gallagher 18

(a * b * a⁻¹)⁻¹ = (a * b⁻¹ * a⁻¹)

This property shows that the inverse of a conjugate by a is also a conjugate by a (“Cube

Groups”). Along with associativity, this shows that conjugates by a form a subgroup.

Here’s where the usefulness comes in. As stated earlier, performing FFRR three times

swaps two pairs of opposing edge pieces. Performing other moves three times that are similar

to FFRR will also swap opposing pairs of edge pieces. Now let’s apply this idea of conjugates to

the (F²R²) subgroup. Suppose that we do a D move, then (FFRR)³, then D’. This could also be

written as D(FFRR)³D⁻¹, which is exactly what a conjugate form looks like. It would be stated as

“a conjugate of (F²R²)³ by D.” When this sequence of moves is performed, it still swaps four

edge pieces, but they are not two pairs of opposing ones. The move swaps four completely

different and more random edge pieces. A conjugate is used to create a useful process from an

already existing sequence of moves (“Cube Groups”). This is a very common practice for speed

cubers and cubologists. Using conjugates can help create an organized plan when solving the

Rubik’s Cube.

The (FRBL) Subgroup

This is a cyclic subgroup of repetitions of the process FRBL (“Cube Groups”). Since this

group is cyclic, performing FRBL over and over again will eventually bring the cube back to its

original configuration. Let’s discuss the order of this subgroup.

If we pick up the cube and start performing the move FRBL repetitiously, we see that it

rotates and switches the orientation of corner and edge cubelets. Through experimentation,

Gallagher 19

we notice that after 5 full repetitions of FRBL, the top four corner cubelets are restored to their

original cubicle and configuration. 5 repetitions is equivalent to 20 total moves. We can also

note that after 3 repetitions of FRBL, the four top layer edge cubelets become restored. This is

equivalent to 12 total moves. So after 5, 10, 15 repetitions and after 3, 6, 9, 12, 15 repetitions,

the corner cubelets and edge cubelets will be restored, respectively. Therefore, after 15 total

repetitions, the entire top layer will be completely restored. In other words, 15 is the least

common multiple of 5 and 3 (“Cube Groups”). 15 repetitions is equivalent to 60 moves.

We will continue to analyze the order of the (FRBL) subgroup with a layer by layer

analysis. Let’s move on to the middle layer. Through experimentation, we notice that after 5

repetitions of FRBL, only one middle edge cubelet (the lf cubelet) returns to its original cubicle

and orientation. The other three middle edge cubelets are restored after 7 repetitions. These

are equivalent to 20 and 28 total moves, respectively. The least common multiple of 5 and 7 is

35. Therefore, after 35 repetitions (140 total moves) the entire middle layer will be restored

(“Cube Groups”).

Finally, we move to the bottom layer. It is found that after 7 repetitions (28 total

moves) the four bottom edge cubelets become restored. We can also notice that after 9

repetitions (36 total moves) the four bottom layer corner cubelets return to their original

positioning (“Cube Groups”). The least common multiple of 7 and 9 is 63. So after 63

repetitions, or 252 total moves, the bottom layer will be fully restored. Since the six center

facelets never change position, we do not have to bother with those.

Gallagher 20

Therefore, to find the total number of repetitions necessary to restore the entire cube,

we must analyze the required repetitions of each layer together. We found that it takes 15

repetitions, 35 repetitions, and 63 repetitions to restore the top, bottom, and middle layer

respectively. The least common multiple of 15, 35, and 63 is 315. Therefore, it will take 315

repetitions of FRBL (or 1260 total moves) to fully restore the cube back to its original

configuration (“Cube Groups”). This means that the (FRBL) subgroup has order 315.

Permutations

When performing move sequences on the Rubik’s Cube, different cubelets are

rearranged. These rearrangements can also be viewed as permutations of the cubelets. Thus,

every move sequence can be written as a permutation (“Mathematics of the Rubik’s Cube” 6).

Every algorithm that is used when solving the Rubik’s Cube is designed to rotate the

configuration or flip the orientation of specified cubelets. For example, a “corner rotation”

algorithm (a very common and easy one) rotates three top layer corner cubelets in a triangular

pattern, leaving the fourth corner cubelet alone. Let’s look at a simple permutation like this

one using numbers. We will write it in what is called cycle notation.

(1)(234)

This cycle notation generally represents the rotation of the corner pieces that is stated

above. This type of notation allows us to “read” the permutation that is occurring using cycles.

Here’s how to read this:

Gallagher 21

1) Since the 1 is by itself, the 1 stays in place and is not rearranged. The 1 in this case

represents the corner cubelet that is not affected.

2) The 2, 3, and 4 are cycled. It is read as “the 2 goes to 3, the 3 goes to 4, the 4 goes to 2.”

Once we get back to 2, the cycle is closed and starts over again. The 2, 3, and 4 in this

case represent the three corner cubelets that are being rotated, or cycled.

Let’s analyze a situation where two sequences of moves are performed back to back.

For simplicity, we will designate numbers to cubelets. Suppose you perform a move that results

in the following permutation: (124)(35). Suppose that immediately after that sequence you

perform a move that results in this permutation: (612)(34). Earlier in this paper, we explained

that our binary operation, *, represents the execution of one move followed by the execution

of another move. This would be written as (124)(35)*(612)(34). Using this, we can actually

develop a cyclic notation that represents the end result after performing these two sequences

back to back. Here’s how to develop this:

1) We start with 1 in the first permutation. 1 goes to 2. Now we move on the other

side of the binary operation and pick it up from 2. We see that 2 goes to 6 in this

permutation. We now see that 1 goes to 6. Continuing with 6, we see that 6 goes

back to 1. Therefore, the cycle is closed and 1 and 6 form a single 2-cycle

(“Mathematics of the Rubik’s Cube” 6). This looks like: (16)

2) Now we pick up 2 in the first permutation and continue in the above manner. 2 goes

to 4, then 4 goes to 3. So 2 goes to 3. In the first permutation 3 goes to 5, and there

is no 5 in the second permutation. Then 5 goes to 3, then 3 goes to 4. So 5 goes to

Gallagher 22

4. Now this cycle is closed with 4 elements in it (“Mathematics of the Rubik’s Cube”

6).

3) Now we write both cycles together to give us the ending permutation of:

(16)(2354)

If each number represents a different cubelet, we would be able to see where each

cubelet ends up after both algorithms are executed. Let’s call a permutation (a set of cycles) P.

The order, n, of a permutation is the number of times the permutation must be executed to

return to the beginning state (“Mathematics of the Rubik’s Cube” 6). If a permutation P

consists of multiple cycles of different lengths, then n is equal to the least common multiple of

all the cycles. In the latter example, the order is 4. In the prior example (the corner rotating

algorithm), the order is 3. Through experimentation, we can see that if the corner rotating

algorithm is applied three times to a solved Rubik’s Cube, the cube becomes restored back to

its original state.

Let’s take a look at another applied example of Rubik’s Cube permutations. Suppose we

execute the move DRD’R’ (this is called a commutator which will be explained later). Through

simple observation and experimentation, we can note how each individual move affects

individual cubelets.

D = (dlf dfr drb dbl)(df dr db dl). This means that the dlf corner cubelet is moved to the dfr

cubicle, the df edge cubelet is moved to the dr cubicle, etc.

R = (rfu rub rbd rdf)(ru rb rd rf)

Gallagher 23

D’ = (dbl drb dfr dlf)(dl db dr df)

R’ = (rdf rbd rub rfu)(rf rd rb ru)

Following the structure that was explained above, we have:

DRD’R’ = (dlf dfr lfd frd fdl rdf)(drb bru bdr ubr rbd rub)(df dr br)

We can now see what the exact cubicle and orientation is for each affected cubelet after

performing this algorithm. This is very helpful to understand. Notice that this permutation is a

product of three cycles, two of which have an even number of elements and one that has an

odd number of elements. A cycle with an even number of elements is odd, and a cycle with an

odd number of elements is even. These concepts of even and odd will be explain later.

As proved earlier, the Rubik’s Cube has a large number of attainable configurations.

Each though this number is large, it is still a finite number of arrangements. So logically

thinking, since there are a finite number of arrangements and each cube process is a sequence

of face turns, eventually the cube will repeat some arrangements (“Mathematics of the Rubik’s

Cube” 9). We can prove this. Let’s say that the cube begins at a solved state, e. If any

sequence of moves is executed over and over again, the cube will eventually return back to its

original solved state.

Gallagher 24

Theorem: If the cube starts at the solved state, and one move sequence P is performed

successively, then eventually the cube will return to its solved state (“Mathematics of the

Rubik’s Cube” 9).

Proof: Let P be any cube move sequence. Then at some number of times m that P is applied, it

repeats the same arrangement k, where k < m and m is the soonest an arrangement appears

for the second time. Therefore, Pᵏ = Pᵐ. If k is equal to 0, then P⁰ is equal to no moves, or the

solved state, e. Therefore, if we show that k = 0, then we have shown that the cube cycles back

to the solved state because e would be equal to Pᵐ.

1° If k = 0, then we are done since P⁰ = e = Pᵐ.

2° If k > 0, we will prove that k must be equal to 0 by a proof by contradiction. Let’s apply P⁻¹ to

both Pᵏ and Pᵐ. Applying P⁻¹ is the same as executing k-1 or m-1 moves, and we will get the

same thing since both arrangements Pᵏ and Pᵐ are the same as assumed above. Then PᵏP⁻¹ =

PᵐP⁻¹ → Pᵏ⁻¹ = Pᵐ⁻¹. But this is a contradiction since we stated that m is the first time that an

arrangement repeats. If k = 1 for example, then this means that the solved stated is reached

one move before m moves are performed; this is where the contradiction takes place.

Therefore, k must equal 0, and every move sequence on the cube must cycle through the initial

state first, before repeating other arrangements (“Mathematics of the Rubik’s Cube” 9). ▪

Gallagher 25

Parity

Any length permutation can be expressed as a product of 2-cycles (“Mathematics of the

Rubik’s Cube” 7). For example:

(1234) = (12)(13)(14)

(12345) = (12)(13)(14)(15)

The number of 2-cycles that a cycle is composed of determines whether or not the

permutation is odd or even and thus gives the parity. We can see from above that a cycle with

an even number of elements has an odd parity and vice versa (“Mathematics of the Rubik’s

Cube” 7). Now, let’s prove a very important theorem about the parity of the cube. Earlier, it

was stated that the total parity of the cube cannot be changed. The following theorem will help

to understand that, and it also helps in understanding how to solve the cube.

Theorem: The Rubik’s Cube always has even parity, or an even number of cubelets exchanged

from the starting position (“Mathematics of the Rubik’s Cube” 7).

Proof (by induction): Every sequence of moves performed on the Rubik’s Cube is a combination

of specified face turns. Let n be equal to the number of face turns executed.

1° Let n = 0. If zero moves are performed on the cube, then zero cubelets are exchanged, and

zero is even.

Gallagher 26

2° Let P(n) be even and be the parity of the cube when n moves are applied. Let’s let n = 1 and

show that P(1) is even. Let’s take a single face turn such as F. F = (fl fu fr fd)(ful fur fdr fdl). This

permutation is equal to (fl fu)(fl fr)(fl fd)(ful fur)(ful fdr)(ful fdl). There are 6 2-cycles here,

which implies that the parity of the F turn is even, and that an even number of cubelets are

exchanged. This applies to all face turns since all face turns are essentially equivalent.

Therefore, P(n) is true when n = 1.

Now assume P(n) is true and show that P(n+1) is true. The n+1 move will simply be another

face turn. Since we assumed that P(n) is true, the n+1 move will exchange an even number of

cubelets as well. Since an even number of cubelets were already exchanged before the n+1

move, an even parity of cubelet exchanges is preserved (“Mathematics of the Rubik’s Cube” 8).

▪

Now it is easier to understand what was stated earlier: There is no process of moves

that exchanges only two edge cubelets or two corner cubelets. We can see that now, because

if this move were possible, it would be a permutation of one cycle with 2 elements, thus

resulting in an odd parity. This contradicts what was just proved above.

Commutator

Gallagher 27

Move sequences of the Rubik’s Cube are not commutative. Consider the move FL, and

note the resulting configuration. The resulting configuration of the cube would not be the same

if the move LF was performed. There are ways though to measure the relative commutativity

of sequences of moves. The commutator PMP⁻¹M⁻¹, is denoted by [P,M], where P and M are

two cube moves (“Mathematics of the Rubik’s Cube” 13). If two moves P and M are

commutative, then their commutator is the identity e. This is because the P⁻¹ will cancel out

the P move and the M⁻¹ will cancel out the M move.

Let’s call the number of cubelets that are changed by a sequence of moves the support

of that sequence (“Mathematics of the Rubik’s Cube” 13). Therefore, two sequences of moves

are commutative if

1) They are the same move or

2) support(P) ∩ support(M) = Ø. This means that moves P and M affect completely

different cubelets (“Mathematics of the Rubik’s Cube” 13).

If moves P and M have affected cubelets in common, then the commutator is not the

identity. This is when we measure the relative commutativity by applying the commutator and

noting the number of affected cubelets. Predictions of relative commutativity can be made by

looking at the number of affected cubelets that the two moves have in common. Many useful

algorithms attempt to minimize the number of changed cubelets in common (“Mathematics of

the Rubik’s Cube” 13).

Gallagher 28

Let’s look at a very practical use of conjugates and commutators. There are

many different methods for solving the Rubik’s Cube, the layer method being one of them. The

bottom layer is solved first, then the middle layer, then the top layer. After solving the first two

layers, the top layer may be disarranged in many different forms. One form may include a

linear, horizontal line of the designated top layer color. In other words, some of the top layer

edge pieces may be flipped incorrectly. It would look something like this:

If we want to solve the cube, we would want to correctly flip these edge pieces, while

simultaneously leaving the bottom two layers intact. We can now use a commutator and

conjugate to solve this. Let’s use the commutator RUR’U’ (“Mathematics of the Rubik’s Cube”

15). After performing this move, seven cubelets are affected and two of them are not in the

top layer. A conjugate can be used to fix this problem, making it so that the only cubelets that

are affected are in the top layer. So if we perform F before RUR’U’, then perform F’ afterwards,

we have the complete conjugate of RUR’U’ by F (“Mathematics of the Rubik’s Cube” 15). This

results in the complete algorithm of FRUR’U’F’. Executing an F turn would result in this:

Gallagher 29

Then executing the commutator RUR’U’ would result in this:

Then executing the F’ turn to complete the conjugate would result in this:

Gallagher 30

As we can see, the top layer edge cubelets are now correctly flipped. However, this

does not mean that all of the edge cubelets are in the correct cubicle. That involves a

completely different algorithm. So anytime that an algorithm is found that rotates three pieces,

flips pieces, etc., it is possible to apply the support to desired pieces by conjugating the

algorithm with the appropriate face turn (“Mathematics of the Rubik’s Cube” 16).

Cube Solving

Now it’s time to put everything together. We have discussed notations, groups,

subgroups, permutations, parity, conjugates, and commutators. All of these things are used in

solving the Rubik’s Cube. What fun is a paper on the Rubik’s Cube and Group Theory without a

demonstration of a solving technique?

There are many different techniques that can be used to solve the Rubik’s Cube. Some are

faster than others and require fewer moves. Others may take longer and require more moves,

but are easier to execute. The level of difficulty often depends on the complexity of the

algorithms used. Every method is just a combination of many different algorithms. Some

algorithms may be upwards of 20 or more face turns. Others can be as simple as 3 face turns.

Experienced cubers have their own arsenal of algorithms memorized. This is how a

cuber is able to solve the Rubik’s Cube so quickly. They glance at the cube’s configuration,

recognize the positioning, and apply an appropriate algorithm to arrange specified cubelets.

Gallagher 31

The speed at which a cuber recognizes positioning and applies the algorithm, determines how

quickly the cube is restored to its solved state.

One method, and probably one of the quickest, is called the Petrus Method. In this

technique, a single corner cubelet is focused on. From there, a small 2x2 square is formed

around that corner piece. The correctly oriented 2x2 square is extended to a 2x2x3 rectangular

shape. This leaves most of the cube solved except for two adjacent faces. These two faces are

then rotated to correctly arrange the remaining cubelets on the cube.

Another method is sometimes called the Cross Method. This is where an “X” is correctly

formed on all six sides of the cube. This is done using simple algorithms. Then, using what is

called a “key” cubicle, the remaining edge pieces are inserted into their correct cubicles.

Finally, any middle layer cubelets that are flipped incorrectly are corrected.

One of the most trivial methods is called the Layer Method. This is the method that will

be explained and analyzed in this paper. For this method, first the bottom layer is correctly

solved using mainly recognition. Then the middle layer edge pieces are solved for. Then the

top layer is correctly solved. As one can see, this method solves from the bottom layer up.

The Layer Method

The first thing we want to do is pick a side to begin. For simplicity, we will start with

green first. Locate the green center facelet and place all four of the green edge facelets around

Gallagher 32

the center. This will create a cross patter on the green side. There aren’t really any algorithms

to do this, it is just simply recognition and a little bit of practice. It will look like this:

Search for a green corner cubelet in the bottom layer (green being the top layer). Note

the other two colors that are on that same corner cubelet. Twist the bottom layer so that the

corner cubelet is between the two faces of the same color:

Notice how the green-yellow-red corner cubelet is in the bottom layer and between the

red and yellow faces. Now here is when our first algorithm occurs. Rotate the entire cube so

that the specified corner cubelet is in the bottom right (we would be looking at the yellow face

in this example) and execute the following algorithm:

Gallagher 33

R’D’RD

Notice how this algorithm is a commutator with moves R and D. It is a very simple

commutator because it is still in the very early stages of solving the cube. If we recall, a

commutator can give us insight about the relative commutativity of two moves. Since most of

the cube is still disoriented at this point, it does not matter that this commutator has many

support pieces in common. This algorithm is executed as many times as it takes until the corner

piece is correctly placed and oriented in the top layer.

This same procedure is executed for all four green corner cubelets. If there is not a

green corner piece in the bottom layer, the above algorithm can be used to remove a green

corner piece from the top layer and put it in the bottom. The result will be the entire first layer

solved:

Now the cube is flipped over for the rest of the solving (green on bottom, blue on top).

The middle layer is next. Locate an edge piece in the top layer that does not contain blue. This

is because we want to complete the middle layer, which consists of red, yellow, orange, and

Gallagher 34

white. This edge cubelet will contain two colors and one of the facelet colors will be on the top

face. Match the other color with the matching center facelet color by twisting the top layer.

Depending on the two colors, this edge cubelet will either have to go left, or right. There are

two different algorithms for each separate case:

URU’R’U’F’UF

U’F’UFURU’R’

Gallagher 35

Both of these algorithms should be performed while looking at the red face in this

example. Now let’s take a closer look at them. Both algorithms are a pair of two different

commutators. It is one commutator followed immediately by another commutator. Notice

how these algorithms are definitely more complex than the previous one. That is because we

now have an entire green face that cannot be messed up permanently. These commutators

allow for the green face to be temporarily messed up but then fully restored at the end of the

move. Also notice how both algorithms only utilize the U, F, and R faces. This is because these

are the only faces that need to be addressed considering that the edge piece is in the U layer,

and it is placed between the F and R faces.

This same procedure is applied to all four edge pieces that do not contain blue. Just like

the previous algorithm, an edge piece can be taken from the middle layer by simply performing

one of the above formulas. This results in the first two layers being successfully solved:

Now comes the final and most challenging layer. This layer is obviously the most

challenging because it must be solved without messing up the bottom two layers. First, we

Gallagher 36

want to obtain a blue cross on top. If a blue cross already exists, then this step is over. If not,

the top layer will be in 1 of 3 configurations. One of the configurations is shown above, with a

blue “dot” in the center. The other two are as follows:

Twist the top layer so that it is positioned like one of examples above (looking at the red

face in this example) and execute:

FRUR’U’F’

This algorithm was briefly discussed earlier in this paper. If we analyze it once more we

can see that it is both a commutator and a conjugate. The algorithm is a conjugate of the

commutator RUR’U’ by F. The commutator allows to swap common support cubelets, while the

Gallagher 37

conjugate by F allows to focus the swaps on designated cubelets. This is a great example of

how commutators and conjugates are used to swap and flip certain pieces of the cube.

Applying this algorithm a certain amount of times will yield this, the blue cross:

Now that all of the blue edge cubelets are correctly oriented, we want to place them in

their correct cubicles. While looking at red, twist the top layer until the red-blue cubelet

matches with the red face. Now check to the right to see if the yellow-blue cubelet matches

with the yellow face. If not, then perform the following algorithm:

RUR’URUUR’

Execute this algorithm until the yellow matches. Then check left to see if the white-blue

cubelet matches with white. If not, look at the white face and execute the above algorithm.

This algorithm is a conjugate of UR’URUU by R. This is another great example of how a

conjugate is used. The conjugate allows for three of the top layer edge cubelets to rotate in a

Gallagher 38

clockwise direction. This is how to successfully place all of the top layer edge cubelets in their

correct cubicles:

Finally, we want to correctly place the top four corner cubelets in their designated

cubicles and then correctly orient them. The first step is to locate a corner piece that is in the

correct cubicle (not necessarily flipped correctly though). Rotate the entire cube so that this

piece is in the top right and execute the following algorithm. If there are no corner cubelets in

the correct cubicle, then execute this algorithm while looking at any side:

URU’L’UR’U’L

If we split this algorithm into two parts, it’s easier to understand. The first part is

URU’L’. The second part contains an inverse to each face turn in the first part. There’s a U and

a U’. There’s an R and an R’. There’s a U’ and a U. There’s an L’ and an L. The second part in

total is UR’U’L. This is a very unique algorithm as it rotates three of the top layer corner

cubelets in a counterclockwise direction. It must be executed as many times as need until all

four top layer corner cubelets are in their correct cubicles:

Gallagher 39

Lastly, it’s time to correctly orient all four top layer corner pieces. This is very easy.

Begin by looking at the red face and noting the corner cubelet in the top right cubicle. If it is

correctly oriented, then turn the U layer until a piece that is not correctly oriented slides into

that cubicle. Anytime that a corner piece in that exact cubicle is incorrectly flipped, simply

execute the very first algorithm (R’D’RD) as many times as need until that specified corner

cubelet is in the correct orientation. Follow this pattern (while continuing to look at the red

face) until all four corner cubelets are oriented correctly and the cube is restored to its original

state:

Gallagher 40

One may ask, “How come the entire cube stays intact when this simple algorithm is

performed?” The answer is quite simple: parity. The cube’s parity cannot be altered, so each

cubelet has the same respect relative to each other. For example: if you take a solved cube and

execute the inverse of R’D’RD three times, while following the pattern above, the cube will be

completely solved except for three flipped U layer corner cubelets. When a cube is solved, it

will always reach a point that can be reached from a solved cube. This is actually how some

algorithms are created; sequences of moves are performed backwards until something

recognizable appears.

We have not just developed a method for solving the cube, but we have done more.

We have analyzed each and every move and attempted to explain why each algorithm works,

using group theory applications.

The Rubik’s Cube is one of the most amazing puzzles in the world. To any kid, it brings

hours of play time. To any adult, it brings hours of confusion. To any mathematician, it brings

hours of conversation. Most people do not realize the mathematical nature that the Rubik’s

Cube holds. From its symmetry to its group theory applications, it’s bewildering to even the

most brilliant of minds. It’s almost unreal how such a simple looking puzzle has so much

complexity within it.