> This post is included as extended reading (Q-005) in the column *From Coins to Error Correction* · Column index: https://zhichai.net/topic/178636834

A Quantum Computer Is Not a Faster Computer

Every time quantum computing makes the news, the same take appears in the comments: "n qubits can be in 2ⁿ states at once, so isn't that just trying all answers simultaneously? One step, one result—of course it's fast."

The reasoning looks airtight, but it goes wrong at the second step. The error is so widespread that it deserves its own article—because once you see where it fails, how quantum computing actually works becomes clear.

The Right Half: The Exponential Space Is Real

An ordinary bit has two states, 0 and 1. A qubit can be in a superposition of both—not "either 0 or 1, we just don't know," but genuinely carrying both components at once, like a spinning coin that hasn't landed. Mathematically it's written as α|0⟩+β|1⟩, where α and β are amplitudes, two complex numbers; when measured, the probability of seeing 0 is |α|² and of seeing 1 is |β|².

Put n qubits together and the state space is 2ⁿ-dimensional. Fifty qubits: a quadrillion amplitudes existing simultaneously. This part is uncontroversial—the space really is exponential. The real problem is the next step.

The Wrong Half: You Only Get to Look Once

All output of a quantum computation passes through a single measurement in the end. Measurement is the coin landing: the 2ⁿ amplitudes instantly collapse into one definite bit string. Once.

If quantum computers really worked by "trying all answers in parallel," then one measurement would hand you an answer picked at random from 2ⁿ candidates. A random answer is worthless—it is almost certainly wrong. Pushed to its logical conclusion, a quantum computer would be a hundred-million-dollar random number generator that must sit in a dilution refrigerator near absolute zero.

So those 2ⁿ amplitudes are not 2ⁿ "programs running at once." They are 2ⁿ waves vibrating at the same time.

The Real Mechanism: Interference

Amplitudes are complex numbers, and complex numbers can add or cancel—a positive plus a negative gets smaller; two out-of-phase waves flatten each other. That's interference, what happens when two ripples meet on water: some places wave higher, some go mirror-flat.

The entire art of quantum algorithms is choreographing a sequence of quantum gates so that these 2ⁿ waves interfere: the amplitudes of wrong answers fall peak-into-trough and gradually cancel, while amplitudes of the correct answer pile peak-on-peak and grow. After the final gate, measurement lands—most likely on the correct answer.

In other words, quantum computing doesn't "try out" an answer; it "sieves out" an answer. The sieve is wave motion, sifting the entire exponential space.

This also explains why genuinely useful quantum algorithms are so rare. Writing a classical algorithm only requires thinking through the steps; writing a quantum algorithm means designing a choreography for a 2ⁿ-dimensional complex space so the waves end up piled exactly in the corner you want. Thirty years on, truly general-purpose quantum algorithms can be counted on one hand.

Two Landmarks, Two Kinds of Speedup

Among those rare algorithms, two are essential to know.

Shor's algorithm, 1994. For factoring large integers, classical computers have no good method—each extra digit makes the time explode; a 2048-bit number would take existing classical methods an eternity. Shor's insight was to rewrite factoring as "finding a period," and periodicity happens to be a wave property, so the interference structure is ready-made. Result: exponential speedup. Once a sufficiently large fault-tolerant quantum machine exists, factoring RSA-2048 should take under a week—per the latest engineering estimates. This is the source of the cryptography community's anxiety, because the internet's locks rest on "factoring is hard."

Grover's algorithm, 1996. To find a target among N unordered entries, the classical approach checks N/2 on average; Grover needs only about √N. One hundred million entries: ten thousand checks. Note: that's a square-root speedup, not an exponential one—good, but no magic. And it's mathematically proven to be the limit: no quantum search algorithm can beat the √N scale. Hoping for "a faster Grover" is a dead end in principle.

Put these two numbers side by side and the true shape of quantum computing emerges: for problems with wave-structured properties like periodicity and algebra, it delivers exponential speedups; for general search, only quadratic; and for your browser, video decoding, and game rendering—everyday computations with no interference structure to exploit—it saves not a single microsecond.

Back to That Phrase

We can now state precisely where the popular claim goes wrong: superposition gives you not "all answers running at once" but "a field of waves vibrating at once." Without an algorithmist's interference choreography, when those waves land, all you get is noise.

A quantum computer is not a faster computer. It is a machine that uses interference as a sieve—politely useless for the vast majority of computational tasks, and for a handful of problems, fast enough to rewrite the rules. Which problems are on that "handful" list, and which news stories overstate the case—that's for the next article.

*(Part two of the quantum computing intro series. Part one, "Quantum Computing 101: The Hard Part Isn't the Math, It's an Unfamiliar Vocabulary," was published ten days ago; this piece and the next two unpack several layers the first article left unexplored.)*