• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Sean Gallagher - Sr. Seminar Paper 40 Pages
 

Sean Gallagher - Sr. Seminar Paper 40 Pages

on

  • 579 views

Senior Paper about the Rubik\'s Cube and It\'s Group Theory Applications.

Senior Paper about the Rubik\'s Cube and It\'s Group Theory Applications.

Statistics

Views

Total Views
579
Views on SlideShare
576
Embed Views
3

Actions

Likes
0
Downloads
7
Comments
0

1 Embed 3

http://www.linkedin.com 3

Accessibility

Upload Details

Uploaded via as Microsoft Word

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Sean Gallagher - Sr. Seminar Paper 40 Pages Sean Gallagher - Sr. Seminar Paper 40 Pages Document Transcript

    • Sean Gallagher<br />Professor Ray Mest<br />Sr. Seminar, MAT 492<br />May 2011<br />The Rubik’s Cube and its Group Theory Applications<br />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. <br />Introduction<br />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:<br />
      • 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.
      • Several pieces move at once, in contrast to other puzzles that may only move one piece at a time.
      • 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).
      • 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).
      • 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)
      • 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).
      • 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 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.
      • The complexity of the cube. For such a simple looking puzzle, the complexity of the cube is remarkable.
      • 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.
      • 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).<br />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 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).<br />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.<br />Notation<br />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 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. <br />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 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:<br />Theorem: The total twist parity of the Rubik’s Cube cannot be changed (“Rubik’s Cube”).<br />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”). <br /> 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)! <br />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:<br />3190875447040RRight00RRight38823904127500-19050447040FFront00FFront8382008890000 <br />3158490715010UUp00UUp38538155016500087630050165000DDownDDown <br />38538155276850087630052768500<br />3148965193040BBack00BBack142875193040LLeft00LLeft<br />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. <br />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 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! <br />Groups<br />First let’s define what a group is. A group, denoted by G,*, is a set G, closed under a binary operation *, such that the following axioms are satisfied:<br />
      • For all a, b, c ∈ G, we have
      • (a * b) * c = a * (b * c). Associativity of *
      • There is an element e in G such that for all x ∈ G,
      • e * x = x * e = x. Identity element e for *
      • 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)
      Note: A binary operation * is a mapping from S x S into S (Fraleigh 20). (ex. +, /, …) <br />Now let’s prove that any sequence of moves performed on the Rubik’s Cube is a group.<br />Proof: To show this, we must show it satisfies the definition of a group as well as all three axioms. If our group is G,* 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:<br />
      • 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).
      • 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 G,* is associative (“Group Theory” 11).
      • 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).
      • 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, G,*, is a group. ∎<br />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). <br />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. <br />Subgroups<br />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. <br />The F Subgroup<br />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”). <br />F = e, F, FF, F'<br />1104900152019000This 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:<br />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. <br />The Slice Squared Subgroup<br />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:<br /> EXYZXYXZYZXYZEEXYZXYXZYZXYZXXEXYXZYZXYZYZYYXYEYZXXYZZXZZZXZYZEXYZXYXYXYXYYXXYZEYZXZZXZXZZXYZXYZEXYYYZYZXYZZYXZXYEXXYZXYZYZXZXYZYXE<br />Cayley Table of the SLICE SQUARED Subgroup<br />The Slice Subgroup<br />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:<br />19145254000500<br />2171700102870000One 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:<br />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:<br />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).<br />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. <br />The (F²R²) Subgroup<br />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. <br />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.<br />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). <br />Definition: gxg⁻¹ is defined as a conjugation of x by g (Fraleigh 141).<br />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.<br />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:<br />(a * b * a⁻¹) * (a * c * a⁻¹) = a * b * (a⁻¹ * a) * c * a⁻¹ = a * (b * c) * a⁻¹<br />This property shows that conjugates by a are closed under the group operation (“Cube Groups”).<br />(a * e * a⁻¹) = e<br />This property shows that the identity e is a conjugate by a (“Cube Groups”).<br />(a * b * a⁻¹)⁻¹ = (a * b⁻¹ * a⁻¹)<br />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. <br />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.<br />The (FRBL) Subgroup<br />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.<br />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, 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.<br />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”). <br />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.<br />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. <br />Permutations<br />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. <br />(1)(234)<br />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:<br />
      • 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.
      • 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:<br />
      • 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)
      • 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 4. Now this cycle is closed with 4 elements in it (“Mathematics of the Rubik’s Cube” 6).
      • 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. <br />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.<br />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.<br />R = (rfu rub rbd rdf)(ru rb rd rf)<br />D’ = (dbl drb dfr dlf)(dl db dr df)<br />R’ = (rdf rbd rub rfu)(rf rd rb ru)<br />Following the structure that was explained above, we have:<br />DRD’R’ = (dlf dfr lfd frd fdl rdf)(drb bru bdr ubr rbd rub)(df dr br)<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. <br />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. <br />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).<br />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ᵐ.<br />1° If k = 0, then we are done since P⁰ = e = Pᵐ.<br />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). ▪<br />Parity<br />Any length permutation can be expressed as a product of 2-cycles (“Mathematics of the Rubik’s Cube” 7). For example:<br />(1234) = (12)(13)(14)<br />(12345) = (12)(13)(14)(15)<br />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. <br />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). <br />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. <br />1° Let n = 0. If zero moves are performed on the cube, then zero cubelets are exchanged, and zero is even. <br />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. <br />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). ▪<br />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. <br />Commutator<br />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. <br />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 <br />
      • They are the same move or
      • 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). <br />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:<br />196278543878500<br />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:<br />184150021399500<br />Then executing the commutator RUR’U’ would result in this:<br />172212017208500<br />Then executing the F’ turn to complete the conjugate would result in this:<br />181038518415000<br />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). <br />Cube Solving<br />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? <br />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. <br />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. The speed at which a cuber recognizes positioning and applies the algorithm, determines how quickly the cube is restored to its solved state. <br />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. <br />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. <br />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. <br />The Layer Method<br />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 the center. This will create a cross patter on the green side. There aren’t really any algorithms 1857375117157500to do this, it is just simply recognition and a little bit of practice. It will look like this:<br />1971675148844000Search 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:<br />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:<br />R’D’RD<br />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. <br />2238375173863000This 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:<br />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 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 1866900139065000different algorithms for each separate case:<br />186690062166500 URU’R’U’F’UF<br /> U’F’UFURU’R’ <br />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. <br />2133600134683500This 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:<br />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 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:<br />326707572390004476757747000<br />Twist the top layer so that it is positioned like one of examples above (looking at the red face in this example) and execute:<br />FRUR’U’F’<br />2171700252984000This 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 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:<br />2181225166687500Now 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:<br />RUR’URUUR’<br />2228850242570000Execute 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 clockwise direction. This is how to successfully place all of the top layer edge cubelets in their correct cubicles:<br />2162175203835000 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:<br />URU’L’UR’U’L<br />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:<br />2190750000<br />2190750351726500Lastly, 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:<br />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.<br />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. <br />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. <br />