06-reference

3blue1brown grovers algorithm clarification

Sun Apr 19 2026 20:00:00 GMT-0400 (Eastern Daylight Time) ·reference ·source: 3Blue1Brown YouTube ·by Grant Sanderson (3Blue1Brown)
3blue1brownquantum-computinggrovers-algorithmexplanation-craftpedagogyhype-correctionlinearitysuperposition

3Blue1Brown — Where my explanation of Grover’s algorithm failed

Why this is in the vault

A 16-minute corrective follow-up where Grant Sanderson openly diagnoses why his prior Grover’s-algorithm video left viewers thinking the quantum computer must already know the answer it’s searching for. It belongs in the vault for two reasons that have nothing to do with quantum computing per se: first, it is a clinic in post-publication explanation craft — Sanderson reads the comments, names the specific framing choice that misled people (“I briefly flashed an example function that just checks if the input is 12 and saying that we were going to treat the function as a black box. That’s on me. That’s a misleading way to open things”), and rewrites the mental model with two better examples (Sudoku verifier, SHA-256 inverter). Second, it ends with an unusual-for-the-genre bit of hype correction: Sanderson explicitly tells viewers that even with a working quantum computer, Grover’s algorithm against SHA-256 still costs 2^128 operations and “this frankly has questionable utility” for most problems. That combination — owning the misframing AND deflating the field’s hype — is the rare-virtue editorial discipline RDCO needs to cultivate in Sanity Check.

Core argument

  1. The framing of an example controls what readers infer about the problem class. Sanderson’s original video used a toy verifier (check if input == 12) as its black-box. That example silently implies the answer lives inside the function’s source. The fix is to swap the toy for an example where verification is genuinely separate from solution: a Sudoku checker or SHA-256. Same algorithm, completely different intuitive footprint. The lesson generalizes: a misleading example is a more expensive bug than a misleading sentence, because readers form their model from the example and treat the surrounding prose as commentary.
  2. “Black box” has two distinct meanings that explanations conflate. The first: the user can only call the function, not inspect it. The second: nobody, including the implementer, can predict the output without running it. Sanderson’s original video traded on (1) but readers heard (2). The Sudoku and SHA-256 examples force the right reading because in those cases neither the user nor the function’s author knows the secret — it’s an emergent property of the rules.
  3. Linearity is the load-bearing concept that gets skipped because it sounds obvious. Sanderson admits “half of my reason for making this whole follow-up video is as an excuse to talk about it.” Quantum operations are linear: the action on a superposition is the weighted sum of the action on each basis vector. This is why you can describe the verifier’s action on every possible input “at once” without that being a literal parallel computation. The hiker-rotated-90° analogy: the linearity is a property of the transformation, not a set of instructions for performing it.
  4. The visualization slice is a happy emergent property, not a chosen input. When Sanderson drew Grover’s algorithm on a 2D plane that included the unknown answer-axis, viewers thought choosing that plane was part of the algorithm. It isn’t. The algorithm doesn’t know which plane it’s confined to; the math just happens to keep it there.
  5. Quadratic speedup is the typical case, not exponential. Sanderson explicitly: “It is not dramatically faster. It’s only a quadratic speed up. And given the overheads for making quantum computing work, this frankly has questionable utility.” For SHA-256, brute force is 2^256, Grover gives 2^128 — still infeasibly large. RSA gets exponential speedup via Shor, but most problems get the much-less-impressive Grover treatment. Most popular coverage flips this ratio.

Mapping against Ray Data Co

Open follow-ups