• 🍎 “Rubik’s Cube group,” symmetries of a shape, modular arithmetic ring puzzles.

• 🍐 The unsolvable angle-trisection puzzle, building finite fields.

Abstract Algebra is the study of sets and the operations defined on them, following specific rules. The key objects we study are:

1️⃣ Groups: A set with a single operation (like addition or multiplication) that follows four key properties.

2️⃣ Rings: A set with two operations, like addition and multiplication (e.g., integers).

3️⃣ Fields: A ring where division (except by zero) is possible (e.g., rational numbers).

---
config:
  look: handDrawn
  theme: dark
---
flowchart TD
div((("÷")))
mult((("✖")))
sum((("✚")))
set((("｛｝")))
closure@{ shape: stadium, label: "Closure"}
assoc@{ shape: stadium, label: "Association"}
ident@{ shape: stadium, label: "Identity"}
invr@{ shape: stadium, label: "Inverse: "}
closure2@{ shape: stadium, label: "Closure"}
assoc2@{ shape: stadium, label: "Association"}
ident2@{ shape: stadium, label: "Identity"}
invr2@{ shape: stadium, label: "Inverse"}
leftDist@{ shape: stadium, label: "Left Distributive"}
rightDist@{ shape: stadium, label: "Right Distributive"}
style set fill:#900,stroke:#100,stroke-width:4px
style sum fill:#090,stroke:#010,stroke-width:4px
style mult fill:#009,stroke:#001,stroke-width:4px
style div fill:#504,stroke:#101,stroke-width:4px
style FIELD fill:#302,stroke:#f0f,stroke-width:7px
style RING fill:#005,stroke:#00f,stroke-width:7px
style GROUP fill:#050,stroke:#0f0,stroke-width:7px
style SET fill:#500,stroke:#f00,stroke-width:7px
subgraph FIELD
 subgraph RING
  subgraph GROUP
    sum <--(a＋b)∈𝔸--> closure 
    sum <--(a＋b)=(b+a)--> assoc 
    sum <-- a+𝕚=a --> ident
    sum <-- a+a̚=𝕚 --> invr
    subgraph SET
        direction RL
        set 
        end
     end
  mult
  closure2 <-- (a⨯b)∈𝔸 --> mult
  assoc2 <-- (a⨯b)=(b⨯a) --> mult
  ident2 <-- a⨯𝕚=a --> mult
  invr2 <-- a⨯ä=𝕚 --> mult 
  leftDist <-. a⨯(b+c)=(a⨯b)+(a⨯c).-> mult
  rightDist <-.(b+c)⨯a=(b⨯a)+(c⨯a).-> mult
  end
div
end

Imagine you join an underground math society 🤓📜, and they have a secret handshake to recognize each other. The handshake follows these rules:

• Every member starts with an open hand, palm up.
  • $✋ = H_0$
• A handshake can be one of two actions:
  1. Flip: Turn your hand (palm up ↔ palm down).
     • 🫳 ↔ 🫴
  2. Rotate Fingers: Open/Close your hand, thumb out.
     • 👍 ↔ ✋

The goal is to understand the difference and explore if these operations form a mathematical structure.

There are four unique states:

• $H_0$ = palm up, fingers up. ✋
• $H_1$ = palm up, fingers down. 👍
• $H_2$ = palm down, fingers up. 👎
• $H_3$ = palm down, fingers down. 🤚

---
config:
  look: handDrawn
  theme: dark
  
---
flowchart LR
    A@{ shape: circle, label: "H0✋" }
    B@{ shape: dbl-circ, label: "H1👍" }
    C@{ shape: dbl-circ, label: "H2👎" }
    D@{ shape: dbl-circ, label: "H3🤚" }
    A ==>|R| B 
    A ==>|F| D
    B ==>|R| A
    B ==>|F| C
    C ==>|R| D
    C ==>|F| B
    D ==>|R| C
    D ==>|F| A
    linkStyle 0,2,4,6 stroke: gold
    linkStyle 1,3,5,7 stroke: tomato

The challenge:

Two flips bring you back to the original position.

You return to the starting position too.

Only if both Rotations and Flips are even.

A group needs four properties:

• ✅ Closure: If you perform $F$ or $R$, you stay within the four hand positions.
• ✅ Identity Element: There must be a "do nothing" move (which is just keeping your hand still). $(I)$
• Inverse: Every action must have an undo.
  • ✅ $F$ is its own inverse: $F+F=I 👉 H_0 ( F+ F) =H_0​ 👉 F = ￢F$
  • ✅ $R$ is also its own inverse: $R+R 👉 H_0 ( R+ R) =H_0​ 👉 R = ￢R$ ​
  • ✅ Associativity: If you do three moves in a row, the order grouping shouldn’t matter. This works here!

Now, let's take a real-world example: The Rubik's Cube. Each move of the cube (like rotating a face) is an operation that can be undone.

Understanding how a sequence of moves on a Rubik’s Cube can form a group and how different subgroups exist within it.

This is an example of a Group because:

• There's a set of moves.
• You can "combine" moves (closure).
• There's a "neutral" move (identity).
• Every move has an "undo" (inverse).

1. If you do one move, can you undo it with another move?
   • Yes! If you rotate a face clockwise, you can then rotate it counterclockwise to go back to the previous shape. Mathematically, this means every element in the group has an inverse. For:

• $R$: Right face clockwise turn
• $R^{−1}$: Right face counterclockwise turn
• $U$: Upper face clockwise turn
• $U^{−1}$: Upper face counterclockwise turn

2. Can you apply a sequence of moves to return to the original state?
   • Well, if you can reverse any move, and if you started at the solved cubed state (Identity), of course you can go back to the original state! But there are many ways to do so, because for every Face Rotation $M$

3. What is the minimum number of moves that return the cube to its original position?

• A good guess is the inverse path we took to scramble it, but there might be a quicker way.
• Some sequences have a natural order (like a cycle of length 6 for the sexy move $(RUR^{−1}U^{−1})$ ).
• The maximum sequence length before a cube state repeats is God’s Number: $\color{gold}20$. This means any cube position can be solved in 20 moves or fewer! However, some specific sequences repeat much sooner than that, especially when looking at smaller subgroups of the full Rubik’s Cube group.

Understand how permutations and subgroups appear in Sudoku and how abstract algebra helps us analyze the possible number placements.

Imagine you are solving a partially filled Sudoku grid. The key rule in Sudoku is: Each row, column, and 3×3 box must contain the numbers 1–9 exactly once.

Let's create a 4-Sudoku (a mini Sudoku with a 4×4 grid) and explore how permutations and group structures appear! 🔢🎲

A 4×4 Sudoku follows similar rules as a standard Sudoku but is simplified:

• We use only the numbers {1, 2, 3, 4}.
• Each row and column must contain all four numbers exactly once.
• Each 2×2 sub-grid must also contain {1, 2, 3, 4} exactly once.

Here’s an example of a solved 4×4 Sudoku matrix:

A valid transformation should maintain the Sudoku rule that each row, column, and 2×2 box contains exactly {1, 2, 3, 4}.

The valid moves (permutations) that keep a Sudoku solution valid are:

• 1️⃣ Row swaps within a "band" (group of two rows)
• 2️⃣ Column swaps within a "stack" (group of two columns)
• 3️⃣ Band swap
• 4️⃣ Stack Swap
• 5️⃣ Permutation of numbers (relabeling 1↔2, 3↔4, etc.)

Let's apply valid permutations that still obey Sudoku rules!

We'll start with this valid solved Sudoku:

✅ Each row, column, and 2×2 block contains {1, 2, 3, 4} exactly once.

Now, let's apply valid row swaps (which form a subgroup of $( S_4 )$ ).

We can swap rows within a 2-row "band" while preserving the Sudoku structure.

Applying the permutation $( (1 \leftrightarrow 2) )$ in rows:

This swap is valid because:

• Every row still contains {1, 2, 3, 4} exactly once.
• Every column still contains {1, 2, 3, 4} exactly once.
• The 2×2 regions remain valid.

Applying ( $(3 \leftrightarrow 4)$ ):

Again, Sudoku rules are preserved! ✅

These row swaps form a subgroup of $( S_4 )$ , where each element represents a valid row permutation.

Similarly, column swaps within a stack maintain Sudoku rules.

Applying $( (1 \leftrightarrow 2) )$ :

✅ Still a valid Sudoku!

These column swaps also form a subgroup of $( S_4 )$ .

All valid row and column swaps form a permutation group:

• The set of all valid Sudoku transformations forms a subgroup of $( S_4 )$.
• These operations obey group axioms:
  • Closure: Any swap results in another valid Sudoku. ✅
  • Identity: Doing nothing (identity permutation) keeps the grid unchanged. ✅
  • Inverse: Every swap can be undone. ✅
  • Associativity: Order of operations follows function composition. ✅

Together, these moves form a symmetry group describing all possible equivalent Sudoku solutions.

A subgroup is a smaller group inside a larger group that inherits the same properties (closure, identity, inverses, associativity).

Mathematically, a subset $(H)$ of a group $(G)$ is a subgroup if and only if:

1. Closure:
   • If $(a, b \in H)$ , then $(a \cdot b \in H)$ (applying any two elements results in another element in the subgroup).
2. Identity:
   • $(H)$ contains the identity element of $(G)$ (the "do-nothing" operation).
3. Inverses:
   • If $(a \in H)$ , then $( a^{-1} \in H)$ (each element has an inverse in $( H )$ ).
4. Associativity:
   • This follows automatically if $(H \subseteq G)$ , since it inherits this property from $(G)$ .

In 4-Sudoku, the larger group $(G)$ is the symmetric group $(S_4)$ , which consists of all possible permutations of valid elements (reordering numbers 1–4). However, not all permutations keep the Sudoku valid, so we focus on special subgroups.

In 4×4 Sudoku, we identified valid transformations (row swaps, column swaps, and number reassignments, swaps of stacks and swap of band swap) that preserve the Sudoku rules. These valid moves form subgroups of $(S_4)$ :

• We can swap entire rows within a band (e.g., swapping row 1 with row 2, or row 3 with row 4).
• This forms a subgroup of $(S_4)$ because:
  • If we swap rows twice, we return to the original order (inverse exists).
  • Swapping rows is associative.
  • The identity (doing nothing) is included.

Thus, row swaps within a band form a subgroup of the symmetric group $(S_4)$ .

🔢 **Example of $( H_{\text{rows}})$ with two elements (permutations of rows 1 & 2):

where:

• $( e )$ is the identity (no swap).
• $( (1 \leftrightarrow 2) )$ swaps rows 1 and 2.

Adding more swaps (e.g., swapping rows 3 and 4) expands this subgroup.

• We can swap entire columns within a stack (e.g., swapping column 1 with column 2).

• These swaps also follow group axioms, forming another subgroup.

🔢 Example of $( H_{\text{cols}} )$ with two elements (permutations of columns 1 & 2):

Just like row swaps, these column swaps create a valid subgroup.

• Instead of swapping rows or columns, we can swap number labels.
• Example: If we replace all 1s with 2s and vice versa, we get a different valid Sudoku.

🔢 Example subgroup of number swaps:

Each element is a valid permutation that transforms one solution into another while preserving Sudoku constraints.

In a 4×4 Sudoku, we divide the grid into two-row bands and two-column stacks:

A band consists of two adjacent rows (those that share a square):

Here, the top band is:

and the bottom band is:

We can swap these entire bands, forming a valid Sudoku transformation:

Similarly, a stack consists of two adjacent columns sharing a square.

✅ These swaps preserve the Sudoku rules , so they also belong to the Sudoku transformation group.

Now, we can classify all valid transformations as forming subgroups of $S_4$:

These subgroups combine to form the full Sudoku Permutation Group, a subgroup of $S_4$ , describing all valid ways to transform a solved Sudoku into another valid solution.

Each of these subgroups interacts in a special way:

1. Row swaps and band swaps commute (order doesn’t matter).
2. Column swaps and stack swaps commute.
3. Number relabeling commutes with all other transformations.
4. Applying a band swap + a row swap within that band gives a larger subgroup.

Thus, we can construct a hierarchical structure:

This means that every valid Sudoku transformation is built from smaller subgroups acting independently.

Now that we’ve defined valid Sudoku subgroups, try these:

1. Find a sequence of swaps (row, column, band, stack) that returns the Sudoku to its original state.
2. Are all row swaps and band swaps commutative (do they always give the same result in any order)?
3. What’s the smallest number of swaps needed to go from one Sudoku solution to another?

Would you like to:

• Represent these Sudoku swaps using matrix operations?
• See how Sudoku transformations relate to cryptography?
• Move to another fun puzzle, like the 15-puzzle or card shuffling?

Let me know what excites you most! 🎲🔥