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
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
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
- 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.
The abstract, sentence by sentence
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
| # | sentence | role | the authors' own work | states the main conclusion | strength |
|---|---|---|---|---|---|
| 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 was examined, and what was not
- arXiv listing abstract v2
- full text
- figures and tables
- references and citing sentences
- relations to other papers
- P abstract
- S sections
- T body sentences
- C citations
- R cross-paper relations
References
How the literature uses it
35 arXiv papers cite this in 45 sentences
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
-
Also, the present efficiency is compatible with other state of the art protocols [ref] and we believe we can increase its efficiency at higher error rates by properly applying quantum error correction strategies at intermediate corrals [ref] .
Quantum Corralling · Disorder · 0.92
-
The first was presented in [ref] and later used in [ref] .
Constructing optimal quantum error correcting codes from absolute maximally entangled states · Quantum error correcting codes from AME states · 0.98
-
The analysis, by definition, has to be completely different from the error analysis in fault tolerant quantum computation, wherein the effect of noise is bounded by counting and weighting different fault paths [ref] .
Noise-resilient preparation of quantum many-body ground states · Introduction · 0.91
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.