The NISQ Paradigm

"Noisy Intermediate-Scale Quantum" is a diagnosis compressed into an acronym. John Preskill coined it in 2018 to name the machines that had just arrived — superconducting and trapped-ion processors of tens to a few hundred qubits — and to be brutally honest about what they can and cannot do. Intermediate-scale is a claim about size: the register is large enough that its $2^n$ -dimensional state vector defeats brute-force classical simulation, yet far too small to spend the thousands of physical qubits that one protected logical qubit demands. Noisy is a claim about quality: every gate, measurement, and idle moment injects errors at rates of order $10^{-2}$ to $10^{-3}$ , sitting above the comfortable margin where fault tolerance pays for itself cheaply. The physics of the regime is entirely the physics of open quantum systems. A qubit is never truly isolated; it is coupled to a colder, larger world, and that coupling drives decoherence described by completely positive trace-preserving maps. The canonical channels — depolarizing, amplitude damping ( $T_1$ ), phase damping ( $T_2$ ) — are the atoms of every NISQ error budget, and the relaxation and dephasing times set the clock the computation races against. The single feature that defines the paradigm is the absence of error correction: errors are not repeatedly purged, so they accumulate. If a circuit performs $V$ error-prone operations each with probability $\epsilon$ of failing, a clean run survives with probability $(1-\epsilon)^V \approx e^{-V\epsilon}$ , and useful signal persists only while $V\epsilon \lesssim 1$ . That one inequality — the circuit-volume budget — explains why NISQ algorithms are deliberately shallow, why mitigation rather than correction is the near-term strategy, and why the whole era is understood as a bridge, not a destination.

Key takeaways

The NISQ paradigm, named by John Preskill in 2018, describes processors of roughly $50$ to a few hundred qubits whose gates are imperfect and whose qubits decohere before quantum error correction can protect them.
"Intermediate-scale" means large enough that the $2^n$ -amplitude state vector defeats classical simulation, yet small enough that there are zero logical (error-corrected) qubits.
The binding constraint is accumulated error: with per-operation error $\epsilon$ and circuit volume $V\sim n\,d$ , useful output requires $V\epsilon\lesssim 1$ , capping circuits at a few hundred to a few thousand reliable operations.
Noise is bookkept with open-systems tools — CPTP maps, Kraus operators, the depolarizing / amplitude-damping / phase-damping channels, and the $T_1$ , $T_2$ times that fix the fidelity budget.
NISQ algorithms (variational eigensolvers, QAOA, sampling) are engineered to be shallow and noise-tolerant; error mitigation reduces bias, it does not remove errors.
NISQ is explicitly transitional: below the fault-tolerance threshold $\epsilon_{\mathrm{th}}$ , correction replaces mitigation and the paradigm gives way.
Key idea: without error correction, errors accumulate multiplicatively. An $n$ -qubit, depth- $d$ circuit with per-gate error $\epsilon$ keeps fidelity $F\approx(1-\epsilon)^{V}\approx e^{-V\epsilon}$ with volume $V\sim n\,d$ , so reliable NISQ computation lives strictly inside the budget $V\epsilon\lesssim 1$ .

The core insight

Without error correction, errors accumulate multiplicatively across a circuit. The fidelity of an $n$ -qubit, depth- $d$ circuit with per-gate error $\epsilon$ falls roughly as $F\approx(1-\epsilon)^{V}\approx e^{-V\epsilon}$ with circuit volume $V\sim n\,d$ , so reliable NISQ computation lives strictly inside the budget $V\epsilon\lesssim 1$ .

Where this lives today

The volume budget is not a chalkboard abstraction; it is the number every hardware team reports against. Google's 2019 Sycamore experiment (Nature 574, 505) ran a $53$ -qubit, $20$ -cycle random circuit and measured a cross-entropy fidelity of about $0.2\%$ — a direct readout of $e^{-V\epsilon}$ living at the very edge of the budget, deep enough to be classically hard yet shallow enough to retain a sliver of signal, which the team argued would take a classical supercomputer far longer to reproduce. Cross-entropy benchmarking, randomized benchmarking, and gate-set tomography are the standard instruments that extract the average $\epsilon$ , $T_1$ , and $T_2$ populating these budgets, and IBM's "quantum volume" collapses width, depth, and error into a single certifiable number. On the algorithmic side, variational methods (VQE for molecular ground states, QAOA for combinatorial optimization) are engineered to stay shallow, though barren plateaus and noise-induced bias remain open obstacles. And error mitigation has matured from idea to headline: IBM's 2023 "utility" experiment (Nature 618, 500) used zero-noise extrapolation on a $127$ -qubit Eagle processor to recover accurate expectation values from circuits well past the point of raw reliability — a vivid demonstration that, inside the NISQ budget, clever post-processing buys real ground while the field builds toward the fault-tolerant machines that will replace mitigation with correction.

The physical picture

Picture a NISQ circuit as a relay race run on a leaking track. Each runner — a gate — is slightly clumsy and may drop the baton with probability $\epsilon$ ; the track itself, the idle qubits, is wet, so the baton degrades on timescales $T_1$ and $T_2$ even between handoffs. The team finishes cleanly only if the total number of handoffs times the drop probability stays below one. Add more runners (more depth, more width) and the chance of a clean finish collapses exponentially, not linearly, because every handoff must succeed. There is no coach on the track: unlike the fault-tolerant era, where error correction inspects and restores the baton after every leg so an arbitrarily long race can be run below threshold, NISQ detects errors only at the finish line, if at all. That is why the whole discipline is obsessed with keeping the race short and the runners clean.

Figure

A NISQ circuit is n qubits by d layers of gates, roughly V ≈ n·d error-prone operations, each failing with probability ε ≈ 10⁻³ — with no error correction the clean-run probability multiplies down to F = (1−ε)^V ≈ e^(−Vε), so the useful window closes once V·ε reaches about 1

The reason the collapse is exponential, and the reason the budget is a product $V\epsilon$ rather than a sum, is that a circuit succeeds only if every one of its operations succeeds. Widen the circuit and each layer spends more of the budget; deepen it and there are more layers to survive. The same accounting says qubit count alone is almost meaningless: a device can boast two hundred physical qubits and still run only a shallow reliable circuit, because the depth ceiling scales as $1/(n\epsilon)$ . The second figure turns the accounting into the number an experimentalist actually watches — the surviving fidelity as a function of circuit volume — for a representative per-gate error $\epsilon = 10^{-3}$ .

Figure

The signal budget: with per-gate error ε = 10⁻³ the clean-run probability F = e^(−Vε) falls through 1/e = 0.368 at circuit volume V = 1/ε = 1000 operations and to 0.135 at V = 2000, so useful NISQ output lives inside V·ε ≲ 1

The core equations

The defining relation is the fidelity budget. Model the circuit as a chain of $V$ independent operations, each of which either succeeds or injects an error; with no correction to intervene, the probability that every operation is clean is a product of survivals. For small $\epsilon$ this product is an exponential in the single dimensionless combination $V\epsilon$ .

F \;\approx\; (1-\epsilon)^{V} \;\approx\; e^{-V\epsilon}, \qquad V \sim n\,d \qquad (1)

where: $F$ — probability of an error-free execution, the usable-signal proxy; $\epsilon$ — average error probability per elementary operation; $V$ — circuit volume, the count of error-prone operations $\sim n\,d$ ; $n$ — number of physical qubits; $d$ — circuit depth in gate layers. Reading it: the budget is the product $V\epsilon$ , so widening or deepening the circuit both spend the same currency. Each noisy operation is not a random classical coin flip but a quantum channel. The most general physical evolution of an open qubit is a completely positive trace-preserving map, written in operator-sum (Kraus) form. This is the object that every specific noise model below is a special case of.

\mathcal{E}(\rho) \;=\; \sum_{k} E_k\,\rho\,E_k^{\dagger}, \qquad \sum_k E_k^{\dagger}E_k = I \qquad (2)

where: $\mathcal{E}$ — the CPTP map for one noisy operation; $\rho$ — density matrix of the register; $E_k$ — Kraus operators encoding the possible error branches; $I$ — identity, and the completeness sum enforces trace preservation, i.e. conservation of probability. The simplest average-case summary of gate noise is the depolarizing channel, which with probability $p$ replaces the state by a random Pauli error and otherwise leaves it alone. It is symmetric and unital, which makes it the natural worst-case model for benchmarking.

\mathcal{D}_p(\rho) \;=\; (1-p)\,\rho \;+\; \frac{p}{3}\big(X\rho X + Y\rho Y + Z\rho Z\big), \qquad \vec{r}\mapsto\Big(1-\tfrac{4p}{3}\Big)\vec{r} \qquad (3)

where: $p$ — depolarizing probability; $X,Y,Z$ — Pauli operators; $\vec r$ — Bloch vector, contracted uniformly toward the center. At $p=3/4$ the factor $1-4p/3$ vanishes and every input collapses to the maximally mixed state $I/2$ — total erasure. Idle qubits leak energy. Amplitude damping models the one-way decay $|1\rangle\to|0\rangle$ that defines the relaxation time $T_1$ , with two Kraus operators for the "no photon emitted" and "photon emitted" branches.

\mathcal{A}_\gamma:\;E_0=\begin{pmatrix}1&0\\0&\sqrt{1-\gamma}\end{pmatrix},\quad E_1=\begin{pmatrix}0&\sqrt{\gamma}\\0&0\end{pmatrix},\qquad \gamma = 1 - e^{-t/T_1} \qquad (4)

where: $\gamma$ — decay probability over the interval; $E_0$ — no-jump branch, damping the excited amplitude by $\sqrt{1-\gamma}$ ; $E_1$ — jump branch, energy loss to the bath. For $t\ll T_1$ , $\gamma\approx t/T_1$ , so the per-gate relaxation error grows linearly in gate time. Coherence also leaks without any energy loss. Phase damping decays the off-diagonal terms while leaving populations untouched, and defines the pure-dephasing contribution to $T_2$ .

\mathcal{P}_\lambda:\;E_0=\sqrt{1-\lambda/2}\;I,\quad E_1=\sqrt{\lambda/2}\;Z,\qquad \frac{1}{T_2} = \frac{1}{2T_1}+\frac{1}{T_\varphi},\quad T_2\le 2T_1 \qquad (5)

where: $\lambda$ — dephasing strength; $Z$ — phase-flip operator; $T_\varphi$ — pure-dephasing time; $T_2$ — total coherence time. The bound $T_2\le 2T_1$ holds because relaxation also destroys phase, so even with zero pure dephasing $1/T_2\ge 1/2T_1$ . All of these discrete channels are snapshots of one continuous generator: the Lindblad (GKSL) master equation, which packages coherent control and every decoherence channel into a single evolution law and is the bridge from hardware coherence times to the abstract error rate $\epsilon$ .

\frac{\mathrm{d}\rho}{\mathrm{d}t} = -\frac{i}{\hbar}[H,\rho] + \sum_j \Big(L_j\rho L_j^\dagger - \tfrac12\{L_j^\dagger L_j,\rho\}\Big) \qquad (6)

where: $H$ — system Hamiltonian (coherent control); $L_j$ — jump operators, e.g. $\sqrt{1/T_1}\,\sigma_-$ for relaxation and $\sqrt{1/2T_\varphi}\,Z$ for dephasing; $\{\cdot,\cdot\}$ — anticommutator supplying the no-jump back-action. Integrating (6) over one gate time reproduces the channels (3)–(5). Combining the fidelity budget with these microscopics gives the quantity a NISQ practitioner cares about most: the largest depth at which output is still meaningful, and the hard coherence-time wall it must also respect.

d_{\max} \;\sim\; \frac{1}{n\,\epsilon}, \qquad d_{\max}\;\lesssim\;\frac{T_2}{\tau_{\mathrm{gate}}} \qquad (7)

where: $d_{\max}$ — largest useful depth; $\tau_{\mathrm{gate}}$ — duration of one gate layer; $T_2$ — coherence time. The first bound comes from the volume budget, the second from simply not outrunning coherence; for idle-dominated noise $\epsilon\approx\tau_{\mathrm{gate}}/T_2$ makes the two agree.

Derivation AFrom the volume budget to a depth ceiling and the coherence wall

The goal is to convert the exponential fidelity law of equation (1) into a concrete, quotable bound on how deep a NISQ circuit may run before its output is indistinguishable from noise, and to show that this algebraic ceiling coincides with the independent physical wall set by the coherence time. We start from the fidelity budget, impose a modest signal floor, solve for the circuit volume and then the depth, and finally cross-check against the requirement that the circuit finish before the qubits decohere. The payoff is a single dimensionless statement, $V\epsilon\lesssim 1$ , seen from two directions.

Step 1. Impose a signal floor $F=e^{-V\epsilon}\ge 1/e$ , i.e. demand that at least a fraction $1/e$ of runs be clean. Why: below $F\sim 1/e$ the surviving signal in an estimated expectation value is buried in shot noise, and the number of repetitions needed to dig it back out grows like $1/F^2$ , which quickly becomes prohibitive.

Step 2. Take the logarithm to get $V\epsilon\le 1$ , hence $V\le 1/\epsilon$ . For $\epsilon\sim 10^{-2}$ to $10^{-3}$ this caps the total reliable operations at roughly $10^{2}$ to $10^{3}$ . Why: the entire computation, summed over every qubit and every layer, must fit inside a budget fixed purely by the inverse error rate — the hardware's single most important number.

Step 3. Substitute $V\sim n\,d$ to convert the volume cap into a depth cap, $d_{\max}\sim 1/(n\epsilon)$ . Why: this exposes why width is not free — every extra qubit in a layer consumes budget, so a wide circuit is forced to be shallow, and 200 physical qubits buys almost no reliable depth.

Step 4. Cross-check against the coherence wall $d_{\max}\,\tau_{\mathrm{gate}}\lesssim T_2$ : no circuit can run longer than the qubits stay coherent. Writing the idle error as $\epsilon\approx\tau_{\mathrm{gate}}/T_2$ turns this into $d_{\max}\lesssim T_2/\tau_{\mathrm{gate}} \sim 1/\epsilon$ , the same budget. Why: two independent lines of reasoning — a statistical fidelity floor and a physical decoherence deadline — converge on $V\epsilon\sim 1$ , which is why the inequality is treated as the definition of the regime rather than a rule of thumb. *Both routes — the statistical fidelity floor and the physical decoherence deadline — reduce to the same condition $V\epsilon\sim 1$ . Numerically, $\epsilon=10^{-3}$ gives $V\le 1000$ total operations, and at $n=50$ qubits that caps the depth at $d_{\max}\approx 20$ layers.*

Go deeper · Derivation B · 1 minAmplitude damping reproduces exponential T1 decay and forces T2 ≤ 2T1

Derivation BAmplitude damping reproduces exponential T1 decay and forces T2 ≤ 2T1

The aim of this derivation is to show that the discrete amplitude-damping channel of equation (4), applied over and over in small steps, reconstructs the continuous exponential population decay that experimentalists call $T_1$ , and that the same channel decays coherence at exactly half the rate — the microscopic origin of the ubiquitous datasheet bound $T_2\le 2T_1$ . We apply the channel to a general single-qubit state, follow the excited population and a coherence separately, and take the many-step limit using the semigroup property of CPTP maps.

Step 1. Act on the excited population: from $E_0,E_1$ one finds $\rho_{11}\mapsto(1-\gamma)\rho_{11}$ , the survival of excited-state population after one step. Why: only the jump operator removes population from $|1\rangle$ , and it does so with probability $\gamma$ , so the survivor is the complementary factor $1-\gamma$ .

Step 2. Fix $\gamma$ for a short step of duration $\Delta t$ by matching exponential relaxation, $\gamma=1-e^{-\Delta t/T_1}$ , and compose $N$ identical steps: $\rho_{11}(N\Delta t)=(1-\gamma)^N\rho_{11}(0)=e^{-N\Delta t/T_1}\rho_{11}(0)$ . Why: the semigroup property lets identical channels multiply their survival factors, and the product of $(1-\gamma)^N$ is precisely the continuous exponential with $t=N\Delta t$ — the abstract $\gamma$ becomes the measured lifetime $T_1$ .

Step 3. Track a coherence through the same step: the no-jump operator carries $\rho_{01}\mapsto\sqrt{1-\gamma}\,\rho_{01}$ , so coherence decays as $e^{-t/2T_1}$ , half the population rate. Why: coherence is linear in the excited amplitude while population is quadratic, so the coherence picks up one factor of $\sqrt{1-\gamma}$ where the population picks up its square.

Step 4. Assemble the rates: relaxation alone gives $1/T_2=1/2T_1$ , and any additional pure dephasing $1/T_\varphi$ can only add, so $1/T_2=1/2T_1+1/T_\varphi$ and therefore $T_2\le 2T_1$ . Why: because dephasing never restores phase, the relaxation contribution is a hard ceiling on the coherence time — a bound printed on every hardware spec sheet and never violated in practice. *The coherence rate is exactly half the population rate: relaxation alone gives $1/T_2 = 1/2T_1$ , the hard floor on the total dephasing rate.*

Go deeper · Derivation C · 1 minThe idle-error rate straight from the Lindblad equation

Derivation CThe idle-error rate straight from the Lindblad equation

This derivation closes the loop between the continuous Lindblad dynamics of equation (6) and the discrete error budget of equation (1), by reading off the per-gate error that idle relaxation and dephasing inflict during a single gate of duration $\tau_{\mathrm{gate}}$ . We choose the standard jump operators for a relaxing, dephasing qubit, expand the master equation to first order in the short gate time, and identify the population and coherence losses as the error $\epsilon$ that then feeds directly into $V\epsilon\lesssim 1$ . This is the step that ties hardware coherence numbers to algorithmic depth.

Step 1. Choose jump operators $L_1=\sqrt{1/T_1}\,\sigma_-$ with $\sigma_-=|0\rangle\langle1|$ for relaxation, and $L_2=\sqrt{1/2T_\varphi}\,Z$ for pure dephasing. Why: these are the two microscopic processes a bare idle qubit suffers — energy loss and phase scrambling — and each is represented by exactly one Lindblad jump operator.

Step 2. Expand the state to first order over one gate time, $\rho(\tau)\approx\rho(0)+\tau\,\mathcal{L}\rho(0)$ , valid because $\tau_{\mathrm{gate}}\ll T_1,T_2$ . Why: gates are far shorter than coherence times, so the Lindbladian acts perturbatively and the leading linear term captures the per-gate error.

Step 3. Read off the losses: the population drains as $\Delta\rho_{11}\sim -\tau/T_1$ and the coherence as $\Delta\rho_{01}\sim -\tau/T_2$ , with $1/T_2=1/2T_1+1/T_\varphi$ . Why: relaxation depletes population at rate $1/T_1$ while the total transverse rate $1/T_2$ governs coherence, exactly as the previous derivation established.

Step 4. Combine into a single error scale $\epsilon_{\mathrm{idle}}\sim\tau_{\mathrm{gate}}\big(1/T_1+1/T_2\big)$ . Why: this idle $\epsilon$ is precisely the quantity that enters the volume budget, so a chip's $T_1$ and $T_2$ translate immediately into the maximum reliable circuit volume $V\lesssim 1/\epsilon_{\mathrm{idle}}$ . *As a concrete check: for $T_1=100\ \mu\mathrm{s}$ , $T_2=80\ \mu\mathrm{s}$ , and $\tau=40\ \mathrm{ns}$ , the two terms are $4\times10^{-4}$ (relaxation) and $5\times10^{-4}$ (dephasing), giving $\epsilon_{\mathrm{idle}}\approx 9\times10^{-4}$ .*

Limiting cases

The NISQ regime is fenced in on every side; the asymptotics show which constraint bites first.

Case	Result	Meaning
Vanishing noise, fixed size	$\epsilon\to0,\ n,d$ fixed	ideal-circuit limit $F\to1$ — the unphysical target that zero-noise extrapolation reaches for by scaling $\epsilon$ up and fitting back to zero
Volume budget	$V\epsilon\lesssim1,\ V\sim n\,d$	the defining NISQ inequality: exceed it and the output is indistinguishable from random
Coherence-limited depth	$d_{\max}\sim T_2/\tau_{\mathrm{gate}}$	a hard wall — no circuit can be deeper than the gates that fit inside $T_2$ , no matter how clever the algorithm
Complete depolarization	$p=3/4\Rightarrow\mathcal{D}(\rho)=I/2$	the Bloch vector contracts by $1-4p/3$ to zero; all information erased, the worst-case bound on reliability
Toward fault tolerance	$\epsilon<\epsilon_{\mathrm{th}}\Rightarrow$ logical error $\downarrow$ with overhead	below the code threshold (about $1\%$ for the surface code) correction suppresses logical error arbitrarily — NISQ gives way to the fault-tolerant regime

Common trapMore qubits means a more powerful NISQ computer

It does not, and this is the single most common misreading of the word "intermediate-scale." A device with 100 or 1000 physical qubits still has exactly zero logical qubits, and its qubit count $n$ fixes only the width of a circuit, not the reliable depth. The binding constraint is the product $V\sim n\,d$ against the error rate $\epsilon$ , so adding qubits without lowering $\epsilon$ actually shrinks the reliable depth as $d_{\max}\sim 1/(n\epsilon)$ — wider circuits exhaust the budget faster. A headline "N-qubit processor" says almost nothing about what it can compute; the meaningful figure of merit combines width, depth, and error rate, which is exactly what the "quantum volume" metric was invented to capture. Likewise, error mitigation reduces bias in estimated expectation values but pays for it in sampling cost and does nothing to extend the coherence-limited depth — only error correction does that.

Worked examples

1 · The circuit-volume budget of a NISQ processor (fully worked)

A processor has average per-operation error $\epsilon=10^{-3}$ and $n=50$ qubits. Demand a clean-run fidelity of at least $1/e$ . How many reliable operations can it perform, how deep can a full-width circuit be, and what happens if you double that depth?

Step 1. The signal floor $F=e^{-V\epsilon}\ge 1/e$ means $V\epsilon\le 1$ , so the total reliable operation count is $V_{\max}=1/\epsilon=1/10^{-3}=\mathbf{1000}$ error-prone operations. Every gate on every qubit draws on this one budget.

Step 2. Spread across the full width $n=50$ , the depth ceiling is $d_{\max}\sim V_{\max}/n=1000/50=\mathbf{20}$ layers. Check the fidelity directly: at $V=1000$ , $F=e^{-1}=0.368$ , and the exact form $(1-10^{-3})^{1000}=0.3677$ agrees to three figures — the exponential approximation is excellent.

Step 3. Double the depth to $40$ layers: now $V=n\,d=50\times40=2000$ , so $V\epsilon=2$ and $F=e^{-2}=\mathbf{0.135}$ . The clean-run probability has not halved — it has fallen by a further factor of $e$ , and the number of repetitions needed to estimate an observable to fixed precision, which scales as $1/F^2$ , has jumped by $e^{2}\approx 7.4\times$ . The lesson: reliable depth is $\sim 20$ layers here; pushing to $40$ multiplies the measurement cost roughly sevenfold for the same answer, which is why NISQ circuits are kept deliberately shallow.

2 · From measured coherence times to a depth ceiling

A transmon has $T_1=100\ \mu\mathrm{s}$ and $T_2=80\ \mu\mathrm{s}$ , and a gate layer takes $\tau_{\mathrm{gate}}=40\ \mathrm{ns}$ . Estimate the idle error per gate, the coherence-limited depth, and — for a $50$ -qubit circuit — the depth at which the volume budget bites. Which wall is hit first?

Step 1. Idle error per gate from the Lindblad estimate $\epsilon_{\mathrm{idle}}\approx\tau_{\mathrm{gate}}(1/T_1+1/T_2)$ : the two terms are $40\times10^{-9}/100\times10^{-6}=4.0\times10^{-4}$ and $40\times10^{-9}/80\times10^{-6}=5.0\times10^{-4}$ , so $\epsilon_{\mathrm{idle}}=\mathbf{9.0\times10^{-4}}\approx 10^{-3}$ .

Step 2. Coherence wall: the number of gate layers that fit inside $T_2$ is $d_{\mathrm{coh}}\sim T_2/\tau_{\mathrm{gate}}=80\times10^{-6}/40\times10^{-9}=\mathbf{2000}$ layers. Taken alone, a single qubit could in principle run two thousand layers before it fully dephases.

Step 3. Volume budget for the full $50$ -qubit width: $d_{\max}\sim 1/(n\epsilon)=1/(50\times 9.0\times10^{-4})=\mathbf{22}$ layers. The volume budget wall at $\sim 22$ layers is hit almost a hundred times sooner than the single-qubit coherence wall at $2000$ layers — because a wide circuit spends its shared budget across all $50$ qubits every layer. In NISQ, width, not raw coherence, is usually what caps useful depth, and this is precisely the regime where lowering $\epsilon$ (better gates) helps far more than adding qubits.

Physics of the portrait

The NISQ paradigm is unusual among physics ideas in having a birthday and a named author. It was not discovered in a lab but named into existence — a piece of conceptual bookkeeping that told a whole field, honestly, where it stood.

Origins · 1 minJohn Preskill and how this was discovered

John Preskill

born 1953 · coined "NISQ" and mapped the boundary to fault tolerance

John Preskill is a theoretical physicist at Caltech, where he directs the Institute for Quantum Information and Matter, and he has a rare gift for naming the thing everyone is circling. Trained in high-energy theory — his early work is on magnetic monopoles, cosmology, and the black-hole information problem — he turned to quantum information in the 1990s and became one of the architects of the theory of fault tolerance, contributing to the threshold theorem that guarantees scalable quantum computation once physical error rates fall below a critical value. In 2012 he coined quantum supremacy for the point at which a quantum device performs a task no classical computer can feasibly reproduce, and in his 2018 essay "Quantum Computing in the NISQ era and beyond" he coined NISQ itself, giving the community a sober, quantitative vocabulary for machines that were powerful enough to be interesting yet too noisy to be corrected. His Caltech Ph219 lecture notes have trained a generation, and the framing in this article — the volume budget, the mitigation-versus-correction distinction, the regime as a bridge — is essentially his. Preskill's genius here was diagnostic: he named the gap so the field could work honestly inside it while building its way out.

History

1995

— Shor's nine-qubit code shows quantum error correction is possible

1997

— the threshold theorem: fault tolerance is achievable below a critical error rate

2012

— Preskill coins "quantum supremacy" for the classical-simulation crossover

2018

— Preskill coins "NISQ" and maps the near-term regime in his Quantum era essay

2019

— Google's Sycamore reports quantum advantage by random-circuit sampling

Going further

Texts. Preskill, "Quantum Computing in the NISQ era and beyond," Quantum 2, 79 (2018) — the founding essay · Nielsen and Chuang, Quantum Computation and Quantum Information (10th anniv. ed.), Ch. 8 (noise, channels) and Ch. 10 (error correction) · Preskill, Caltech Ph219 Lecture Notes, Ch. 3 (Foundations II) and Ch. 7 · Wilde, Quantum Information Theory (2nd ed.), Ch. 4 (quantum channels) · Watrous, The Theory of Quantum Information, Ch. 2 · Nielsen and Chuang §8.3 for the specific channel Kraus operators. The key relations used throughout this article are: the fidelity law $F=(1-\epsilon)^V\approx e^{-V\epsilon}$ and budget $V\epsilon\lesssim1$ ; the Kraus operators and Bloch contractions for the depolarizing, amplitude-damping, and phase-damping channels; the decay parameter $\gamma=1-e^{-t/T_1}$ , coherence decay $e^{-t/T_2}$ , and $1/T_2=1/2T_1+1/T_\varphi$ with $T_2\le2T_1$ ; and the GKSL form (6) with short-time idle error $\epsilon_{\mathrm{idle}}\sim\tau_{\mathrm{gate}}(1/T_1+1/T_2)$ . Worked-example anchor numbers: $V_{\max}=1000$ , $d_{\max}=20$ , $F(2000)=0.135$ ; $\epsilon_{\mathrm{idle}}=9.0\times10^{-4}$ , coherence wall $2000$ layers, volume-budget depth $22$ layers. Device figures (Sycamore $53$ qubits, XEB fidelity $\sim0.2\%$ ; IBM $127$ -qubit Eagle) are published values.

Prerequisites. Open Quantum Systems and Reduced Dynamics · Decoherence · Quantum Operations and CPTP Maps · Relaxation and Dephasing: T1 and T2 Times. Leads to. Depolarizing Channel · Amplitude Damping Channel · Phase Damping Channel · Lindblad / GKSL Master Equation.

Ask the tutor: Ask me to turn your device's $\epsilon$ , $T_1$ , and $T_2$ into a concrete depth ceiling, to compare error mitigation with correction, or to walk a state through any of the NISQ noise channels on the Bloch ball.

What exactly do "noisy" and "intermediate-scale" each mean?

They are two independent statements packed into one acronym. Intermediate-scale is about size: the register holds tens to a few hundred qubits — large enough that its $2^n$ -dimensional state vector cannot be stored or simulated on any classical computer, but far too small to encode even one fault-tolerant logical qubit, which costs thousands of physical ones. Noisy is about quality: every gate, measurement, and idle interval fails at a rate of order $10^{-2}$ to $10^{-3}$ , above the regime where error correction becomes cheap. Crucially the two are somewhat in tension — the interesting size makes classical checking impossible, while the noise makes the quantum answer only partly trustworthy — and navigating that tension is what the whole paradigm is about.

Why is the constraint a product V·ε rather than a sum of errors?

Because a circuit succeeds only if every one of its operations succeeds, and independent survival probabilities multiply. With $V$ operations each surviving with probability $1-\epsilon$ , the clean-run probability is $(1-\epsilon)^V$ , and taking the logarithm turns the product into $-V\epsilon$ (for small $\epsilon$ ), so $F\approx e^{-V\epsilon}$ . The relevant quantity is therefore the product of how many things can go wrong, $V$ , and how likely each is to go wrong, $\epsilon$ . This is why you cannot compensate a large circuit by anything short of a smaller per-gate error: doubling the depth and halving the error leaves $V\epsilon$ — and hence the fidelity — unchanged.

Can't we just keep adding qubits until NISQ machines are useful?

No — width alone does not help and can even hurt. The reliable depth scales as $d_{\max}\sim 1/(n\epsilon)$ , so at fixed gate error $\epsilon$ each extra qubit in a layer spends the shared volume budget faster, shrinking how deep you can compute. A thousand-qubit processor with $\epsilon=10^{-2}$ can run only a handful of clean layers. What actually unlocks useful computation is lowering $\epsilon$ : once the per-gate error drops below the fault-tolerance threshold (around $1\%$ for the surface code), error correction lets you trade many physical qubits for a few high-quality logical ones and run arbitrarily deep circuits. So the path forward is better qubits first, then more of them — not more of them at today's quality.

How is error mitigation different from error correction?

Error correction detects and removes errors during the computation, using redundant encoding and mid-circuit measurement, and — once physical errors are below threshold — enables arbitrarily long reliable circuits at the cost of many extra physical qubits. Error mitigation does none of that: it leaves the noisy circuit untouched and instead runs it many times, then post-processes the results to cancel bias in an estimated expectation value. Zero-noise extrapolation, for instance, deliberately amplifies the noise, measures how the answer drifts, and extrapolates back to the zero-noise point. Mitigation needs no extra qubits and works today, but it buys accuracy with a steep increase in sampling cost and, critically, it cannot extend the coherence-limited depth. It is a NISQ-era stopgap, not a substitute for correction.

Why does the coherence bound T2 ≤ 2T1 always hold?

Because relaxation destroys phase information as a side effect. Coherence — the off-diagonal $\rho_{01}$ of the density matrix — can be lost two ways: by genuine dephasing (random phase kicks with no energy change, rate $1/T_\varphi$ ) and by relaxation itself, since an energy decay event also erases the phase relationship. Amplitude damping alone decays coherence at rate $1/2T_1$ , the factor of two coming from coherence being linear in an amplitude that populations depend on quadratically. Adding pure dephasing only speeds coherence loss: $1/T_2=1/2T_1+1/T_\varphi$ . Since $1/T_\varphi\ge0$ , we always have $1/T_2\ge 1/2T_1$ , i.e. $T_2\le 2T_1$ . Equality holds only for a perfectly dephasing-free qubit, which real hardware never quite achieves.

What kinds of algorithms are actually suited to NISQ hardware?

Anything that stays shallow and tolerates imperfect answers. The flagship family is variational: a low-depth parameterized circuit prepares a trial state, only expectation values are measured, and a classical optimizer adjusts the parameters in a loop — the variational quantum eigensolver for molecular ground-state energies, the quantum approximate optimization algorithm for combinatorial problems. Sampling demonstrations (random-circuit sampling, boson sampling) are the other class: they are chosen precisely because a shallow, scrambling circuit produces a distribution believed hard to simulate classically, even though its raw fidelity is tiny. What unites them is respect for the budget — they keep $V\epsilon$ small, extract a statistical rather than an exact answer, and lean on classical co-processing. Deep, exact algorithms like Shor's factoring need error correction and are out of NISQ reach.

Is NISQ a dead end, or a step toward something?

It is explicitly a bridge, and Preskill said so in the title of the founding essay — "the NISQ era and beyond." The regime is defined by the absence of error correction, so it is temporary by construction: as physical error rates fall below the fault-tolerance threshold and qubit counts climb into the thousands, correction becomes affordable and the machine crosses into the fault-tolerant era, where the volume budget no longer caps depth. What NISQ contributes in the meantime is real: it validates hardware at scale, sharpens the benchmarking and mitigation toolkit, probes where quantum advantage genuinely lives, and pressures gate errors downward. Whether NISQ machines deliver decisive practical value before that crossover is still an open question — but as a proving ground on the road to fault tolerance, its role is not in doubt.