What NISQ means
NISQ stands for *Noisy Intermediate-Scale Quantum*. John Preskill coined the term in 2018 to describe the kind of quantum computer we actually have today, as opposed to the fault-tolerant machine many people imagine. Let's unpack the three words, because each one is a promise about a limit.
*Intermediate-Scale* means roughly 50 to 1000 [[qubit|qubits]] — big enough that you can't easily simulate the machine on a laptop, but nowhere near the millions of qubits a truly powerful application would need. *Noisy* is the important word: every gate you apply is slightly wrong, and every qubit slowly forgets its state (see decoherence and coherence time, measured as T1 and T2). There is no error correction running underneath to clean this up. What you program is what you get, noise and all.
Why does the missing error correction matter so much? Because errors compound. If each gate is 99.9% reliable (a gate fidelity of 0.999, which is excellent for today's hardware), then after about 1000 gates roughly *half* your signal is gone. That single fact sets the budget for everything you can do on a NISQ machine: short circuits only, and accept that the answer comes out fuzzy.
What you can do with noisy qubits
If circuits must stay short, what's actually useful? The honest answer is: hybrid algorithms that lean on a classical computer for most of the work and use the quantum chip only for the part that is genuinely hard to simulate classically. The quantum computer runs a small circuit, you measure, a classical optimizer adjusts the circuit's knobs, and you repeat. The noise hurts, but a short circuit run many times can still extract a useful signal.
The two best-known examples are the VQE (Variational Quantum Eigensolver), used to estimate the ground-state energy of molecules in quantum chemistry, and QAOA (Quantum Approximate Optimization Algorithm), aimed at combinatorial optimization. Both follow the same loop: a parameterized circuit proposes a state, you measure an energy or cost, and a classical routine nudges the parameters toward a better value. The quantum part stays shallow on purpose.
What you cannot do on NISQ hardware is run the famous textbook algorithms at interesting sizes. Shor's algorithm for factoring needs deep, precise circuits with millions of well-protected operations; that requires fault tolerance, which NISQ machines do not have. Your phone's RSA keys are safe from today's hardware. NISQ is for short, noise-tolerant, hybrid workloads and for physics experiments — not for breaking cryptography.
Error mitigation (not correction)
Here is a distinction worth carving into stone. Error correction detects and fixes errors *while the computation runs*, by spreading one logical qubit across many physical qubits (the surface code is the leading scheme). NISQ machines do not have it. Error mitigation is different: it accepts that each run is noisy and uses clever *post-processing and extra runs* to estimate what the noiseless answer would have been. It never produces a clean qubit — it only sharpens a statistical average.
A common technique is *zero-noise extrapolation*: you deliberately run the circuit at several higher noise levels (for example by stretching gate times), watch how your measured value drifts as noise grows, and extrapolate back to the zero-noise point. Other methods estimate and invert the measurement-error pattern, or average over randomized variations of the circuit. All of them cost you many more shots — mitigation buys accuracy with runtime, not with cleaner hardware.
Benchmarks & honesty
Qubit count is the number everyone quotes and the least informative on its own. A machine with 1000 qubits that can only run a handful of gates before decoherence wins is weaker than a smaller, cleaner machine. What actually matters is the combination of [[gate-fidelity|gate fidelity]], coherence time (T1, T2), qubit connectivity, and measurement accuracy — how many *good* gates you can chain together before the result is noise.
This is why honest benchmarks try to capture quality, not just size. *Quantum volume* is a single number that rewards both more qubits and lower error, so it cannot be inflated by adding sloppy qubits. Other reports quote circuit-layer operations per second for speed, or application-specific scores. When you read a headline, ask: how good are the gates, how deep can the circuit go, and was this a contrived task or a useful one?
The road to fault tolerance
The endgame beyond NISQ is [[fault-tolerance|fault tolerance]]: many noisy physical qubits woven together into a few reliable logical qubits via error correction. The threshold theorem is the reason this can work at all — it proves that *if* your physical gate fidelity is better than some threshold (around 1% error per gate for the surface code), then adding more physical qubits per logical qubit drives the logical error rate down as far as you like.
The catch is overhead. Protecting one logical qubit well enough for an algorithm like Shor's could take hundreds to thousands of physical qubits each, so a useful fault-tolerant machine may need millions of physical qubits — far beyond today's hundreds. Bridging that gap is the central hardware challenge of the field, and it is a question of years, not months.