Pith. Sign in

REVIEW

Fault Tolerant Quantum Computation with Constant Error

Quantum Physics · Submitted 14 Nov 1996 · 25 references

Pith's verdict: The paper that turned the threshold theorem into a real target — concatenation plus 'proper codes' — and the core argument holds, though the appendix proof is a sketch and one linchpin is asserted more than shown.

T0 · AI review

How this review was made: An AI referee (selfhosted/deepseek-v4.1-flash) read the paper on November 13, 2026 and answered a fixed list of questions about it. T0 is the starting level every paper gets. The levels describe how deeply Pith has checked the paper, never the authors.

  1. T0 AI review An AI read the paper and answered a fixed list of questions.
  2. T1 Audit Automatic checks that the references and files the paper relies on exist and match.
  3. T2 Compute The paper's code or calculations re-run with the same results.
  4. T3 Formal statement The claims written out in a formal math language a computer can read.
  5. T4 Proof Those claims proved, and the proof checked by computer.

How Pith checks papers →

· 4 major objections · 7 minor · Ask about this paper · The compiled record · Read the full review →
Challenge this review Comment (0) Read on arXiv ↗
Cite ▾
arXiv IDquant-ph/9611025 (version 2)
CitationComputer Science, Dorit Aharonov (Physics, Hebrew Univ.), Michael Ben-Or (Computer science. "Fault Tolerant Quantum Computation with Constant Error." arXiv:quant-ph/9611025 (1996). https://pith.science/paper/quant-ph/9611025
Cite this reviewBibTeX for Pith's review of this paper
Claim paper

Why Pith says this

Highlight any text to comment on it.

Referee report
The paper

The paper claims

Constant-rate noise can be made survivable for quantum computation.

The reading

The paper asks whether a quantum circuit can keep computing correctly when every qubit and every gate has a fixed, non-negligible chance of failing at every time step. Shor had shown this only when the fault probability falls logarithmically with the circuit size; Aharonov and Ben-Or argue that a constant threshold is enough. Their route is to encode each logical qubit in a block, alternate computation with error correction, and then concatenate the whole simulation several times so that the effective fault rate shrinks exponentially in the number of levels. If the argument holds, a quantum computer built from noisy components could run long computations at polylogarithmic overhead in time and space, provided its physical error rate is below a code-dependent constant that the paper estimates near $10^{-6}$ for its explicit codes.

What carries the argument

The machinery is concatenated simulation by a proper quantum computation code. A code is proper when its gate, initialization, reading, and correction procedures use only gates from the code’s own universal set, and when the correction procedure takes any density matrix—not only one close to a codeword—to some word in the code. Concatenation replaces each qubit of the simulated circuit by a block, each time step by a working period, and each gate by a fault-tolerant procedure; correction stages are inserted between computation stages. Lemma 2 proves by induction on the number of levels $r$ that an $(r,k)$-sparse fault path with $2kl ≤ d$ leaves the state $(r,d/2)$-deviated from the correct one, and the threshold inequality makes such sparse fault paths overwhelmingly likely for $r = O(log log V(M_0))$. The procedures replace measurements with controlled-NOT gates, so no measurement is used during the quantum computation.

Extended reading notes

Core claim

The central claim is a threshold theorem for noisy quantum circuits: for any circuit $M_0$ of size $s$ and depth $t$, and any noise rate $η$ below a constant $η_0$ determined by the chosen code, there is a simulating circuit $M_r$ of size $O(s · polylog(s))$ and depth $O(t · polylog(t))$ that outputs the correct answer with probability at least $2/3$. The threshold condition is $((a)/(d/2l+1)) η^{d/2l} < 1$, where the code corrects $d$ errors, has spread $l$, and all its procedures fit in rectangles of size at most $a$. The paper also supplies two explicit families of “proper” quantum computation codes—linear codes over $F_p$ for $p=2$, and polynomial quantum codes over $F_p$—and estimates the resulting threshold at about $10^{-6}$.

Load-bearing premise

The load-bearing premise is Definition 4’s second condition: the correction procedure must turn any input state, including one far from every codeword, into some codeword; without that closure, the multi-level induction cannot restart at the next level.

Editorial extensions

If this is right

  • A physical error rate below a code-dependent constant suffices for arbitrarily long quantum computation with polylogarithmic time and space overhead, rather than requiring the error rate to shrink as the computation grows.
  • The threshold is not fixed by nature: better proper codes with larger distance-to-spread ratios and smaller procedures raise $η_0$, making the practical target easier to meet.
  • The same construction can be laid out on nearest-neighbor architectures at a lower threshold, so locality costs can be traded against error tolerance.
  • Because the scheme avoids measurement during computation and is defined for mixed states, it fits a unitary noisy-circuit model in which faults are analyzed as random sparse paths.
  • The construction leaves open whether the polylogarithmic depth overhead can be reduced to a constant factor, as in the classical fault-tolerance analogy.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The hard part shifts from “can noise be tolerated at all” to “which codes are proper”: a search for codes with high distance, small spread, and a correction map defined on every state is the practical lever for raising the threshold.
  • The $10^{-6}$ estimate is a proof-of-concept parameter rather than a barrier, because the threshold depends exponentially on $d/2l$; modest improvements in code parameters could move it by orders of magnitude.
  • The requirement that correction map every state to a codeword is an attractor-like property, so candidate codes can be tested by deliberately feeding their correction step states far from any codeword and checking whether the output lands back in the code.
  • Nearest-neighbor layout plus concatenation suggests a hardware-design tradeoff: extra swap gates lower the threshold but preserve the polylogarithmic overhead, so architectural locality can be treated as a parameter in the same threshold calculation.
Original abstract

Recently Shor showed how to perform fault tolerant quantum computation when the error probability is logarithmically small. We improve this bound and describe fault tolerant quantum computation when the error probability is smaller than some constant threshold. The cost is polylogarithmic in time and space, and no measurements are used during the quantum computation. The result holds also for quantum circuits which operate on nearest neighbors only. To achieve this noise resistance, we use concatenated quantum error correcting codes. The scheme presented is general, and works with all quantum codes that satisfy some restrictions, namely that the code is ``proper''. We present two explicit classes of proper quantum codes. The first example of proper quantum codes generalizes classical secret sharing with polynomials. The second uses a known class of quantum codes and converts it to a proper code. This class is defined over a field with p elements, so the elementary quantum particle is not a qubit but a ``qupit''. With our codes, the threshold is about 10^(-6). Hopefully, this paper motivates a search for proper quantum codes with higher thresholds, at which point quantum computation becomes practical.

The compiled record

The paper's own sentences, arranged, kept beside the review and separate from it. Each label is drawn from a closed vocabulary; the number beside it is the probability the classifier gave that label. Numbers in the tables are the authors', checked by code. No sentence in this record was written by a model.

Compiled by classifier-1.13.0 via TypeSafe API, question bank abstract-p1-20260923, 2026-09-23: 1 request, 8,526 input tokens.

What the abstract itself states, as probabilities: claims first 0.07 · states limitation 0.87 · human participants 0.01 · controlled comparison 0.09 · randomized assignment 0.01 · states quantitative result 0.98 · compares with prior results 0.96 · mentions code or data availability 0.02.

The abstract, sentence by sentence

arXiv listing abstract v2. Results and the main claim are underlined; .

Recently Shor showed how to perform fault tolerant quantum computation when the error probability is logarithmically small. We improve this bound and describe fault tolerant quantum computation when the error probability is smaller than some constant threshold. The cost is polylogarithmic in time and space, and no measurements are used during the quantum computation. The result holds also for quantum circuits which operate on nearest neighbors only. To achieve this noise resistance, we use concatenated quantum error correcting codes. The scheme presented is general, and works with all quantum codes that satisfy some restrictions, namely that the code is ``proper''. We present two explicit classes of proper quantum codes. The first example of proper quantum codes generalizes classical secret sharing with polynomials. The second uses a known class of quantum codes and converts it to a proper code. This class is defined over a field with p elements, so the elementary quantum particle is not a qubit but a ``qupit''. With our codes, the threshold is about 10^(-6). Hopefully, this paper motivates a search for proper quantum codes with higher thresholds, at which point quantum computation becomes practical.

background contribution method result interpretation main claim

What the classifier reports for each sentence. The number is the probability it gave the label.
#sentencerolethe authors' own workstates the main conclusionstrength
s0 Recently Shor showed how to perform fault tolerant quantum computation when the error probability is logarithmically small. background 1.00 0.03 0.03 asserted 1.00
s1 We improve this bound and describe fault tolerant quantum computation when the error probability is smaller than some constant threshold. contribution 0.90 0.94 0.85 asserted 1.00
s2 The cost is polylogarithmic in time and space, and no measurements are used during the quantum computation. result 0.94 0.89 0.21 asserted 1.00
s3 The result holds also for quantum circuits which operate on nearest neighbors only. result 0.96 0.82 0.07 asserted 1.00
s4 To achieve this noise resistance, we use concatenated quantum error correcting codes. method 1.00 0.87 0.07 asserted 1.00
s5 The scheme presented is general, and works with all quantum codes that satisfy some restrictions, namely that the code is ``proper''. contribution 0.47 0.82 0.16 asserted 1.00
s6 We present two explicit classes of proper quantum codes. contribution 0.98 0.93 0.06 asserted 1.00
s7 The first example of proper quantum codes generalizes classical secret sharing with polynomials. contribution 0.89 0.79 0.03 asserted 1.00
s8 The second uses a known class of quantum codes and converts it to a proper code. contribution 0.74 0.82 0.03 asserted 1.00
s9 This class is defined over a field with p elements, so the elementary quantum particle is not a qubit but a ``qupit''. method 0.46 0.44 0.03 asserted 1.00
s10 With our codes, the threshold is about 10^(-6). result 1.00 0.90 0.16 asserted 0.92
s11 Hopefully, this paper motivates a search for proper quantum codes with higher thresholds, at which point quantum computation becomes practical. future work 0.99 0.09 0.08 hedged possibility 0.68

What kind of paper the classifier reports this is: theoretical result 0.76 · evidence from proof or derivation 0.98.

What was examined, and what was not

sources read
  • arXiv listing abstract v2
not examined
  • full text
  • figures and tables
  • references and citing sentences
  • relations to other papers
levels run
  • P abstract
not run
  • S sections
  • T body sentences
  • C citations
  • R cross-paper relations

Every quoted sentence on this record is the authors'. Every label is from Pith's closed vocabulary, with the probability shown beside it. Every number in the measurements table is the authors', checked by code. Record as JSON

References
How the literature uses it

35 arXiv papers cite this in 45 sentences

Each citing sentence is taken from the citing paper's LaTeX source and typed by Pith's classifier. A label appears at probability 0.8 or more (0.95 for support), a contest at 0.7 or more; the quoted words are the citing authors'. How each label was checked · JSON

Papers citing it · 26 sentences without a confident label

Uses its method or tool 1 paper
  • The second strategy takes advantage of the well developed methods of quantum error correction, either employing techniques known as subsystem-, operator-, or Hamiltonian-encoding [ref] that suppress qubit errors using energy penalties, or more fundamentally and systematically, building the Feynman-Kitaev construct from a quantum circuit ${U_L(t)}_t=1^T$ that has quantum error correction and fault tolerance via concatenated encoding [ref] built in as being explained previously in this section.

    Monte Carlo Quantum Computing · Universal Quantum Circuits Using Bi-Fermion Rebits · 0.87

Compares with it 3 papers
Cites it as support 1 paper
  • Now we know that, provided that the physical error rate per gate and per time step is below some constant threshold value, it is possible to make the logical quantum computation we wish to perform arbitrarily close to correct with overhead that is polylogarithmic in the length of the computation [ref] .

    An Introduction to Quantum Error Correction and Fault-Tolerant Quantum Computation · The need for fault tolerance · 0.98

Cites it as background 13 papers
  • On the basis of fundamental early theoretical work [ref] , lip service is frequently paid to a necessary universal set of operations containing the two-qubit controlled-$σ_x$ (cnot) gate, and a necessary “threshold” error rate in the $10^-5-10^-4$ range.

    Fault-Tolerant Computing With Biased-Noise Superconducting Qubits · Introduction · 0.97

  • While we cannot expect to reduce qubit noise arbitrarily with laboratory engineering alone, the theory of quantum error correction [ref] has shown that we can produce logical qubits that experience next-to-no noise by using a redundancy of high-quality physical qubits, provided the noise strength on the physical qubits as they perform computational operations is below some threshold value [ref] .

    Practical quantum error correction with the XZZX code and Kerr-cat qubits · Introduction · 0.81

  • Quantum error-correcting codes [ref] used fault-tolerantly can perform arbitrarily accurate computations with noisy components, provided the noise stays below a threshold as the system size is scaled up [ref] .

    Lower overhead fault-tolerant building blocks for noisy quantum computers · Local measurements on a 1-D chain · 0.99

Discussion

Disagree with the review, or know something it missed? Leave a comment, highlight any passage above to comment on it, or challenge this review formally.