Algebra: Symmetry in crystals, codes, and puzzles, and what algebra still can't classify

If you've ever held a scrambled Rubik's Cube, you know how hopeless it can feel. Each of its six faces can twist, every twist scatters colors across the faces, and there seem to be endless ways to make things worse. So here is a question worth pausing on: is there a limit to how bad a scramble can get? Is there some number of moves that always suffices, however the cube has been mixed?

There is, and the number is 20. In July 2010, Tomas Rokicki, Herbert Kociemba, Morley Davidson, and John Dethridge announced that every position of the cube can be solved in 20 moves or fewer, counting any twist of a single face as one move (Rokicki et al. 2010). They also knew that some positions need all 20. The puzzle community calls this number "God's number": the fewest moves that would always suffice for someone who could see the shortest solution to every position.

The answer wasn't found by clever insight alone. The cube has 43,252,003,274,489,856,000 positions, about 43 quintillion. Checking each one separately, even at a billion positions a second, would take more than a thousand years. The team instead used about 35 CPU-years of idle computer time donated by Google (Rokicki et al. 2010). A CPU-year is the work one computer processor does in a year of continuous running.

Even 35 CPU-years would not have been enough without mathematics. Here is where algebra enters. The cube's moves form a group: a collection of actions that can be combined, that includes a "do nothing" action, and in which every action can be undone. Any twist can be reversed, and any two sequences of twists combine into a third. Thinking of the cube this way let the team split its positions into large, evenly sized sets and treat each set as a single job. The cube's own symmetries cut the work further. A position and its mirror image, or the same position seen with the cube turned around, need the same number of moves, so those cases needed solving only once (Rokicki et al. 2010).

What the branch offers here is a single framework for any system of reversible moves. The same three rules describe the symmetries of a triangle, the twists of a cube, and the rearrangements of an equation's solutions. Once you know a system follows those rules, every fact proved about groups applies to it. In the cube's case, that turned a search far too large to run into one that a large computer cluster could finish.

This content reflects the field as of October 2026.

References

• Rokicki, Tomas, Herbert Kociemba, Morley Davidson, and John Dethridge. 2010. "God's Number Is 20." Cube20.org.
  • Free: Cube20.org

Introduction

Salt, quartz, and snowflakes all have a regular, repeating structure that you can sometimes see with the naked eye. Group theory gave crystal scientists a complete list of the ways such a structure can be symmetric, and there turn out to be exactly 230. This reading covers what a crystal's symmetries are, how that number was found, and how crystallographers use the list.

A Crystal as a Repeating Pattern

A crystal is a solid whose atoms are arranged in a pattern that repeats in every direction. A grain of table salt, for example, is a regular stacking of sodium and chlorine atoms. Because the pattern repeats, it has symmetries: moves of space that leave the whole pattern looking exactly the same.

A crystal pattern can have three kinds of symmetry:

• Rotations, which turn the pattern about an axis.
• Reflections, which mirror it across a plane.
• A translation, which shifts the whole pattern a fixed distance in a fixed direction without turning it.

A tiled floor of identical square tiles shows all three in two dimensions, if you treat the floor as going on forever. A quarter-turn about the center of any tile leaves the pattern unchanged. So does a flip across a line through the middle of a row of tiles, and so does a shift of exactly one tile in any direction along the rows.

Translations are what make a crystal different from a single shape. A triangle cut from paper has no translation symmetry; slide it, and it leaves its outline. An idealized crystal, treated as repeating without end, can be shifted by one repeat and land on itself.

All the symmetries of a crystal pattern, taken together, follow the same three rules as any group. Doing one symmetry and then another gives a symmetry. Doing nothing is a symmetry. Every symmetry can be undone. The group of all symmetries of a three-dimensional crystal pattern is called its space group.

Exactly 230 Possibilities

Not every collection of rotations, reflections, and translations can be the symmetry group of a repeating pattern. The requirement that the pattern repeat in three directions rules many out. So a natural question arose in the 19th century: how many different space groups are possible?

The answer is 230. The crystallographer Leonhard Sohncke had derived 65 of them, the groups built only from moves that don't mirror the pattern. Adding the groups that include mirror-type moves brought the total to 230. Two researchers reached this list independently: Evgraf Fedorov in St. Petersburg, in a work of 1890, and Arthur Schoenflies in Germany, whose book on crystal systems and structure appeared in 1891 (Ewald 1962).

This result is a classification: a complete list of every possible case of some kind of object, with a proof that the list misses none. It was worked out before anyone could see the arrangement of atoms in a real crystal; X-ray methods for doing that arrived only in the 20th century (Ewald 1962).

How Crystallographers Use the List

The 230 space groups are now standard reference material. The International Union of Crystallography publishes diagrams and data tables for all 230 in International Tables for Crystallography, Volume A, which serves professional crystallographers as well as chemists, physicists, mineralogists, biologists, and materials scientists (Aroyo 2016).

Describing a crystal starts with its space group. Once the space group is known, a scientist only needs to give the positions of a few atoms; the symmetries produce the rest of the pattern. The space group also limits which structures are possible, which narrows the search when a new crystal is being identified.

Conclusion

A crystal's symmetries form a group, called its space group, built from rotations, reflections, and translations. Fedorov and Schoenflies independently showed that exactly 230 space groups exist in three dimensions. That classification remains the standard framework for describing crystal structures.

This content reflects the field as of October 2026.

Key Terms

• Crystal: A solid whose atoms are arranged in a pattern that repeats in every direction.
• Translation: A move that shifts a whole pattern a fixed distance in a fixed direction without turning it.
• Space group: The group of all symmetries of a three-dimensional crystal pattern.
• Classification: A complete list of every possible case of some kind of object, with a proof that the list misses none.

References

• Aroyo, M. I., ed. 2016. International Tables for Crystallography. Vol. A, Space-Group Symmetry. 6th ed. Chester, UK: International Union of Crystallography. doi:10.1107/97809553602060000114.
  • Free: None
  • Publisher: International Union of Crystallography: International Tables, Volume A
• Ewald, P. P., ed. 1962. Fifty Years of X-Ray Diffraction. Utrecht: International Union of Crystallography. Section on Arthur Schoenflies. Digitized edition 1999.
  • Free: IUCr: Schoenflies

Introduction

Every stored file and transmitted message is a long string of 0s and 1s, and some of those bits get flipped along the way. Most of the time you never notice, because the data carries enough structure for a machine to find and fix the damage itself. This reading covers the problem that started the field, the idea of structured redundancy, the (7, 4) Hamming code, and the algebra that makes decoding systematic.

A Problem at Bell Labs

In the late 1940s, Richard Hamming worked with relay computers at Bell Telephone Laboratories. The machines could detect some errors, but detecting an error was not the same as fixing it. The computers ran unattended over nights and weekends, and a single failure could bring a long computation to a halt (Hamming 1950, 147–148).

Hamming's 1950 paper asked a sharper question. If a machine can tell that an error happened, can it also tell where, and fix it? For binary data the answer to "where" is enough, because a wrong bit can only be a 0 that should be a 1, or the reverse. Flip it back and the error is gone.

Structured Redundancy

An error-correcting code is a way of adding extra bits to data so that a receiver can find and fix errors without asking for the data again. The extra bits are redundancy: information beyond the data itself, included only to protect it.

The simplest form of redundancy is repetition. Send every bit three times and take a majority vote at the other end. That works, but it triples the length of every message. Hamming's codes do better by adding a few bits arranged with care.

The basic tool is a parity bit: an extra bit chosen so that a given group of bits contains an even number of 1s. If one bit in that group flips, the count becomes odd, and the receiver knows something went wrong. One parity bit detects an error but can't say where it is. Hamming's insight was to use several parity bits, each covering a different overlapping group of positions, arranged so that each possible single error fails a different combination of checks. That combination, read as a binary number, gives the position of the error (Hamming 1950, 150–153).

The (7, 4) Hamming Code

In the Hamming code with seven positions, four positions carry data and three carry parity bits. The parity bits sit in positions 1, 2, and 4, and the data in positions 3, 5, 6, and 7 (Hamming 1950, 151–152). It is called the (7, 4) code: 7 bits sent, 4 of them data.

Each allowed string of seven bits is a codeword. With four data bits there are 2^4 = 16 possible messages, so the code has 16 codewords (Hamming 1950, 153). Any single flipped bit turns a codeword into a string that isn't a codeword, and the three parity checks say which bit to flip back. Two flipped bits are a different matter: the code then points to the wrong position.

Why the Algebra Helps

The 16 codewords have a structure that makes decoding systematic. Add two bit strings position by position, with the rule that 1 + 1 = 0, so a 1 and a 1 give 0 and a 1 and a 0 give 1. Hamming used this arithmetic in his paper (Hamming 1950, 157). Under this addition, the sum of any two codewords is again a codeword. For example, 1110000 + 1001100 = 0111100, and all three are codewords.

That makes the codewords a group. Adding two gives another codeword, the all-zero string acts as "do nothing," and every codeword undoes itself, because adding any string to itself gives all zeros. Because of this structure, the receiver doesn't need a list of all 16 codewords. Three parity checks, the same for every message, are enough to locate any single error.

Present-Day Descendants

Many codes have followed Hamming's. Some use more elaborate algebra to correct many errors at once. Reed–Solomon codes, introduced in a 1960 paper, are one example. Codes of that family protect data on CDs and DVDs, are built into QR codes, and support communication with spacecraft in deep space (MIT Lincoln Laboratory n.d.).

Conclusion

Error-correcting codes add structured redundancy, so a receiver can repair damaged data without asking for it again. Hamming's (7, 4) code fixes any single flipped bit with three parity checks, and its codewords form a group under bitwise addition. More powerful codes built on the same principle now protect stored and transmitted data.

This content reflects the field as of October 2026.

Key Terms

• Error-correcting code: A way of adding extra bits to data so that a receiver can find and fix errors without asking for the data again.
• Redundancy: Information added beyond the data itself, included only to protect it.
• Parity bit: An extra bit chosen so that a given group of bits contains an even number of 1s.
• Hamming code: A code in which several parity bits cover overlapping groups of positions, so that the failed checks give the position of a single error.
• Codeword: One of the allowed strings of bits in a code.

References

• Hamming, R. W. 1950. "Error Detecting and Error Correcting Codes." Bell System Technical Journal 29 (2): 147–160.
  • Free: Internet Archive: BSTJ 29:2
• MIT Lincoln Laboratory. n.d. "Empowering Digital Communications." Accessed October 13, 2026.
  • Free: MIT Lincoln Laboratory: Empowering digital communications

Introduction

A Rubik's Cube is a toy, but its moves follow the same rules as the symmetries of a crystal or the rearrangements of an equation's solutions. Treating the cube as a group made it possible to answer a question that brute force alone could not. This reading covers the cube's group, the number of its positions, how symmetry cut the work, and what the 2010 result shows about proofs that rely on computers.

The Cube's Moves Form a Group

Each twist of a face is an action on the cube. You can do one sequence of twists and then another, and the result is again a sequence of twists. Doing nothing leaves the cube unchanged. Every twist can be undone by twisting the same face back, so every sequence can be undone by reversing it.

Those are the three rules of a group, with composition as the way of combining: doing one action and then another. The collection of all twist sequences, where two sequences count as the same when they rearrange the cube the same way, is the cube group. Each element of the group corresponds to one position: an arrangement of the cube's pieces that can be reached from the solved cube by twisting.

How Many Positions

The cube has exactly 43,252,003,274,489,856,000 positions (Rokicki et al. 2010). That is about 43 quintillion, or about 4.3 \times 10^{19} in scientific notation, where 10^{19} means 1 followed by 19 zeros.

The question that puzzle solvers and mathematicians pursued for decades was how far the farthest position is from solved. God's number is the smallest number of moves that is always enough to solve the cube, from any position. To find it, you need to know the shortest solution for the hardest position, which means, in principle, dealing with all 43 quintillion.

The answer depends on what counts as a move. In the half-turn metric, any twist of one face, whether a quarter-turn or a half-turn, counts as one move. In that metric, God's number is 20 (Rokicki et al. 2010). If only quarter-turns count as single moves, the number is 26.

How Symmetry Cut the Work

Rokicki, Kociemba, Davidson, and Dethridge did not solve 43 quintillion positions one at a time. They used the group structure in two ways (Rokicki et al. 2010).

First, they split the positions into 2,217,093,120 sets of 19,508,428,800 positions each, using a subgroup of the cube group: a smaller group of moves inside it. Each set could be handled as one job by a fast program.

Second, they used the cube's symmetry. Turning the whole cube, or viewing it in a mirror, changes how a position looks but not how many moves it needs. Treating such equivalent positions as one gave a reduction by a factor of about 48. Combined with a covering argument, it cut the number of sets to solve from about 2.2 billion to 55,882,296. The remaining work took about 35 CPU-years of computer time donated by Google.

A Computer-Assisted Proof

The 2010 result is a computer-assisted proof: a proof in which part of the argument is a calculation too long for a person to check by hand, carried out by a program. The mathematics shows that the computation covers every case. The computer does the checking.

Proofs like this raise a fair question: how do you trust a calculation no person can repeat by hand? The usual answers are careful program design, independent checks, and making the method public so others can test it.

Conclusion

The cube's twists form a group with about 4.3 \times 10^{19} elements, one for each position. Using that structure and the cube's symmetries, a team proved in 2010 that every position can be solved in 20 moves or fewer in the half-turn metric. The result shows algebra and large-scale computation working as parts of a single proof.

This content reflects the field as of October 2026.

Key Terms

• Cube group: The group of all twist sequences of a Rubik's Cube, where two sequences count as the same when they rearrange the cube the same way.
• Position: An arrangement of the cube's pieces that can be reached from the solved cube by twisting.
• God's number: The smallest number of moves that is always enough to solve the cube, from any position.
• Computer-assisted proof: A proof in which part of the argument is a calculation too long for a person to check by hand, carried out by a program.

References

• Rokicki, Tomas, Herbert Kociemba, Morley Davidson, and John Dethridge. 2010. "God's Number Is 20." Cube20.org.
  • Free: Cube20.org

Introduction

Some questions in algebra took one person a lifetime; one took a large community of mathematicians several decades and hundreds of papers. This reading covers that finished project, the classification of finite simple groups, and a question about equations and groups that is still open: the inverse Galois problem.

Simple Groups as Building Blocks

Every whole number greater than 1 can be broken into prime numbers, which can't be broken further. Finite groups behave in a similar way. A finite group, one with a limited number of elements, can be broken down into smaller pieces called simple groups. A simple group is a group that can't be broken down this way; simple groups are the building blocks of all finite groups, as primes are the building blocks of whole numbers under multiplication (Solomon 2018).

So a natural project is to list every finite simple group. Such a classification is a complete list of every possible case of some kind of object, with a proof that the list misses none.

The Classification

The answer is that the finite simple groups fall into a few infinite families, plus 26 exceptions called sporadic groups (Solomon 2018). The largest sporadic group is known as the Monster.

Reaching that answer was a project that Ronald Solomon, one of its participants, describes as running about 110 years from its beginnings (Solomon 2001). Its proof was spread over hundreds of journal articles by many authors (Solomon 2018). When it was finished depends on what you count:

• In 1981 the project appeared to be nearing its conclusion (Solomon 2018).
• The culminating piece of the original project, Michael Aschbacher and Stephen D. Smith's treatment of a class called quasithin groups, was published in 2004 (Solomon 2018).
• Daniel Gorenstein, Richard Lyons, and Solomon set out to write a unified, revised proof in a planned series of twelve volumes. The first six appeared between 1994 and 2005, and a seventh had just appeared at the time of a 2018 progress report (Solomon 2018).

The theorem is widely used today. The revision was undertaken because the original proof was scattered over hundreds of journal articles, some of which cited work that was never published (Solomon 2018). Whether to date the classification's completion to the early 1980s, to 2004, or to the end of the revision is a matter of judgment.

An Open Question: The Inverse Galois Problem

Every equation built from whole numbers has a Galois group: the group of rearrangements of an equation's solutions that keep every relationship among them true. The inverse Galois problem runs the question backward. Given any finite group, is there an equation with whole-number coefficients whose Galois group is that group?

The answer is known to be yes for many groups. It holds for every finite abelian group, a group in which the order of combining never matters. It holds for the group of all rearrangements of a list of any length. In 1954 Igor Shafarevich showed that it holds for every solvable group, a large class of groups that can be broken down step by step into simple layers of a particular kind; his proof had inaccuracies that were corrected later (Jensen 2011). By 2011 it was known for 25 of the 26 sporadic groups, all except one called M_{23} (Jensen 2011).

In August 2026, six mathematicians posted a preprint giving an explicit equation of degree 23 whose Galois group is M_{23} (Huang et al. 2026). A preprint is a paper shared publicly before formal peer review. If it holds up, every sporadic group is now known to occur. The general problem remains an open problem, a question that is precisely stated and unsolved: no one knows whether every finite group occurs.

Conclusion

The classification of finite simple groups lists the building blocks of all finite groups, and most mathematicians regard it as complete, though a revised proof is still being written. The inverse Galois problem remains open. Recent work has filled in individual groups, including a 2026 preprint on M_{23}, but the general question is unanswered.

This content reflects the field as of October 2026.

Key Terms

• Simple group: A group that can't be broken down into smaller groups; simple groups are the building blocks of all finite groups.
• Classification: A complete list of every possible case of some kind of object, with a proof that the list misses none.
• Inverse Galois problem: The question of whether every finite group is the Galois group of some equation with whole-number coefficients.
• Open problem: A precisely stated mathematical question that no one has yet answered.

References

• Huang, Xiaoyu, Blake Jackson, Kyu-Hwan Lee, Bjorn Poonen, Rachel Pries, and Shaowu Zhang. 2026. "The Mathieu Group M_{23} Is a Galois Group over \mathbb{Q}." arXiv:2608.08538. Preprint.
  • Free: arXiv 2608.08538
• Jensen, Christian U. 2011. "The Inverse Problem of Galois Theory." Normat 59 (3–4): 131–143.
  • Free: Normat (PDF)
• Solomon, Ronald. 2001. "A Brief History of the Classification of the Finite Simple Groups." Bulletin of the American Mathematical Society 38: 315–352.
  • Free: American Mathematical Society
• Solomon, Ronald. 2018. "The Classification of Finite Simple Groups: A Progress Report." Notices of the American Mathematical Society 65 (6): 646–651. doi:10.1090/noti1689.
  • Free: Notices of the AMS (PDF)

Introduction

A Hamming code can tell a receiver not only that a bit was damaged in transit, but which one. That sounds like it should need a lot of extra data. It needs three extra bits for every four bits of message. This walkthrough encodes a four-bit message, damages one bit, and then finds and repairs the damage using nothing but counting.

The Starting Point

The message is four bits, the 0s and 1s that computers use to store everything:

You'll send it using the seven-position code that Richard Hamming described in 1950, often called the (7, 4) Hamming code: 7 bits are sent, and 4 of them carry the message (Hamming 1950, 151–153). The other three are parity bits. A parity bit is an extra bit chosen so that a given group of bits contains an even number of 1s.

The seven positions are numbered 1 through 7. Positions 1, 2, and 4 hold the parity bits. Positions 3, 5, 6, and 7 hold the message (Hamming 1950, 152). Each parity bit watches its own group of positions:

The groups aren't arbitrary. Write each position number in binary, using the place values 4, 2, and 1. Position 6 is 4 + 2, so it's covered by check 4 and check 2. Position 5 is 4 + 1, so it's covered by checks 4 and 1. Each position is covered by exactly the checks that add up to its number (Hamming 1950, 151–152). That is the design choice that will let the checks name a position.

Somewhere between sender and receiver, one bit will flip.

Walking Through the Encoding and Decoding

Step 1: Place the message bits

Put the four message bits, in order, into positions 3, 5, 6, and 7. Leave positions 1, 2, and 4 empty for now.

Step 2: Set the three parity bits

Fill each parity position so that its check group has an even number of 1s.

• Check 1 covers positions 1, 3, 5, 7. Positions 3, 5, 7 hold 1, 0, 1: two 1s, already even. So position 1 gets 0.
• Check 2 covers positions 2, 3, 6, 7. Positions 3, 6, 7 hold 1, 1, 1: three 1s, which is odd. So position 2 gets 1, making four.
• Check 4 covers positions 4, 5, 6, 7. Positions 5, 6, 7 hold 0, 1, 1: two 1s, already even. So position 4 gets 0.

The word you send, positions 1 through 7, is

This seven-bit string is a codeword: one of the 16 allowed strings in the code, one for each possible four-bit message.

Step 3: Flip one bit to simulate an error

During transmission, the bit in position 6 flips from 1 to 0. The receiver gets

The receiver doesn't know which bit changed, or whether any did. All it has is these seven bits and the rule that each check group should have an even number of 1s.

Step 4: Recompute the checks and read the failures as a number

The receiver counts the 1s in each check group of the received word. A check passes (written 0) if the count is even and fails (written 1) if it's odd.

• Check 1, positions 1, 3, 5, 7: bits 0, 1, 0, 1. Two 1s, even. Passes: 0.
• Check 2, positions 2, 3, 6, 7: bits 1, 1, 0, 1. Three 1s, odd. Fails: 1.
• Check 4, positions 4, 5, 6, 7: bits 0, 0, 0, 1. One 1, odd. Fails: 1.

Now write the results in the order check 4, check 2, check 1: that gives 1, 1, 0. Read as a binary number, 110 means 4 + 2 + 0 = 6. Hamming called this the checking number (Hamming 1950, 150). It points at position 6, which is the bit that flipped.

Why does it work? Position 6 is covered by checks 4 and 2 and by no other check. Flipping it changes the count in exactly those two groups, from even to odd. A flip in any other single position would fail a different combination of checks, so each single error leaves its own signature. If no bit had flipped, all three checks would pass and the checking number would be 0, meaning no error.

Step 5: Flip the bad bit back and recover the message

Flip position 6 from 0 back to 1. The corrected word is

which matches the codeword that was sent. Read the message positions 3, 5, 6, and 7: they hold 1, 0, 1, 1. The message 1011 is recovered, and the receiver never had to ask for it again.

Key Considerations

One error, not two. This code is built to correct a single flipped bit. With two flips, it goes wrong in a specific way. Suppose positions 1 and 2 both flip, so the receiver gets 1010011. Check 1 now fails, check 2 fails, and check 4 passes, giving the checking number 011, which is 3. The receiver flips position 3, which was correct, and ends up with three wrong bits instead of two. Hamming's paper also shows how one more parity bit, covering the whole word, lets a receiver detect that two errors occurred, though not where (Hamming 1950, 153–154).

The common mistake: thinking the extra bits are copies of the data. It's natural to assume that error correction works by sending the data more than once. A Hamming code doesn't repeat anything. Each parity bit summarizes a different overlapping group of positions, and it's the pattern of overlaps that locates an error. Copying would need far more bits. Sending each of the four message bits three times takes 12 bits, while the Hamming code takes 7 and still corrects any single error.

Order matters when you read the checks. The checking number is read with check 4 first and check 1 last, because those are the binary place values 4, 2, and 1. Reading the results in the other order, 011 instead of 110, would point to position 3 and introduce a new error.

What the receiver needs. The receiver doesn't store a list of the 16 codewords. The three checks are the same for every message, so the same few counts work for any word that arrives.

Summary

The four-bit message 1011 was encoded into seven bits, damaged in one position, and repaired by three parity checks whose failures, read in binary, named the damaged position.

Stage	Bits in positions 1 to 7	Check 4, check 2, check 1	Verdict
Sent word	0 1 1 0 0 1 1	0, 0, 0	Codeword
Received word	0 1 1 0 0 0 1	1, 1, 0	Checking number 6: error in position 6
Corrected word	0 1 1 0 0 1 1	0, 0, 0	Codeword; message 1011 recovered

1. The parity bits in positions 1, 2, and 4 are set so that each check group has an even number of 1s.
2. The failed checks, read as the binary number 110, give the error position 6.
3. The corrected word passes all three checks, and positions 3, 5, 6, and 7 return the original message.

References

• Hamming, R. W. 1950. "Error Detecting and Error Correcting Codes." Bell System Technical Journal 29 (2): 147–160.
  • Free: Internet Archive: BSTJ 29:2