Knot Theory Educator

Knot Theory Educator

Transform abstract braid theory and topological concepts into intuitive, visual, interactive learning experiences. This skill bridges the gap between formal mathematics and genuine understanding.

When to Use

✅ Use for:

• Creating visual explanations of braid generators (σ₁, σ₂, etc.)
• Building step-wise animations showing crossing sequences
• Designing explainer cards for mathematical terms
• Translating group theory concepts into physical intuition
• Creating interactive demonstrations of 2-strand vs 3-strand differences
• Illustrating why certain operations commute (or don't)

❌ NOT for:

• Pure computation of knot invariants (Jones polynomial, etc.)
• Academic research-level proofs
• General mathematics tutoring unrelated to braids/knots
• Software architecture decisions for visualization frameworks

Core Principle: The Physical-First Approach

Shibboleth: Experts explain braids through physical manipulation first, notation second.

Novice approach: "σ₁ is a generator of B₃ satisfying..."
Expert approach: "Imagine holding three strings. σ₁ means 'cross the
                  left string OVER the middle one.' Now they've swapped
                  positions. σ₁⁻¹? Cross it back UNDER."

Visual Vocabulary

The Core Crossing Diagrams

σ₁ (Left-over-middle):

  1   2   3          2   1   3
  │   │   │          │   │   │
  │ ╲ │   │    →     │   │   │
  │   ╳   │          │   │   │
  │ ╱ │   │          │   │   │
  │   │   │          │   │   │

σ₂ (Middle-over-right):

  1   2   3          1   3   2
  │   │   │          │   │   │
  │   │ ╲ │    →     │   │   │
  │   ╳   │          │   │   │
  │   │ ╱ │          │   │   │
  │   │   │          │   │   │

The Yang-Baxter Relation Visualized

σ₁σ₂σ₁ = σ₂σ₁σ₂ (The "braid relation")

This isn't just algebra - it's a physical fact about moving strings:

• Left path: Cross left-over-middle, then middle-over-right, then left-over-middle again
• Right path: Cross middle-over-right, then left-over-middle, then middle-over-right again
• BOTH end up with strings in the same final configuration!

Create animations showing both paths side-by-side, arriving at identical results.

Explainer Card Patterns

Pattern: Term Definition Card

For bolded terms like "word problem", "Garside normal form", etc.:

<div class="explainer-card graph-paper">
  <h3>The Word Problem</h3>
  <p class="intuition">
    "Given two different-looking recipes for tangling strings,
    do they produce the same tangle?"
  </p>
  <p class="formal">
    Formally: Given braid words w₁ and w₂, determine if they
    represent the same element of Bₙ.
  </p>
  <p class="example">
    Example: Is σ₁σ₂σ₁ the same as σ₂σ₁σ₂? (Yes! Yang-Baxter)
  </p>
  <p class="complexity">
    Solved by Artin (1947) - polynomial time in word length
  </p>
</div>

Pattern: Step-wise Animation Card

For processes like "how crossings accumulate":

// Animation sequence for σ₁σ₂σ₁⁻¹
const steps = [
  { state: 'initial', label: 'Three untangled strands: ε (identity)' },
  { state: 'after_s1', label: 'σ₁: Left crosses over middle', highlight: [0,1] },
  { state: 'after_s2', label: 'σ₂: Middle crosses over right', highlight: [1,2] },
  { state: 'after_s1_inv', label: 'σ₁⁻¹: Left crosses UNDER middle', highlight: [0,1] },
  { state: 'final', label: 'Result: Strands repositioned, complexity = 3' }
];

Pattern: Comparison Card

For "why 3 dogs is fundamentally different from 2":

┌─────────────────────┬─────────────────────┐
│   TWO STRANDS (B₂)  │  THREE STRANDS (B₃) │
├─────────────────────┼─────────────────────┤
│ One generator: σ₁   │ Two generators: σ₁,σ₂│
│                     │                     │
│ Abelian (order      │ NON-abelian         │
│ doesn't matter)     │ (order MATTERS!)    │
│                     │                     │
│ σ₁σ₁⁻¹ = ε always  │ σ₁σ₂ ≠ σ₂σ₁        │
│                     │                     │
│ Always untangle by  │ May need complex    │
│ counting crossings  │ algorithms to solve │
│                     │                     │
│ Like a single dial  │ Like a Rubik's cube │
└─────────────────────┴─────────────────────┘

Common Anti-Patterns

Anti-Pattern: Notation Before Intuition

Symptom: Starting with "B₃ = ⟨σ₁, σ₂ | σ₁σ₂σ₁ = σ₂σ₁σ₂⟩"

Problem: Readers without group theory background are immediately lost. The notation is correct but pedagogically backwards.

Solution: 1. Start with physical demonstration (hold three strings) 2. Name the basic moves (left-over-middle = σ₁) 3. Show why certain moves can be reordered 4. THEN introduce formal notation as shorthand

Anti-Pattern: Static Diagrams for Dynamic Processes

Symptom: A single image showing "before and after" a braid operation

Problem: Braiding is inherently a continuous process. Students need to see the motion, not just endpoints.

Solution:

• Use step-wise animations
• Show intermediate states
• Allow scrubbing forward/backward
• Highlight which strands are moving at each moment

Anti-Pattern: Complexity Without Consequence

Symptom: "The complexity is 7" without explaining what that means practically

Problem: Numbers are meaningless without grounding in physical reality

Solution:

• "Complexity 7 means you need at least 7 crossing moves to untangle"
• "Complexity 3 vs 7: First takes 5 seconds, second takes 30+ seconds"
• "High complexity = more friction when pulling (Capstan effect)"

Visualization Techniques

Technique 1: Color-Coded Strands

Each strand gets a consistent color throughout all diagrams:

• Strand 1 (leftmost initially): Red/Ruby
• Strand 2 (middle initially): Green/Emerald
• Strand 3 (rightmost initially): Blue/Sapphire

This makes tracking permutations intuitive.

Technique 2: Over/Under Emphasis

• Over-crossing: Solid line, strand appears "in front"
• Under-crossing: Broken/dashed line where it passes behind
• Use shadows or depth cues in 2.5D representations

Technique 3: Time-Slice Representation

Show the braid as horizontal slices:

t=0:  R───G───B  (initial positions)
t=1:  G───R───B  (after σ₁: R crossed over G)
t=2:  G───B───R  (after σ₂: R crossed over B)

Technique 4: Physical Analogy Gallery

Create mappings to everyday objects:

• "Like braiding hair, but tracking which strand is which"
• "Like a maypole dance - dancers are strands"
• "Like tangled headphone cords - same math!"

Interactive Demo Specifications

Demo: The 2 vs 3 Dog Revelation

Purpose: Show why walking 2 dogs is trivially manageable but 3 dogs creates genuine complexity.

Implementation:

// Simplified physics demo with thick rope rendering
class BraidDemo {
  constructor(numStrands) {
    this.strands = numStrands;
    this.crossings = [];
    this.mode = 'interactive'; // or 'playback'
  }

  // Render thick ropes with clear over/under
  renderThickRope(strand, ctx) {
    ctx.lineWidth = 20;
    ctx.lineCap = 'round';
    // Draw shadow pass first (creates depth)
    // Then main strand with gradient
  }

  // Highlight the key insight
  showComplexityDifference() {
    if (this.strands === 2) {
      return "Count crossings. Apply that many σ₁⁻¹. Done.";
    } else {
      return "Must track which strand crossed which. Order matters!";
    }
  }
}

Demo: Yang-Baxter Playground

Purpose: Let users discover that σ₁σ₂σ₁ = σ₂σ₁σ₂ through experimentation.

Features:

• Two side-by-side braid visualizations
• Apply operations to each independently
• Highlight when they reach equivalent states
• "Aha!" moment when both paths lead to same result

Content Structure for Theory Page

High-Level Page (The Hook)

• Visual hero: Animated tangled dogs → untangled
• One-sentence problem statement
• "Why 3 is magic" comparison card
• Navigation to detailed topics

Subpage: Braid Basics

• Interactive strand manipulation
• Generator introduction with animations
• "Build your own braid word" playground

Subpage: The Algebra

• Yang-Baxter with side-by-side proof
• Word problem explanation
• Complexity metrics with physical meaning

Subpage: Solutions & Algorithms

• Rename to "Untangling Strategies"
• Greedy vs optimal approaches
• Physical device design concepts
• ML heuristics exploration

Subpage: Applications

• Robotics with illustrations
• Quantum computing connection
• Surgical robots, cable drones

Decision Tree: What Visualization to Use

Is the concept about static structure or dynamic process?
├── Static (e.g., "what is a braid group?")
│   └── Use: Comparison cards, diagrams with annotations
└── Dynamic (e.g., "how does σ₁ work?")
    ├── Is it a single operation?
    │   └── Use: Before/after with animation between
    └── Is it a sequence?
        └── Use: Step-wise timeline with scrubbing

Integration with Physics Renderer

When using the simulation's physics engine for demonstrations:

1. Zoom to close-up view: Focus on just the leashes, not full scene 2. Thick rope rendering: Increase rope thickness for clarity 3. Slow motion: 0.25x speed for crossing moments 4. Pause on events: Auto-pause when crossing detected 5. Annotation overlay: Label which σ just occurred

---

This skill encodes: Visual pedagogy for braid theory | Explainer card patterns | Animation specifications | Anti-patterns in math education | Physical-first teaching approach

Knot Garden: Educational Content & Visualization Guide

Comprehensive reference for the educational layer of Knot Garden—transforming mathematical knots into intuitive, interactive learning experiences.

---

The Educational Mission

Core Goal: Help users understand WHY knots behave the way they do, not just THAT they do.

The Aha Moments We're Designing For: 1. "Oh! A knot's Jones polynomial is like its fingerprint—it can't change no matter how I twist it!" 2. "I get it now—the trefoil CAN'T become an unknot because the math literally forbids it." 3. "So THAT'S why this tangled mess simplifies to exactly 3 crossings and no fewer."

---

Knot Content Database

Tier 1: The Essential Collection (First Release)

Tier 2: Mathematical Depth (Later Release)

---

Invariant Explanations

The Jones Polynomial

Intuitive Explanation:

Imagine you could color a knot with a special paint that
responds to crossings. Each over-crossing adds one type of
"color charge," each under-crossing adds another.

The Jones polynomial is the TOTAL color pattern of the knot.

No matter how you twist, stretch, or rearrange the knot
(without cutting), this color pattern NEVER changes.

If two knots have different Jones polynomials, they're
definitely different knots. Forever. Math guarantees it.

Formal-to-Intuitive Mapping:

Visual Card:

┌─────────────────────────────────────────────────────────────┐
│  THE JONES POLYNOMIAL                                       │
│  ══════════════════════                                     │
│                                                             │
│  What it tells you:                                         │
│  ─────────────────                                          │
│  • Whether two knots are DEFINITELY different               │
│  • Whether a knot is chiral (different from mirror image)   │
│  • A lower bound on crossing number                         │
│                                                             │
│  What it DOESN'T tell you:                                  │
│  ─────────────────────────                                  │
│  • Whether two knots with SAME polynomial are the same      │
│    (Some different knots share polynomials!)                │
│  • How to actually untie the knot                           │
│                                                             │
│  ┌─────────────┬──────────────────────────┐                │
│  │   Knot      │   Jones Polynomial       │                │
│  ├─────────────┼──────────────────────────┤                │
│  │   Unknot    │   1                      │                │
│  │   Trefoil   │   t + t³ - t⁴            │                │
│  │   Figure-8  │   t⁻² - t⁻¹ + 1 - t + t² │                │
│  └─────────────┴──────────────────────────┘                │
│                                                             │
│  Notice: Figure-8's polynomial is symmetric (t ↔ t⁻¹)      │
│  This proves it's amphichiral (equal to its mirror image)! │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Crossing Number

Intuitive Explanation:

The crossing number is the MINIMUM number of times
the rope must cross over/under itself in ANY drawing
of the knot.

Key insight: You can always ADD more crossings by
twisting. But there's a floor—you can't go below
the crossing number.

The trefoil's crossing number is 3. No matter how
cleverly you draw it, you need at least 3 crossings.

Interactive Demo Specification:

// User tries to draw trefoil with fewer crossings
const demo = {
  challenge: "Draw this knot with only 2 crossings",
  knot: "trefoil",
  onAttempt: (drawing) => {
    const crossings = countCrossings(drawing);
    if (crossings >= 3) {
      return "Great drawing! But notice: you still have 3+ crossings.";
    } else {
      // This should never happen with valid trefoil
      return "Wait—check that this is still a trefoil!";
    }
  },
  reveal: "The trefoil's crossing number is 3. It's mathematically impossible to draw it with fewer!"
};

Unknotting Number

Intuitive Explanation:

The unknotting number is how many times you'd need
to CHEAT (pass one strand through another) to untangle
the knot.

Imagine you have magic scissors that can cut one strand,
pass another through, and instantly heal the cut.

A trefoil has unknotting number 1: one magic cut and
it falls apart into an unknot.

A knot with unknotting number 3 would need three such
magic interventions.

---

The Reidemeister Moves: Educational Deep Dive

Move I: The Twist

Physical Metaphor: Like twisting a rubber band around your finger once, then untwisting it.

Visualization:

BEFORE:          AFTER:
   ╭─╮              │
   │ ╲│             │
   │  ╳             │
   │ ╱│             │
   ╰─╯│             │
     │              │

What happened:
- A simple twist was "pulled straight"
- Crossing count: -1
- Rope configuration: unchanged (topologically)

Why It Works (Educational Text):

A twist that goes "nowhere"—the rope crosses over itself
and immediately crosses back—can always be pulled out.

This isn't about force or physics. It's a TOPOLOGICAL fact.
The "loop" created by the twist contains no other strands,
so it adds nothing to the knot's structure.

Think of it like a typo in a word: "helllo" → "hello"
The extra 'l' doesn't add meaning; removing it doesn't
change the word's identity.

Move II: The Poke

Physical Metaphor: Like poking your finger through a gap between two parallel strings, then withdrawing it.

Visualization:

BEFORE:              AFTER:
   ╲    ╱               │    │
    ╲  ╱                │    │
     ╲╱                 │    │
     ╱╲                 │    │
    ╱  ╲                │    │
   ╱    ╲               │    │

What happened:
- Two strands were "poked" through each other
- Crossing count: -2
- The strands are now separate (no interaction)

Why It Works (Educational Text):

When two strands cross twice in immediate succession—
first one over, then the other over—those crossings
CANCEL OUT.

It's like walking forward two steps, then backward two
steps. You haven't gone anywhere. The strand hasn't
really "passed through" anything meaningful.

Key insight: The crossings must be ADJACENT (nothing
else between them) and OPPOSITE (one over, one under).

Move III: The Slide

Physical Metaphor: Like sliding a strand across a crossing between two other strands.

Visualization:

BEFORE:              AFTER:
     │                    │
   ╲ │ ╱              ╲   │   ╱
    ╲│╱                ╲  │  ╱
    ╱│╲                 ╲ │ ╱
   ╱ │ ╲                 ╲│╱
     │                    ╳
                         ╱│╲
                        ╱ │ ╲
                          │

What happened:
- Crossing count: UNCHANGED (still 3 crossings)
- But the CONFIGURATION changed
- This may enable a Type I or Type II move!

Why It Matters (Educational Text):

Move III is the "rearrangement" move. It doesn't reduce
crossings directly, but it can ENABLE reductions.

Imagine rearranging furniture to reach a window. The
furniture count doesn't change, but your path does.

This is why knot simplification can require exploration:
sometimes you need to Move III before you can Move I or II.

The Three Moves Together

Interactive Playground Spec:

const reidemeisterPlayground = {
  mode: 'sandbox',
  tools: [
    { name: 'Type I', description: 'Remove a simple twist' },
    { name: 'Type II', description: 'Cancel adjacent opposite crossings' },
    { name: 'Type III', description: 'Slide strand across a crossing' }
  ],
  challenges: [
    {
      name: 'Simplify the Loop',
      start: 'unknot_with_3_twists',
      goal: 'unknot_minimal',
      hint: 'Use Type I three times'
    },
    {
      name: 'Unweave',
      start: 'figure8_with_pokes',
      goal: 'figure8_minimal',
      hint: 'Look for Type II opportunities'
    },
    {
      name: 'The Slide Puzzle',
      start: 'complex_trefoil',
      goal: 'trefoil_minimal',
      hint: 'Type III first, then Type I becomes possible'
    }
  ]
};

---

Progressive Disclosure: The Three Layers

Layer 1: Just Looking (Casual Visitor)

What they see:

• Beautiful 3D knot floating in space
• Name and one-sentence description
• "Crossings: 3"

What's hidden:

• Polynomial calculations
• Invariant comparisons
• Mathematical proofs

Example Card:

┌─────────────────────────────────┐
│       TREFOIL KNOT              │
│       ════════════              │
│                                 │
│   The simplest knot that can't  │
│   be untied without cutting.    │
│                                 │
│   Crossings: 3                  │
│                                 │
│   [Explore More ▼]              │
└─────────────────────────────────┘

Layer 2: Getting Curious (Engaged Visitor)

What they see (on click):

• Animated crossing diagram
• Basic invariants with plain-English explanations
• "Why is this interesting?" section
• Interactive manipulation

Example Card:

┌─────────────────────────────────────────────────┐
│  TREFOIL KNOT (3₁)                              │
│  ════════════════                               │
│                                                 │
│  ┌─────────────────────────────────────────┐   │
│  │   The Basics                             │   │
│  │   ─────────                              │   │
│  │   Crossing number:    3 (minimum)        │   │
│  │   Unknotting number:  1 (one cut)        │   │
│  │   Chiral:             Yes (has a mirror) │   │
│  │   Prime:              Yes (can't split)  │   │
│  └─────────────────────────────────────────┘   │
│                                                 │
│  WHY IT'S INTERESTING                           │
│  ───────────────────                            │
│  The trefoil proves that "knotted" is a real    │
│  mathematical property, not just a tangle.      │
│  No amount of manipulation can unknot it.       │
│                                                 │
│  This was proven using INVARIANTS—properties    │
│  that never change no matter how you twist.     │
│                                                 │
│  [Show Me the Math ▼]                           │
└─────────────────────────────────────────────────┘

Layer 3: Going Deep (Math Enthusiast)

What they see:

• Full polynomial formulas
• Invariant calculations
• Comparison tools
• Historical context
• Academic references

Example Card:

┌─────────────────────────────────────────────────────┐
│  TREFOIL KNOT (3₁) — FULL ANALYSIS                  │
│  ═════════════════════════════════                  │
│                                                     │
│  POLYNOMIAL INVARIANTS                              │
│  ─────────────────────                              │
│                                                     │
│  Jones Polynomial:                                  │
│    V(t) = t + t³ - t⁴                               │
│                                                     │
│  Alexander Polynomial:                              │
│    Δ(t) = t - 1 + t⁻¹                               │
│                                                     │
│  HOMFLY-PT Polynomial:                              │
│    P(a,z) = -a⁴ + a²z² + 2a²                        │
│                                                     │
│  Conway Polynomial:                                 │
│    ∇(z) = z + z³                                    │
│                                                     │
│  CHIRALITY PROOF                                    │
│  ─────────────────                                  │
│  The Jones polynomial of the mirror trefoil is:    │
│    V̄(t) = t⁻¹ + t⁻³ - t⁻⁴                          │
│                                                     │
│  Since V(t) ≠ V̄(t), the trefoil is CHIRAL.         │
│  It cannot be transformed into its mirror image.   │
│                                                     │
│  HISTORICAL NOTE                                    │
│  ─────────────────                                  │
│  The trefoil appears in the Book of Kells (~800 AD)│
│  and has been studied mathematically since 1847    │
│  (Listing). Its knot group was computed by         │
│  Max Dehn in 1910.                                  │
│                                                     │
│  [Show Calculation ▼] [Compare to Others ▼]         │
└─────────────────────────────────────────────────────┘

---

Animation Specifications

Reidemeister Move Animation Timing

const animationConfig = {
  moveI: {
    duration: 1200,  // ms
    phases: {
      highlight: { start: 0, end: 300 },     // Glow the twist
      transform: { start: 300, end: 1000 },  // Pull straight
      settle: { start: 1000, end: 1200 }     // Physics settle
    },
    easing: 'easeInOutQuad',
    audioHint: 'soft_whoosh'
  },
  moveII: {
    duration: 1500,
    phases: {
      highlight: { start: 0, end: 400 },      // Glow both crossings
      separate: { start: 400, end: 1200 },    // Pull apart
      settle: { start: 1200, end: 1500 }
    },
    easing: 'easeInOutCubic',
    audioHint: 'soft_pop'
  },
  moveIII: {
    duration: 1800,
    phases: {
      highlight: { start: 0, end: 400 },
      slide: { start: 400, end: 1400 },       // Strand slides across
      settle: { start: 1400, end: 1800 }
    },
    easing: 'easeInOutQuart',
    audioHint: 'slide_across'
  }
};

Camera Animation During Moves

// Camera should follow the action
const cameraConfig = {
  onMoveStart: {
    // Zoom in to frame the affected region
    targetZoom: 1.5,
    targetCenter: moveCenter,
    transitionDuration: 300
  },
  duringMove: {
    // Slight orbit to show depth
    orbitAngle: 15, // degrees
    orbitSpeed: 0.5 // per second
  },
  onMoveComplete: {
    // Zoom back out
    targetZoom: 1.0,
    transitionDuration: 500
  }
};

Crossing Count Animation

// The crossing count display should animate during simplification
const crossingCountDisplay = {
  position: 'top-right',
  format: 'Crossings: {n}',
  onDecrease: {
    animation: 'pulse_green',
    sound: 'positive_ding',
    duration: 300
  },
  onIncrease: {
    animation: 'pulse_red',
    sound: 'subtle_warning',
    duration: 300
  },
  atMinimum: {
    animation: 'glow_gold',
    sound: 'achievement',
    text: 'Crossings: {n} (MINIMAL!)'
  }
};

---

Interactive Learning Sequences

Sequence 1: "What is a Knot?"

const whatIsAKnot = {
  steps: [
    {
      type: 'text',
      content: "A mathematical knot is a closed loop in 3D space.",
      visual: 'rotating_trefoil'
    },
    {
      type: 'text',
      content: "Unlike shoelaces, both ends are connected—no loose ends.",
      visual: 'trefoil_highlighting_closure'
    },
    {
      type: 'interactive',
      prompt: "Try to pull this knot apart without cutting.",
      knot: 'trefoil',
      timeout: 15000,
      onTimeout: "Notice: no matter how you pull, it won't come undone."
    },
    {
      type: 'comparison',
      left: { knot: 'unknot', label: 'Unknot (a simple loop)' },
      right: { knot: 'trefoil', label: 'Trefoil (a true knot)' },
      prompt: "Can you tell the difference?"
    },
    {
      type: 'reveal',
      content: "The unknot CAN be pulled into a circle. The trefoil CANNOT. That's the fundamental question of knot theory: which is which?"
    }
  ]
};

Sequence 2: "Why Can't I Untie It?"

const whyCantUntie = {
  steps: [
    {
      type: 'challenge',
      prompt: "Try to simplify this trefoil below 3 crossings.",
      knot: 'trefoil',
      tools: ['pin', 'pull', 'reidemeister_assist'],
      goal: { crossings: 2 }, // Impossible!
      timeout: 60000
    },
    {
      type: 'reveal',
      content: "It's impossible. Here's why:",
      visual: 'jones_polynomial_comparison'
    },
    {
      type: 'text',
      content: "The Jones polynomial of the trefoil is: V(t) = t + t³ - t⁴"
    },
    {
      type: 'text',
      content: "The Jones polynomial of the unknot is: V(t) = 1"
    },
    {
      type: 'emphasis',
      content: "These are DIFFERENT. The Jones polynomial NEVER changes during manipulation. Therefore, the trefoil can NEVER become an unknot."
    },
    {
      type: 'interactive',
      prompt: "Watch the polynomial as you manipulate the knot.",
      knot: 'trefoil',
      display: 'jones_polynomial',
      observation: "See? It never changes. That's what 'invariant' means."
    }
  ]
};

Sequence 3: "The Magic of Reidemeister"

const reidemeisterMagic = {
  steps: [
    {
      type: 'text',
      content: "In 1927, Kurt Reidemeister proved something remarkable:"
    },
    {
      type: 'emphasis',
      content: "ANY manipulation of a knot can be broken down into exactly THREE types of moves."
    },
    {
      type: 'demo',
      content: "Move I: Remove a simple twist",
      animation: 'reidemeister_I_demo'
    },
    {
      type: 'demo',
      content: "Move II: Cancel two opposite crossings",
      animation: 'reidemeister_II_demo'
    },
    {
      type: 'demo',
      content: "Move III: Slide a strand across a crossing",
      animation: 'reidemeister_III_demo'
    },
    {
      type: 'interactive',
      prompt: "Now YOU try. Use the three moves to simplify this tangled unknot.",
      knot: 'unknot_tangled',
      tools: ['reidemeister_I', 'reidemeister_II', 'reidemeister_III'],
      goal: { crossings: 0 }
    },
    {
      type: 'celebration',
      content: "You just proved this was an unknot—using the same tools mathematicians use!"
    }
  ]
};

---

Audio Design for Learning

---

Summary: What Makes This Educational

The goal is not to teach knot theory notation. It's to build understanding of why knots behave the way they do—and why mathematicians find this so fascinating.