Quantum computing explained simply: what a lab demo taught me

Two classical bits can sit at 00, 01, 10, or 11, but only one of those at any moment. Two qubits, by contrast, occupy a state in which all four combinations contribute to the calculation simultaneously — and yet the final readout returns a single classical string per run. The apparent contradiction is the entire field in miniature: a wider computational space, a noisier physical substrate, and a probabilistic readout that requires thousands of identical runs to interpret.

The lesson is not that quantum computers try every answer at once and select the right one. The lesson is structural. The qubit's state, the entanglement between qubits, and the pattern of probabilities that emerge from many runs together encode a different kind of information than a classical register — one that certain algorithms can exploit and that present-day hardware can only approximate.

The mechanics of the qubit: moving beyond classical bits

A classical bit is a switch: a voltage is high or low, a magnetic domain points one way or the other, a capacitor is charged or discharged. The state is single-valued at every moment. A qubit, by contrast, is described by a two-dimensional complex vector whose squared amplitudes give the probabilities of measuring 0 or 1. This is not a metaphor. The state lives in a Hilbert space; operations on it are unitary transformations; measurement collapses the state to one classical outcome.

IBM's superconducting processors, built around transmon qubits, are patterned from superconducting materials on silicon substrates and must be cooled to a few millikelvin — close to absolute zero. Other platforms, including trapped-ion and photonic systems, achieve similar two-level behavior through entirely different physics, but the mathematical object they implement is the same.

The doubling effect is what gives quantum machines their theoretical scaling. Two qubits span a four-dimensional state space; three qubits span eight; each additional qubit doubles the number of amplitudes the system must track. A 156-qubit processor, such as IBM's Heron r2 introduced in July 2024, manipulates a state vector with 2^156 complex entries — a number larger than the estimated count of atoms in the observable universe. That does not mean the machine "contains" that many simultaneous answers. It means the machinery required to evolve the state, in principle, grows exponentially with qubit count.

The amplitude vector is normalized: the sum of squared magnitudes equals one, because measurement probabilities must sum to one. In the Bloch sphere picture, a single-qubit state lives on the surface of a unit sphere; the north and south poles are the classical 0 and 1, and everything in between is a coherent superposition. Operations move the state around the sphere; measurement projects it onto one of the two poles. That geometric picture is useful for intuition even when the underlying mathematics is more general.

A qubit's state lives in a Hilbert space; classical bits live in a switch position. The gap between those two descriptions is where every quantum speedup, and every quantum headache, originates.

Demystifying superposition and entanglement through circuit experiments

The standard pedagogical circuit is two operations: a Hadamard gate on the first qubit, then a CNOT gate linking the two. The Hadamard takes |0⟩ and rotates it into an equal superposition of |0⟩ and |1⟩. The CNOT flips the second qubit if and only if the first is 1, producing the Bell state (|00⟩ + |11⟩) / √2. Run the circuit once and a single classical bit string comes back. Run it a thousand times and the histogram converges on 50% |00⟩, 50% |11⟩ under ideal conditions, with the cross terms |01⟩ and |10⟩ suppressed. Real hardware deviates — gate errors, readout errors, and decoherence push some probability into the forbidden states — but the asymmetry between the allowed and disallowed outcomes remains the signature of entanglement.

The suppressed cross terms are exactly what Bell-inequality experiments look for. Local hidden-variable models predict that the correlations between the two qubits, measured in different bases, must obey a classical bound. The Bell state violates that bound; the violation is the empirical fingerprint of entanglement, and it is what makes the quantum circuit useful as a probabilistic resource rather than a deterministic one. From the same construction comes the no-cloning theorem: an unknown quantum state cannot be copied perfectly, which is why quantum communication protocols rely on entanglement rather than on transmitting the state itself.

Three points matter in the demo:

1. Superposition is not simultaneous observation. One measurement yields one classical outcome. The distribution is built from many shots, not extracted in a single readout.

2. Entanglement is not hidden coordination. The two-qubit state cannot be written as a product of two single-qubit states, which is precisely why the |01⟩ and |10⟩ outcomes are suppressed.

3. The circuit depth is short on purpose. Every additional gate compounds the chance of error, and the demo deliberately stops before the noise budget is exhausted.

I find this circuit useful because it dispenses with two myths at once. The first is that a quantum machine tries every possibility and reads out the best. It does not. The second is that measurement reveals a hidden simultaneous state. It does not. The state is described by amplitudes; measurement returns a sample drawn from those amplitudes.

The noise barrier: why physical qubits are inherently fragile

NIST's public comparison is blunt: leading quantum machines produce an error roughly once every thousand operations. Classical silicon, by contrast, flips a bit at random roughly once every 10^18 calculations. That gap — fifteen orders of magnitude — is the single largest reason quantum computing has not yet delivered routine commercial advantage.

The sources of noise are mundane. Stray electric and magnetic fields leak into the chip. Temperature fluctuations shift qubit frequencies. Cosmic rays deposit energy that flips nearby qubits. Each platform attacks these problems differently. Superconducting qubits sit inside dilution refrigerators that suppress thermal photons; trapped ions rest in ultra-high vacuum inside shielded chambers; photonic systems encode information in modes of light that interact weakly with the environment. None of these solutions is free, and none of them closes the fifteen-order-of-magnitude gap on its own.

The threshold theorem, established in the late 1990s, is what keeps the gap from being a permanent barrier. Once physical error rates fall below a code-dependent threshold, error correction can suppress logical errors arbitrarily, at the cost of using more physical qubits per logical qubit. The threshold varies by code, by platform, and by the operations being protected, but the qualitative claim holds: there is an engineering regime in which adding more physical qubits actually buys you a quieter logical qubit. The threshold is not a destination; it is an entry point. Crossing it does not produce a useful machine on its own, but it changes which questions are reasonable to ask.

The practical consequence is that any algorithm worth running must either be short enough to finish inside the noise budget, or must protect itself through error correction. The second option is where the field is currently investing.

From physical to logical: the path toward fault-tolerant computing

Quantum error correction does not preserve individual qubits; it encodes logical qubits across many physical ones. The exact ratio — how many physical qubits form one fault-tolerant logical qubit — depends on the error-correcting code, the underlying physical error rate, the target algorithm, and the chip's connectivity. Surface codes and color codes are the dominant candidates; recent estimates place the overhead somewhere between several hundred and several thousand physical qubits per logical qubit for useful algorithms.

Code distance is the variable that controls the trade-off. A larger code distance catches more errors and suppresses logical failure rates more aggressively, but it consumes more physical qubits per logical qubit. The hardware roadmap is essentially a sequence of bets on which combination of code distance, physical error rate, and target algorithm produces a useful logical qubit count within a tractable engineering budget. Researchers routinely report the trade-off as a curve rather than a single number, which is why the same processor can look modest or impressive depending on what the speaker is trying to suppress.

Three structural milestones track progress:

The honest summary: we are transitioning from a regime where the qubit count is the headline number to one where the logical qubit count, the gate fidelity, and the circuit depth matter more. This shift is already underway in the hardware roadmaps of IBM, Google, and several startups, though no reviewed source places a precise date on the arrival of a general-purpose, fault-tolerant machine.

The relevant metric is no longer "how many qubits" but "how many logical qubits running at what fidelity over what circuit depth." The industry is quietly rewriting its progress reports.

Preparing for the post-quantum era: NIST's new cryptographic standards

The cryptographic implications of fault-tolerant quantum computing are concrete and have already triggered a regulatory response. On August 13, 2024, NIST approved the first three U.S. Federal Information Processing Standards designed to resist quantum attack:

• FIPS 203 (ML-KEM) — a key-encapsulation mechanism built on module-lattice cryptography, intended to replace key exchange in protocols like TLS.
• FIPS 204 (ML-DSA) — a digital signature scheme derived from the CRYSTALS-Dilithium algorithm, intended for authentication and code signing.
• FIPS 205 (SLH-DSA) — a stateless hash-based signature scheme, intended as a conservative fallback whose security relies on the security properties of its underlying hash functions.

The three standards are not interchangeable. ML-KEM has compact key sizes and fast operations, which is why it is favored for key exchange. ML-DSA produces signatures of moderate size and is intended for general-purpose authentication. SLH-DSA generates noticeably larger signatures but is built from a minimal cryptographic assumption — that the chosen hash function behaves as a random oracle — which is why engineers treat it as the conservative option when the other two raise concerns. The point of publishing three standards is not redundancy; it is choice under uncertainty.

The migration is not theoretical. Adversaries can record present-day encrypted traffic and decrypt it later once a fault-tolerant quantum computer becomes available — a "harvest now, decrypt later" pattern that gives urgency to standards adoption. Organizations running long-lifecycle data — government records, medical files, industrial control systems, certain financial instruments — face the longest exposure windows and the tightest deadlines. Replacing the cryptographic primitives is the visible part of the work; the larger part is the operational plumbing, the software rollouts, the hardware compatibility, and the years of testing that have to happen before a standard actually protects a system.

Three finalized NIST standards do not yet protect a single deployed system. Standards describe algorithms; deployment requires software updates, hardware compatibility, and years of operational testing.

What the lab demo actually teaches

The two-qubit histogram is the entry point, not the destination. It shows that the underlying state is wider than the measurement reveals, that entanglement structures which outcomes are possible, and that the readout is irreducibly probabilistic. None of this translates directly into practical speedups. The translation requires error correction at scale, and that requires physical qubits that are quieter than the ones we have today.

The headline question — when will quantum computers replace classical ones — is the wrong one. The structural question is whether the noise gap can be closed quickly enough that useful algorithms, running on logical qubits, outperform classical hardware on problems that matter. The trajectory is upward; the timeline is uncertain.

What I take from the lab demo is a smaller, more useful point: the strange outputs are not magic, and they are not fraud. They are the signatures of a different computational regime, one whose constraints are physical, not theoretical. Engineers can work with physical constraints.