Quantum Mechanics as Computation: A Primer

I cover climate. I spend most of my time thinking about carbon budgets, tipping points, and whether any government on earth is moving fast enough to matter. So when I found myself watching an hour-long IBM lecture on quantum state vectors and unitary matrices, the honest explanation is that I followed the problem to where it leads.

The problem: the clean energy transition doesn't just require new turbines and better batteries. It requires computation at a scale and precision that classical machines are struggling to deliver — modeling molecular interactions for next-generation solar materials, simulating atmospheric chemistry, optimizing continent-spanning grids in real time. The researchers working on those problems keep pointing at quantum computing as part of the answer. Which means the mathematics Kevin Sung explains in a recent Qiskit Summer School lecture is, in a roundabout way, infrastructure. Not glamorous infrastructure. The kind you need to understand before you can evaluate whether the promises being made about it are real.

Sung, a software engineer at IBM, opens with classical information — not because it's a warm-up, but because the contrast is doing genuine work. A classical system holds a determinate state or, if you're reasoning about probabilities, a vector of non-negative numbers that sum to one. The vector grows with the number of systems you combine: two bits gives you four possible states, three gives you eight, and so on in powers of two. The rule is Cartesian products all the way down, and the corresponding linear-algebra operation is the tensor product.

This is where Sung lands what I think is the lecture's sharpest observation. He notes that fully describing the probabilistic state of 500 bits would require a vector with 2^500 entries — a number he describes as exceeding "the number of atoms in the observable universe." I'm attributing that comparison to Sung rather than vouching for it independently; the point is directionally correct and the implication is real: you cannot write down this vector, full stop. Classical computers don't actually do this. They find efficient algorithms that sidestep the explicit representation.

"Clearly actual computer programs don't explicitly store all of the probabilities," Sung says, which sounds obvious until you hold it next to what comes next.

Because a quantum system faces the same scaling problem — its state vector also grows exponentially with the number of qubits — but it faces it differently. Where a classical probabilistic state uses real, non-negative numbers that sum to one, a quantum state uses complex numbers whose squared absolute values sum to one. Swap the normalization rule, admit complex amplitudes, and you get a completely different kind of vector space. The operations that preserve valid classical states are stochastic matrices; the operations that preserve valid quantum states are unitary matrices. The tensor product still combines multiple systems. The mathematics rhymes across both regimes, and Sung is deliberate about making that structure visible.

This is what makes his approach worth spending time with. He isn't starting from quantum weirdness and working backward toward the formalism. He's building both classical and quantum information from the same scaffolding — vectors, matrices, tensor products, normalization — and then showing exactly where they diverge. The divergence is precise: one number constraint versus another. Everything else follows from that.

The hands-on portion, conducted live in a Jupyter notebook using Qiskit, translates the abstraction into something runnable. Sung constructs quantum state vectors with NumPy, verifies their validity using numpy.linalg.norm, then uses Qiskit's StateVector class to add structure — automatic subsystem detection, measurement sampling, gate application. He walks through the X gate (a bit flip), then the RX gate, which rotates a qubit's state by a tunable angle. As he increases the angle parameter, the probability of measuring a 1 rises from near-zero toward certainty. What the code demonstrates is that quantum gates are just unitary matrices acting on state vectors, and that measurement probabilistically collapses the state to a classical outcome.

"The closer it is to the zero state, the more often you'll see zero. The closer it is to the one state, the more often you'll see one," Sung explains during the Bloch sphere section — a remark that sounds trivially obvious until you've spent ten minutes watching a rotating vector trace out measurement statistics in real time.

The Bloch sphere is how you visualize a single qubit without losing your mind. Because the two complex amplitudes of a qubit state must satisfy the unit-norm constraint, any valid state can be mapped to a point on the surface of a unit sphere. The poles are the classical states — zero at the top, one at the bottom. Everything in between is superposition, with the angle from the pole encoding the probabilities and the azimuthal angle encoding the relative phase between amplitudes. The RX, RY, and RZ gates rotate this point around their respective axes. When Sung chains together a sequence of gates and watches the Bloch sphere vector track its path, the geometry of quantum operations becomes legible in a way that staring at matrices doesn't quite provide.

He's careful about the limits of this picture: the Bloch sphere works for one qubit. For two or more, the state lives in a higher-dimensional complex space that doesn't reduce to anything you can draw. Sung credits work on quantum information foundations by John Watrous as background reading for anyone who wants the full theoretical treatment. The lecture itself is selective by design — a conceptual map, not the territory.

That selectivity is, I think, exactly right for what this lecture is trying to do. The quantum computing basics conversation has been dominated by either breathless capability claims or impenetrable formalism. Sung threads between them. He doesn't promise applications; he builds a vocabulary. Unitary operations preserve the Euclidean norm. Quantum circuits are the analogue of classical programs. Measurement is irreversible and probabilistic in a way that can't be reduced to ignorance about a pre-existing classical state — "in the quantum case," Sung notes, "for all we know, this is really the complete description of the quantum state."

That last point matters more than it might appear. Classical probability vectors represent uncertain knowledge about a system that has a definite state we just haven't looked at. Quantum state vectors, under the standard interpretation, represent something more fundamental: the system genuinely doesn't have a definite classical state until measurement forces it to pick one. Whether or not that philosophical distinction cashes out into different engineering constraints is one of the genuinely open questions in quantum computing research. For now, the working answer is: it does, and the engineering constraints are hard.

IBM making this material freely accessible isn't purely altruistic — they need a trained workforce as much as anyone — but the effect is real. The gap between "quantum computing matters" and "here is the mathematics of why" has historically been wide enough to swallow most public understanding of the technology.

I came to this lecture as a climate correspondent chasing the computational demands of a problem I know well. I left it with a cleaner sense of what quantum computers are actually doing at the mathematical level, and therefore a better-calibrated skepticism about which promised applications are plausible on what timeline. Whether quantum advantage ever arrives at the scale climate modeling needs is still an open question. But you can't ask it precisely until you understand what the advantage would actually consist of — and that's what Sung, to his credit, teaches.

---

Olivia Meng is a climate and environment correspondent for Buzzrag.