Quantum computing

An ordinary computer does everything with bits, tiny switches that are either off or on, 0 or 1. Every photo, song and game is just a long string of these. A quantum computer uses something stranger, called a qubit, and a qubit can be 0 and 1 at the same time, a blur of both, right up until you look at it.

That sounds like a gimmick, but it adds up fast. A few qubits together can hold a huge number of combinations at once. The catch is that you cannot simply read them all out. The moment you measure, the blur snaps to a single ordinary answer, 0 or 1, and the rest vanishes. So having all those possibilities is useless unless you can be clever about it.

Here is the clever part. Each possibility comes with something like a wave, and waves can add up or cancel out. A quantum program is built so that the paths leading to wrong answers cancel each other, like ripples flattening, while the paths to the right answer pile up and grow strong. When you finally measure, the right answer is overwhelmingly the one you get. That cancelling and reinforcing is called interference, and it is the real engine.

If this can be made to work at scale, it would crack a few specific problems that stump every normal computer: cracking some of the codes that protect the internet, and simulating molecules to design new medicines and materials. But qubits are delicate. A stray nudge from the outside ruins the blur, today's machines are small and error-prone, and a genuinely useful quantum computer has not been built yet.

A classical bit is 0 or 1. A qubit's state is a blend of the two, written

\[ |\psi\rangle = \alpha\,|0\rangle + \beta\,|1\rangle, \qquad |\alpha|^2 + |\beta|^2 = 1. \]

The numbers \(\alpha\) and \(\beta\) are amplitudes. When you measure, you get 0 with probability \(|\alpha|^2\) and 1 with probability \(|\beta|^2\), and the qubit collapses to whichever you saw. The widget above shows this directly: tilt the state, and the bars are exactly those probabilities. You can picture any single qubit as an arrow on a sphere, the Bloch sphere, with \(|0\rangle\) at the north pole and \(|1\rangle\) at the south.

Why it scales. One qubit needs two amplitudes, two qubits need four, three need eight. In general \(n\) qubits carry \(2^n\) amplitudes evolving at once. What links them is entanglement: the qubits stop being separate switches and become one joined state, so a description of the whole cannot be split back into parts. Fifty entangled qubits already track more numbers than a laptop can store.

The catch, and the trick. You cannot read out all \(2^n\) amplitudes. A measurement returns just \(n\) ordinary bits, one sample drawn from those probabilities. So a quantum computer is not simply trying every answer in parallel and reporting the best. The amplitudes can be negative, even complex, and that is the whole point: you run operations, called gates, that rotate the state so amplitudes for wrong answers interfere destructively and cancel, while the right answer's amplitude grows. Measure at the end and it falls out.

What it is good for. Only some problems suit this. Shor's algorithm factors huge numbers in a flash, which would break the RSA encryption guarding much of the internet. Grover's algorithm searches an unsorted list of \(N\) items in about \(\sqrt{N}\) steps instead of \(N\). And the original idea, due to Feynman, is that a quantum machine is the natural way to simulate quantum chemistry and materials, where ordinary computers choke. For most everyday tasks a quantum computer offers no advantage at all.

Why it is hard. Qubits lose their delicate state to the smallest disturbance, a problem called decoherence, so they must be isolated, often chilled to near absolute zero, and operated in microseconds. Errors creep in constantly. The fix is quantum error correction, but it is expensive: it can take a thousand or more shaky physical qubits to build one reliable logical qubit. Today's machines have hundreds of noisy qubits and run short programs; they have shown a clear speed advantage only on contrived benchmarks, not yet on a problem anyone needs solved.

The formal picture. The state of \(n\) qubits is a unit vector in the Hilbert space \(\mathbb{C}^{2^n}\). A single qubit is \(|\psi\rangle = \alpha|0\rangle + \beta|1\rangle\) with \(|\alpha|^2+|\beta|^2=1\), represented on the Bloch sphere as \(|\psi\rangle = \cos\tfrac{\theta}{2}|0\rangle + e^{i\varphi}\sin\tfrac{\theta}{2}|1\rangle\). Computation is a sequence of unitary gates, reversible linear maps that preserve the norm: single-qubit rotations like the Hadamard \(H=\tfrac{1}{\sqrt2}\left[\begin{smallmatrix}1&1\\1&-1\end{smallmatrix}\right]\) and the phase gates, together with an entangling two-qubit gate such as CNOT, form a universal set. Measurement is a projection onto a basis, returning outcome \(k\) with probability \(|\langle k|\psi\rangle|^2\), the Born rule. Two theorems shape everything: arbitrary unknown states cannot be copied (no-cloning), and entangled states like the Bell pair \(\tfrac{1}{\sqrt2}(|00\rangle+|11\rangle)\) carry correlations with no classical description.

Where the speedups come from. The advantage is not parallel brute force but the interference of amplitudes that can be made to cancel. The class of problems efficiently solvable on a quantum computer is BQP, believed to sit strictly between P and PSPACE and not to contain the NP-complete problems, so quantum computers are not expected to solve everything quickly. The marquee results are narrow and structural. Shor's algorithm reduces integer factoring and discrete logarithms to period-finding, solved in polynomial time by the quantum Fourier transform, which is why migration to post-quantum cryptography is already underway. Grover's algorithm gives a provably optimal quadratic speedup for unstructured search, \(O(\sqrt N)\). Hamiltonian simulation, the founding application, runs quantum dynamics that scale exponentially for classical methods.

Decoherence and error correction. Real qubits couple to their environment and lose coherence on timescales \(T_1\) (relaxation) and \(T_2\) (dephasing). The answer is fault tolerance. Quantum error-correcting codes, the surface code chief among them, spread one logical qubit across many physical ones and detect errors via stabiliser measurements without collapsing the data. The threshold theorem guarantees that if the physical error rate is pushed below a fixed threshold, arbitrarily long computations become reliable at a polylogarithmic overhead, but the constant factors are brutal: useful algorithms may need millions of physical qubits.

Where the field actually is. Hardware is a contest of platforms: superconducting transmons (fast, the basis of Google's and IBM's chips), trapped ions (slower but very high fidelity), neutral atoms in optical tweezers, integrated photonics, and the still-speculative topological qubit built from Majorana modes, prized because it would be intrinsically protected from noise. This is the noisy intermediate-scale quantum (NISQ) era: devices with tens to hundreds of qubits, error rates too high for deep circuits, and "quantum advantage" demonstrated only on sampling tasks engineered to be hard for classical machines. Early logical qubits that beat their physical components have now been shown, but a fault-tolerant computer solving a problem of real value remains a goal, not a product. The physics is settled; the engineering is the mountain. It runs on the same superposition and entanglement that puzzled Einstein, now put to work.