manim-mcp 0.1.0

package/references/composer/references/scene-examples.md

@@ -0,0 +1,379 @@
+# Scene Examples
+
+Example scene breakdowns from 3b1b-style videos, derived from actual video source code (2015-2026).
+
+---
+
+## Example 1: Explaining the Dot Product (EoLA Ch 9)
+
+### Scene 1: The Question
+**Duration**: ~30 seconds
+**Purpose**: Hook the viewer with the mystery
+
+**Visual Elements**
+- Two vectors a and b drawn as arrows
+- The dot product formula: a . b = |a||b|cos(theta)
+- Question mark animation
+
+**Content**
+Open on two vectors. Show the formula. Pose the question: "Why does multiplying components and adding them give you something related to the angle between vectors?"
+
+**Narration Notes**
+Tone: curious, slightly puzzled. Emphasize that the formula seems arbitrary.
+
+**Technical Notes**
+- Use Arrow for vectors
+- Tex for formula with `t2c` for color-coded variables
+- `Indicate()` on the cos(theta) term
+
+---
+
+### Scene 2: Geometric Interpretation
+**Duration**: ~90 seconds
+**Purpose**: Show projection interpretation
+
+**Visual Elements**
+- Vector a (horizontal, GREEN -- basis vector convention)
+- Vector b (angled, YELLOW)
+- Projection of b onto a (dashed line)
+- Right angle marker
+- Length labels
+
+**Content**
+Show that a . b equals |a| times the projection of b onto a. Animate the projection dropping down. Show this equals |a||b|cos(theta) geometrically.
+
+**Narration Notes**
+"The dot product measures how much one vector goes in the direction of another."
+
+**Technical Notes**
+- DashedLine for projection
+- RightAngle mobject
+- `animate.rotate()` for showing different angles
+
+---
+
+### Scene 3: Numeric Connection
+**Duration**: ~60 seconds
+**Purpose**: Connect geometry to algebra (Two Perspectives -> Unity)
+
+**Visual Elements**
+- Coordinate grid
+- Vector a = [a1, a2] with GREEN column coloring
+- Vector b = [b1, b2] with YELLOW coloring
+- Components highlighted
+
+**Content**
+Show vectors on grid with components labeled. Demonstrate why a1*b1 + a2*b2 equals the geometric interpretation. Use specific numbers (e.g., a=[2,1], b=[1,3]).
+
+**Narration Notes**
+Walk through calculation slowly. "Let's see why the algebra matches the geometry."
+
+**Technical Notes**
+- NumberPlane or Axes
+- Brace for component labels
+- TransformMatchingTex for equation steps
+
+---
+
+## Example 2: Introduction to Fourier Series (DiffEq Part 4)
+
+### Scene 1: The Hook (Result Preview Pattern)
+**Duration**: ~45 seconds
+**Purpose**: Show the surprising result
+
+**Visual Elements**
+- A square wave (sharp corners)
+- Sum of smooth sine waves
+- Morphing animation between them
+
+**Content**
+"You can build a square wave -- something with sharp corners -- from perfectly smooth sine waves." Show the result first, then promise to explain how.
+
+**Narration Notes**
+Tone: wonder, slight disbelief. This should feel surprising.
+
+**Technical Notes**
+- ParametricFunction for waves
+- Transform animation for the morph
+- Consider showing 1, 3, 5 terms building up (Progressive Build pattern)
+
+---
+
+### Scene 2: Building Blocks
+**Duration**: ~120 seconds
+**Purpose**: Introduce sine waves as basis
+
+**Visual Elements**
+- Single sine wave
+- Frequency visualization (faster oscillation)
+- Amplitude visualization (taller/shorter)
+- Phase visualization (shifting left/right)
+
+**Content**
+Introduce the three parameters: frequency, amplitude, phase. Show each one separately, then combine.
+
+**Narration Notes**
+Go slow. "A sine wave has three knobs we can adjust..."
+
+**Technical Notes**
+- ValueTracker for animating parameters
+- Updaters to make wave respond to trackers
+- Labels for each parameter
+
+---
+
+### Scene 3: Superposition
+**Duration**: ~90 seconds
+**Purpose**: Show waves can be added
+
+**Visual Elements**
+- Two sine waves (different colors)
+- Their sum (third color)
+- Point-by-point addition visualization
+
+**Content**
+Show that adding waves means adding their heights at each point. Demonstrate with two specific frequencies combining.
+
+**Narration Notes**
+"Adding waves is simple -- at each point, just add the heights."
+
+**Technical Notes**
+- VGroup of three function graphs
+- Vertical lines showing addition at specific x values
+- Animate the addition happening
+
+---
+
+## Example 3: Matrix as Linear Transformation (EoLA Ch 3)
+
+### Scene 1: Grid Transformation
+**Duration**: ~60 seconds
+**Purpose**: THE fundamental 3b1b visual
+
+**Visual Elements**
+- 2D coordinate grid (NumberPlane)
+- Basis vectors i-hat (GREEN) and j-hat (RED)
+- Grid lines transforming
+
+**Content**
+Show a grid. Highlight i-hat (1,0) and j-hat (0,1). Apply a transformation -- watch the entire grid move while tracking where basis vectors land.
+
+**Narration Notes**
+"Watch what happens to the grid when we apply this transformation. Notice how every point moves."
+
+**Technical Notes**
+- NumberPlane with visible grid lines
+- `apply_matrix()` method for the transformation
+- Keep basis vectors visually distinct (GREEN, RED)
+- run_time=3 for the transformation (let it breathe)
+
+---
+
+### Scene 2: Basis Vectors Determine Everything
+**Duration**: ~90 seconds
+**Purpose**: Key insight (this is the "aha moment" of the chapter)
+
+**Visual Elements**
+- Transformed i-hat and j-hat
+- Arbitrary vector v (YELLOW) as combination
+- v = xi + yj visualization
+
+**Content**
+Show that knowing where i-hat and j-hat land tells you where ANY vector lands. Because v = xi + yj, the transformed v = x(new i) + y(new j).
+
+**Narration Notes**
+"Here's the key insight..." Build anticipation before the reveal. Use FlashAround on the result.
+
+**Technical Notes**
+- Vector addition animation (tip-to-tail)
+- Scaling animation for coefficients
+- TransformMatchingShapes for the combination
+- self.wait(2) after the insight
+
+---
+
+## Example 4: Autoregressive Text Generation (Transformers Series)
+
+### Scene 1: Black Box Input/Output
+**Duration**: ~60 seconds
+**Purpose**: Ground the abstract architecture in observable behavior
+
+**Visual Elements**
+- Text string as input
+- MachineWithDials as the "model"
+- Bar chart of next-token probabilities as output
+- Highlight rect jumping between bars (random sampling)
+
+**Content**
+Show text flowing into a machine, probability distribution coming out, random sampling selecting the next token.
+
+**Narration Notes**
+"At its core, a large language model takes in text and predicts the next word."
+
+**Technical Notes**
+From `_2024/transformers/auto_regression.py`:
+```python
+class SimpleAutogregression(InteractiveScene):
+    def new_selection_cycle(self, text_mob, next_word_line, machine, quick=False):
+        self.animate_text_input(text_mob, machine)
+        bar_groups = self.animate_prediction_output(machine, self.cur_str)
+        self.animate_random_sample(bar_groups)
+        new_text_mob = self.animate_word_addition(bar_groups, text_mob, next_word_line)
+```
+- Live GPT-2 inference via `gpt2_predict_next_token()`
+- `UpdateFromAlphaFunc` for the jumping highlight rect
+
+---
+
+### Scene 2: Opening the Machine
+**Duration**: ~90 seconds
+**Purpose**: Transition from black box to architecture overview
+
+**Visual Elements**
+- 3D transformer blocks (VPrism stack)
+- Embedding array flowing through blocks
+- Labels for attention, MLP layers
+
+**Content**
+"Open up the machine." Show the stack of transformer blocks. Data flows in one side, through alternating attention and MLP layers, out the other.
+
+**Technical Notes**
+From `_2024/transformers/network_flow.py`:
+```python
+blocks = VGroup(VPrism(3, 2, 0.2) for n in range(10))
+blocks.set_fill(GREY_D, 1)
+blocks.set_shading(0.25, 0.5, 0.2)
+blocks.arrange(OUT)
+```
+- Camera reorientation: `frame.animate.reorient(theta, phi, 0)`
+- ContextAnimation arcs between token positions
+
+---
+
+## Example 5: Bayesian Updating with Population Grid
+
+### Scene 1: The Medical Test Setup
+**Duration**: ~45 seconds
+**Purpose**: Concrete problem that traps intuition
+
+**Visual Elements**
+- Statement: "Test is 90% accurate. You test positive."
+- Question: "What's the probability you have the disease?"
+- Pi creature with "pondering" expression
+
+**Content**
+Present the medical test scenario. Most people answer "about 90%." This is wrong.
+
+**Technical Notes**
+- TeacherStudentsScene for emotional setup
+- Text with key numbers color-coded
+
+---
+
+### Scene 2: Population Frequency Approach
+**Duration**: ~120 seconds
+**Purpose**: Make probability visual and countable
+
+**Visual Elements**
+- Grid of 1000 dots (Population class)
+- 10 dots colored RED (disease positive)
+- 990 dots colored GREEN (disease negative)
+- Subset highlighting for test results
+
+**Content**
+Show 1000 people. 10 have disease (RED). 990 are healthy (GREEN). Now apply the test: 9 of 10 sick test positive. 89 of 990 healthy test positive (false positives!). P(sick|positive) = 9/(9+89) = 9.2%.
+
+**Narration Notes**
+The FALSE POSITIVE group is the surprise. Color them GREEN+bright to show they're HEALTHY but tested positive.
+
+**Technical Notes**
+From `_2020/med_test.py`:
+- Population class creates the grid
+- Subset coloring with SurroundingRectangle
+- AnimationGroup for simultaneous color changes
+- self.wait(2) after revealing the surprisingly low probability
+
+---
+
+## Example 6: Galton Board Simulation (CLT)
+
+### Scene 1: The Physical Setup
+**Duration**: ~30 seconds
+**Purpose**: Ground the abstract in the physical
+
+**Visual Elements**
+- Peg array (triangular grid)
+- Ball at the top
+- Bins at the bottom
+
+**Content**
+"Imagine dropping a ball through a field of pegs."
+
+**Technical Notes**
+From `_2023/clt/galton_board.py`:
+- Physical simulation with collision detection
+- `self.add_sound("clack")` for ball-peg impacts
+
+---
+
+### Scene 2: Many Balls
+**Duration**: ~90 seconds
+**Purpose**: Show distribution emerging from randomness
+
+**Visual Elements**
+- Dozens of balls dropping simultaneously
+- Bins filling up (bar chart growing)
+- Gaussian curve overlay appearing
+
+**Content**
+Drop many balls. Watch the bins fill up into a bell curve shape. Overlay the Gaussian formula.
+
+**Technical Notes**
+- Progressive speed-up: first 10 balls animated fully, rest quick
+- Bar chart using ChartBars with gradient coloring
+- Gaussian curve in YELLOW overlaid with `always_redraw`
+
+---
+
+## Scene Transition Patterns
+
+### Zoom Focus
+```
+Full scene -> Zoom into detail -> Explain -> Zoom out
+```
+Implementation: `frame.animate.set_height(smaller)` + `frame.animate.move_to(target)`
+
+### Side-by-Side Build
+```
+Empty left | Empty right
+Add to left | Compare
+Add to right | Connect them
+```
+Implementation: `VGroup.to_edge(LEFT/RIGHT)` with `Line` or `Arrow` between
+
+### Transform Chain
+```
+Object A -> Transform -> Object B -> Transform -> Object C
+(Maintain visual continuity throughout)
+```
+Implementation: `TransformMatchingTex` or `FadeTransform` for smooth continuity
+
+### Reset and Rebuild
+```
+Complex scene -> FadeOut most -> Focus on one element -> Build new complexity
+```
+Implementation: `FadeOut(VGroup(*to_remove))` then progressive `FadeIn/Write` of new elements
+
+### The "Fourier Land" Split
+```
+Time domain (left) | Frequency domain (right)
+Operate in time    | Watch frequency response
+```
+Implementation: `FullScreenRectangle().stretch(0.5, 0).set_fill(TEAL, 0.2)` for visual domain separation
+
+### Phase Space Dual View
+```
+Physical system (left/top) | Phase portrait (right/bottom)
+System evolves             | Trajectory traced in phase space
+```
+Implementation: Linked via updaters; physical system state drives dot position on phase plane