Welcome to the Qubit Kingdom.

Entanglement-assisted (EA) stabilizer code[1][2]
Constructed using a variation of the stabilizer formalism designed to utilize pre-shared entanglement between sender and receiver. An EA stabilizer code is denoted as \([[n,k;c]]\) or \([[n,k,d;c]]\), where \(d\) is the code's distance, and \(c\) is the number of required pre-shared maximally entangled Bell states.'
Parents:
Entanglement-assisted (EA) QECC, Qubit stabilizer code.
Parent of:
Quantum polar code.
Cousins:
Linear binary code, Linear \(q\)-ary code, Calderbank-Shor-Steane (CSS) stabilizer code.

Pastawski-Yoshida-Harlow-Preskill (HaPPY) code[3]
Also known as a hyperbolic pentagon code (HyPeC). Holographic code constructed out of a network of perfect tensors that tesselates hyperbolic space. Physical qubits are associated with uncontracted tensor legs at the boundary of the tesselation, while logical qubits are associated with uncontracted legs in the bulk. The code serves as a minimal model for several aspects of the AdS/CFT holographic duality. The construction below is described for qubits, but straightforward generalizations exist to modular qudits, oscillators, and rotors [4].
Protection: Protects against erasure errors and Pauli errors on the boundary qubits.
Parents:
Holographic code, Qubit stabilizer code.
Cousins:
Five-qubit perfect code, Majorana stabilizer code.

Qubit code
Encodes \(K\)-dimensional Hilbert space into a \(2^n\)-dimensional (i.e., \(n\)-qubit) Hilbert space. Usually denoted as \(((n,K))\) or \(((n,K,d))\), where \(d\) is the code's distance.
Protection: A convenient and often considered error set is the Pauli error or Pauli string basis. For a single qubit, this set consists of products of powers of the Pauli matrices \begin{align}
X=\begin{pmatrix}0 & 1\\
1 & 0
\end{pmatrix}\,\,\text{ and }\,\,Z=\begin{pmatrix}1 & 0\\
0 & -1
\end{pmatrix}~.
\end{align} For multiple qubits, error set elements are tensor products of elements of the single-qubit error set.
Parents:
Finite-dimensional quantum error-correcting code.
Parent of:
Codeword stabilized (CWS) code, Movassagh-Ouyang Hamiltonian code, XP stabilizer code.
Cousin of:
Fermionic code, Fock-state bosonic code, Group-based quantum code, Spin code.

Movassagh-Ouyang Hamiltonian code[5]
This is a family of codes derived via an algorithm that takes as input any binary classical code and outputs a quantum code (note that this framework can be extended to \(q\)-ary codes). The algorithm is probabalistic but succeeds almost surely if the classical code is random. An explicit code construction does exist for linear distance codes encoding one logical qubit. For finite rate codes, there is no rigorous proof that the construction algorithm succeeds, and approximate constructions are described instead.
Protection: Let \(C \subset \{0,1,\dots,q-1\}^n\) be a classical code with distance \(d_x\). Let \(d_z\) satisfy \(q^n > 2 V_q(d_z-1) -1\), where \(V_q(r)\) is the volume of the \(q\)-ary Hamming ball of radius \(r\). Then the algorithm produces a quantum code with distance \(d = \text{min}(d_x,d_z)\). Asymptotically, the distance scales linearly with \(n\).
Parents:
Qubit code, Hamiltonian-based code.
Parent of:
Calderbank-Shor-Steane (CSS) stabilizer code.
Cousins:
Qubit stabilizer code, Binary code.
Cousin of:
Codeword stabilized (CWS) code.

Qubit stabilizer code[6][7]
Also called a Pauli stabilizer code. An \(((n,2^k,d))\) qubit stabilizer code is denoted as \([[n,k]]\) or \([[n,k,d]]\), where \(d\) is the code's distance. Logical subspace is the joint eigenspace of commuting Pauli operators forming the code's stabilizer group \(\mathsf{S}\). Traditionally, the logical subspace is the joint \(+1\) eigenspace of a set of \(2^{n-k}\) commuting Pauli operators which do not contain \(-I\). The distance is the minimum weight of a Pauli string that implements a nontrivial logical operation in the code.
Protection: Detects errors on up to \(d-1\) qubits, and corrects erasure errors on up to \(d-1\) qubits. More generally, define the normalizer \(\mathsf{N(S)}\) of \(\mathsf{S}\) to be the set of all operators that commute with all \(S\in\mathsf{S}\). A stabilizer code can correct a Pauli error set \({\mathcal{E}}\) if and only if \(E^\dagger F \notin \mathsf{N(S)}\setminus \mathsf{S}\) for all \(E,F \in {\mathcal{E}}\).
Parents:
Stabilizer code, Codeword stabilized (CWS) code, XP stabilizer code, Quantum Lego code.
Parent of:
Calderbank-Shor-Steane (CSS) stabilizer code, Clifford-deformed surface code (CDSC), Entanglement-assisted (EA) stabilizer code, Floquet code, Fusion-based quantum computing (FBQC) code, Haah cubic code, Majorana stabilizer code, Matching code, Pastawski-Yoshida-Harlow-Preskill (HaPPY) code, Quantum convolutional code, Qubit BCH code, Raussendorf-Bravyi-Harrington (RBH) code, Stabilizer code over \(GF(4)\), Transverse-field Ising model (TFIM) code, XYZ product code, \([[2^r, 2^r-r-2, 3]]\) quantum Hamming code.
Cousins:
Linear binary code, Dual linear code, Hamiltonian-based code, Modular-qudit stabilizer code.
Cousin of:
Galois-qudit stabilizer code, Metrological code, Movassagh-Ouyang Hamiltonian code, Subsystem qubit stabilizer code, Translationally-invariant stabilizer code.

Floquet code[8]
Dynamically-generated stabilizer-based code whose logical qubits are generated through a particular sequence of check-operator measurements such that the number of logical qubits is larger than when the code is viewed as a static subsystem stabilizer code. After each measurement in the sequence, the codespace is a joint \(+1\) eigenspace of an instantaneous stabilizer group (ISG), i.e., a particular stabilizer group corresponding to the measurement. The ISG specifies the state of the system as a Pauli stabilizer state at a particular round of measurement, and it evolves into a (potentially) different ISG depending on the check operators measured in the next step in the sequence. As opposed to subsystem codes, only specific measurement sequences maintain the codespace.
Protection: Protects against single-qubit Pauli noise and check operator measurement errors.
Parents:
Dynamically-generated quantum error-correcting code, Qubit stabilizer code.
Parent of:
Honeycomb code.
Cousins:
Subsystem qubit stabilizer code, Monitored random-circuit code, Majorana stabilizer code.

Quantum polar code[9]
Entanglement-assisted CSS code utilized in a quantum polar coding scheme producing entangled pairs of qubits between sender and receiver. In such a scheme, the amplitude and phase information of a quantum state is handled in complementary fashion [10] using an encoding based on classical polar codes. Variants of the initial scheme have been developed for degradable channels [11] and extended to arbitrary channels [12].
Protection: Protects against Pauli noise and erasures.
Parents:
Entanglement-assisted (EA) stabilizer code.
Cousins:
Polar code.
Cousin of:
\([[4,2,2]]\) CSS code.

Codeword stabilized (CWS) code[13]
This family of codes strictly generalizes stabilizer codes. They are usually denoted by \( \mathcal{Q} = (\mathcal{G},\mathcal{C}) \) where \(\mathcal{G}\) is a graph and \(\mathcal{C}\) is a \( (n,K,d) \) binary classical code. From the graph we form the unique graph state (stabilizer state) \( |G \rangle \). From the classical code we form Pauli \(Z\)-type operators \( W_i = Z^{c_{i,1}} \otimes \cdots \otimes Z^{c_{i,n}} \), where \(c_{i,j} \) is the \(j\)-th bit of the \(i\)-th classical codeword. The CWS codewords are then \( | i \rangle = W_i | G \rangle \).
Protection: Code distance \(\mathcal{Q} = ( \mathcal{G},\mathcal{C}) \) is upper bounded by the distance of the classical code \(\mathcal{C} \). The diagonal distance is upper bounded by \(\delta + 1\), where \(\delta\) is the minimum degree of \(\mathcal{G}\). Computing the distance is generally NP-complete, and is NP-hard for non-degenerate codes [14].
Parents:
Qubit code.
Parent of:
Qubit stabilizer code.
Cousins:
Movassagh-Ouyang Hamiltonian code, Spacetime code (STC).
Cousin of:
XP stabilizer code.

XP stabilizer code[15]
The XP Stabilizer formalism is a generalization of the XS and Pauli stabilizer formalisms, with stabilizer generators taken from the group \( \{\omega I, X, P\}^{\otimes n} \). Here, \( \omega \) is a \( 2N \) root of unity, and \( P = \text{diag} ( 1, \omega^2) \). The codespace is a \(+1\) eigenspace of a set of XP stabilizer generators, which need not commute to define a valid codespace.
Parents:
Qubit code.
Parent of:
Qubit stabilizer code, XS stabilizer code.
Cousins:
Calderbank-Shor-Steane (CSS) stabilizer code, Codeword stabilized (CWS) code.

Calderbank-Shor-Steane (CSS) stabilizer code[16][17][18]
An \([[n,k,d]]\) stabilizer code admitting a set of stabilizer generators that are either \(Z\)-type or \(X\)-type Pauli strings. The stabilizer generator matrix is of the form \begin{align}
H=\begin{pmatrix}0 & H_{Z}\\
H_{X} & 0
\end{pmatrix}
\label{eq:parity}
\end{align} such that the rows of the two blocks must be orthogonal \begin{align}
H_X H_Z^T=0~.
\label{eq:comm}
\end{align} The above condition guarantees that the \(X\)-stabilizer generators, defined in the symplectic representation as rows of \(H_X\), commute with the \(Z\)-stabilizer generators associated with \(H_Z\).
Protection: Detects errors on \(d-1\) qubits, corrects errors on \(\left\lfloor (d-1)/2 \right\rfloor\) qubits.
Parents:
Qubit stabilizer code, Movassagh-Ouyang Hamiltonian code.
Parent of:
Balanced product code, Color code, Dinur-Hsieh-Lin-Vidick (DHLV) code, Distance-balanced code, H code, Kitaev surface code, Quantum Reed-Muller code, Quantum Tanner code, Quantum divisible code, Quantum parity code (QPC), Triorthogonal code, \([[2^r-1, 2^r-2r-1, 3]]\) Hamming-based CSS code.
Cousins:
Linear binary code, Dual linear code, Alternant code.
Cousin of:
Entanglement-assisted (EA) stabilizer code, Galois-qudit CSS code, Generalized homological product code, Graph homology code, Group GKP code, Homological bosonic code, Majorana stabilizer code, Modular-qudit CSS code, Qubit BCH code, XP stabilizer code.

Clifford-deformed surface code (CDSC)[19]
A generally non-CSS derivative of the surface code defined by applying a constant-depth Clifford circuit to the original (CSS) surface code. Unlike the surface code, CDSCs include codes whose thresholds and subthreshold performance are enhanced under noise biased towards dephasing. Examples of CDSCs include the XY code, XZZX code, and random CDSCs.
Protection: As a stabilizer code, \([[n=O(d^2), k=O(1), d]]\).
Parents:
Qubit stabilizer code, Abelian topological code.
Parent of:
Kitaev surface code, Rotated surface code, XY surface code, XZZX surface code.
Cousins:
Dynamically-generated quantum error-correcting code, Random quantum code.

Fusion-based quantum computing (FBQC) code[20]
Fusion Based Quantum Computing, or FBQC, describes a fault tolerant way to produce fusion networks, or large entangled states starting from small constant-sized entangled resource states along with destructive measurements called fusions. These large states can be produced asychronously in the fusion framework and can be used as resources, as in measurement-based quantum computation (MBQC), or as logical states of topological codes. The difference from ordinary MBQC is that error-correction is baked into the state-generation protocol.
Protection: Protects against erasure, Pauli errors, photon loss, fusion failure from non-determinism, and faulty resource states. Redundancy in fusion outcomes is captured by the check operator group. Fusion measurement outcomes form a syndrome that allows to correct for Pauli errors. There is no physical error correction, and decoding output is simply used to update the Pauli frame.
Parents:
Qubit stabilizer code.
Cousins:
Topological code, Fock-state bosonic code.

Haah cubic code[21]
Class of stabilizer codes on a length-\(L\) cubic lattice with one or two qubits per site. We also require that the stabilizer group \(\mathsf{S}\) is translation invariant and generated by two types of operators with support on a cube. In the non-CSS case, these two are related by spatial inversion. For CSS codes, we require that the product of all corner operators is the identity. We lastly require that there are no non-trival ''string operators'', meaning that single-site operators are a phase, and any period one logical operator \(l \in \mathsf{S}^{\perp}\) is just a phase. Haah showed in his original construction that there is exactly one non-CSS code of this form, and 17 CSS codes [21]. The non-CSS code is labeled code 0, and the rest are numbered from 1 - 17. Codes 1-4, 7, 8, and 10 do not have string logical operators [21][22].
Protection: Cubic codes protect against simultaneous independent Pauli errors on different sites (not qubits, since there can be 2 qubits per site). Codes 0-4 are known to have distance \(d \ge L\), meaning they can achieve macroscopic code distance as \(L\to\infty\).
Parents:
Qubit stabilizer code, Fracton code.
Cousins:
Color code, Kitaev surface code.
Cousin of:
Fibonacci code, Lifted-product (LP) code, Self-correcting quantum code.

Majorana stabilizer code[23]
Majorana fermion stabilizer codes are stabilizer codes whose stabilizers are products of an even number of Majorana fermion operators, analogous to Pauli strings for a traditional stabilizer code and referred to as Majorana stabilizers. The codespace is the mutual \(+1\) eigenspace of all Majorana stabilizers. In such systems, Majorana fermions may either be considered individually or paired into creation and annihilation operators for fermionic modes. Codes can be denoted as \([[n,k,d]]_{f}\) [24], where \(n\) is the number of fermionic modes.
Protection: Detects products of Majorana operators with weight up to \(d-1\). Physically, protects against dephasing errors caused by coupling of fermion density to the environment and bit-flip errors caused by quasiparticle poisoning processes.
Parents:
Fermionic code, Qubit stabilizer code.
Cousins:
Dual linear code, Calderbank-Shor-Steane (CSS) stabilizer code, Cyclic linear binary code, Reed-Muller (RM) code, Stabilizer code.
Cousin of:
Five-qubit perfect code, Floquet code, Honeycomb code, Kitaev surface code, Pastawski-Yoshida-Harlow-Preskill (HaPPY) code, Transverse-field Ising model (TFIM) code.

Matching code[25]
Stub.
Parents:
Qubit stabilizer code, Abelian topological code.
Parent of:
XYZ\(^2\) hexagonal stabilizer code.
Cousin of:
Honeycomb code.

Quantum convolutional code[26]
Stub.
Parents:
Qubit stabilizer code.
Cousin of:
Convolutional code, Quantum Reed-Muller code.

Qubit BCH code[27][28][29][30]
Qubit stabilizer code constructed from a self-orthogonal binary BCH code via the CSS construction, from a Hermitian self-orthogonal quaternary BCH code via the stabilizer-over-\(GF(4)\) construction, or by taking a Euclidean self-orthogonal BCH code over \(GF(2^m)\), converting it to a binary code, and applying the CSS construction.
Parents:
Qubit stabilizer code.
Cousins:
Binary BCH code, Bose–Chaudhuri–Hocquenghem (BCH) code, Calderbank-Shor-Steane (CSS) stabilizer code, Stabilizer code over \(GF(4)\).
Cousin of:
Galois-qudit BCH code.

Raussendorf-Bravyi-Harrington (RBH) code[31]
Stub. (see Sec. III E of [31])
Protection: Code exhibiting symmetry-protected self-correction. The energy barrier for symmetry-preserving exhitations outside of the code space grows linearly with the lattice width. When the system is coupled locally to a thermal bath respecting the symmetry and below a critical temperature, the memory time grows exponentially with the lattice width.
Parents:
Qubit stabilizer code.
Cousins:
Symmetry-protected self-correcting quantum code, Subsystem color code, Kitaev surface code.

Stabilizer code over \(GF(4)\)[28]
An \([[n,k,d]]\) stabilizer code constructed from a quaternary classical code using the one-to-one correspondence between the four Pauli matrices \(\{I,X,Y,Z\}\) and the four elements \(\{0,1,\alpha^2,\alpha\}\) of the quaternary field \(GF(4)\).
Protection: Detects errors on \(d-1\) qubits, corrects errors on \(\left\lfloor (d-1)/2 \right\rfloor\) qubits.
Parents:
Qubit stabilizer code.
Parent of:
Five-qubit perfect code.
Cousins:
Dual additive code, Dual linear code.
Cousin of:
Qubit BCH code, Stabilizer code over \(GF(q^2)\).

Transverse-field Ising model (TFIM) code[32]
A 1D translationally invariant stabilizer code whose encoding is a constant-depth circuit of nearest-neighbor gates on alternating even and odd bonds that consist of transverse-field Ising Hamiltonian interactions. The code allows for perfect state transfer of arbitrary distance using local operations and classical communications (LOCC).
Protection: Code distance is 1 for open boundary conditions similar to a repetition code, and 3 for periodic boundary conditions with an encoding circuit depth of 4.
Parents:
Qubit stabilizer code, Translationally-invariant stabilizer code.
Cousins:
Majorana stabilizer code, Quantum repetition code.

XYZ product code[33]
A non-CSS QLDPC code constructed from three classical codes. The construction of an XYZ product code is similar to that of a hypergraph product code and related codes. The idea is that rather than taking a product of only two classical codes to produce a CSS code, a third classical code is considered, acting with Pauli-\(Y\) operators.
Parents:
Qubit stabilizer code, Generalized homological product code.
Cousins:
Hypergraph product code.

\([[2^r, 2^r-r-2, 3]]\) quantum Hamming code[34]
A family of stabilizer codes of distance \(3\) that asymptotically saturate quantum Hamming bound.
Protection: Protects against any single qubit error.
Parents:
Qubit stabilizer code.
Cousins:
Perfect quantum code.
Cousin of:
Hamming code.

Honeycomb code[8]
Floquet code inspired by the Kitaev honeycomb model [35] whose logical qubits are generated through a particular sequence of measurements.
Protection: Protective features similar to the surface code: on a torus geometry, the code protects two logical qubits with a code distance proportional to the linear size of the torus. Properties of the code with open boundaries are discussed in Refs. [36][37], and various other generalizations have been proposed [38].
Parents:
Floquet code.
Cousins:
Kitaev surface code, Subsystem color code, Majorana stabilizer code, Matching code, Quantum low-density parity-check (QLDPC) code.

Five-qubit perfect code[39]
Five-qubit stabilizer code with generators that are symmetric under cyclic permutation of qubits, \begin{align} \begin{split} S_1 &= IXZZX \\ S_2 &= XZZXI \\ S_3 &= ZZXIX \\ S_4 &= ZXIXZ~. \end{split} \end{align}
Protection: Smallest stabilizer code that protects against a single error on any one qubit. Detects two-qubit errors.
Parents:
Stabilizer code over \(GF(4)\), Quantum maximum-distance-separable (MDS) code.
Cousins:
Perfect quantum code, Quantum cyclic code, Hamiltonian-based code, Majorana stabilizer code.
Cousin of:
Braunstein five-mode code, Hexacode, Pastawski-Yoshida-Harlow-Preskill (HaPPY) code, Quantum divisible code, \([[4,2,2]]\) CSS code, \([[5,1,3]]_{\mathbb Z}\) rotor code.

Balanced product code[40]
Family of CSS quantum codes based on products of two classical codes which share common symmetries. The balanced product can be understood as taking the usual tensor/hypergraph product and then factoring out the symmetries factored. This reduces the overall number of physical qubits \(n\), while, under certain circumstances, leaving the number of encoded qubits \(k\) and the code distance \(d\) invariant. This leads to a more favourable encoding rate \(k/n\) and normalized distance \(d/n\) compared to the tensor/hypergraph product.
Protection: Taking balanced products of two classical LDPC codes which have a symmetry group which grows linearly in their block lengths were known to give QLDPC codes with a linear rate and which were conjectured to have linear distance [40]. This conjecture was proved in Ref. [41].
Parents:
Calderbank-Shor-Steane (CSS) stabilizer code, Generalized homological product code.
Parent of:
Dinur-Hsieh-Lin-Vidick (DHLV) code, Fiber-bundle code, Lifted-product (LP) code.
Cousins:
Subsystem qubit stabilizer code, Distance-balanced code.
Cousin of:
Left-right Cayley complex code.

Color code[42]
A family of abelian topological CSS stabilizer codes defined on a \(D\)-dimensional lattice which satisfies two properties: The lattice is (1) a homogeneous simplicial \(D\)-complex obtained as a triangulation of the interior of a \(D\)-simplex and (2) is \(D+1\)-colorable. Qubits are placed on the \(D\)-simplices and generators are supported on suitable simplices [43]. For 2-dimensional color code, the lattice must be such that it is 3-valent and has 3-colorable faces, such as a honeycomb lattice. The qubits are placed on the vertices and two stabilizer generators are placed on each face [44].
Protection: As with the surface code, the code distance depends on the specific kind of lattice used to define the code. More precisely, the distance depends on the homology of logical string operators [44].
Parents:
Calderbank-Shor-Steane (CSS) stabilizer code, Abelian topological code.
Parent of:
Steane \([[7,1,3]]\) code, \([[15,1,3]]\) quantum Reed-Muller code.
Cousins:
Kitaev surface code, Triorthogonal code.
Cousin of:
Galois-qudit topological code, Haah cubic code, Self-correcting quantum code, Solid code, Subsystem color code.

Dinur-Hsieh-Lin-Vidick (DHLV) code[45]
Stub.
Parents:
Balanced product code, Calderbank-Shor-Steane (CSS) stabilizer code.
Cousins:
Good QLDPC code, Tanner code, Tensor-product code.

Distance-balanced code[46][47]
CSS stabilizer code constructed from a CSS code and a classical code using a distance-balancing procedure based on a generalized homological product. The initial code is said to be unbalanced, i.e., tailored to noise biased toward either bit- or phase-flip errors, and the procedure can result in a code that is treats both types of errors on a more equal footing. The original distance-balancing procedure [46], later generalized in Ref. [47], can yield QLDPC codes; see Thm. 1 in Ref. [46].
Parents:
Calderbank-Shor-Steane (CSS) stabilizer code, Homological product code.
Cousins:
Subsystem qubit stabilizer code.
Cousin of:
Balanced product code, Fiber-bundle code, Quantum check-product code, Ramanujan-complex product code.

H code[48]
Family of \([[k+4,k,2]]\) CSS codes with transversal Hadmard gates; relevant to magic state distillation. Four stablizer generators are \(X_1X_2X_3X_4\), \(Z_1Z_2Z_3Z_4\), \(X_1X_2X_5X_6...X_{k+4}\), and \(Z_1Z_2Z_5Z_6...Z_{k+4}\).
Protection: Detects weight-1 Pauli errors. The \(r\)-level contatenated H code detects weight Pauli errors up to weight \(2^r-1\).
Parents:
Calderbank-Shor-Steane (CSS) stabilizer code.

Kitaev surface code[49][50][51]
A family of abelian topological CSS stabilizer codes whose generators are few-body \(X\)-type and \(Z\)-type Pauli strings associated to the stars and plaquettes, respectively, of a cellulation of a two-dimensional surface (with a qubit located at each edge of the cellulation). Toric code often either refers to the construction on the two-dimensional torus or is an alternative name for the general construction. The construction on surfaces with boundaries is often called the planar code [52].
Protection: Toric code on an \(L\times L\) torus is a \([[2L^2,2,L]]\) CSS code, and there exists a planar code with \([[L^2,1,L]]\) [53]. More generally, the code distance is related to the homology of the cellulation [54].
Parents:
Calderbank-Shor-Steane (CSS) stabilizer code, Clifford-deformed surface code (CDSC), Abelian topological code.
Parent of:
Fractal surface code, Higher-dimensional surface code, Hyperbolic surface code, Projective-plane surface code, \([[4,2,2]]\) CSS code.
Cousins:
Hypergraph product code, Quantum-double code, String-net code, Majorana stabilizer code.
Cousin of:
Color code, Double-semion code, Galois-qudit topological code, Haah cubic code, Heavy-hexagon code, Honeycomb code, Lifted-product (LP) code, Modular-qudit surface code, Raussendorf-Bravyi-Harrington (RBH) code, Translationally-invariant stabilizer code.

Quantum Reed-Muller code[55]
A CSS code formed from a classical Reed-Muller code in which polynomials over finite fields encode data. This is done by transforming these polynomials into the stabilizer generator matrices.
Protection: Detects errors on \(d-1\) qubits, corrects errors on \(\left\lfloor (d-1)/2 \right\rfloor\) qubits.
Parents:
Calderbank-Shor-Steane (CSS) stabilizer code.
Parent of:
\([[15,1,3]]\) quantum Reed-Muller code.
Cousins:
Reed-Muller (RM) code, Quantum convolutional code.
Cousin of:
Covariant code, Quantum divisible code, Triorthogonal code.

Quantum Tanner code[56]
Stub.
Protection: Minimum distance bound obtained using robustness of dual tensor-product codes [57].
Parents:
Generalized homological product code, Calderbank-Shor-Steane (CSS) stabilizer code.
Parent of:
Rotated surface code.
Cousins:
Good QLDPC code, Tanner code, Tensor-product code, Expander lifted-product code.
Cousin of:
Left-right Cayley complex code.

Quantum divisible code[58]
Consider a CSS code whose \(Z\)-stabilizers are determined by the dual of a classical \([n, k_1]\) linear binary code \(C_1\), and whose \(X\)-stabilizers are determined by a classical \([n, k_2]\) binary code \(C_2 \subset C_1\). This code is quantum divisible if all weights in \(C_2\) share a common divisor \(\Delta > 1\), and all weights in each coset of \(C_2\) in \(C_1\) are congruent to \(\Delta\).
Protection: Distance \(d\) is upper bounded by the two classical codes that determine the CSS code.
Parents:
Calderbank-Shor-Steane (CSS) stabilizer code.
Cousins:
Divisible code, Reed-Muller (RM) code, Quantum Reed-Muller code, Triorthogonal code, Concatenated quantum code, Five-qubit perfect code, Steane \([[7,1,3]]\) code.

Quantum parity code (QPC)[59][60][61]
Also called a generalized Shor code [62]. A \([[m_1 m_2,1,\min(m_1,m_2)]]\) CSS code family obtained from concatenating an \(m_1\)-qubit phase-flip repetition code with an \(m_2\)-qubit bit-flip repetition code. Logical codewords are \begin{align}
\begin{split}
|\overline{0}\rangle&=\frac{1}{2^{m_2/2}}\left(|0\rangle^{\otimes m_1}+|1\rangle^{\otimes m_1}\right)^{\otimes m_2}\\
|\overline{1}\rangle&=\frac{1}{2^{m_2/2}}\left(|0\rangle^{\otimes m_1}-|1\rangle^{\otimes m_1}\right)^{\otimes m_2}~.
\end{split}
\end{align}
Protection: Has distance \(d=\min(m_1,m_2)\).
Parents:
Calderbank-Shor-Steane (CSS) stabilizer code, Translationally-invariant stabilizer code.
Parent of:
Quantum repetition code, Shor \([[9,1,3]]\) code.
Cousins:
Concatenated quantum code, Bacon-Shor code.
Cousin of:
\([[4,2,2]]\) CSS code.

Triorthogonal code[63]
A triorthogonal \(m \times n\) binary matrix is triorthogonal if its rows \(r_1, \ldots, r_m\) satisfy \(|r_i \cdot r_j| = 0\) and \(|r_i \cdot r_j \cdot r_k| = 0\), where addition and multiplication are done on \(\mathbb{Z}_2\). The triorthogonal code associated with the matrix is constructed by mapping non-zero entries in even-weight rows to \(X\) operators, and \(Z\) operators for each row in the orthogonal complement.
Protection: Weight \(t\) Pauli errors, where \(t\) depends on the family. For example, Ref. [63] provides a family of distance \(2\) codes. It also presents a \([[49, 1, 5]]\) code.
Parents:
Calderbank-Shor-Steane (CSS) stabilizer code.
Parent of:
\([[15,1,3]]\) quantum Reed-Muller code.
Cousins:
Quantum Reed-Muller code.
Cousin of:
Color code, Quantum divisible code.

\([[2^r-1, 2^r-2r-1, 3]]\) Hamming-based CSS code
A Hamming-based CSS code is a CCS code constructed with a classical Hamming code \([2^r-1,2^r-1-r,3]=C_X=C_Z\).
Protection: Protects against any single qubit error.
Parents:
Calderbank-Shor-Steane (CSS) stabilizer code.
Parent of:
Steane \([[7,1,3]]\) code.
Cousins:
Hamming code.
Cousin of:
\([[2^r-1, 2^r-2r-1, 3]]_p\) prime-qudit CSS code.

Rotated surface code[64][65][66][67]
Also called a checkerboard code. CSS variant of the surface code defined on a square lattice that has been rotated 45 degrees such that qubits are on vertices, and both \(X\)- and \(Z\)-type check operators occupy plaquettes in an alternating checkerboard pattern.
Protection: The \([[L^2,1,L]]\) variant of this family includes the \([[9,1,3]]\) surface-17 code, named as such because 8 ancilla qubits are used for check operator measurements alongside the 9 physical qubits.
Parents:
Clifford-deformed surface code (CDSC), Quantum Tanner code.
Parent of:
Surface-17 code.
Cousins:
Hypergraph product code, Heavy-hexagon code.
Cousin of:
XZZX surface code, \([[4,2,2]]\) CSS code.

XY surface code[68]
Non-CSS derivative of the surface code whose generators are \(XXXX\) and \(YYYY\), obtained by mapping \(Z \to Y\) in the surface code.
Protection: As a stabilizer code, \([[n=O(d^2), k=O(1), d]]\).
Parents:
Clifford-deformed surface code (CDSC).

XZZX surface code[69][70]
Non-CSS variant of the rotated surface code whose generators are \(XZXZ\) Pauli strings associated, clock-wise, to the vertices of each face of a two-dimensional lattice (with a qubit located at each vertex of the tessellation).
Protection: As a stabilizer code, \([[n=O(d^2), k=O(1), d]]\).
Parents:
Clifford-deformed surface code (CDSC).
Cousins:
Rotated surface code, Fracton code, Abelian topological code.

XYZ\(^2\) hexagonal stabilizer code[71][72]
An instance of the matching code based on the Kitaev honeycomb model. It is described on a hexagonal lattice with \(XYZXYZ\) stabilizers on each hexagonal plaquette. Each vertical pair of qubits has an \(XX\), \(YY\), or \(ZZ\) link stabilizer depending on the orientation of the plaquette stabilizers.
Protection: As a stabilizer code with boundaries, protects a single qubit with parameters \([[2 d^2, 1, d]]\).
Parents:
Matching code.

XS stabilizer code[73]
A type of stabilizer code where stabilizer generators are elements of the group \( \{\alpha I, X, \sqrt{Z}]\}^{\otimes n} \), with \( \sqrt{Z} = \text{diag} (1, i)\). The codespace is a joint \(+1\) eigenspace of a set of stabilizer generators, which need not commute to define a valid codespace.
Parents:
XP stabilizer code.
Cousins:
Abelian topological code.

Fiber-bundle code[74]
Also called a twisted product code. CSS code constructed by combining a random LDPC code as the base and a cyclic repetition code as the fiber of a fiber bundle. After applying distance balancing, a QLDPC code with distance \(\Omega(n^{3/5}\text{polylog}(n))\) and rate \(\Omega(n^{-2/5}\text{polylog}(n))\) is obtained.
Parents:
Balanced product code.
Parent of:
Homological product code.
Cousins:
Distance-balanced code, Random quantum code.

Lifted-product (LP) code[75][41]
Also called a Panteleev-Kalachev (PK) code. Code that utilizes the notion of a lifted product in its construction. Lifted products of certain classical Tanner codes are the first (asymptotically) good QLDPC codes.
Protection: Code performance strongly depends on the group \(G\) used in the product [76].
Parents:
Balanced product code, Galois-qudit CSS code.
Parent of:
Expander lifted-product code, Hypergraph product code.
Cousins:
Kitaev surface code, Haah cubic code.

Steane \([[7,1,3]]\) code[77]
A \([[7,1,3]]\) CSS code that uses the classical binary \([7,4,3]\) Hamming code for protecting against \(X\) errors and its dual \([7,3,4]\) for \(Z\) errors. The parity-check matrix for the \([7,4,3]\) Hamming code is \begin{align}
H = \left(\begin{matrix}
1&0&0&1&0&1&1\\
0&1&0&1&1&0&1\\
0&0&1&0&1&1&1
\end{matrix}\right),
\end{align} and the check matrix for the Steane code is therefore \begin{align}
\left(\begin{matrix}
0&H\\
H&0
\end{matrix}\right).
\end{align} The stabilizer group for the Steane code has six generators.
Protection: The Steane code is a distance 3 code. It detects errors on 2 qubits, corrects errors on 1 qubit.
Parents:
\([[2^r-1, 2^r-2r-1, 3]]\) Hamming-based CSS code, Color code.
Cousins:
Hamming code.
Cousin of:
Quantum divisible code.

\([[15,1,3]]\) quantum Reed-Muller code
\([[15,1,3]]\) CSS code that is most easily thought of as a tetrahedral 3D color code. This code contains 15 qubits, represented by four vertices, four face centers, six edge centers, and one body center. The tetrahedron is cellulated into four identical polyhedron cells by connecting the body center to all four face centers, where each face center is then connected by three adjacent edge centers. Each colored cell corresponds to a weight-8 \(X\)-check, and each face corresponds to a weight-4 \(Z\)-check. A logical \(Z\) is any weight-3 \(Z\)-string along an edge of the entire tetrahedron. The logical \(X\) is any weight-7 \(X\)-face of the entire tetrahedron.
Parents:
Quantum Reed-Muller code, Triorthogonal code, Color code.

Fractal surface code[78][79]
Kitaev surface code on a fractal geometry, which is obtained by removing qubits from the surface code on a cubic lattice. Stub.
Parents:
Kitaev surface code.
Cousins:
Higher-dimensional surface code.

Higher-dimensional surface code[54]
A family of Kitaev surface codes on planar or toric surfaces of dimension greater than two. Stub.
Parents:
Kitaev surface code.
Parent of:
Freedman-Meyer-Luo code, Guth-Lubotzky code, Hemicubic code, Hypersphere product code, Solid code.
Cousin of:
Fractal surface code, Self-correcting quantum code.

Hyperbolic surface code
An extension of the Kitaev surface code construction to hyperbolic manifolds in dimension two or greater. Given a cellulation of a manifold, qubits are put on \(i\)-dimensional faces, \(X\)-type stabilizers are associated with \((i-1)\)-faces, while \(Z\)-type stabilizers are associated with \(i+1\)-faces.
Protection: Constructions (see code children below) have yielded distances scaling favorably with the number of qubits. The use of hyperbolic surfaces allows one to circumvent bounds on surface code parameters that are valid for surfaces with bounded geometry.
Parents:
Kitaev surface code.
Parent of:
Freedman-Meyer-Luo code, Guth-Lubotzky code, Two-dimensional hyperbolic surface code.
Cousins:
Holographic code.

Projective-plane surface code[80]
A family of Kitaev surface codes on the non-orientable 2-dimensional compact manifold \(\mathbb{R}P^2\) (in contrast to a genus-\(g\) surface). Whereas genus-\(g\) surface codes require \(2g\) logical qubits, qubit codes on \(\mathbb{R}P^2\) are made from a single logical qubit.
Protection: If \(\mathcal{C}\) is a cellulation of \(\mathbb{R}P^2\), then the bit-flip distance \(d_X\) is the shortest cycle in \(\mathcal{C}\), and the phase-flip distance \(d_Z\) is the shortest cycle in the dual cellulation \(\mathcal{C}^*\).
Parents:
Kitaev surface code.
Cousin of:
Shor \([[9,1,3]]\) code.

\([[4,2,2]]\) CSS code[81]
Also known as the \(C_4\) code. Four-qubit CSS stabilizer code with generators \(\{XXXX, ZZZZ\} \) and codewords \begin{align}
\begin{split}
|\overline{00}\rangle = (|0000\rangle + |1111\rangle)/\sqrt{2}~{\phantom{.}}\\
|\overline{01}\rangle = (|0011\rangle + |1100\rangle)/\sqrt{2}~{\phantom{.}}\\
|\overline{10}\rangle = (|0101\rangle + |1010\rangle)/\sqrt{2}~{\phantom{.}}\\
|\overline{11}\rangle = (|0110\rangle + |1001\rangle)/\sqrt{2}~.
\end{split}
\end{align} This code is the smallest single-qubit error-detecting code. It is also the smallest instance of the toric code, and its various single-qubit subcodes are small planar surface codes.
Protection: Detects a single-qubit error [81] or single erasure [27]. Not able to correct arbitrary single-qubit errors because \( \lfloor \frac{d-1}{2} \rfloor =0 \). Approximately corrects a single amplitude damping error [82].
Parents:
Kitaev surface code.
Cousins:
Rotated surface code, Quantum parity code (QPC), Five-qubit perfect code, Quantum polar code, Approximate quantum error-correcting code (AQECC), Binomial code.
Cousin of:
Heavy-hexagon code.

Surface-17 code[67]
A \([[9,1,3]]\) rotated surface code named for the sum of its 9 data qubits and 8 syndrome qubits. It uses the smallest number of qubits to perform error correction on a surface code with parallel syndrome extraction.
Protection: Independent correction of single-qubit \(X\) and \(Z\) errors. Correction for some two-qubit \(X\) and \(Z\) errors.
Parents:
Rotated surface code.

Quantum repetition code[83]
Encodes \(1\) qubit into \(n\) qubits according to \(|0\rangle\to|\phi_0\rangle^{\otimes n}\) and \(|1\rangle\to|\phi_1\rangle^{\otimes n}\). Also known as a bit-flip code when \(|\phi_i\rangle = |i\rangle\), and a phase-flip code when \(|\phi_0\rangle = |+\rangle\) and \(|\phi_1\rangle = |-\rangle\).
Protection: Bit-flip code detects bit-flip errors \(X\) on \(\left\lfloor (n-1)/2\right\rfloor\) qubits and does not detect any phase-flip errors \(Z\). Phase-flip code detects phase-flip errors \(Z\) on \(\left\lfloor (n-1)/2\right\rfloor\) qubits and does not detect any bit-flip errors \(X\). Because they protect against only one type of noise, both codes can be thought of as a classical \([n,1,d]\) repetition code with classical distance \(d=\left\lfloor (n-1)/2\right\rfloor\) embedded in a quantum system.
Parents:
Quantum parity code (QPC).
Cousins:
Hamiltonian-based code.
Cousin of:
GNU permutation-invariant code, Repetition code, Self-correcting quantum code, Shor \([[9,1,3]]\) code, Transverse-field Ising model (TFIM) code, Very small logical qubit (VSLQ) code.

Shor \([[9,1,3]]\) code[84]
Nine-qubit CSS code that is the smallest such code to correct a single-qubit error. The logical state is encoded using \begin{align}
\begin{split}
|\overline{0}\rangle&=\frac{1}{2\sqrt{2}}\left(|000\rangle+|111\rangle\right)^{\otimes3}\\
|\overline{1}\rangle&=\frac{1}{2\sqrt{2}}\left(|000\rangle-|111\rangle\right)^{\otimes3}~.
\end{split}
\end{align} The code works by concatenating each qubit of a phase-flip with a bit-flip repetition code. Therefore, the code can correct both type of errors simultaneously.
Protection: The code detects two-qubit errors or corrects an arbitrary single-qubit error.
Parents:
Quantum parity code (QPC).
Cousins:
Quantum repetition code, Concatenated quantum code, Projective-plane surface code.
Cousin of:
Lloyd-Slotine nine-mode code.

Homological product code[85][86]
CSS code formulated using the homological product of two chain complexes (see CSS-to-homology correspondence). Stub.
Protection: Given two codes \([[n_a, k_a, d_a, w_a]]\) for \(a\in\{1,2\}\), where \(w_a\) denotes the maximum hamming weight of all rows and columns of \(\partial_a\), the homological product code has parameter \([[n=n_1 n_2, k=k_1 k_2, d\leq d_1 d_2, w\leq w_1+w_2]]\). From this formula, and the fact that a randomly selected boundary operator \(\partial\) yields a CSS code that is good with high probability, we see that the product code has \(k=\Theta(n)\) and \(w=O(\sqrt{n})\) with high probability. The main result in [86] is to show that the product code actually has linear distance with high probability as well. To sum up, it is shown that we have a family of \([[n,k=c_1 n, d=c_2 n, w=c_3 \sqrt{n}]]\) codes given small enough \(c_1,c_2,c_3\).
Parents:
Fiber-bundle code.
Parent of:
Distance-balanced code, Hypergraph product code.
Cousins:
Random quantum code.

Hypergraph product code[87][66]
A family of \([[n,k,d]]\) CSS codes whose construction is based on two binary linear seed codes \(C_1\) and \(C_2\).
Protection: The hypergraph product has distance \(d=O(\sqrt{n})\). The number of encoded logical qubits is \(k=O(k_1k_2)\) where \(k_1\) and \(k_2\) are the dimensions of the classical seed codes \(C_1\) and \(C_2\).
Parents:
Lifted-product (LP) code, Homological product code.
Parent of:
Quantum expander code.
Cousin of:
Kitaev surface code, Rotated surface code, XYZ product code.

Expander lifted-product code[41]
Family of \(G\)-lifted product codes constructed using two random classical Tanner codes defined on expander graphs. For certain parameters, this construction yields the first asymptotically good QLDPC codes. Classical codes resulting from this construction are one of the first two families of \(c^3\)-LTCs.
Protection: Code performance strongly depends on \(G\). Certain nonabelian groups yield asymptotically good QLDPC codes with parameters \([[n, k = \Theta(n), d = \Theta(n)]]\) [41]. Abelian groups like \(\mathbb{Z}_{\ell}\) for \(\ell=\Theta(n / \log n)\) yield constant-rate codes with parameters \([[n, k = \Theta(n), d = \Theta(n / \log n)]]\) [76]; this construction can be derandomized by being reformulated as a balanced product code [40].
Parents:
Lifted-product (LP) code.
Cousins:
Good QLDPC code, \(q\)-ary linear LTC, Tanner code, Random code.
Cousin of:
Quantum Tanner code.

Freedman-Meyer-Luo code[88]
Hyperbolic surface code constructed using cellulation of a Riemannian Manifold \(M\) exhibiting systolic freedom [89]. Codes derived from such manifolds can achieve distances scaling better than \(\sqrt{n}\), something that is impossible using closed 2D surfaces or 2D surfaces with boundaries [90]. Improved codes are obtained by studying a weak family of Riemann metrics on closed 4-dimensional manifolds \(S^2\otimes S^2\) with the \(Z_2\)-homology.
Protection: Four-dimensional manifolds with weak systolic freedom yield \([[n,2,\Omega(\sqrt{n \sqrt{\log n}})]]\) surface codes.
Parents:
Hyperbolic surface code, Higher-dimensional surface code.
Cousin of:
Ramanujan-complex product code.

Guth-Lubotzky code[91]
Hyperbolic surface code based on cellulations of certain four-dimensional manifolds. The manifolds are shown to have good homology and systolic properties for the purposes of code construction, with corresponding codes exhibiting linear rate.
Protection: Protection stems from the relationship between properties of manifolds and CSS codes derived from their cellulation. The number of physical \(k\) qubits and distance \(d\) of the code will scale as \(\Omega(n)\) and \(\Omega(n^\epsilon)\), respectively.
Parents:
Hyperbolic surface code, Higher-dimensional surface code.
Parent of:
Golden code.

Hemicubic code[92]
Stub.
Parents:
Higher-dimensional surface code.
Cousins:
Quantum locally testable code (QLTC).

Hypersphere product code[93]
Stub.
Parents:
Higher-dimensional surface code.
Cousins:
Quantum locally testable code (QLTC).

Solid code[94]
A variant of Kitaev's surface code on a 3D lattice.
Parents:
Higher-dimensional surface code.
Cousins:
Color code.
Cousin of:
Self-correcting quantum code.

Two-dimensional hyperbolic surface code[95]
Hyperbolic surface codes based on a tessellation of a closed 2D manifold with a hyperbolic geometry (i.e., non-Euclidean geometry, e.g., saddle surfaces when defined on a 2D plane).
Protection: Protects against Pauli errors with distance \( d \propto \log(n) \). Code parameters are \( [[n, (1-2/r - 2/s) n + 2, O(\log n) ]] \)
Parents:
Hyperbolic surface code.

Quantum expander code[96]
CSS codes constructed from a hypergraph product of bipartite expander graphs with bounded left and right vertex degrees. For every bipartite graph there is an associated matrix (the parity check matrix) with columns indexed by the left vertices, rows indexed by the right vertices, and 1 entries whenever a left and right vertex are connected. This matrix can serve as the parity check matrix of a classical code. Two bipartite expander graphs can be used to construct a quantum CSS code (the quantum expander code) by using the parity check matrix of one as \(X\) checks, and the parity check matrix of the other as \(Z\) checks.
Protection: Pauli errors of weight \(\leq t\), distance scales as \(\Omega(n^{1/2})\).
Parents:
Hypergraph product code.
Cousins:
Expander code.

Golden code[97]
Variant of the Guth-Lubotzky hyperbolic surface code that uses regular tessellations for 4-dimensional hyperbolic space.
Protection: Nonvanishing rate and asymptotic distance lower bounded by \(n^0.1\).
Parents:
Guth-Lubotzky code.

## References

- [1]
- T. A. Brun, I. Devetak, and M.-H. Hsieh, “Catalytic Quantum Error Correction”, IEEE Transactions on Information Theory 60, 3073 (2014). DOI; quant-ph/0608027
- [2]
- T. Brun, I. Devetak, and M.-H. Hsieh, “Correcting Quantum Errors with Entanglement”, Science 314, 436 (2006). DOI; quant-ph/0610092
- [3]
- F. Pastawski et al., “Holographic quantum error-correcting codes: toy models for the bulk/boundary correspondence”, Journal of High Energy Physics 2015, (2015). DOI; 1503.06237
- [4]
- P. Faist et al., “Continuous Symmetries and Approximate Quantum Error Correction”, Physical Review X 10, (2020). DOI; 1902.07714
- [5]
- Ramis Movassagh and Yingkai Ouyang, “Constructing quantum codes from any classical code and their embedding in ground space of local Hamiltonians”. 2012.01453
- [6]
- A. R. Calderbank et al., “Quantum Error Correction and Orthogonal Geometry”, Physical Review Letters 78, 405 (1997). DOI; quant-ph/9605005
- [7]
- Daniel Gottesman, “Stabilizer Codes and Quantum Error Correction”. quant-ph/9705052
- [8]
- M. B. Hastings and J. Haah, “Dynamically Generated Logical Qubits”, Quantum 5, 564 (2021). DOI; 2107.02194
- [9]
- J. M. Renes, F. Dupuis, and R. Renner, “Efficient Polar Coding of Quantum Information”, Physical Review Letters 109, (2012). DOI; 1109.3195
- [10]
- J. M. Renes and J.-C. Boileau, “Physical underpinnings of privacy”, Physical Review A 78, (2008). DOI; 0803.3096
- [11]
- M. M. Wilde and J. M. Renes, “Quantum polar codes for arbitrary channels”, 2012 IEEE International Symposium on Information Theory Proceedings (2012). DOI; 1201.2906
- [12]
- M. M. Wilde and S. Guha, “Polar Codes for Degradable Quantum Channels”, IEEE Transactions on Information Theory 59, 4718 (2013). DOI; 1109.5346
- [13]
- A. Cross et al., “Codeword Stabilized Quantum Codes”, IEEE Transactions on Information Theory 55, 433 (2009). DOI; 0708.1021
- [14]
- Upendra Kapshikar and Srijita Kundu, “Diagonal distance of quantum codes and hardness of the minimum distance problem”. 2203.04262
- [15]
- Mark A. Webster, Benjamin J. Brown, and Stephen D. Bartlett, “The XP Stabiliser Formalism: a Generalisation of the Pauli Stabiliser Formalism with Arbitrary Phases”. 2203.00103
- [16]
- A. R. Calderbank and P. W. Shor, “Good quantum error-correcting codes exist”, Physical Review A 54, 1098 (1996). DOI; quant-ph/9512032
- [17]
- A. M. Steane, “Error Correcting Codes in Quantum Theory”, Physical Review Letters 77, 793 (1996). DOI
- [18]
- “Multiple-particle interference and quantum error correction”, Proceedings of the Royal Society of London. Series A: Mathematical, Physical and Engineering Sciences 452, 2551 (1996). DOI; quant-ph/9601029
- [19]
- Arpit Dua et al., “Clifford-deformed Surface Codes”. 2201.07802
- [20]
- Sara Bartolucci et al., “Fusion-based quantum computation”. 2101.09310
- [21]
- J. Haah, “Local stabilizer codes in three dimensions without string logical operators”, Physical Review A 83, (2011). DOI; 1101.1962
- [22]
- A. Dua et al., “Sorting topological stabilizer models in three dimensions”, Physical Review B 100, (2019). DOI; 1908.08049
- [23]
- S. Bravyi, B. M. Terhal, and B. Leemhuis, “Majorana fermion codes”, New Journal of Physics 12, 083039 (2010). DOI; 1004.3791
- [24]
- Sagar Vijay and Liang Fu, “Quantum Error Correction for Complex and Majorana Fermion Qubits”. 1703.00459
- [25]
- J. R. Wootton, “A family of stabilizer codes for $D({{\mathbb{Z}}_{2}})$ anyons and Majorana modes”, Journal of Physics A: Mathematical and Theoretical 48, 215302 (2015). DOI; 1501.07779
- [26]
- G. D. Forney, M. Grassl, and S. Guha, “Convolutional and Tail-Biting Quantum Error-Correcting Codes”, IEEE Transactions on Information Theory 53, 865 (2007). DOI; quant-ph/0511016
- [27]
- M. Grassl, T. Beth, and T. Pellizzari, “Codes for the quantum erasure channel”, Physical Review A 56, 33 (1997). DOI; quant-ph/9610042
- [28]
- A. R. Calderbank et al., “Quantum Error Correction via Codes over GF(4)”. quant-ph/9608006
- [29]
- Andrew M. Steane, “Enlargement of Calderbank Shor Steane quantum codes”. quant-ph/9802061
- [30]
- Markus Grassl and Thomas Beth, “Quantum BCH Codes”. quant-ph/9910060
- [31]
- S. Roberts and S. D. Bartlett, “Symmetry-Protected Self-Correcting Quantum Memories”, Physical Review X 10, (2020). DOI; 1805.01474
- [32]
- Y. Hong et al., “Quantum error correction in a time-dependent transverse-field Ising model”, Physical Review A 106, (2022). DOI; 2205.12998
- [33]
- A. Leverrier, S. Apers, and C. Vuillot, “Quantum XYZ Product Codes”, Quantum 6, 766 (2022). DOI; 2011.09746
- [34]
- D. Gottesman, “Class of quantum error-correcting codes saturating the quantum Hamming bound”, Physical Review A 54, 1862 (1996). DOI; quant-ph/9604038
- [35]
- A. Kitaev, “Anyons in an exactly solved model and beyond”, Annals of Physics 321, 2 (2006). DOI; cond-mat/0506438
- [36]
- J. Haah and M. B. Hastings, “Boundaries for the Honeycomb Code”, Quantum 6, 693 (2022). DOI; 2110.09545
- [37]
- Christophe Vuillot, “Planar Floquet Codes”. 2110.05348
- [38]
- D. Aasen, Z. Wang, and M. B. Hastings, “Adiabatic paths of Hamiltonians, symmetries of topological order, and automorphism codes”, Physical Review B 106, (2022). DOI; 2203.11137
- [39]
- Raymond Laflamme et al., “Perfect Quantum Error Correction Code”. quant-ph/9602019
- [40]
- N. P. Breuckmann and J. N. Eberhardt, “Balanced Product Quantum Codes”, IEEE Transactions on Information Theory 67, 6653 (2021). DOI; 2012.09271
- [41]
- Pavel Panteleev and Gleb Kalachev, “Asymptotically Good Quantum and Locally Testable Classical LDPC Codes”. 2111.03654
- [42]
- H. Bombin and M. A. Martin-Delgado, “Topological Quantum Distillation”, Physical Review Letters 97, (2006). DOI; quant-ph/0605138
- [43]
- A. M. Kubica, The Abcs of the Color Code: A Study of Topological Quantum Codes as Toy Models for Fault-tolerant Quantum Computation and Quantum Phases of Matter, California Institute of Technology, 2018. DOI
- [44]
- H. Bombin, “An Introduction to Topological Quantum Codes”. 1311.0277
- [45]
- Irit Dinur et al., “Good Quantum LDPC Codes with Linear Time Decoders”. 2206.07750
- [46]
- M. B. Hastings, “Weight Reduction for Quantum Codes”. 1611.03790
- [47]
- Shai Evra, Tali Kaufman, and Gilles Zémor, “Decodable quantum LDPC codes beyond the $\sqrt{n}$ distance barrier using high dimensional expanders”. 2004.07935
- [48]
- C. Jones, “Multilevel distillation of magic states for quantum computing”, Physical Review A 87, (2013). DOI; 1210.3388
- [49]
- A. Y. Kitaev, “Quantum computations: algorithms and error correction”, Russian Mathematical Surveys 52, 1191 (1997). DOI
- [50]
- A. Y. Kitaev, “Quantum Error Correction with Imperfect Gates”, Quantum Communication, Computing, and Measurement 181 (1997). DOI
- [51]
- A. Y. Kitaev, “Fault-tolerant quantum computation by anyons”, Annals of Physics 303, 2 (2003). DOI; quant-ph/9707021
- [52]
- S. B. Bravyi and A. Yu. Kitaev, “Quantum codes on a lattice with boundary”. quant-ph/9811052
- [53]
- C. Horsman et al., “Surface code quantum computing by lattice surgery”, New Journal of Physics 14, 123011 (2012). DOI; 1111.4022
- [54]
- E. Dennis et al., “Topological quantum memory”, Journal of Mathematical Physics 43, 4452 (2002). DOI; quant-ph/0110143
- [55]
- Andrew Steane, “Quantum Reed-Muller Codes”. quant-ph/9608026
- [56]
- Anthony Leverrier and Gilles Zémor, “Quantum Tanner codes”. 2202.13641
- [57]
- Anthony Leverrier and Gilles Zémor, “A parallel decoder for good quantum LDPC codes”. 2208.05537
- [58]
- Jingzhen Hu, Qingzhong Liang, and Robert Calderbank, “Divisible Codes for Quantum Computation”. 2204.13176
- [59]
- T. C. Ralph, A. J. F. Hayes, and A. Gilchrist, “Loss-Tolerant Optical Qubits”, Physical Review Letters 95, (2005). DOI; quant-ph/0501184
- [60]
- E. Knill, R. Laflamme, and G. J. Milburn, “A scheme for efficient quantum computation with linear optics”, Nature 409, 46 (2001). DOI
- [61]
- E. Knill, R. Laflamme, and G. Milburn, “Efficient Linear Optics Quantum Computation”. quant-ph/0006088
- [62]
- Dave Bacon and Andrea Casaccino, “Quantum Error Correcting Subsystem Codes From Two Classical Linear Codes”. quant-ph/0610088
- [63]
- S. Bravyi and J. Haah, “Magic-state distillation with low overhead”, Physical Review A 86, (2012). DOI; 1209.2426
- [64]
- H. Bombin and M. A. Martin-Delgado, “Optimal resources for topological two-dimensional stabilizer codes: Comparative study”, Physical Review A 76, (2007). DOI; quant-ph/0703272
- [65]
- Jonas T. Anderson, “Homological Stabilizer Codes”. 1107.3502
- [66]
- A. A. Kovalev and L. P. Pryadko, “Improved quantum hypergraph-product LDPC codes”, 2012 IEEE International Symposium on Information Theory Proceedings (2012). DOI; 1202.0928
- [67]
- Y. Tomita and K. M. Svore, “Low-distance surface codes under realistic quantum noise”, Physical Review A 90, (2014). DOI; 1404.3747
- [68]
- D. K. Tuckett, S. D. Bartlett, and S. T. Flammia, “Ultrahigh Error Threshold for Surface Codes with Biased Noise”, Physical Review Letters 120, (2018). DOI; 1708.08474
- [69]
- X.-G. Wen, “Quantum Orders in an Exact Soluble Model”, Physical Review Letters 90, (2003). DOI; quant-ph/0205004
- [70]
- J. P. Bonilla Ataides et al., “The XZZX surface code”, Nature Communications 12, (2021). DOI; 2009.07851
- [71]
- J. R. Wootton, “Hexagonal matching codes with two-body measurements”, Journal of Physics A: Mathematical and Theoretical 55, 295302 (2022). DOI; 2109.13308
- [72]
- B. Srivastava, A. Frisk Kockum, and M. Granath, “The XYZ<mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"><mml:msup><mml:mi /><mml:mn>2</mml:mn></mml:msup></mml:math> hexagonal stabilizer code”, Quantum 6, 698 (2022). DOI; 2112.06036
- [73]
- X. Ni, O. Buerschaper, and M. Van den Nest, “A non-commuting stabilizer formalism”, Journal of Mathematical Physics 56, 052201 (2015). DOI; 1404.5327
- [74]
- Matthew B. Hastings, Jeongwan Haah, and Ryan O'Donnell, “Fiber Bundle Codes: Breaking the $N^{1/2} \operatorname{polylog}(N)$ Barrier for Quantum LDPC Codes”. 2009.03921
- [75]
- P. Panteleev and G. Kalachev, “Degenerate Quantum LDPC Codes With Good Finite Length Performance”, Quantum 5, 585 (2021). DOI; 1904.02703
- [76]
- P. Panteleev and G. Kalachev, “Quantum LDPC Codes With Almost Linear Minimum Distance”, IEEE Transactions on Information Theory 68, 213 (2022). DOI; 2012.04068
- [77]
- “Multiple-particle interference and quantum error correction”, Proceedings of the Royal Society of London. Series A: Mathematical, Physical and Engineering Sciences 452, 2551 (1996). DOI; quant-ph/9601029
- [78]
- Guanyu Zhu, Tomas Jochym-O'Connor, and Arpit Dua, “Topological Order, Quantum Codes and Quantum Computation on Fractal Geometries”. 2108.00018
- [79]
- Arpit Dua, Tomas Jochym-O'Connor, and Guanyu Zhu, “Quantum error correction with fractal topological codes”. 2201.03568
- [80]
- Michael H. Freedman and David A. Meyer, “Projective plane and planar quantum codes”. quant-ph/9810055
- [81]
- L. Vaidman, L. Goldenberg, and S. Wiesner, “Error prevention scheme with four particles”, Physical Review A 54, R1745 (1996). DOI; quant-ph/9603031
- [82]
- D. W. Leung et al., “Approximate quantum error correction can lead to better codes”, Physical Review A 56, 2567 (1997). DOI; quant-ph/9704002
- [83]
- A. Peres, “Reversible logic and quantum computers”, Physical Review A 32, 3266 (1985). DOI
- [84]
- P. W. Shor, “Scheme for reducing decoherence in quantum computer memory”, Physical Review A 52, R2493 (1995). DOI
- [85]
- M. H. Freedman and M. B. Hastings, “Quantum Systems on Non-$k$-Hyperfinite Complexes: A Generalization of Classical Statistical Mechanics on Expander Graphs”. 1301.1363
- [86]
- Sergey Bravyi and Matthew B. Hastings, “Homological Product Codes”. 1311.0885
- [87]
- J.-P. Tillich and G. Zemor, “Quantum LDPC Codes With Positive Rate and Minimum Distance Proportional to the Square Root of the Blocklength”, IEEE Transactions on Information Theory 60, 1193 (2014). DOI; 0903.0566
- [88]
- “Z2-systolic freedom and quantum codes”, Mathematics of Quantum Computation 303 (2002). DOI
- [89]
- M. H. Freedman, “<b>Z</b><sub>2</sub>–Systolic-Freedom”, Proceedings of the Kirbyfest (1999). DOI
- [90]
- E. Fetaya, “Bounding the distance of quantum surface codes”, Journal of Mathematical Physics 53, 062202 (2012). DOI
- [91]
- L. Guth and A. Lubotzky, “Quantum error correcting codes and 4-dimensional arithmetic hyperbolic manifolds”, Journal of Mathematical Physics 55, 082202 (2014). DOI; 1310.5555
- [92]
- A. Leverrier, V. Londe, and G. Zémor, “Towards local testability for quantum coding”, Quantum 6, 661 (2022). DOI; 1911.03069
- [93]
- M. B. Hastings, “Quantum Codes from High-Dimensional Manifolds”. 1608.05089
- [94]
- K. P. Michnicki, “3D Topological Quantum Memory with a Power-Law Energy Barrier”, Physical Review Letters 113, (2014). DOI; 1406.4227
- [95]
- N. P. Breuckmann and B. M. Terhal, “Constructions and Noise Threshold of Hyperbolic Surface Codes”, IEEE Transactions on Information Theory 62, 3731 (2016). DOI; 1506.04029
- [96]
- A. Leverrier, J.-P. Tillich, and G. Zemor, “Quantum Expander Codes”, 2015 IEEE 56th Annual Symposium on Foundations of Computer Science (2015). DOI; 1504.00822
- [97]
- “[]”, Quantum Information and Computation 19, (2019). DOI; 1712.08578