Quantum Computing (QC)

Definition

Quantum computing is a way of processing information using qubits, quantum bits that can be placed in a superposition of 0 and 1 at the same time and can be entangled so that their states are linked. This lets a quantum computer represent and manipulate combinations of possibilities that a classical computer, which must fix every bit to a definite 0 or 1, cannot hold at once. The payoff is not general speed: it is an exponential advantage on a narrow set of problems with special mathematical structure — factoring large numbers, simulating quantum physics and chemistry, and a few search and optimization tasks. For everything else, a classical computer is faster.

The single most important thing to understand is what a quantum computer is not. It is not a faster processor for ordinary work — not for video encoding, not for databases, and not for training a neural network. If someone describes it as "a supercomputer that does everything a million times faster," they have the concept wrong. The honest version is narrower and stranger: for a short list of problems, a quantum computer can do in hours what would take a classical machine longer than the age of the universe, and for almost everything else it does worse.

How It Works

The power and the limits of quantum computing both come from one fact about the arithmetic. A system of n qubits is described not by n bits but by 2^n complex numbers called amplitudes, one for every possible n-bit string. Ten qubits carry 1,024 amplitudes; fifty qubits carry 2^50, about 1.13 × 10^15 — more than a quadrillion numbers evolving together inside a device you could hold in one hand. This exponential state space is the source of every claim you have heard about quantum "power."

It is tempting to read that as "the computer tries all 2^n answers in parallel," and that reading is wrong. When you measure the qubits, you get back exactly one n-bit string, not a quadrillion. The probability of seeing a particular string is the square of the size of its amplitude, and measurement destroys the superposition — the other amplitudes vanish. So the raw ability to hold 2^n amplitudes buys you nothing on its own; a random measurement just gives a random answer.

What makes an algorithm useful is interference. Amplitudes are complex numbers, so like waves they can add or cancel. A good quantum algorithm arranges the computation so that the amplitudes leading to wrong answers cancel out and the amplitudes leading to the right answer reinforce, making it overwhelmingly likely to appear when you finally measure. Entanglement is what lets operations on one qubit shape the amplitudes of the whole system at once, which is how that orchestrated cancellation becomes possible. Designing that interference pattern is the entire difficulty of quantum algorithms, and it is why only a handful of problems have ever yielded one. The two famous successes make the ceiling concrete:

• Grover's search gives a quadratic speedup, not an exponential one. Searching an unstructured space of N possibilities takes about √N steps instead of N. That still matters — but for a 128-bit key it turns 2^128 guesses into 2^64, roughly 1.8 × 10^19, which is faster yet still astronomically infeasible. Symmetric encryption survives Grover simply by doubling key lengths.
• Shor's algorithm gives a genuine exponential speedup, factoring an integer in time polynomial in its number of digits. That is the one that breaks RSA — and it works precisely because factoring has a hidden periodic structure that interference can expose, which unstructured search does not.

Types

Quantum hardware comes in two genuinely distinct computational models, and confusing them is behind a lot of misleading "qubit count" comparisons. Gate-model (or gate-based) quantum computers are universal: they apply a sequence of quantum gates to build up any computation, and they are the only kind that can run Shor's or Grover's algorithm. The machines from IBM, Google, IonQ, and Quantinuum are gate-model devices; their physical qubit counts span from a few dozen on the highest-fidelity trapped-ion systems to more than a thousand on IBM's largest superconducting chip, and — as the next paragraph explains — the high end of that range is no longer the interesting number.

Quantum annealers are special-purpose machines that solve one thing — optimization problems phrased as finding the lowest-energy state of a system — by physically relaxing toward that minimum. D-Wave's annealers advertise several thousand qubits, but those qubits are not doing the same job: an annealer cannot run Shor's algorithm at all. This is why "a 5,000-qubit annealer" and "a 1,000-qubit gate computer" are not comparable numbers, and why a headline qubit count with no mention of the model tells you almost nothing.

The gate count itself stopped being the number to watch, and the reason is instructive. IBM's Condor processor reached 1,121 physical qubits in December 2023 — the first past a thousand — and IBM then said it would shift its effort from making chips larger to making them less error-prone. Its subsequent flagships are deliberately smaller devices built for higher-fidelity gates rather than higher counts. So the frontier moved away from raw count while the press releases were still quoting it: a bigger headline number after 2023 often signals an annealer or a lower-quality chip, not a better computer.

Real-World Applications

The honest state of the field is that quantum computers do not yet have a commercially useful application. What they have is a small number of credible candidate applications and one very concrete future threat, and it is worth being precise about which is which.

The threat is cryptographic. Because Shor's algorithm would break RSA and elliptic-curve cryptography, the risk is not hypothetical even before a working machine exists: an adversary can record encrypted traffic today and decrypt it later ("harvest now, decrypt later"). This is a real decision organizations are making differently right now — in August 2024 NIST finalized three post-quantum cryptography standards, FIPS 203 (ML-KEM) for key exchange and FIPS 204 (ML-DSA) and FIPS 205 (SLH-DSA) for signatures, and browsers and cloud providers have begun deploying them. That migration is happening because of a computer that does not exist yet.

The most credible positive application is simulating quantum systems themselves — molecules and materials whose behavior is governed by the same quantum mechanics the computer runs on. Estimating the ground-state energy of a molecule with a variational quantum eigensolver is the flagship demonstration, and it is genuinely promising for chemistry and drug discovery. But today's machines can only handle very small molecules before noise dominates, so this remains a research result, not a production tool.

The intersection with AI is where overclaiming is easiest and where you should be most skeptical. Quantum machine learning — quantum kernels, quantum neural networks, quantum-enhanced linear algebra — is an active research area, but it is early-stage and largely unproven at scale. No quantum method has shown a durable, reproducible advantage over a good classical model on a real machine-learning task, and a fundamental obstacle is that loading a large classical dataset into a quantum state can cost as much as the computation you hoped to save. Treat any near-term "quantum AI" product claim as marketing until it shows a benchmark a classical computer cannot match.

Key Concepts

A few terms carry most of the weight and are worth pinning down precisely rather than collecting as vocabulary. Decoherence is the process by which a qubit loses its quantum state through unavoidable interaction with its environment; it is the enemy the whole field is organized against. Quantum supremacy (or quantum advantage) names the milestone of a quantum computer completing some task faster than any classical computer — even a contrived, useless task — and reaching it does not imply a useful application. Error correction is the machinery for building one reliable logical qubit out of many noisy physical qubits, and the gap between those two numbers, explored below, is the central engineering problem of the field.

Challenges

Every limitation of quantum computing traces back to a single physical fact: qubits are exquisitely fragile. A superposition survives only as long as the qubit stays isolated from its surroundings, and coherence times for today's leading hardware are measured in microseconds — a blink during which only a limited number of operations can run before the state decays into noise. Worse, the gates themselves are imperfect: two-qubit gate error rates on current machines sit near a percent, so errors accumulate across a circuit faster than useful work does.

This is what "NISQ" describes. When John Preskill coined the term in 2018, he pegged the era at machines of 50 to 100 qubits whose gate noise "will limit the size of quantum circuits that can be executed reliably." That sentence is still the whole story. It is why a headline like "1,000-qubit processor" can be simultaneously true and misleading: the useful figure is not how many qubits a chip has but how deep a circuit it can run before the answer is indistinguishable from random.

The way out is quantum error correction, and its cost is the reason large-scale quantum computing is hard rather than merely expensive. Because physical qubits are so noisy, error correction spreads the information of one logical (reliable) qubit across many physical ones. How many is the number that has been moving fastest. The surface code, the long-standing default, needs on the order of a thousand physical qubits per logical qubit to reach an error rate low enough for a long algorithm — but newer qLDPC codes cut that sharply: IBM's 2024 "gross code" preserves 12 logical qubits with 288 physical ones, roughly a 24-to-1 ratio where the surface code would spend closer to a thousand-to-one.

That progress reaches all the way to the headline threat. The 2019 estimate for breaking RSA-2048 was about 20 million noisy physical qubits running for eight hours; a 2025 revision by Google's Craig Gidney brought it down to under a million noisy qubits in under a week — a twentyfold cut from better codes and arithmetic, not better hardware. Both numbers are still far beyond the ~1,000 physical qubits of the largest machine built to date, and the point survives the revision: the gap between the qubits a press release counts and the usable, error-corrected qubits an algorithm needs is not a detail. It is the reason quantum computing is a promise rather than a product — but the gap is closing from the algorithm side faster than from the hardware side.

Future Trends

The organizing goal of the field is fault tolerance: crossing from the NISQ era into machines whose logical error rates are low enough to run algorithms of arbitrary length. Progress here is measured not in qubit count but in demonstrations that adding more physical qubits to a logical qubit makes its error rate go down rather than up — the point at which error correction starts paying for itself. Google's 2024 "below threshold" result is the concrete version: a 101-qubit distance-7 surface code whose logical qubit outlived its best physical component by about 2.4×, with the error rate falling by roughly 2.14× each time the code was made larger. A logical qubit that beats its own parts is the milestone that matters, far more than any raw qubit tally.

Alongside the hardware race, a quieter and more certain trend is defensive: the migration to post-quantum cryptography. Unlike a working quantum computer, which may be a decade or more away, the cryptographic response is deployable now and is already underway across the internet's infrastructure. It is the rare case where the honest near-term impact of quantum computing is not something quantum computers do, but something the anticipation of them forces everyone else to do.

Code Example

You can see why 50 qubits is a meaningful threshold — and why classical computers cannot simply "simulate" a quantum computer — by counting the memory a classical simulation needs. Storing the full state means keeping one complex amplitude per basis state, and there are 2^n of them:

# Simulating n qubits classically means storing one complex amplitude
# per basis state. There are 2**n basis states, so memory grows as 2**n.

BYTES_PER_AMPLITUDE = 16  # one complex128 number = 2 x 8-byte floats

def human(nbytes):
    for unit in ("B", "KB", "MB", "GB", "TB", "PB", "EB"):
        if nbytes < 1000:
            return f"{nbytes:5.1f} {unit}"
        nbytes /= 1000
    return f"{nbytes:.1e} ZB"

for n in (10, 30, 50):
    amplitudes = 2 ** n
    mem = amplitudes * BYTES_PER_AMPLITUDE
    print(f"{n:2d} qubits: 2**{n} = {amplitudes:>22,d} amplitudes  ->  {human(mem)}")

Running it prints:

10 qubits: 2**10 =                  1,024 amplitudes  ->   16.4 KB
30 qubits: 2**30 =          1,073,741,824 amplitudes  ->   17.2 GB
50 qubits: 2**50 =  1,125,899,906,842,624 amplitudes  ->   18.0 PB

Ten qubits fit in a cache line's worth of memory; thirty already need a well-equipped server; fifty demand about 18 petabytes, a datacenter's worth of storage, just to hold the state — before doing any computation on it. Each qubit added doubles the requirement, so a few dozen more would exceed the storage on Earth. That exponential wall is exactly why a large error-corrected quantum computer, if one is ever built, could do things no classical machine can — and, symmetrically, why simulating even a modest quantum computer on a classical one is hopeless.