Quantum, reconsidered

The hardware is genuinely advancing. Every year the qubits get better-controlled, more integrated, and less noisy — real engineering, worth taking seriously. But that progress quietly hides the actual insight. The reason certain quantum algorithms are powerful is not the fridge — it is a way of structuring a computation around amplitudes that can add and cancel. That structure is a design idea, and design ideas do not need a particular substrate; they need to be understood, then implemented on whatever hardware is scalable and deployed today.

So the reframe is not "the hardware won't work" — it will keep improving. It is three sharper claims. One: a device with a few dozen qubits is a scaling milestone, not a computational advantage — at that size a laptop still out-computes it, for reasons you'll measure in Module 05. Two: for a large, important class of problems the quantum advantage is dequantizable, so waiting for the machine is the wrong default — you can deploy it classically today. Three: the hardware's real payoff is producing quantum data, the one place the advantage genuinely survives (Module 06). Seen this way, hardware progress and this course are complementary, not opposed.

So we invert the usual order. Instead of "wait for the machine, then run the algorithm," we ask: which part of a quantum algorithm is the irreducible idea, and can it run classically at scale? For a surprisingly large class the answer is yes — the same interference algebra runs in polynomial space on a CPU, a GPU, or an FPGA, deterministically. And this is not "quantum-inspired" hand-waving: everything here is byte-for-byte or float-for-float reproducible, and where we claim two computations are equal, you can re-run both and check.

Start by demystifying the object. A single qubit is not exotic hardware — it is two numbers and some trigonometry: a state cos(θ/2)|0⟩ + e^(iφ)·sin(θ/2)|1⟩. Drag it and watch the amplitudes and probabilities update. This is the whole thing, and it runs anywhere arithmetic runs.

A classical probabilistic model works with probabilities: non-negative numbers that only add. A quantum model works with amplitudes: complex numbers whose squared magnitude gives a probability, and which can destructively cancel. That single difference — the ability to subtract — is the resource. When people say a problem is "genuinely quantum," this is almost always what they mean.

You can see where it comes from. Send particles through two slits. Add amplitudes and they interfere — bright and dark bands appear, and each dark band is a place where two paths cancel to zero. Add probabilities instead — what a classical particle does — and the bands vanish into a uniform blur. Same two slits; only amplitudes can subtract. Flip the switch:

Now the same principle inside a learning model. A parity distribution puts all its mass on bitstrings of one parity and exactly zero on the other. A model built from non-negative weights that only add can spread mass but never carve a clean zero into half the outcomes — an independent-bit sampler sits stuck at 50% mass in the wrong sector. A Born machine — P(x) = |ψ(x)|² — drives that sector toward zero by making its amplitudes cancel, exactly like a dark fringe. Train one now, in this tab:

Here is the load-bearing result of the whole course. A quantum model that encodes data x into rotations and reads out an expectation is exactly a truncated Fourier series f(x) = Σω cω eiωx — a sum of phasors (Schuld–Sweke–Meyer). The data encoding sets which frequencies ω appear; the trainable gates set the coefficients.

That one identity collapses a pile of separate-sounding things into a single algebra: quantum feature maps, quantum kernels, Born machines, and — on the classical side — random Fourier features and holographic / hyperdimensional representations (FHRR / HDC) are all the same phasor algebra, where complex-phase binding is interference. So the quantum model can be computed on the state vector (green), or reproduced as a classical phasor sum (blue) — identical function, two substrates. Watch them coincide:

If a quantum kernel is a phasor algebra (Module 03), then it deploys as a bank of phasor features and an ordinary linear model on top. Draw random frequencies, map each point through the phasor bank, and a plain ridge classifier now separates data that is not linearly separable — concentric circles, XOR — the supervised twin of the generative Born machine. And because each phasor is just a phase, it runs at low integer resolution (qFHRR) for the edge with no loss of accuracy.

A course that only sold the upside would be hype. Here is the boundary. Train a deep, generic parameterized quantum circuit and its gradients vanish exponentially with system size — the barren plateau. The landscape flattens so fast that you cannot tell which way is downhill; the model is untrainable. Measure the gradient variance shrinking as we add qubits:

And there's a subtler trap: the tricks that avoid barren plateaus — shallow, heavily structured circuits — tend to be exactly the ones a classical computer can simulate efficiently. So the deployable regime is not "a giant parameterized circuit." It is the shallow, structured, phasor regime from Modules 03–04. That is the honest home of quantum machine learning on classical inputs — and it is why the next module looks somewhere else entirely for a durable advantage.

Every advantage so far dissolved on classical input. But flip the question: what if the data itself is quantum — copies of an unknown state or channel? Now there is a real, unconditional, exponential separation (Chen–Cotler–Huang–Li; Huang et al., Science 2022). To learn an unknown n-qubit channel's 2ⁿ error fidelities, a strategy without quantum memory must spread its measurements across every probe — Ω(2ⁿ) copies. A two-copy Bell measurement reads the error pattern directly and pins down every fidelity at once — O(1/ε²) copies, independent of n. Watch the gap open:

A deployable substrate is only trustworthy if its cost is auditable. So every interference computation seals a signed receipt that splits the two halves honestly: the work — the exact phasor-operation count, recomputable by anyone from the problem's shape, and linear, never 2ⁿ — from the energy, the measured draw only the signer can attest. Bound together, they turn qFHRR from merely fast into accountable. Seal one from Module 04's classifier: