Math-To-Manim: Reverse Knowledge Tree Animation Pipeline

Transform any concept into professional mathematical animations using a six-agent workflow that requires NO training data - only pure LLM reasoning.

Core Innovation: Reverse Knowledge Tree

Instead of training on example animations, this system recursively asks: "What must I understand BEFORE this concept?" This builds pedagogically sound animations that flow naturally from foundation concepts to advanced topics.

When to Use This Skill

Invoke this workflow when:

• Creating mathematical or scientific animations

• Building educational visualizations with Manim

• Generating code from conceptual explanations

• Needing pedagogically structured content progression

The Six-Agent Pipeline

Agent 1: ConceptAnalyzer

Parse user intent to extract:

• Core concept (specific topic name)

• Domain (physics, math, CS, etc.)

• Level (beginner/intermediate/advanced)

• Goal (learning objective)

Agent 2: PrerequisiteExplorer (Key Innovation)

Recursively build knowledge tree:

• Ask: "What are the prerequisites for [concept]?"

• For each prerequisite, recursively ask the same question

• Stop when hitting foundation concepts (high school level)

• Build DAG structure with depth tracking

Foundation detection criteria: Would a high school graduate understand this without further explanation?

Agent 3: MathematicalEnricher

For each node in the tree, add:

• LaTeX equations (2-5 key formulas)

• Variable definitions and interpretations

• Worked examples with typical values

• Complexity-appropriate rigor

Agent 4: VisualDesigner

For each node, design:

• Visual elements (graphs, 3D objects, diagrams)

• Color scheme (maintain consistency)

• Animation sequences (FadeIn, Transform, etc.)

• Camera movements and transitions

• Duration and pacing

Agent 5: NarrativeComposer

Walk tree from foundation to target:

• Topologically sort nodes

• Generate 200-300 word segment per concept

• Include exact LaTeX, colors, animations

• Stitch into 2000+ token verbose prompt

Agent 6: CodeGenerator

Generate working Manim code:

• Use Manim Community Edition

• Handle LaTeX with raw strings: r"$\frac{a}{b}$"

• Implement all visual specifications

• Produce runnable Python file

Workflow Execution

To execute this workflow for a user request:

Step 1: Analyze the Concept

Extract intent

analysis = { "core_concept": "quantum tunneling", "domain": "physics/quantum mechanics", "level": "intermediate", "goal": "Understand barrier penetration" }

Step 2: Build Knowledge Tree

Recursively discover prerequisites with max depth of 3-4 levels:

Target: quantum tunneling ├─ wave-particle duality │ ├─ de Broglie wavelength [FOUNDATION] │ └─ Heisenberg uncertainty ├─ Schrödinger equation │ ├─ wave function │ └─ probability density └─ potential barriers [FOUNDATION]

Step 3: Enrich with Mathematics

Add to each node:

• Primary equations in LaTeX

• Variable definitions

• Physical interpretations

Step 4: Design Visuals

Specify for each concept:

• Elements: ['wave_function', 'potential_barrier']

• Colors: {'wave': 'BLUE', 'barrier': 'RED'}

• Animations: ['FadeIn', 'Create', 'Transform']

• Duration: 15-30 seconds per concept

Step 5: Compose Narrative

Generate verbose prompt with:

• Scene-by-scene instructions

• Exact LaTeX formulas

• Specific animation timings

• Color and position details

Step 6: Generate Code

Produce complete Python file:

from manim import *

class ConceptAnimation(ThreeDScene): def construct(self): # Implementation following verbose prompt ...

Critical Implementation Details

LaTeX Handling

Always use raw strings for LaTeX:

equation = MathTex(r"E = mc^2")

Color Consistency

Define color palette at scene start and reuse throughout.

Transition Pattern

Connect concepts with smooth animations:

• Previous concept fades

• New concept builds from prior elements

• Use Transform or ReplacementTransform

Verbose Prompt Format

Structure prompts with:

• Overview section with concept count and duration

• Scene-by-scene instructions

• Exact specifications (no ambiguity)

See references/verbose-prompt-format.md for complete template.

Output Files

The pipeline generates:

• {concept}_prompt.txt

• Verbose prompt

• {concept}_tree.json

• Knowledge tree structure

• {concept}_animation.py

• Manim Python code

• {concept}_result.json

• Complete metadata

Additional Resources

Reference Files

• references/reverse-knowledge-tree.md

• Detailed algorithm explanation

• references/agent-system-prompts.md

• All six agent prompts

• references/verbose-prompt-format.md

• Complete prompt template

• references/manim-code-patterns.md

• Code generation patterns

Example Files

• examples/pythagorean-theorem/
• Complete workflow example

Quick Start

For immediate use, follow this simplified pattern:

• Parse: Extract the core concept from user input

• Discover: Build prerequisite tree (depth 3-4)

• Enrich: Add math and visual specs to each node

• Compose: Generate verbose prompt (2000+ tokens)

• Generate: Produce working Manim code

The key insight: verbose, specific prompts with exact LaTeX and visual specifications produce dramatically better code than vague descriptions.