manim-mcp 0.1.0

package/references/manimce/rules/mathematical-domains.md

@@ -0,0 +1,689 @@
+---
+name: mathematical-domains
+description: Domain-specific patterns for visualizing different branches of mathematics in ManimCE, based on 3b1b's actual video code
+metadata:
+  tags: linear-algebra, calculus, probability, complex-analysis, number-theory, topology, neural-networks, quantum, math
+---
+
+# Mathematical Domain-Specific Patterns
+
+Patterns extracted from specific 3b1b video series: Essence of Linear Algebra, Essence of Calculus, probability videos, complex analysis, prime spirals, topology, transformers series, and quantum computing.
+
+## Linear Algebra
+
+From `_2016/eola/` (chapters 0-11) and `_2024/linalg/eigenlecture.py`.
+
+### Basis Vectors (Green i-hat, Red j-hat)
+
+The canonical 3b1b convention: i-hat is GREEN, j-hat is RED, k-hat is BLUE.
+
+```python
+from manim import *
+
+X_COLOR = GREEN
+Y_COLOR = RED
+Z_COLOR = BLUE
+
+class BasisVectors(Scene):
+    """Standard EoLA basis vector setup."""
+
+    def construct(self):
+        plane = NumberPlane()
+        plane.set_stroke(BLUE_D, 1, opacity=0.4)
+
+        # Basis vectors with labels
+        i_hat = Vector([1, 0], color=X_COLOR, stroke_width=5)
+        j_hat = Vector([0, 1], color=Y_COLOR, stroke_width=5)
+
+        i_label = MathTex(r"\hat{\imath}", color=X_COLOR, font_size=36)
+        i_label.next_to(i_hat.get_end(), DOWN + RIGHT, buff=0.1)
+        j_label = MathTex(r"\hat{\jmath}", color=Y_COLOR, font_size=36)
+        j_label.next_to(j_hat.get_end(), UP + LEFT, buff=0.1)
+
+        self.play(Create(plane), run_time=2)
+        self.play(
+            GrowArrow(i_hat), Write(i_label),
+            GrowArrow(j_hat), Write(j_label),
+        )
+        self.wait()
+```
+
+### Grid Transformations (Linear Map Visualization)
+
+```python
+class LinearTransformation(Scene):
+    """Apply a linear transformation to the grid -- EoLA signature."""
+
+    def construct(self):
+        plane = NumberPlane()
+        i_hat = Vector([1, 0], color=X_COLOR)
+        j_hat = Vector([0, 1], color=Y_COLOR)
+
+        self.add(plane, i_hat, j_hat)
+        self.wait()
+
+        # The transformation matrix
+        matrix = [[1, 1], [-1, 1]]  # Rotation + scaling
+
+        # Apply transformation to the plane and basis vectors
+        self.play(
+            ApplyMatrix(matrix, plane),
+            ApplyMatrix(matrix, i_hat),
+            ApplyMatrix(matrix, j_hat),
+            run_time=3,
+        )
+        self.wait()
+
+        # Show where basis vectors land
+        new_i_coords = MathTex(
+            r"\hat{\imath} \to", r"\begin{bmatrix} 1 \\ -1 \end{bmatrix}",
+            tex_to_color_map={r"\hat{\imath}": X_COLOR},
+        ).to_corner(UL)
+        new_j_coords = MathTex(
+            r"\hat{\jmath} \to", r"\begin{bmatrix} 1 \\ 1 \end{bmatrix}",
+            tex_to_color_map={r"\hat{\jmath}": Y_COLOR},
+        ).next_to(new_i_coords, DOWN, aligned_edge=LEFT)
+
+        self.play(Write(new_i_coords), Write(new_j_coords))
+        self.wait(2)
+```
+
+### Determinant Visualization
+
+```python
+class DeterminantVisualization(Scene):
+    """Visualize determinant as area scaling factor."""
+
+    def construct(self):
+        plane = NumberPlane().set_opacity(0.3)
+        self.add(plane)
+
+        # Unit square
+        unit_square = Polygon(
+            ORIGIN, RIGHT, RIGHT + UP, UP,
+            fill_color=YELLOW, fill_opacity=0.3,
+            stroke_color=YELLOW, stroke_width=2,
+        )
+        area_label = MathTex(r"\text{Area} = 1", font_size=30)
+        area_label.move_to(unit_square)
+
+        self.play(DrawBorderThenFill(unit_square), Write(area_label))
+        self.wait()
+
+        # Transform
+        matrix = [[2, 1], [0, 3]]
+        det_value = matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0]
+
+        self.play(
+            ApplyMatrix(matrix, unit_square),
+            ApplyMatrix(matrix, plane),
+            run_time=2,
+        )
+
+        new_label = MathTex(
+            rf"\text{{Area}} = {det_value}",
+            font_size=30, color=YELLOW,
+        )
+        new_label.move_to(unit_square)
+        self.play(Transform(area_label, new_label))
+
+        # Show det formula
+        det_formula = MathTex(
+            rf"\det \begin{{bmatrix}} 2 & 1 \\ 0 & 3 \end{{bmatrix}} = {det_value}",
+        ).to_edge(UP)
+        self.play(Write(det_formula))
+        self.wait(2)
+```
+
+### Eigenvalue Tracing
+
+From `_2024/linalg/eigenlecture.py` -- using `t2c` for color-coded eigenvalue equations.
+
+```python
+class EigenvalueEquation(Scene):
+    """Color-coded eigenvalue equation in the 3b1b style."""
+
+    def construct(self):
+        eq = MathTex(
+            r"A", r"\vec{v}", r"=", r"\lambda", r"\vec{v}",
+            tex_to_color_map={
+                r"\vec{v}": YELLOW,
+                r"\lambda": TEAL,
+            },
+        )
+        eq.scale(1.5)
+        self.play(Write(eq))
+        self.wait()
+
+        # Rearrange to characteristic equation
+        char_eq = MathTex(
+            r"\det(", r"A", r"-", r"\lambda", r"I", r") = 0",
+            tex_to_color_map={r"\lambda": TEAL},
+        )
+        char_eq.scale(1.2)
+        char_eq.next_to(eq, DOWN, buff=1.0)
+        self.play(Write(char_eq, run_time=2))
+        self.wait(2)
+```
+
+## Calculus
+
+From `_2017/` Essence of Calculus and related videos.
+
+### Riemann Rectangles
+
+```python
+class RiemannRectangles(Scene):
+    """Progressive refinement of Riemann sums."""
+
+    def construct(self):
+        axes = Axes(
+            x_range=[0, 5, 1], y_range=[0, 5, 1],
+            x_length=8, y_length=5,
+        )
+        graph = axes.plot(lambda x: 0.2 * x**2, color=YELLOW)
+        graph_label = axes.get_graph_label(graph, r"f(x) = 0.2x^2")
+
+        self.play(Create(axes), Create(graph), Write(graph_label))
+        self.wait()
+
+        # Show progressively finer rectangles
+        for n_rects in [4, 8, 20, 50]:
+            rects = axes.get_riemann_rectangles(
+                graph,
+                x_range=[0, 4],
+                dx=4.0 / n_rects,
+                fill_opacity=0.5,
+                stroke_width=1,
+                stroke_color=WHITE,
+            )
+            rects.set_color_by_gradient(BLUE, GREEN)
+
+            if n_rects == 4:
+                self.play(Create(rects), run_time=1.5)
+            else:
+                self.play(Transform(rects_prev, rects), run_time=1)
+
+            rects_prev = rects
+            n_label = MathTex(f"n = {n_rects}", font_size=36)
+            n_label.to_corner(UR)
+            self.play(Write(n_label), run_time=0.5)
+            self.wait(0.5)
+            self.remove(n_label)
+
+        self.wait(2)
+```
+
+### Secant Line to Tangent Line
+
+```python
+class SecantToTangent(Scene):
+    """The derivative as limit of secant slopes."""
+
+    def construct(self):
+        axes = Axes(x_range=[-1, 5], y_range=[-1, 6], x_length=8, y_length=5)
+        graph = axes.plot(lambda x: 0.3 * x**2, color=YELLOW)
+        self.add(axes, graph)
+
+        # Fixed point
+        x0 = 2
+        dot_a = Dot(axes.i2gp(x0, graph), color=WHITE)
+        a_label = MathTex("a", font_size=30).next_to(dot_a, DL, buff=0.1)
+        self.play(FadeIn(dot_a), Write(a_label))
+
+        # Secant line that approaches tangent
+        dx_tracker = ValueTracker(2.0)
+
+        def get_secant_line():
+            dx = dx_tracker.get_value()
+            x1 = x0 + dx
+            p0 = axes.i2gp(x0, graph)
+            p1 = axes.i2gp(x1, graph)
+            slope = (p1[1] - p0[1]) / (p1[0] - p0[0]) if p1[0] != p0[0] else 0
+            line = axes.get_secant_slope_group(
+                x0, graph, dx=dx,
+                secant_line_color=BLUE,
+                secant_line_length=5,
+            )
+            return line
+
+        secant = always_redraw(get_secant_line)
+        self.add(secant)
+
+        # Animate dx shrinking
+        self.play(dx_tracker.animate.set_value(0.01), run_time=5, rate_func=smooth)
+        self.wait()
+
+        # Label as derivative
+        tangent_label = MathTex(
+            r"\text{slope} = f'(a)", font_size=36, color=BLUE,
+        ).to_corner(UR)
+        self.play(Write(tangent_label))
+        self.wait(2)
+```
+
+### Taylor Approximation
+
+```python
+class TaylorApproximation(Scene):
+    """Progressive Taylor polynomial approximation."""
+
+    def construct(self):
+        axes = Axes(x_range=[-3, 3], y_range=[-2, 4], x_length=10, y_length=6)
+        original = axes.plot(np.exp, color=YELLOW, x_range=[-3, 1.5])
+        original_label = MathTex(r"e^x", color=YELLOW, font_size=36)
+        original_label.next_to(original, UR)
+
+        self.play(Create(axes), Create(original), Write(original_label))
+        self.wait()
+
+        # Taylor polynomials of increasing order
+        taylor_funcs = [
+            lambda x: 1,
+            lambda x: 1 + x,
+            lambda x: 1 + x + x**2 / 2,
+            lambda x: 1 + x + x**2 / 2 + x**3 / 6,
+            lambda x: 1 + x + x**2 / 2 + x**3 / 6 + x**4 / 24,
+        ]
+        colors = [RED, GREEN, BLUE, PURPLE, ORANGE]
+
+        prev_approx = None
+        for n, (func, color) in enumerate(zip(taylor_funcs, colors)):
+            approx = axes.plot(func, color=color, x_range=[-3, 3])
+            label = MathTex(f"n = {n}", font_size=30, color=color)
+            label.to_corner(UR).shift(n * 0.4 * DOWN)
+
+            if prev_approx is None:
+                self.play(Create(approx), Write(label))
+            else:
+                self.play(
+                    Transform(prev_approx, approx),
+                    Write(label),
+                )
+            prev_approx = approx
+            self.wait(0.5)
+
+        self.wait(2)
+```
+
+## Probability
+
+From `_2019/bayes/`, `_2023/clt/`, `_2022/convolutions/`, and `_2018/eop/`.
+
+### Bar Charts for Distributions
+
+```python
+class DistributionChart(Scene):
+    """Bar chart for probability distributions -- from CLT video."""
+
+    def construct(self):
+        axes = Axes(
+            x_range=[0, 6, 1], y_range=[0, 0.5, 0.1],
+            x_length=6, y_length=4,
+            axis_config={"include_tip": False},
+        )
+        axes.y_axis.add_numbers(font_size=20, num_decimal_places=1)
+
+        # Dice distribution
+        dist = [1/6] * 6
+        bars = VGroup()
+        for i, p in enumerate(dist):
+            bar = Rectangle(
+                width=0.7 * axes.x_axis.get_unit_size(),
+                height=p * axes.y_axis.get_unit_size(),
+                fill_color=BLUE_D, fill_opacity=0.8,
+                stroke_color=WHITE, stroke_width=1,
+            )
+            bar.move_to(axes.c2p(i + 0.5, 0), DOWN)
+            bars.add(bar)
+        bars.set_color_by_gradient(BLUE, TEAL)
+
+        # Dice face labels
+        dice_labels = VGroup(*[
+            MathTex(str(n), font_size=24).next_to(axes.c2p(n - 0.5, 0), DOWN, SMALL_BUFF)
+            for n in range(1, 7)
+        ])
+
+        self.play(Create(axes))
+        self.play(
+            LaggedStartMap(GrowFromEdge, bars, edge=DOWN, lag_ratio=0.15),
+            Write(dice_labels),
+        )
+        self.wait(2)
+```
+
+### Bayes Diagram
+
+```python
+class BayesDiagram(Scene):
+    """Visual Bayes' theorem -- area-based probability."""
+
+    def construct(self):
+        # Full rectangle = total probability space
+        full_rect = Rectangle(width=8, height=4, stroke_color=WHITE)
+        full_rect.set_fill(BLUE_E, opacity=0.3)
+
+        # Split by prior P(H)
+        prior = 0.01  # e.g., disease prevalence
+        divider_x = full_rect.get_left()[0] + prior * full_rect.width
+        v_line = Line(
+            [divider_x, full_rect.get_bottom()[1], 0],
+            [divider_x, full_rect.get_top()[1], 0],
+            color=YELLOW, stroke_width=3,
+        )
+
+        # H region
+        h_rect = Rectangle(
+            width=prior * full_rect.width,
+            height=full_rect.height,
+            fill_color=GREEN, fill_opacity=0.5,
+            stroke_color=WHITE,
+        )
+        h_rect.align_to(full_rect, LEFT + DOWN)
+
+        h_label = MathTex(r"P(H)", font_size=30, color=GREEN)
+        h_label.next_to(h_rect, UP)
+
+        not_h_label = MathTex(r"P(\neg H)", font_size=30, color=RED)
+        not_h_label.next_to(full_rect, UP).shift(2 * RIGHT)
+
+        self.play(DrawBorderThenFill(full_rect))
+        self.play(Create(v_line), DrawBorderThenFill(h_rect))
+        self.play(Write(h_label), Write(not_h_label))
+        self.wait(2)
+```
+
+## Complex Analysis
+
+From `_2018/holomorphic.py`, `_2016/zeta.py`, `_2025/zeta/play.py`, and `_2025/laplace/`.
+
+### Complex Plane Transformations
+
+```python
+class ComplexTransformation(Scene):
+    """Visualize a complex function as a transformation of the plane."""
+
+    def construct(self):
+        plane = ComplexPlane(
+            x_range=[-3, 3], y_range=[-3, 3],
+            background_line_style={"stroke_opacity": 0.4},
+        )
+        plane.add_coordinate_labels(font_size=20)
+        self.add(plane)
+
+        # Label
+        func_label = MathTex(r"f(z) = z^2", font_size=40)
+        func_label.to_corner(UL)
+        func_label.set_backstroke(width=3)
+        self.play(Write(func_label))
+        self.wait()
+
+        # Apply the transformation
+        self.play(
+            plane.animate.apply_complex_function(lambda z: z**2),
+            run_time=3,
+        )
+        self.wait(2)
+```
+
+### Partial Sum Paths (Zeta Function Pattern)
+
+From `_2025/zeta/play.py`:
+
+```python
+class ZetaPartialSums(Scene):
+    """Visualize partial sums of a complex series as a spiral path."""
+
+    def construct(self):
+        plane = ComplexPlane(
+            x_range=[-3, 3], y_range=[-3, 3],
+            x_length=8, y_length=8,
+        )
+        plane.add_coordinate_labels(font_size=16)
+        self.add(plane)
+
+        # Partial sums of 1/n^s
+        s = complex(0.5, 14.134)  # Near first zeta zero
+        partial_sums = [0]
+        for n in range(1, 100):
+            partial_sums.append(partial_sums[-1] + 1 / n**s)
+
+        # Convert to points on the plane
+        points = [plane.n2p(z) for z in partial_sums]
+
+        # Draw the path
+        path = VMobject()
+        path.set_points_smoothly(points)
+        path.set_stroke(YELLOW, 2)
+
+        # Starting dot
+        start_dot = Dot(points[0], color=GREEN)
+        end_dot = Dot(points[-1], color=RED)
+
+        self.play(FadeIn(start_dot))
+        self.play(Create(path), run_time=5)
+        self.play(FadeIn(end_dot))
+        self.wait(2)
+```
+
+## Number Theory
+
+From `_2019/spirals.py` -- prime number spirals.
+
+```python
+class PrimeSpiral(Scene):
+    """Ulam-like prime spiral visualization."""
+
+    def construct(self):
+        # Generate dots for integers 1 to N
+        N = 5000
+        dots = VGroup()
+        prime_dots = VGroup()
+
+        for n in range(1, N):
+            # Polar coordinates: angle = n, radius = sqrt(n)
+            angle = n
+            radius = np.sqrt(n) * 0.05
+            point = radius * np.array([np.cos(angle), np.sin(angle), 0])
+            dot = Dot(point, radius=0.02)
+
+            if self._is_prime(n):
+                dot.set_color(TEAL)
+                prime_dots.add(dot)
+            else:
+                dot.set_color(GREY_D)
+                dot.set_opacity(0.2)
+            dots.add(dot)
+
+        self.play(
+            LaggedStartMap(FadeIn, dots, lag_ratio=0.001),
+            run_time=5,
+        )
+        self.wait(2)
+
+    @staticmethod
+    def _is_prime(n):
+        if n < 2:
+            return False
+        for k in range(2, int(np.sqrt(n)) + 1):
+            if n % k == 0:
+                return False
+        return True
+```
+
+## Topology
+
+From `_2020/surface_play.py`, `_2024/inscribed_rect/`.
+
+### 3D Surface Construction
+
+```python
+class SurfaceVisualization(ThreeDScene):
+    """Torus, sphere, and Mobius strip -- from surface_play.py."""
+
+    def construct(self):
+        self.set_camera_orientation(phi=70 * DEGREES, theta=-45 * DEGREES)
+
+        # Torus
+        torus = Surface(
+            lambda u, v: np.array([
+                (3 + np.cos(v)) * np.cos(u),
+                (3 + np.cos(v)) * np.sin(u),
+                np.sin(v),
+            ]),
+            u_range=[0, TAU],
+            v_range=[0, TAU],
+            resolution=(30, 20),
+        )
+        torus.set_fill_by_checkerboard(BLUE_D, BLUE_E, opacity=0.8)
+        torus.scale(0.5)
+
+        self.play(Create(torus), run_time=3)
+        self.begin_ambient_camera_rotation(rate=0.2)
+        self.wait(5)
+```
+
+## Neural Networks / Machine Learning
+
+From `_2024/transformers/` (attention, embedding, mlp, helpers).
+
+### Weight Matrix Visualization
+
+```python
+class WeightMatrixViz(Scene):
+    """Heatmap-style weight matrix -- from transformers helpers."""
+
+    def construct(self):
+        # Create matrix with color-coded entries
+        n_rows, n_cols = 6, 8
+        values = np.random.randn(n_rows, n_cols)
+
+        entries = VGroup()
+        cell_size = 0.5
+        for i in range(n_rows):
+            for j in range(n_cols):
+                val = values[i, j]
+                # value_to_color: positive=BLUE, negative=RED
+                alpha = min(abs(val) / 3, 1)
+                if val >= 0:
+                    color = interpolate_color(BLUE_E, BLUE_B, alpha)
+                else:
+                    color = interpolate_color(RED_E, RED_B, alpha)
+
+                cell = Square(side_length=cell_size)
+                cell.set_fill(color, opacity=0.8)
+                cell.set_stroke(WHITE, 0.5)
+                cell.move_to([j * cell_size, -i * cell_size, 0])
+                entries.add(cell)
+
+        entries.center()
+
+        # Brackets
+        left_bracket = MathTex(r"\left[", font_size=72)
+        right_bracket = MathTex(r"\right]", font_size=72)
+        left_bracket.next_to(entries, LEFT, buff=0.1)
+        right_bracket.next_to(entries, RIGHT, buff=0.1)
+
+        matrix_group = VGroup(left_bracket, entries, right_bracket)
+
+        label = MathTex(r"W_Q", font_size=36, color=YELLOW)
+        label.next_to(matrix_group, UP)
+
+        self.play(
+            FadeIn(entries, lag_ratio=0.01),
+            Write(left_bracket), Write(right_bracket),
+            Write(label),
+            run_time=2,
+        )
+        self.wait(2)
+```
+
+### Attention Arcs (from transformers/attention.py)
+
+```python
+class AttentionArcs(Scene):
+    """Visualize attention patterns between words -- from 3b1b's transformer series."""
+
+    def construct(self):
+        words = ["a", "fluffy", "blue", "creature", "roamed"]
+        word_mobs = VGroup(*[Text(w, font_size=30) for w in words])
+        word_mobs.arrange(RIGHT, buff=0.6)
+        word_mobs.shift(UP)
+
+        # Word rectangles
+        rects = VGroup(*[
+            SurroundingRectangle(w, buff=0.1, stroke_color=GREY, stroke_width=1)
+            for w in word_mobs
+        ])
+
+        self.play(
+            LaggedStartMap(FadeIn, word_mobs, shift=0.5 * UP, lag_ratio=0.25)
+        )
+        self.play(FadeIn(rects))
+        self.wait()
+
+        # Attention arcs: adjectives attend to their nouns
+        connections = [(1, 3), (2, 3)]  # "fluffy"->creature, "blue"->creature
+        arcs = VGroup()
+        for src, tgt in connections:
+            arc = Arrow(
+                word_mobs[src].get_top(),
+                word_mobs[tgt].get_top(),
+                path_arc=-150 * DEGREES,
+                buff=0.1,
+                stroke_color=GREY_B,
+                stroke_width=2,
+            )
+            arcs.add(arc)
+
+        self.play(LaggedStartMap(Create, arcs, lag_ratio=0.3, run_time=1.5))
+        self.wait(2)
+```
+
+### Embedding Vectors
+
+```python
+class EmbeddingVisualization(Scene):
+    """Token embedding as a column of colored numbers."""
+
+    def construct(self):
+        # Create a numeric embedding display
+        values = np.random.randn(10)
+        entries = VGroup()
+        for val in values:
+            alpha = min(abs(val) / 2, 1)
+            color = interpolate_color(BLUE_E, BLUE_B, alpha) if val >= 0 else \
+                    interpolate_color(RED_E, RED_B, alpha)
+            dec = DecimalNumber(val, num_decimal_places=2, font_size=24)
+            dec.set_color(color)
+            entries.add(dec)
+
+        entries.arrange(DOWN, buff=0.15)
+
+        # Brackets
+        left_b = MathTex(r"\left[", font_size=60).next_to(entries, LEFT, buff=0.1)
+        right_b = MathTex(r"\right]", font_size=60).next_to(entries, RIGHT, buff=0.1)
+
+        embedding = VGroup(left_b, entries, right_b)
+
+        # Label
+        word = Text("creature", font_size=30)
+        word.next_to(embedding, UP, buff=0.5)
+        arrow = Arrow(word.get_bottom(), embedding.get_top(), buff=0.1)
+
+        self.play(Write(word))
+        self.play(GrowArrow(arrow))
+        self.play(FadeIn(embedding, shift=0.5 * DOWN))
+        self.wait(2)
+```
+
+## Best Practices by Domain
+
+1. **Linear Algebra**: Always use GREEN for x/i-hat, RED for y/j-hat, BLUE for z/k-hat
+2. **Calculus**: Show the geometric meaning alongside every formula
+3. **Probability**: Use bar charts with gradient coloring (BLUE to TEAL)
+4. **Complex Analysis**: Use ComplexPlane with `apply_complex_function()` for transformations
+5. **Number Theory**: Polar coordinate layouts reveal hidden structure
+6. **Topology**: Use ThreeDScene with ambient camera rotation for surfaces
+7. **Neural Networks**: Color-code matrix entries by value (positive=BLUE, negative=RED)
+8. **Across all domains**: Use `tex_to_color_map` / `t2c` for consistent color-coded equations