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.

Operating Modes

This skill operates in TWO distinct modes:

1. Teaching Mode (Default)

•Purpose: Explain concepts from first principles
•Input: Concept name (e.g., "quantum tunneling", "Pythagorean theorem")
•Structure: Concept tree (recursive prerequisites)
•Foundation: High school graduate baseline
•Style: Pedagogical explanation using the reverse knowledge tree

2. Problem-Solving Mode (JEE/NEET)

•Purpose: Solve competitive exam problems step-by-step
•Input: LaTeX problem statement with Given/Find (e.g., "A projectile is fired with u=20m/s at θ=30°. Find max height and range.")
•Structure: Solution tree (step-by-step solution path)
•Foundation: Indian NCERT Class 10 baseline
•Style: 70% solving, 30% explaining (interleaved)
•Visual: Color-coded (Given=GREEN, Unknown=YELLOW, Focus=BLUE, Answer=GOLD) with problem-specific diagrams (FBDs, trajectories, circuits)

Mode Detection

The system automatically detects which mode to use based on the input:

Trigger Problem-Solving Mode if:

•Input contains a LaTeX problem statement with numerical values and units
•Keywords present: "JEE", "NEET", "solve this problem", "step-by-step solution"
•Explicit structure: "Given:", "Find:", "Calculate:", "Determine:"
•User specifies mode: "problem-solving" parameter

Otherwise: Default to Teaching Mode

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

python

# 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:

code

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:

python

from manim import *

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

Critical Implementation Details

LaTeX Handling

Always use raw strings for LaTeX:

python

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

Teaching Mode (Concept Explanation)

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.

Problem-Solving Mode (JEE/NEET Problems)

For solving competitive exam problems:

•Parse Problem: Extract given values, unknowns, constraints from LaTeX problem statement
•Decompose Solution: Build solution tree (NOT prerequisite tree) - what steps lead to the answer?
•Enrich Steps: Add equations before/after each step, identify concepts used
•Design Visuals: Apply problem-specific visuals (FBD, trajectory, circuit) with color coding (Given=GREEN, Unknown=YELLOW, Answer=GOLD)
•Compose Narrative: 70% solving, 30% explaining interleaved (15s solve, 5s explain per step)
•Generate Code: Produce color-coded Manim code with problem-specific diagrams

Important Differences:

•Foundation baseline: NCERT Class 10 (India) - see ncert-class10-foundation.md
•Stop recursion at concepts listed in foundation document
•Reference: See jee-neet-problem-solving.md for complete problem-solving logic