How to read quantum

A classical bit is a switch: 0 or 1, settled, locally readable. A qubit is a direction in three-dimensional space. The physics of a quantum two-level system happens to be exactly this: everything the qubit can be is a point on the surface of a unit sphere — the Bloch sphere. The north pole is the familiar "0" state. The south pole is "1". Every other direction is a superposition, and that direction is the entire job description.

The intuition that pays off is this: a quantum gate is a rotation. Operating on a qubit means rotating its arrow on the sphere. The art of quantum engineering — and most of what a fidelity number measures — is rotating the arrow precisely and predictably. A 99.99% two-qubit gate fidelity, in this picture, means the executed rotation lands within a tiny cone of the intended one.

Spin the sphere below. Each control is a rotation axis. When you measure, the qubit's arrow collapses to one of the two poles — but the probability of which pole is set by where the arrow was pointing first.

Take two qubits. Put each in a superposition. Then operate them with a gate that couples them — typically a controlled-NOT or its variants. What you get is a state that cannot be written as two separate qubits. Their fates are correlated in a way that has no classical analogue.

The trap is to read "correlated" as "communicating instantly." Entanglement does not transmit signals; you cannot phone your colleague on Mars through a Bell pair. What entanglement does is allow many qubits to participate in a computation as a single coherent object, which is precisely what classical computers cannot do.

Move the dials. Notice that the joint outcomes are constrained even though the local outcomes look random. That constraint is the resource — the object every quantum algorithm spends.

A quantum program is a circuit: a left-to-right schedule of gates applied to specific qubits. There is no goto, no while-loop, no branch-on-classical-state — at least, not inside the quantum part of the program. Time flows once, gates fire in sequence, and at the end of the schedule every qubit is measured.

This is much less expressive than a classical instruction set, and that's the point. The constraint is how quantum machines achieve speedup: they apply the same family of operations to an enormous superposition of inputs in one pass. The hard work is choreographing the gates so that the right answer rings out at the end while the wrong answers cancel.

Click a gate, then click a slot to place it. The state vector updates as you build; measurement happens at the right edge. Try the canonical recipes first (H ➞ CX is a Bell pair); then break them and see what falls apart.

Grover's algorithm is the textbook example of a quantum speedup, and the one most often abused in press releases. It searches an unstructured database of N items in roughly √N steps — quadratic, not exponential. The trick is geometric: each step rotates the state vector incrementally toward the marked answer.

Two things are easy to miss. First, Grover requires that you be able to build a quantum circuit — an oracle — that recognizes the answer; if you can already do that classically with similar cost, you've not saved much. Second, Grover overshoots if you iterate too many times: past the optimum, the state rotates away from the answer again. Quantum algorithms are choreographed, not iterated.

Step through the trace below. Watch the amplitude of the marked state climb, peak, and then — if you keep going — start to fall. The number of iterations is part of the algorithm; you don't run it "until it's right."

Everything in this primer comes down to one idea: interference. Amplitudes — complex numbers attached to each possible outcome — add and cancel. A well-built quantum algorithm arranges the gates so that, when the dust settles, the amplitudes of the correct answers reinforce each other while the amplitudes of the wrong answers destructively interfere into nothing.

This is also why quantum machines are so demanding. The reason decoherence matters, the reason a stray photon in the dilution fridge is fatal, the reason a misaligned laser pulse on a trapped ion costs you a shot — all of it traces back to phase. Lose the relative phases between amplitudes and you lose the ability to interfere. Without interference, the machine is an expensive random number generator.

The figure below superposes two complex amplitudes; rotate the relative phase and watch the joint probability oscillate between zero and one. The information in a quantum computer lives in those phase relationships, and everything else — fidelity, coherence time, error correction — is engineering aimed at preserving them.