Most of the writing here comes in series: a set of posts that build one idea from the ground up, in order. Some of that material is easier to follow when it moves: a diagram that assembles itself, a value moving through a pipeline, a bar chart of amplitudes that shifts when you apply a gate. So I built a way to animate it, and the results are on the metafunctor YouTube channel.
This post describes the channel at launch. It has grown since; the current playlist catalog has the full list.
The videos are not a separate project. Each one is built from the same source material as the post it comes from, through a pipeline I wrote from scratch: Manim for the animation, narrated dialogue for the voice, and the code and math taken straight from the series text. Each series landing page embeds its full playlist, and each post embeds its own episode at the bottom, so you can read and watch in the same place.
At launch there were four playlists, thirty-seven videos in total.
Algorithms Arise from Algebraic Structure
The Stepanov series, nine episodes: declare the algebraic structure a problem lives in, and the algorithms fall out for free.
Open the playlist on YouTube (9 episodes)
Episode list
- Algorithms Arise from Algebraic Structure
- One Algorithm, Infinite Powers
- Polynomials as Euclidean Domains
- Forward-Mode Automatic Differentiation via Dual Numbers
- Reverse-Mode Automatic Differentiation
- Semirings: One Algorithm, Six Graph Problems
- Homomorphisms: Fold Is the Universal Map
- Free Algebras: Why Lists and Polynomials Are Universal
- Lattices: Fixed Points and Tarski's Theorem
Next-Token Prediction: From Solomonoff to Transformers
The sequential-prediction series, eight episodes: what-comes-next as the foundation the whole language-model era stands on, traced from Solomonoff to the transformer.
Open the playlist on YouTube (8 episodes)
Episode list
- Why Predict the Next Symbol?
- Introduction to Sequential Prediction
- Solomonoff Induction: The Incomputable Ideal
- The Bayesian Prediction Framework
- N-gram Language Models: Counting and Smoothing
- Context Tree Weighting: Theory Meets Practice
- Neural Language Models: From RNNs to Transformers
- CTW vs. N-grams vs. Neural Language Models
Quantum Computing from Scratch, in Python
The quantum series, ten episodes: a working simulator built in NumPy from nothing, with a visual language of amplitude bars that makes interference something you can see.
Open the playlist on YouTube (10 episodes)
Episode list
- Why Build a Quantum Computer from Scratch?
- Classical Information First: The Coin Under the Cup
- What Is a Qubit? Building the First Gate
- Many Qubits and Entanglement: Tensor Products
- Circuits and Interference: Making Amplitudes Useful
- Grover's Search: Quadratic Speedup from Structured Interference
- The Quantum Fourier Transform
- Shor's Algorithm: Why RSA Has an Expiration Date
- Mixed States and the Density Matrix
- Noise, Decoherence, and Why Error Correction Is Hard
Inductive Biases: What Your Architecture Assumes
The inductive-biases series, ten episodes: every architecture is a bet on the shape of the world, and each one is graded on the same scorecard, what it assumes, what that assumption buys, and what it costs when the world does not comply.
Open the playlist on YouTube (10 episodes)
Episode list
- Learning Without Assumptions Is Impossible
- Sample Efficiency and the Price of Priors
- A Network Computes Numbers. The Loss Decides What They Mean.
- The Loss Function Is a Distribution Assumption
- What a Convolution Assumes
- Bengio's Language Model: The Markov Assumption Made Architectural
- Recurrence Is Weight Sharing Across Time, and It Costs You
- Attention Is a Learned Pointer Dereference
- Attention Weight Is Not Information Flow
- Reinforcement Learning Is Cross-Entropy, Reweighted by Reward
More playlists will follow, drawn from the other series on the site, as I get the animation for each one right. The plan is to keep the two in step: what gets written gets animated, and both come from the same source.
Discussion