Preview slides for all chapters, Chapter 0 now has benchmarks, chapter 8 now also contains triangle centrality scenes and notebook.

Author: michelp

Chapter0/Scene0.py

@@ -41,4 +41,28 @@ def construct(self):
 
         # Fade out title and logos at the end
         self.play(FadeOut(title), FadeOut(logos_group), FadeOut(footer))
+
+        # Chapter summary slide
+        with self.voiceover(
+            """In this chapter, we'll cover how sparse matrices represent graphs,
+            the duality between graphs and matrices, the basics of matrix-vector
+            multiplication, and why algebraic approaches to graph algorithms
+            are so powerful."""
+        ):
+            chapter_title = Text("Chapter 0: Introduction to GraphBLAS", font_size=40).to_edge(UP)
+
+            outline = VGroup(
+                Text("Sparse matrices and graph representation", font_size=28),
+                Text("Graph-matrix duality", font_size=28),
+                Text("Matrix-vector multiplication basics", font_size=28),
+                Text("Why algebraic graph algorithms", font_size=28),
+            ).arrange(DOWN, buff=0.4, aligned_edge=LEFT)
+            outline.next_to(chapter_title, DOWN, buff=0.8)
+
+            self.play(Write(chapter_title))
+            self.play(FadeIn(outline))
+            self.wait(1)
+
+        # Fade out summary
+        self.play(FadeOut(chapter_title), FadeOut(outline))
         self.wait(0.5)

Chapter0/Scene3.py

@@ -102,7 +102,7 @@ def construct(self):
                     if value == 0:
                         sparse_matrix.get_entries()[i * len(row) + j].set_opacity(0)
 
-            sparse_matrix.to_edge(LEFT, buff=0.5)
+            sparse_matrix.to_edge(LEFT, buff=0.75)
             sparse_vector = Matrix(initial_result_data, v_buff=0.5).scale(1).next_to(sparse_matrix, RIGHT, buff=0.5)
 
             for j, sparse_entry in enumerate(sparse_vector.get_entries()):

Chapter0/Scene4.py

@@ -1,5 +1,6 @@
 import sys
 sys.path.insert(0, '..')
+import math
 
 from manim import *
 from manim_voiceover import VoiceoverScene
@@ -8,58 +9,106 @@
 
 from scene_utils import setup_scene
 
-matrices = [
-    ('pct20stif', 'Structural Analysis', 1, 2),
-    ('rw5151', 'Statistics and Mathematics', 1, 5),
-    ('lpl1', 'Resource Optimization', 2, 4),
-    ('poli_large', 'Economic Planning', 1, 5),
-    ('conf5_0-4x4-10', 'Theoretical Quantum Chemistry', 1, 5),
-]
+
+def get_chart_config(values):
+    """Return y_range, scale factor, and format function based on max value."""
+    max_val = max(values)
+
+    if max_val >= 1.0:  # Billions scale
+        # Round up to nice number for y_max
+        y_max = math.ceil(max_val * 1.2)  # 20% headroom
+        y_step = max(1, y_max // 4)
+        scale = 1.0
+        suffix = "B"
+    else:  # Millions scale (values are in billions, so 0.375 = 375M)
+        # Convert to millions for display
+        max_millions = max_val * 1000
+        y_max_millions = math.ceil(max_millions / 100) * 100  # Round to nearest 100M
+        y_max = y_max_millions / 1000  # Back to billions for chart
+        y_step = y_max / 4
+        scale = 1000  # Multiply by 1000 to get millions
+        suffix = "M"
+
+    return y_max, y_step, scale, suffix
+
+
+def format_value(val, scale, suffix):
+    """Format value for bar label."""
+    display_val = val * scale if scale > 1 else val
+    if display_val >= 10:
+        return f"{int(display_val)}{suffix}"
+    else:
+        return f"{display_val:.1f}{suffix}"
+
+# Graph labels with edge counts
+GRAPHS = ["Twitter\n1.5B", "web\n1.9B", "kron\n4.2B", "urand\n4.3B"]
+
+# Placeholder benchmark results (billions of edges/second)
+BENCHMARKS = {
+    "Breadth First Search": [5.8, 7.1, 7.6, 5.0],
+    "PageRank": [0.148, 0.337, 0.217, 0.375],
+    "Connected Components": [1.2, 1.1, 1.1, 1.1],
+    "Single Source Shortest Path": [0.181, 0.717, 0.257, 0.175],
+}
+
+ALGORITHM_SUMMARIES = {
+    "Breadth First Search": "BFS explores a graph level by level, traversing all nodes reachable from a starting node.",
+    "PageRank": "PageRank computes the importance of each node based on the structure of incoming links.",
+    "Connected Components": "Connected components identifies groups of nodes that are reachable from one another.",
+    "Single Source Shortest Path": "SSSP finds the minimum cost path from a source node to all other nodes in a weighted graph.",
+}
 
 class Scene4(VoiceoverScene, Scene):
     def construct(self):
         setup_scene(self)
 
+        title = Text("SuiteSparse GraphBLAS Performance", font_size=36).to_edge(UP)
+        y_label = Text("Edges/Second", font_size=20).rotate(PI/2)
+
         with self.voiceover(
-                """Sparse graphs and linear algebra play an important
-                role in many scientific and engineering disciplines,
-                including:"""
+            """SuiteSparse GraphBLAS achieves impressive performance across
+            standard graph algorithm benchmarks on four large-scale graphs
+            ranging from 1.5 to 4.3 billion edges."""
         ):
-            title = Tex("Graphs are Everywhere").scale(1.5).to_edge(UP)
             self.play(Write(title))
-            self.wait(3)
 
-        for subdir, description, ai, gi in matrices:
-            matrix_image = ImageMobject(f"../scraped_images/{subdir}/image_{ai}_inv.jpg").scale(1.5).to_edge(LEFT)
-            graph_image = ImageMobject(f"../scraped_images/{subdir}/image_{gi}.jpg").scale(1.5).to_edge(RIGHT)
+        for bench_name, values in BENCHMARKS.items():
+            subtitle = Text(bench_name, font_size=28).next_to(title, DOWN)
 
-            self.play(FadeIn(matrix_image), FadeIn(graph_image))
-            with self.voiceover(description):
-                self.wait(2)
-                self.play(FadeOut(matrix_image), FadeOut(graph_image))
+            # Get dynamic y-axis configuration based on data scale
+            y_max, y_step, scale, suffix = get_chart_config(values)
 
-        self.play(FadeOut(title))
+            # Create chart with zero values initially
+            chart = BarChart(
+                values=[0, 0, 0, 0],
+                bar_names=GRAPHS,
+                y_range=[0, y_max, y_step],
+                y_length=4,
+                x_length=10,
+                bar_colors=[BLUE, GREEN, ORANGE, RED],
+            ).scale(0.9)
 
-        with self.voiceover(
-                """In our next video, we will introduce the Python
-                bindings for GraphBLAS and explore the duality between
-                matrix multiplication and graph traversal in more
-                depth. We will also introduce fundamental GraphBLAS
-                concepts including semirings, accumulation, and
-                masking."""
-        ):
-            title = Tex("Coming Next").scale(1.5).to_edge(UP)
-
-            bullet_points = BulletedList(
-                "Install Python library",
-                "Matrix Multiplication as Breadth First Search.",
-                "Using Semirings to perform combining operations.",
-                "Accumulating results as you go.",
-                "Masking or including only certain values.",
-                font_size=36
-            )
-            bullet_points.next_to(title, DOWN, buff=0.5)
+            y_label_copy = y_label.copy().next_to(chart, LEFT)
 
-            self.play(Write(title))
-            self.play(FadeIn(bullet_points, shift=UP, lag_ratio=0.1))
-            self.wait(3)
+            with self.voiceover(f"Results for {bench_name}."):
+                self.play(Write(subtitle))
+                self.play(Create(chart), FadeIn(y_label_copy))
+                # Animate bars growing from zero to actual values
+                self.play(chart.animate.change_bar_values(values))
+
+                # Add value labels above each bar
+                bar_labels = VGroup()
+                for i, (bar, val) in enumerate(zip(chart.bars, values)):
+                    label = Text(format_value(val, scale, suffix), font_size=18)
+                    label.next_to(bar, UP, buff=0.1)
+                    bar_labels.add(label)
+                self.play(FadeIn(bar_labels))
+                self.wait(1)
+
+            with self.voiceover(ALGORITHM_SUMMARIES[bench_name]):
+                self.wait(0.5)  # Chart stays visible during voiceover
+
+            self.play(FadeOut(chart), FadeOut(subtitle), FadeOut(y_label_copy), FadeOut(bar_labels))
+
+        self.play(FadeOut(title))
+        self.wait(0.5)

Chapter0/Scene5.py

@@ -0,0 +1,65 @@
+import sys
+sys.path.insert(0, '..')
+
+from manim import *
+from manim_voiceover import VoiceoverScene
+from dotenv import load_dotenv
+load_dotenv()
+
+from scene_utils import setup_scene
+
+matrices = [
+    ('pct20stif', 'Structural Analysis', 1, 2),
+    ('rw5151', 'Statistics and Mathematics', 1, 5),
+    ('lpl1', 'Resource Optimization', 2, 4),
+    ('poli_large', 'Economic Planning', 1, 5),
+    ('conf5_0-4x4-10', 'Theoretical Quantum Chemistry', 1, 5),
+]
+
+class Scene5(VoiceoverScene, Scene):
+    def construct(self):
+        setup_scene(self)
+
+        with self.voiceover(
+                """Sparse graphs and linear algebra play an important
+                role in many scientific and engineering disciplines,
+                including:"""
+        ):
+            title = Tex("Graphs are Everywhere").scale(1.5).to_edge(UP)
+            self.play(Write(title))
+            self.wait(3)
+
+        for subdir, description, ai, gi in matrices:
+            matrix_image = ImageMobject(f"../scraped_images/{subdir}/image_{ai}_inv.jpg").scale(1.5).to_edge(LEFT)
+            graph_image = ImageMobject(f"../scraped_images/{subdir}/image_{gi}.jpg").scale(1.5).to_edge(RIGHT)
+
+            self.play(FadeIn(matrix_image), FadeIn(graph_image))
+            with self.voiceover(description):
+                self.wait(2)
+                self.play(FadeOut(matrix_image), FadeOut(graph_image))
+
+        self.play(FadeOut(title))
+
+        with self.voiceover(
+                """In our next video, we will introduce the Python
+                bindings for GraphBLAS and explore the duality between
+                matrix multiplication and graph traversal in more
+                depth. We will also introduce fundamental GraphBLAS
+                concepts including semirings, accumulation, and
+                masking."""
+        ):
+            title = Tex("Coming Next").scale(1.5).to_edge(UP)
+
+            bullet_points = BulletedList(
+                "Install Python library",
+                "Matrix Multiplication as Breadth First Search.",
+                "Using Semirings to perform combining operations.",
+                "Accumulating results as you go.",
+                "Masking or including only certain values.",
+                font_size=36
+            )
+            bullet_points.next_to(title, DOWN, buff=0.5)
+
+            self.play(Write(title))
+            self.play(FadeIn(bullet_points, shift=UP, lag_ratio=0.1))
+            self.wait(3)

Chapter1/Scene0.py

@@ -58,4 +58,27 @@ def construct(self):
 
         # Fade out title and logos at the end
         self.play(FadeOut(title), FadeOut(logos_group), FadeOut(footer))
+
+        # Chapter summary slide
+        with self.voiceover(
+            """This chapter covers installing the python-graphblas library,
+            creating matrices and vectors, basic operations, and provides
+            code examples that will be used throughout the rest of the series."""
+        ):
+            chapter_title = Text("Chapter 1: Python GraphBLAS", font_size=40).to_edge(UP)
+
+            outline = VGroup(
+                Text("Installing python-graphblas", font_size=28),
+                Text("Creating matrices and vectors", font_size=28),
+                Text("Basic operations", font_size=28),
+                Text("Code examples throughout the series", font_size=28),
+            ).arrange(DOWN, buff=0.4, aligned_edge=LEFT)
+            outline.next_to(chapter_title, DOWN, buff=0.8)
+
+            self.play(Write(chapter_title))
+            self.play(FadeIn(outline))
+            self.wait(1)
+
+        # Fade out summary
+        self.play(FadeOut(chapter_title), FadeOut(outline))
         self.wait(0.5)

Chapter2/Scene0.py

@@ -55,4 +55,27 @@ def construct(self):
 
         # Fade out title and logos at the end
         self.play(FadeOut(title), FadeOut(logos_group), FadeOut(footer))
+
+        # Chapter summary slide
+        with self.voiceover(
+            """We'll learn what a semiring is, explore plus-times for standard
+            arithmetic, min-plus for tropical optimization, and any-pair for
+            structural operations on graphs."""
+        ):
+            chapter_title = Text("Chapter 2: Semirings", font_size=40).to_edge(UP)
+
+            outline = VGroup(
+                Text("What is a semiring", font_size=28),
+                Text("Plus-times (standard arithmetic)", font_size=28),
+                Text("Min-plus (tropical semiring)", font_size=28),
+                Text("Any-pair (structural operations)", font_size=28),
+            ).arrange(DOWN, buff=0.4, aligned_edge=LEFT)
+            outline.next_to(chapter_title, DOWN, buff=0.8)
+
+            self.play(Write(chapter_title))
+            self.play(FadeIn(outline))
+            self.wait(1)
+
+        # Fade out summary
+        self.play(FadeOut(chapter_title), FadeOut(outline))
         self.wait(0.5)

Chapter3/Scene0.py

@@ -57,4 +57,27 @@ def construct(self):
 
         # Fade out title and logos at the end
         self.play(FadeOut(title), FadeOut(logos_group), FadeOut(footer))
+
+        # Chapter summary slide
+        with self.voiceover(
+            """This chapter covers vector-matrix multiply, masking to control
+            which outputs are written, complement masks for inverting selection,
+            and replacement semantics for managing state between iterations."""
+        ):
+            chapter_title = Text("Chapter 3: BFS Implementation", font_size=40).to_edge(UP)
+
+            outline = VGroup(
+                Text("Vector-matrix multiply (vxm)", font_size=28),
+                Text("Masking to control output", font_size=28),
+                Text("Complement masks", font_size=28),
+                Text("Replacement semantics", font_size=28),
+            ).arrange(DOWN, buff=0.4, aligned_edge=LEFT)
+            outline.next_to(chapter_title, DOWN, buff=0.8)
+
+            self.play(Write(chapter_title))
+            self.play(FadeIn(outline))
+            self.wait(1)
+
+        # Fade out summary
+        self.play(FadeOut(chapter_title), FadeOut(outline))
         self.wait(0.5)

Chapter4/Scene0.py

@@ -37,4 +37,27 @@ def construct(self):
 
         # Fade out intro elements
         self.play(FadeOut(title), FadeOut(logos_group), FadeOut(footer))
+
+        # Chapter summary slide
+        with self.voiceover(
+            """We'll explore multi-hop path discovery, how A squared finds
+            two-hop neighbors, transitive closure, and using mxm with
+            different semirings."""
+        ):
+            chapter_title = Text("Chapter 4: Matrix-Matrix Multiplication", font_size=40).to_edge(UP)
+
+            outline = VGroup(
+                Text("Multi-hop path discovery", font_size=28),
+                Text("A squared finds 2-hop neighbors", font_size=28),
+                Text("Transitive closure", font_size=28),
+                Text("mxm with semirings", font_size=28),
+            ).arrange(DOWN, buff=0.4, aligned_edge=LEFT)
+            outline.next_to(chapter_title, DOWN, buff=0.8)
+
+            self.play(Write(chapter_title))
+            self.play(FadeIn(outline))
+            self.wait(1)
+
+        # Fade out summary
+        self.play(FadeOut(chapter_title), FadeOut(outline))
         self.wait(0.5)

Chapter5/Scene0.py

@@ -59,4 +59,27 @@ def construct(self):
 
         # Fade out title and logos at the end
         self.play(FadeOut(title), FadeOut(logos_group), FadeOut(footer))
+
+        # Chapter summary slide
+        with self.voiceover(
+            """This chapter covers source and destination matrices, how
+            S times D equals the adjacency matrix, multigraphs with parallel
+            edges, and hypergraphs for complex relationships."""
+        ):
+            chapter_title = Text("Chapter 5: Incidence Matrices", font_size=40).to_edge(UP)
+
+            outline = VGroup(
+                Text("Source and destination matrices", font_size=28),
+                Text("S x D = Adjacency", font_size=28),
+                Text("Multigraphs (parallel edges)", font_size=28),
+                Text("Hypergraphs", font_size=28),
+            ).arrange(DOWN, buff=0.4, aligned_edge=LEFT)
+            outline.next_to(chapter_title, DOWN, buff=0.8)
+
+            self.play(Write(chapter_title))
+            self.play(FadeIn(outline))
+            self.wait(1)
+
+        # Fade out summary
+        self.play(FadeOut(chapter_title), FadeOut(outline))
         self.wait(0.5)