nLab quantum error correction

Redirected from "code subspace".

Context

Quantum systems

quantum logic


quantum physics


quantum probability theory – observables and states


quantum information


quantum technology


quantum computing

Computation

Contents

Idea

Quantum error correction (QEC) is concerned with ensuring the robustness of quantum computation against noise (as in classical error correction) and particularly against quantum noise and quantum decoherence, by correcting computational errors as they occur at runtime.

The need for quantum error correction is particularly urgent for the currently existing noisy quantum memories (cf. NISQ), which, despite their inherent instability, are widely envisioned to scale up to useful quantum computers by having them vigorously corrected by massive classical computing power; cf. discussion of the decoding bottleneck below.

What is being corrected with QEC are quantum computations on a quantum computer, while the correction mechanisms are classical computations: During and in parallel to the execution of the quantum computer, a classical computer executes an indefinite loop which in each step:

  1. reads out quantum measurement results on parts of the quantum memory (on the “syndromes”),

  2. infers from these (via a decoding algorithm) potential errors that may have occured in the quantum machine,

  3. controls the quantum computer to execute quantum gates designed to counteract these errors.

Hence QEC is about a quantum/classical interaction loop:

It is a nontrivial and remarkable theoretical insight (involving results such as quantum error threshold theorems) that such a scheme can work

but it remains a substantial engineering challenge to also make it work

In principle

From Ferris & Poulin 2013:

The basic principle of quantum error correction (QEC) is to encode information into the long-range correlations of entangled quantum many-body states in such a way that it cannot be accessed locally. When a local error affects the system, it leaves a detectable imprint—called the error syndrome. The decoding problem consists in inferring the recovery with greatest probability of success given the error syndrome. In general, this is a hard problem, but for well-chosen codes, it can be solved efficiently either exactly or heuristically.

From Steane 06:

Error correction is especially important in quantum computers, because efficient quantum algorithms make use of large scale quantum interference, which is fragile, i.e. sensitive to imprecision in the computer and to unwanted coupling between the computer and the rest of the world. This makes large scale quantum computation so difficult as to be practically impossible unless error correction methods are used. Indeed, before quantum error correction was discovered, it seemed that this fragility would forbid large scale quantum computation. The ability to correct a quantum computer efficiently without disturbing the coherence of the computation is highly non-intuitive, and was thought more or less impossible. The discovery of powerful error correction methods therefore caused much excitement, since it converted large scale quantum computation from a practical impossibility to a possibility.

From Devitt, Nemoto & Munro 2009:

Starting in 1995, several papers appeared, in rapid succession, proposing codes which were appropriate to perform error correction on quantum data (Sho95; Ste96a; CS96; LMPZ96; BSW96). This was a key theoretical development needed to convince the general community that quantum computation was indeed a possibility. Since this initial introduction, the progress in this field has been extensive.

From Zhu & Cross 20:

Although we are currently in an era of quantum computers with tens of noisy qubits, it is likely that a decisive, practical quantum advantage can only be achieved with a scalable, fault-tolerant, error-corrected quantum computer. Therefore, development of quantum error correction is one of the central themes of the next five to ten years.

Lucero 21:

Within the decade, Google aims to build a useful, error-corrected quantum computer. [⋯][\cdots] Our journey to build an error-corrected quantum computer within the decade includes several scientific milestones, including building an error-corrected logical qubit.

Specifically on holographic quantum error correcting codes (see references below):

From Harlow 20:

The codes provided by AdS/CFT often come close to saturating theoretical bounds on the performance of quantum codes. It seems AdS/CFT may be a tool for discovering better quantum cryptography?

WVSB 20:

[[ holographic codes ]] could be promising candidates to circumvent our results and could possibly realise a universal set of unitary implementations of logical operators.

From CDCW 21:

There are a number of reasons to suspect that holographic codes may be of practical use for quantum computing.

Holographic codes can admit erasure thresholds comparable to that of the widely-studied surface code, and likewise for their threshold against Pauli errors. Their holographic structure also naturally leads to an organization of encoded qubits into a hierarchy of levels of protection from errors, which could be useful for applications which call for many qubits withvarying levels of protection. In particular, this is reminiscent of many schemes for magic state distillation – and indeed, the concatenated codes utilized for magic state distillation share a similar hierarchical structure to holographic codes. The layered structure of holographic codes is also reminiscent of memory architectures in classical computers, where it is useful to have different levels of short- and long-term memory. Although these codes have some notable drawbacks, in particular holographic stabilizer codes require nonlocal stabilizer generators, other codes such as concatenated codes suffer similar drawbacks and have still proven to be useful. Conversely, the stringent requirement of non-local stabilizer generators allows holographic codes to protect many more qubits than a topological code and in fact attain a finite nonzero encoding rate, which is typically not possible for topological codes. Nonetheless, many open questions remain about the usefulness of holographic codes for fault-tolerant quantum computing.

Basic idea of QEC via the 3-qbit code

It is useful and common to illustrate the basic idea of QEC with the 3-qbit code, since it already showcases the key stages of (1.) encoding, (2) syndrome and (3.) correction. But beware that practically relevant code these days are surface codes which are quite different in nature, see also below.

The classical case

Before considering quantum error correction it is useful to step back and briefly reconsider the analogous case of classical error correction.

To set the stage: We regard bit values as elements of the cyclic group ℤ /2={0,1}\mathbb{Z}_{/2} = \{0,1\} of integers modulo 2.

  1. Their addition mod 2 is the exclusive or (xor) of bits, denoted

    0⊕0 =1⊕1=0 0⊕1 =1⊕0=1, \begin{aligned} 0 \oplus 0 & = 1 \oplus 1 \,=\, 0 \\ 0 \oplus 1 & = 1 \oplus 0 \,=\, 1 \mathrlap{\,,} \end{aligned}

    so that b↦b⊕1b \mapsto b \oplus 1 is the flip of a bit bb,

  2. Their multiplication mod 2 is the logical and.

Now, a bit stored or transmitted in a noisy medium may get flipped with some small probability p∈[0,1]p \in [0,1], and error correction is about fixing such flips.

The simplest remedy is redundancy: encode each logical bit by a triple of equal physical bits,

(1)ℤ /2 ⟶ (ℤ /2) 3 b ↦ (b,b,b). \array{ \mathbb{Z}_{/2} &\longrightarrow& (\mathbb{Z}_{/2})^{3} \\ b &\mapsto& (b,b,b) \mathrlap{\,.} }

If at most one of the bits in (b 1,b 2,b 3)(b_1, b_2, b_3) gets flipped, its position in the triple is exactly determined by the following pair of parities:

s 1 ≔b 1⊕b 2 s 2 ≔b 2⊕b 3, \begin{aligned} s_1 & \coloneqq b_1 \oplus b_2 \\ s_2 & \coloneqq b_2 \oplus b_3 \,, \end{aligned}

which vanish exactly on the codewords (0,0,0)(0,0,0) and (1,1,1)(1,1,1). This pair (s 1,s 2)(s_1,s_2) is hence called the error syndrome, since it allows to uniquely identify the position of a one-it flip error (if any), as follows:

(2)(s 1,s 2)=(0,0) ⇔no error (s 1,s 2)=(1,0) ⇔1st bit flipped (s 1,s 2)=(1,1) ⇔2nd bit flipped (s 1,s 2)=(0,1) ⇔3rd bit flipped. \begin{aligned} (s_1, s_2) = (0,0) & \;\;\;\;\Leftrightarrow\;\;\;\; \text{no error} \\ (s_1, s_2) = (1,0) & \;\;\;\;\Leftrightarrow\;\;\;\; \text{1st bit flipped} \\ (s_1, s_2) = (1,1) & \;\;\;\;\Leftrightarrow\;\;\;\; \text{2nd bit flipped} \\ (s_1, s_2) = (0,1) & \;\;\;\;\Leftrightarrow\;\;\;\; \text{3rd bit flipped} \mathrlap{\,.} \end{aligned}

Hence classical error correction in this case proceeds by:

  1. Syndrome: Measuring the triple state and computing the error syndrome from it.

  2. Decoding: Computing from the syndrome the apparent position of the flipped bit according to (2).

  3. Correction: Flipping that identified bit back.

This prodedure:

  • succeeds if none or one bit flipped,

  • fails if two or three bits flipped.

    Assuming that the bits flip independently of each other, this failure happens with probability

    3p 2(1−p)⏟two flips+p 3⏟three flips=3p 2−2p 3, \underset{ \text{two flips} }{ \underbrace{ 3 p^2 (1-p) }} \;+\; \underset{ \text{three flips} }{ \underbrace{ p^3 }} \;=\; 3 p^2 - 2 p^3 \,,

    where the factor of 3 counts the choices of the pair of flipped bits. Since p−(3p 2−2p 3)=p(1−p)(1−2p)p - (3p^2 - 2p^3) = p(1-p)(1-2p), this is smaller than the error probability pp of an unprotected bit as long as p<1/2p \lt 1/2.


A characteristic property of this classical error correction is that the error syndrome is obtained in the most direct way: by reading out, hence by measuring, the state of the tuple of physical bits. Classically, this does no harm, but for qbits this does not work so directly and quantum error correction needs to be a tad more clever than this.

The issue with the quantum case

As we pass from classical bits to quantum bits, qbits, the information to be protected is that of a quantum state |ψ⟩=α|0⟩+β|1⟩{\vert \psi \rangle} = \alpha {\vert 0 \rangle} + \beta {\vert 1 \rangle} of a qbit, encoded by the amplitudes α,β∈ℂ\alpha, \beta \in \mathbb{C}.

The classical triple encoding (1) extends linearly from the canonical linear basis {|0⟩,|1⟩}\big\{ {\vert 0\rangle}, {\vert 1 \rangle} \} to QBit≡ℂ 2QBit \equiv \mathbb{C}^2:

(3)ℂ 2 ⟶ (ℂ 2) ⊗ 3 |ψ⟩ ↦ |ψ L⟩ α|0⟩+β|1⟩ ↦ α|000⟩+β|111⟩. \begin{array}{ccc} \mathbb{C}^2 &\longrightarrow& \big(\mathbb{C}^2\big)^{\otimes_3} \\ {\vert \psi \rangle} &\mapsto& {\vert \psi_L \rangle} \\ \alpha {\vert 0\rangle} + \beta {\vert 1 \rangle} &\mapsto& \alpha {\vert 000 \rangle} + \beta {\vert 111 \rangle} \,. \end{array}

In terms of quantum circuits this operation (3) may be implemented by |ψ⟩↦|ψ⟩⊗|00⟩{\vert \psi\rangle} \mapsto {\vert \psi \rangle} \otimes {\vert 00 \rangle} followed by two CNOT gates (see below).

This (3) is a copying operation, namely of the computational basis states. The no-cloning theorem only rules out that copying be natural (in particular: independent of the choice of basis), which would instead send general |ψ⟩{\vert \psi \rangle} to |ψ⟩ ⊗3{\vert \psi \rangle}^{\otimes 3}.

A flip of the iith qbit now acts as the Pauli operator X iX_i, hence as

X≔(0 1 1 0),X|b⟩=|b⊕1⟩ X \;\coloneqq\; \left( \array{ 0 & 1 \\ 1 & 0 } \right) \,, \qquad X {\vert b \rangle} \,=\, {\vert b \oplus 1 \rangle}

on the iith tensor factor and as the identity on the others (with X 0≔1X_0 \coloneqq 1 for the error-free case). For example:

X 2|ψ L⟩=α|010⟩+β|101⟩. X_2 {\vert \psi_L \rangle} \;=\; \alpha {\vert 010 \rangle} + \beta {\vert 101 \rangle} \,.

Now, applying the classical strategy above verbatim would mean measuring the three qbits in the computational basis. While this would reveal the syndrome, already the first measurement would collapses the quantum state onto one of its two branches (here |010⟩{\vert 010 \rangle} or |101⟩{\vert 101 \rangle}, with Born rule probability |α| 2{\vert \alpha \vert}^2 or |β| 2{\vert \beta \vert}^2, respectively). This would serve to diagnose the error, but would itself destroy the quantum state completely: the amplitudes α,β\alpha, \beta (the very data to be protected) would be lost.

Notice, however, that the syndrome takes the same value on both branches (here (s 1,s 2)=(1,1)(s_1, s_2) = (1,1) for |010⟩{\vert 010 \rangle} as well as for |101⟩{\vert 101 \rangle}).

To turn this into a quantum observable, consider the Pauli operator

Z≔(1 0 0 −1),Z|b⟩=(−1) b|b⟩, Z \;\coloneqq\; \left( \array{ 1 & 0 \\ 0 & -1 } \right) \,, \qquad Z {\vert b \rangle} \,=\, (-1)^b {\vert b \rangle} \,,

with which the syndrome appears as

Z 1Z 2|b 1b 2b 3⟩ =(−1) b 1⊕b 2|b 1b 2b 3⟩ Z 2Z 2|b 1b 2b 3⟩ =(−1) b 2⊕b 3|b 1b 2b 3⟩. \begin{aligned} Z_1 Z_2 {\vert b_1 b_2 b_3 \rangle} & = (-1)^{b_1 \oplus b_2} {\vert b_1 b_2 b_3 \rangle} \\ Z_2 Z_2 {\vert b_1 b_2 b_3 \rangle} & = (-1)^{b_2 \oplus b_3} {\vert b_1 b_2 b_3 \rangle} \mathrlap{\,.} \end{aligned}

This means that each X i|ψ L⟩X_i {\vert \psi_L \rangle} is a joint eigenstate of the syndrome parity observables Z 1Z 2Z_1 Z_2 and Z 2Z 3Z_2 Z_3, with eigenvalues (−1) s 1(-1)^{s_1} and (−1) s 2(-1)^{s_2}, respectively.

Hence while the individual physical bits must not be measured, their parities may.

This motivates adjoining auxiliary ancilla qbits onto which the parities are imprinted by unitary gates. A quantum measurement of just the ancillas is then a measurement on the total system which reveals the syndrome without collapsing the encoded state.

The proper quantum case

Concretely, consider adjoining to the logical Hilbert space (ℂ 2) 3\big(\mathbb{C}^2\big)^3 two ancilla qbits, hence pass to

ℋ≔(ℂ 2) 3⊗(ℂ 2) 2⏟ ancillary \mathscr{H} \coloneqq \big(\mathbb{C}^2\big)^3 \otimes \underbrace{ \big(\mathbb{C}^2\big)^2 }_{\text{ancillary}}

and consider on this the imprint unitary operator

(4)ℋ ⟶I ℋ |b 1b 2b 3⟩⊗|a 1a 2⟩ ↦ |b 1b 2b 3⟩⊗|a 1⊕b 1⊕b 2,a 2⊕b 2⊕b 3⟩ \begin{array}{ccc} \mathscr{H} &\overset{I}{\longrightarrow}& \mathscr{H} \\ {\vert b_1 b_2 b_3 \rangle} \otimes {\vert a_1 a_2 \rangle} &\mapsto& {\vert b_1 b_2 b_3 \rangle} \otimes {\vert a_1 \oplus b_1 \oplus b_2 ,\, a_2 \oplus b_2 \oplus b_3 \rangle} \end{array}

(a permutation of the computational basis, implementable by four CNOT gates), which imprints the parities of the code qbits onto ancillas initialized in |00⟩{\vert 00 \rangle}.

Suppose that the code state has suffered at most one bit flip, so that it is X i|ψ L⟩X_i {\vert \psi_L \rangle} for some unknown i∈{0,1,2,3}i \in \{0,1,2,3\}. Since the parities agree on both branches of X i|ψ L⟩X_i {\vert \psi_L \rangle}, we have

I(X i|ψ L⟩⊗|00⟩)=X i|ψ L⟩⊗|s 1s 2⟩, I\left( X_i {\vert \psi_L \rangle} \otimes {\vert 00 \rangle} \right) \;=\; X_i {\vert \psi_L \rangle} \otimes {\vert s_1 s_2 \rangle} \,,

where (s 1,s 2)(s_1, s_2) is the syndrome of the error X iX_i in that ii may be computed from it (2).

Error correction now proceeds in three steps analogous to the classical case above, but replacing code bit measurement by ancilla qbit quantum measurement:

  1. Syndrome: Since on the right of (4) we have a product state, measuring only the ancillas yields the syndrome (s 1,s 2)(s_1, s_2) with certainty, while leaving the code qbits in X i|ψ L⟩X_i {\vert \psi_L \rangle}, uncollapsed.

  2. Decoding: From the syndrome, a classical algorithm, the decoder, determines ii, here via the above) syndrome table (2), and thereby chooses the correcting quantum gate X iX_i.

  3. Correction: Applying the chosen correction quantum gate, which restores the code state in case of at most one bit flip error: X iX i|ψ L⟩=|ψ L⟩X_i X_i {\vert \psi_L \rangle} = {\vert \psi_L \rangle}, since XX=1X X = 1.

This is the 3-qbit bit flip code. Its full quantum circuit reads as follows: encoding, error, syndrome extraction by II, measurement, decoding and correction:



(5)

(The final gates are classically controlled (double lines) by the quantum measurement outcomes.)

It should be noted here that the quantum correction mechanism (5) is itself nothing but a quantum circuit, hence, when physically executed, is itself subject to quantum errors. This is a problem that is solved in principle by the quantum error threshold theorems, but in practice it makes this and similar codes actually unusable, see the discussion of Nested codes and Surface codes below.

Refinements

The above bit flip code does not protect against phase flips as reflected by the Pauli operator Z iZ_i. These send |ψ L⟩{\vert \psi_L \rangle} to α|000⟩−β|111⟩\alpha {\vert 000 \rangle} - \beta {\vert 111 \rangle}, which is again a code state and hence has trivial syndrome under the above code: the error goes undetected and corrupts the logical state.

But since the Hadamard gate

H≔12(1 1 1 −1) H \;\coloneqq\; \frac{1}{\sqrt{2}} \left( \array{ 1 & 1 \\ 1 & -1 } \right)

exchanges bit and phase flips, HXH=ZH X H = Z, the same scheme may be run in the Hadamard-transformed basis |±⟩≔H|0/1⟩=12(|0⟩±|1⟩){\vert {\pm} \rangle} \coloneqq H {\vert 0/1 \rangle} = \frac{1}{\sqrt{2}} \left( {\vert 0 \rangle} \pm {\vert 1 \rangle} \right). Hence the encoding

|0⟩ ↦|+++⟩ |1⟩ ↦|−−−⟩ \begin{aligned} {\vert 0 \rangle} & \mapsto {\vert {+}{+}{+} \rangle} \\ {\vert 1 \rangle} & \mapsto {\vert {-}{-}{-} \rangle} \end{aligned}

gives the “3-qbit phase flip code”, with syndrome given by the parity observables X 1X 2X_1 X_2 and X 2X 3X_2 X_3. It corrects any single phase flip, but now not bit flips.

Nesting the two codes, by encoding each of the three qbits of the phase flip code via the bit flip code, yields Shor’s 9-qbit code:

|0⟩ ↦122(|000⟩+|111⟩) ⊗3 |1⟩ ↦122(|000⟩−|111⟩) ⊗3. \begin{aligned} {\vert 0 \rangle} & \mapsto \frac{1}{2\sqrt{2}} \left( {\vert 000 \rangle} + {\vert 111 \rangle} \right)^{\otimes 3} \\ {\vert 1 \rangle} & \mapsto \frac{1}{2\sqrt{2}} \left( {\vert 000 \rangle} - {\vert 111 \rangle} \right)^{\otimes 3} \mathrlap{\,.} \end{aligned}

This corrects bit flips, phase flips and their composites X iZ iX_i Z_i on any single qbit. In fact this suffices to correct arbitrary errors on a single qbit. Every operator on a qbit is a linear combination of 11, XX, ZZ and XZX Z, and the syndrome measurement collapses such a superposition of errors onto one of its components, which is then corrected as before.

All of these are examples of stabilizer codes: the code space is the joint (+1)(+1)-eigenspace of a commuting set of products of Pauli operators (for the bit flip code: Z 1Z 2Z_1 Z_2 and Z 2Z 3Z_2 Z_3), whose measurement via ancillas yields the error syndrome.

General QEC codes

The simple but important special case of passive correction of erasures may be handled by quantum error correcting codes:

Recall that a classical error correcting code on a finite set of states LL is, typically, a choice of injection of LL into some larger finite set, typically a Cartesian power

L↪codeP≔H×⋯×H L \overset{code}{\hookrightarrow} P \coloneqq H \times \cdots \times H

(often considered in the form of linear codes, but classical nonetheless). In quantum physics the Cartesian product of sets of states is replaced by the tensor product of Hilbert spaces.

For ℒ\mathcal{L} a given Hilbert space of quantum states (finite-dimensional in practice), a quantum error correcting code is a choice of linear embedding (the code subspace) of ℒ\mathcal{L} into a larger Hilbert spaces, often an nn-fold tensor product of copies of some ℋ\mathcal{H}:

ℒlogicalqbits ↪codesubspacecode 𝒫≔ℋ (1)⊗⋯⊗ℋ (n)physicalqbits, \array{ \underset{ {\color{blue}logical} \atop {\color{blue}qbits} }{ \mathcal{L} } & \underoverset {{\color{blue}code} \atop {\color{blue} subspace}} {\;\;\;code\;\;\;} { \hookrightarrow } & \mathcal{P} \coloneqq \underset{ \color{blue} physical\;qbits }{ \mathcal{H}^{(1)} \otimes \cdots \otimes \mathcal{H}^{(n)} } } \,,

such that the information in code(ψ)code(\psi) in some of the tensor factors ℋ (i)\mathcal{H}^{(i)} can be lost without obstructing the reconstruction of ψ\psi (cf. Rowell & Wang 17, Sec. 3.2.3).

(Often one demands additional properties, such as that a given set of linear operators OO (quantum observables) acting on ψ∈ℋ\psi \in \mathcal{H} are implemented on code(ψ)code(\psi) by combinations of operators that act non-trivially only on some of the tensor factors.)

While this is superficially analogous to a classical error correcting code, the crucial and subtle difference is that quantum error correction codes thus take place in a non-Cartesian symmetric monoidal category. For this reason, effects of quantum entanglement play a paramount role in quantum error correction codes.

In practice

While the quantum error threshold theorem shows that quantum error correction of noisy quantum circuits is possible in principle, the practice of QEC at scale remains a major engineering challenge.

The decoding bottleneck

As of the 2020s, quantum error correction (QEC) applied to noisy intermediate-scale quantum (NISQ) machines is the dominant strategy paradigm, in both academia and industry, for potentially achieving meaningful quantum computation in the future.

But in technical discussions, the physical reality of the “endgame” of this approach may be easily missed by outsiders: Even in optimistic scenarios where theoretical error thresholds are achieved, the NISQ+QEC roadmap requires envisioning a staggering future feat of quantum and classical hardware engineering, haunted by intrinsic design tensions.

Namely, the quantum error-correcting mechanism required to run a useful, large-scale application on currently available qubit technology — such as Shor's algorithm (e.g. for cracking RSA-2048 encryption) will involve an astronomical rate of data processing. To maintain the logical quantum state, the auxiliary classical system must measure millions of physical qubits every microsecond, exchanging hundreds of terabytes of error “syndrome” data per second between the quantum device and its classical controller (cf. riverlane 2025). This is a data rate of the order of the global internet traffic! Decoding this torrent of data in real-time requires an amount of classical computational power that exceeds the capabilities of contemporary, building-sized exascale supercomputers (cf. Waintal 2024).

Even if such classical computing power is or were available, standard data cables connecting the quantum chip to an external supercomputer would introduce signal latency exceeding the coherence time of current qubits, rendering the correction commands obsolete upon arrival. Furthermore, the sheer volume of data transfer will or would transmit enormous amounts of thermal noise from the outside world into the quantum machine, jeopardizing its near-zero cooling and its quantum coherence.

This problem is also known as the decoding bottleneck or decoder bottleneck (cf. Mishan 2025, Croot et al. 2025, Ivezic 2026, Mahmud at al. 2026, Canton 2026).

To overcome this formidable scenario, the NISQ+QEC field has now turned to speculating on future classical hardware technology where Application Specific Integrated Circuit (ASICs) hardware is integrated directly into the ultra-cooled quantum refrigerator (e.g., via specialized “Cryo-CMOS” logic; cf. Erol 2026). However, this poses severe thermodynamic contradictions: Standard silicon transistors suffer from carrier freeze-out below ∼40K\sim 40K, whence one needs to envision an entire new kind of classical computing hardware. More generally, the cooling power at the base of a dilution refrigerator is strictly limited to a few micro-Watts. Therefore, placing a petaflop ASIC chip in near proximity to the quantum device would produce excess heat that under currently understood conditions would destroy the cryogenic environment that the quantum computer relies on.

Error correcting a reasonably powerful but noisy quantum computer will require novel classical supercomputers operating, partially, in currently unachieved cryogenic temperature regimes. [graphics from Schreiber 2026]

In conclusion, the NISQ+QEC roadmap for achieving meaningful commercial value quantum computers is now tacitly banking on unheard of and intrinsically dubious future progress in classical supercomputing technology — which, assuming it can be brought into existence, would then not be used for contentful computation itself, but would solely serve the task of preventing the memory of a quantum computer from decaying.

Noisy qbits are like water in a leaky bucket. In this analogy, (1.) quantum error correction is like continuously catching the leaking water and rapidly filling it back into the bucket, (2.) the decoding bottleneck is the intense amount of auxiliary machinery and effort of pumping this requires, (3.) hardware-level topological quantum protection is the patching of the buckets. [graphics from Schreiber 2026]

Aside: Hardware-level protection

The initial problem at the base of the decoding bottlenck problem above is the instability of current qubit technology (NISQ, see there).

The problem is akin to that of a bucket brigade which operates with extremely leaky buckets. In this picture, the QEC-style solution is like using ever more buckets together with sophisticated machinery that cleverly catches the leaked water only to fill it back into the buckets.

This analogy makes clear that an alternative strategy may be to actually fix the buckets. On the quantum technology side this corresponds to the approach of topological quantum computing (cf. Das Sarma 2022), where it is not runtime software redundancy that stabilizes shaky qubits, but intrinsic physical effects in topological quantum hardware.

However, while such topological stabilization of quantum states and topological protection of quantum gates exists in theory (and even that theory is not well developed at this point) essentially no experience with practical engineering implementation exists to date.

Nested codes and Surface codes

An intrinsic practical problem with QEC implemented via quantum circuits as in the simple 3-qbit code example (5) above is that these quantum circuits are themselves subject to errors, needing themselves another layer of QEC, and so on. This may appear to already lead to an infinite regression problem. Remarkably, the quantum error threshold theorem says that, in principle, a finite depth of nested codes is sufficient for breaking even if the baseline physical error rate pp is below some threshold (whence the name).

However, nested codes require non-local qbit connectivity on the quantum hardware, which becomes quickly technologically unachievable. For this reason, the nested codes that the theory of the threshold theorem considers are actually useless in practice.

For this reason the community has turned instead to surface codes. These mimic (“simulate”) topological mechanisms of error protection by a lattice of qbits using only local connectivity.

While surface codes solve the non-locality of nested codes, this comes at the cost that they correct errors only in Clifford gates, which are not sufficient for universal quantum computation, leaving non-Clifford gates like T-gates unprotected (see below).

Magic state factories

The decoding bottleneck (above) is only part of the problem of practically implementing QEC at scale.

Namely, with the currently most popular error correcting codes, which are surface codes (above), it is only Clifford gates that are error protected (after solving the decoding bottleneck), while universal quantum computing requires further gate type (such as the T-gate) that remain uncorrected by surface codes.

The now standard strategy to work around this problem, trades the missing gate for a resource quantum state: T-gates are enacted by gate teleportation, consuming magic states |A⟩=T|+⟩{\vert A \rangle} = T {\vert + \rangle} via a CNOT, a Z Z -measurement and a classically controlled SS-correction (which are all Clifford operations).

This leads to the further practical problem of equipping the quantum computer with a good supply of magic states, which has become a research field all in itself: “magic state factories”. Current estimates are that “magic state distillation” alone will occupy about 90% of the quantum chip, leaving 10% for actual computation, and that this creates a bottleneck on top of and dwarfing the error correction bottlenect (cf. NKM 2026).

Summary and outlook

Pushing the bump in the carpet around. The strategy of quantum error correction at scale has led to a cascade of subsequent technological problems. The currently dominant strategy for QEC at useful scale is now betting on future advances in classical supercomputer technology, in order to handle the decoding bottleneck and the magic state factory bottleneck of classical compute needed for fixing surface codes, which in turn were introduced to solve the impractical qbit non-locality of QEC.

References: Practical challenges of QEC

More on the above discussion of practical QEC challenges may be found in the following references, with some quotes highlighted:

  • Sankar Das Sarma: Quantum computing has a hype problem, MIT Technology Review (March 2022)

    “The qubit systems we have today are a tremendous scientific achievement, but they take us no closer to having a quantum computer that can solve a problem that anybody cares about. […] What is missing is the breakthrough […] bypassing quantum error correction by using far-more-stable qubits, in an approach called topological quantum computing.”

  • Francesco Battistel et al.: Real-Time Decoding for Fault-Tolerant Quantum Computing: Progress, Challenges and Outlook, Nano Futures 7 032003 (2023) [arXiv:2303.00054, doi:10.1088/2399-1984/aceba6]

  • Xavier Waintal: The Quantum House Of Cards, PNAS 121 1 (2024) e2313269120 [doi:10.1073/pnas.2313269120, arXiv:2312.17570]

  • Lior Mishan: Scalable Quantum Error Correction: Breaking Bottlenecks in Quantum Computing, Quantum Machine Blog (June 2025)

  • riverlane: Quantum Error Correction (2025)

  • Volkan Erol: Quantum Computing is No Longer a Physics Problem. It is a Systems Engineering Nightmare, Medium (Jan 2026) [pdf]

  • X. Croot et al.: Enabling Technologies for Scalable Superconducting Quantum Computing [arXiv:2512.15001 quant-ph]

    “The i/o of signal between qubit and control electronics is a central bottleneck to scaling. […] Many proposals for long-term fault-tolerant quantum computing require qubit numbers that are orders of magnitude greater than the capacity of available fridges, even when accounting for densification of components and reduction of thermal loads per qubit. […] The qubit overheads for the best FT-QEC schemes are daunting, and the implementation of decoding on the time-scale of the quantum gates (clock cycle) remains an open challenge in many leading hardware platforms. […] Systems of 100k qubits would demand large fractions of the yearly world production [of Helium] based on naive linear scaling.”

  • Marin Ivezic: The Decoder Bottleneck: The CRQC Challenge Nobody Is Talking About, PostQuantum (April 2026)

    “The Capability Nobody Mentioned […] The decoder is the classical computer sitting next to the quantum processor, receiving a continuous stream of error syndrome measurements and determining, in real time, what corrections to apply. […] Without a decoder that can keep pace with the quantum hardware, quantum error correction is an offline statistical exercise, not a fault-tolerant computation. A million qubits without a real-time decoder is a million qubits that cannot compute.

    This is the capability dimension that […] is most likely to determine whether a cryptographically relevant quantum computer (CRQC) arrives in 2030 or 2045. It is the classical engineering challenge hiding inside the quantum machine, the piece that connects the quantum physics to the classical computation, and the capability that most threat assessments ignore entirely.

    The quantum computing field has trained the public, and by extension the security community, to track one number: how many qubits. Security professionals need a more sophisticated model.

    If the decoder cannot keep up with the syndrome stream, a backlog forms. […] The backlog grows exponentially, and eventually the computation fails. This is the “backlog problem,” and it is the reason that decoder speed is not a performance optimization but a hard requirement. A decoder that is 10% too slow does not produce a 10% slower computation. It produces a computation that fails entirely.

    The decoder must satisfy three simultaneous requirements. […] Speed, accuracy, and scale. Getting any two of three is tractable. Getting all three simultaneously is the unsolved engineering problem at the center of the CRQC timeline.

    […] Decoding Is Harder Than It Sounds

    [For superconducting qbits] the decoder must complete its work within that microsecond to avoid backlog. This is the most demanding timing constraint in the quantum computing stack, and it is why FPGA and ASIC implementations are necessary: software decoders running on conventional CPUs cannot reliably meet microsecond deadlines for codes at the distances required for cryptographic applications. The superconducting decoder challenge is fundamentally a hardware problem. The algorithm must be compiled into dedicated circuitry (FPGA or ASIC) that executes in deterministic time, without the variable-latency interrupts, cache misses, and scheduling jitter that make general-purpose CPUs unsuitable for hard real-time constraints.

    […] The gap between current decoder demonstrations and CRQC requirements is large and precisely quantifiable. […] The progress curve is steep. But the destination […] remains far ahead.“

  • Kris Naudts, Zeynep Koruturk, Donald Harmitt: The Quantum Bottleneck Isn’t Error Correction, It’s the Magic State Factory, Firgun Ventures Insight (July 2026)

  • Mahmud et al.: Decoder Architectures and Computational Bottlenecks in QEC: section IV of: Quantum Error Correction Survey, IEEE Access 14 (Sep 2026) 154233–154277 [doi:10.1109/ACCESS.2026.3737721]

  • Manuel Esparcia Cantos: Decoders: The Quiet Bottleneck of Quantum Error Correction, LinkedIn (8. Oct 2026)

    “[Quantum error] correction is a hard computational problem that has to be solved by a classical computer, in real time, faster than the quantum computer produces the next round of errors. This is the decoder, and it is one of the field’s quietest and most underappreciated bottlenecks.

    This article is about the problem almost no popular account mentions. Everyone talks about qubits and codes; far fewer talk about the classical machine that has to keep up with them. Yet a fault-tolerant quantum computer is impossible without a decoder that is simultaneously accurate enough to correct the errors and fast enough to do it before the backlog explodes.

    […] In a superconducting machine, a new round of syndrome data arrives roughly every microsecond. If the decoder cannot keep pace, unprocessed syndromes pile up faster than they are cleared, a backlog that grows without bound and eventually makes the computation impossible. This is the decoding bottleneck, and it is as real an obstacle to fault tolerance as qubit quality.

    […] WHY DECODERS DESERVE MORE ATTENTION

    The decoder is where a beautiful theory meets an unforgiving stopwatch. All the elegance of stabilizer codes and the guarantee of the threshold theorem assume, quietly, that a decoder exists which is accurate enough and fast enough. That assumption is doing enormous work. A code below threshold with a decoder too slow to keep up is not fault-tolerant in practice, no matter how good the qubits are. The classical co-processor is not a footnote to the quantum computer; it is part of the quantum computer.

    […] There is a genuine tension the field has not fully resolved: the most accurate decoders tend to be the slowest, and the fastest tend to be less accurate. The whole game is beating that trade-off, and the platform that first fields a decoder both accurate enough and fast enough at scale removes one of the last quiet obstacles between below-threshold hardware and a working machine.“


Examples

Specific examples

Bit flip codes

See at bit flip code, and the exposition of the 3-qbit code above.

A 3-qutrit code

The following is a simple illustrative example from Cleve, Gottesman & Lo 99, p. 1-2:

Consider a quantum system with a 3-dimensional space of quantum states:

ℋ≔ℂ 3=Span(|0⟩,|1⟩,|2⟩) \mathcal{H} \;\coloneqq\; \mathbb{C}^3 \;=\; Span\big( \left\vert 0 \right\rangle,\, \left\vert 1 \right\rangle,\, \left\vert 2 \right\rangle \big)

and consider a code space inside 3 copies of this space given by the following linear map

ℋ ⟶AAAAcodeAAAA ℋ ⊗3 α|0⟩ + β|1⟩ + γ|2⟩ ↦ α13(|000⟩+|111⟩+|222⟩) + β13(|012⟩+|120⟩+|201⟩) + γ13(|021⟩+|102⟩+|210⟩) \array{ \mathcal{H} & \overset{ \phantom{AAAA} code \phantom{AAAA} }{\longrightarrow}& \mathcal{H}^{\otimes 3} \\ \array{ & \alpha \left\vert 0 \right\rangle \\ + & \beta \left\vert 1 \right\rangle \\ + & \gamma \left\vert 2 \right\rangle } & \mapsto & \array{ & \alpha \tfrac{1}{\sqrt{3}} \big( \left\vert 000 \right\rangle + \left\vert 111 \right\rangle + \left\vert 222 \right\rangle \big) \\ + & \beta \tfrac{1}{\sqrt{3}} \big( \left\vert 012 \right\rangle + \left\vert 120 \right\rangle + \left\vert 201 \right\rangle \big) \\ + & \gamma \tfrac{1}{\sqrt{3}} \big( \left\vert 021 \right\rangle + \left\vert 102 \right\rangle + \left\vert 210 \right\rangle \big) } }

This code corrects errors consisting of the loss of one of the three copies, in the following sense:

There is a linear operator acting only on two of the three copies, explicitly given (ADH 14 (3.6)) by

ℋ⊗ℋ ⟶U (12) ℋ⊗ℋ |00⟩ ↦ |00⟩ |01⟩ ↦ |12⟩ |02⟩ ↦ |21⟩ |10⟩ ↦ |22⟩ |11⟩ ↦ |01⟩ |12⟩ ↦ |10⟩ |20⟩ ↦ |11⟩ |21⟩ ↦ |20⟩ |22⟩ ↦ |02⟩ \array{ \mathcal{H} \otimes \mathcal{H} & \overset{ \;\;\;\;\;\; U^{(12)} \;\;\;\;\;\; }{\longrightarrow} & \mathcal{H} \otimes \mathcal{H} \\ \left\vert 00 \right\rangle &\mapsto& \left\vert 00 \right\rangle \\ \left\vert 01 \right\rangle &\mapsto& \left\vert 12 \right\rangle \\ \left\vert 02 \right\rangle &\mapsto& \left\vert 21 \right\rangle \\ \left\vert 10 \right\rangle &\mapsto& \left\vert 22 \right\rangle \\ \left\vert 11 \right\rangle &\mapsto& \left\vert 01 \right\rangle \\ \left\vert 12 \right\rangle &\mapsto& \left\vert 10 \right\rangle \\ \left\vert 20 \right\rangle &\mapsto& \left\vert 11 \right\rangle \\ \left\vert 21 \right\rangle &\mapsto& \left\vert 20 \right\rangle \\ \left\vert 22 \right\rangle &\mapsto& \left\vert 02 \right\rangle }

such that

(U (12)⊗id (3))∘code(|ψ⟩)=|ψ⟩⊗13(|00⟩+|11⟩+|22⟩) \big( U^{(12)} \otimes id^{(3)} \big) \circ code \big( \left\vert \psi \right\rangle \big) \;\; = \;\; \left\vert \psi \right\rangle \, \otimes \, \tfrac{1}{\sqrt{3}} \left( \left\vert 00 \right\rangle + \left\vert 11 \right\rangle + \left\vert 22 \right\rangle \right)

The HaPPY code

The HaPPY code is a quantum error correction code (a class of such codes really, indexed by a “cutoff” natural number) which is thought to exhibit characteristic properties akin to the encoding of bulk-quantum states by boundary-states expected in the AdS/CFT correspondence. In particular, the HaPPY code (or rather the tensor network that defines it) exhibits a discretized form of the Ryu-Takayanagi formula for holographic entanglement entropy.

Concretely, the the HaPPY code subspace is the image of the linear map formed by:

From Harlow 18
  1. picking a perfect tensor TT of rank 6;

  2. picking a finite cutoff of the pentagonal tesselation of the hyperbolic plane;

  3. regarding its Poincaré dual graph as a tensor network (string diagram in finite-dimensional vector spaces) by

    1. assigning TT to each vertex at the center of the pentagons (show in blue), with 5 of its indices contracted with its neighbours in the hyperbolic plane,

    2. and its 6th uncontracted index remaining as an input (shown in red);

  4. regarding the uncontracted edges at the cutoff boundary as output (shown in white)

and thus as a linear map from the tensor product over the bulk-vertices to the tensor product over the edges sticking out over the boundary.

Majorana dimer codes

See at Majorana dimer code.

Classes of examples

References

General

The idea of quantum encryption based on the no-cloning theorem originates with:

Original articles on quantum error correcting codes:

Realization that quantum error correcting codes could make quantum computation practically feasible (quantum error threshold theorem):

Operator algebraic formulation of quantum error correction:

on quantum observables:

Introduction and survey:

See also:

In the context of quantum secret sharing:

In the context of quantum communication:

On (in-)compatibility of quantum error correction with universality of quantum gates (Eastin-Knill theorem):

  • Bryan Eastin, Emanuel Knill, Restrictions on Transversal Encoded Quantum Gate Sets, Phys. Rev. Lett. 102, 110502 (2009) (arXiv:0811.4262)

  • Paul Webster, Michael Vasmer, Thomas R. Scruby, Stephen D. Bartlett, Universal Fault-Tolerant Quantum Computing with Stabiliser Codes (arXiv:2012.05260)

For quantum annealing processes:

  • Kristen L. Pudenz, Tameem Albash, Daniel A. Lidar: Error-corrected quantum annealing with hundreds of qubits, Nature Communications 5 3243 (2014) [doi:10.1038/ncomms4243]

On continuous variable quantum codes:

In relation to the SYK model:

In relation to continuous symmetries:

  • Zi-Wen Liu, Sisi Zhou, Approximate symmetries and quantum error correction (arXiv:2111.06355)

Further developments:

  • Mackenzie H. Shaw, Andrew C. Doherty, Arne L. Grimsmo, Stabilizer subsystem decompositions for single- and multi-mode Gottesman-Kitaev-Preskill codes [arXiv:2210.14919]

On relevant classical control mechanisms:

In relation to the Penrose tiling:

Relating quantum error correction to linear logic:

Experimental realization

Realization of quantum error correction in experiment, hence in actual quantum computers:

Via holographic tensor networks

First quantum error correcting codes associated with planar bulk/boundary systems:

First suggestion relating quantum error correction to black hole entropy:

Introducing the idea of quantum error correcting codes given by tensor network states:

  • Andrew J. Ferris, David Poulin, Tensor Networks and Quantum Error Correction, Phys. Rev. Lett. 113, 030501 (2014) (arXiv:1312.4578)

  • Dave Bacon, Steven T. Flammia, Aram W. Harrow, Jonathan Shi, Sparse Quantum Codes from Quantum Circuits, Proc. of STOC ‘15, pp. 327-334 (2015); IEEE Transactions on Information Theory, vol 63, no 4, pp 2464-2479, April 2017 (arXiv:1411.3334)

following observations in

Interpretation of holographic tensor networks encoding holographic entanglement entropy in models for AdS2-CFT1 duality as quantum error correcting codes:

with precursor observations in

and concrete implementation by the HaPPY code:

and possibly more generally:

Introduction of the more general Majorana dimer code:

Exposition and review:

Further discussion of holographic quantum error correcting codes:

Understanding in terms of the eigenstate thermalization hypothesis:

  • Ning Bao, Newton Cheng, Eigenstate Thermalization Hypothesis and Approximate Quantum Error Correction, JHEP 08 (2019) 152 (arXiv:1906.03669)

In relation to holographic Renyi entropy:

From tesselations of higher-dimensional hyperbolic space:

  • Vivien Londe, Anthony Leverrier, Golden codes: quantum LDPC codes built from regular tessellations of hyperbolic 4-manifolds (arXiv:1712.08578)

In view of black hole thermodynamics:

Discussion of gauge symmetry of holographic tensor networks and their quantum error correcting codes:

  • Kfir Dolev, Vladimir Calvera, Sam Cree, Dominic J. Williamson, Gauging the bulk: generalized gauging maps and holographic codes (arXiv:2108.11402)

Relation of quantum error correcting codes to the Monster vertex operator algebra and more generally to 2d SCFT and string theory:

In relation to the large N limit:

In relation to renormalization group flow:

  • Keiichiro Furuya, Nima Lashkari, Mudassir Moosa, Renormalization group and approximate error correction (arXiv:2112.05099)

In relation to fixed-point path integrals:

  • Andreas Bauer, Topological error correcting processes from fixed-point path integrals (arXiv:2303.16405)

Musings on possible implications on relations between quantum gravity and quantum information:

Last revised on November 5, 2026 at 11:09:27. See the history of this page for a list of all contributions to it.