Glossary of concepts

Construction A

Construction \(A\) converts a linear binary code into a sphere packing. Each binary codeword \(c\) of the code is mapped to an infinite set of points \(x\) such that \(x = c\) modulo two. If the underlying binary code is linear, then the resulting set of points forms a lattice.

Defined in: Construction-\(A\) code

Referenced in: Sphere packing, \(D_4\) hyper-diamond lattice, \(D_n\) checkerboard lattice, \(E_8\) Gosset lattice, \(E_7\) root lattice, Linear binary code, Binary code, Repetition code, \([7,4,3]\) Hamming code, \([8,4,4]\) extended Hamming code, Best \((10,40,4)\) code, Julin-Golay code, Single parity-check (SPC) code, \(D_4\) hyper-diamond GKP code, Concatenated GKP code, Quantum repetition code

Finite fields

The most common alphabets used in block codes Galois or finite fields \(GF(q)=\mathbb{F}_q\), which are sets of \(q\) elements closed under addition and multiplication. They are finite analogues of the real or complex numbers, and a unique field exists for every power \(q=p^m\) of a prime \(p\). The prime-field case reduces to \(\mathbb{Z}_p\), a group under addition that is promoted to a field by defining multiplication modulo \(p\); the case \(p=2\) yields the binary field \(\mathbb{Z}_2\). Every finite field comes with a 0 element (additive identity), a 1 element (multiplicative identity), and additive (multiplicative) inverses for all (nonzero) elements. An element whose powers exhaust all nonzero field elements is called primitive. Fields come with a trace operation, the field trace, which maps elements \(\gamma \in GF(q)\) to elements of \(GF(p)\) as \begin{align} \text{tr}(\gamma)=\sum_{k=0}^{m-1}\gamma^{p^{k}}~. \tag*{(1)}\end{align} The field trace can be thought of as an averaging over the field's Galois group, which is the cyclic group generated by \(\gamma\to\gamma^p\) [1; pg. 113]. Fields also come with a field norm, \begin{align} N(\gamma)=\prod_{k=0}^{m-1}\gamma^{p^{k}}=\gamma^{(p^{m}-1)/(p-1)}~. \tag*{(2)}\end{align} In the case of the complex numbers, analogues of the field trace and field norm are the real part and norm squared of a complex number, respectively.

Any field \(GF(q=p^m)\) can be thought of as an \(m\)-dimensional vector space over \(GF(p)\) a.k.a. the \(m\)th extension of \(GF(p)\) (similar to the complex numbers being an extension of the reals). Conversely, \(GF(p)\) is an example of a subfield of \(GF(q)\). Certain field elements are chosen to be the basis of \(GF(q)\) over \(GF(p)\), and all other elements are expressed as linear combinations of these basis elements. More generally, elements of fields such as \(GF(p^{ml})\) can be written as \(m\)-dimensional vectors over \(GF(p^l)\) or \((m\times l)\)-dimensional matrices over \(GF(p)\). This idea is used to convert between ordinary block codes and matrix-based codes such as disk array codes and rank-metric codes. The field norm and field trace can likewise be defined for fields \(GF(q^m)\) that are extensions of \(GF(q)\) for non-prime \(q\).

Defined in: Block code

Referenced in: Difference-set cyclic (DSC) code, Finite-geometry LDPC (FG-LDPC) code, Array code, Evaluation AG code, Hermitian code, Norm-trace code, Berlekamp code, Generalized RS (GRS) code, Narrow-sense RS code, Reed-Solomon (RS) code, Cartier code, Goppa code, Residue AG code, Generalized RM (GRM) code, Alternant code, Bose–Chaudhuri–Hocquenghem (BCH) code, Dual additive code, Dodecacode, Hexacode, Block quantum code, Hermitian qubit code, Qubit stabilizer code, Galois-qudit code, Galois-qudit stabilizer code

Asymptotic notation

We are often interested in how parameters of particular infinite block-code families scale with increasing block length \(n\), necessitating the use of asymptotic or Bachmann–Landau notation; see the book [2]. The table below summarizes the notation used throughout the EC Zoo for relating functions \(f,g\) that both grow with \(n\).

relation	behavior
\(f(n)=O(g(n))\)	\(\phantom{c_{2}\geq}{\displaystyle \underset{n\to\infty}{\lim}\frac{|f(n)|}{|g(n)|}}\leq c\)
\(f(n)=\Omega(g(n))\)	\(0<{\displaystyle \underset{n\to\infty}{\lim}\frac{|f(n)|}{|g(n)|}}\phantom{\leq c_{2}}\)
\(f(n)=\Theta(g(n))\)	\(c_{1}\leq{\displaystyle \underset{n\to\infty}{\lim}\frac{|f(n)|}{|g(n)|}}\leq c_{2}\)

Defined in: Block code

Referenced in: Linear binary code, Binary BCH code, Fountain code, Binary linear LTC, Ben-Sasson-Goldreich-Harsha-Sudan-Vadhan (BGHSV) code, Goldreich-Sudan code, Ta-Shma zigzag code, Expander code, Gallager (GL) code, Rank-modulation code, Traceability code, Generalized RS (GRS) code, Reed-Solomon (RS) code, Bose–Chaudhuri–Hocquenghem (BCH) code, Turbo code, \(q\)-ary linear LTC, Linear \(q\)-ary code, Wozencraft ensemble code, Chebyshev code, Approximate quantum error-correcting code (AQECC), Amplitude-damping (AD) code, Block quantum code, W-state code, Topological code, Commuting-projector Hamiltonian code, Frustration-free Hamiltonian code, Quantum locally testable code (QLTC), Self-correcting quantum code, Random quantum code, Lattice stabilizer code, Quantum LDPC (QLDPC) code, Quantum low-weight check (QLWC) code, Quantum locally recoverable code (QLRC), Random stabilizer code, Brown-Fawzi random Clifford-circuit code, Circuit-to-Hamiltonian approximate code, Post-selected PI code, Qubit code, Hierarchical code, Fiber-bundle code, Hypergraph product (HGP) code, Quantum expander code, Dinur-Lin-Vidick (DLV) code, High-dimensional expander (HDX) code, Quasi-hyperbolic color code, Kitaev surface code, Hemicubic code, Hypersphere product code, Guth-Lubotzky code, Freedman-Meyer-Luo code, XZZX surface code, Bacon-Shor code, Quantum Tamo-Barg (QTB) code, Galois-qudit stabilizer code, Balanced product (BP) code, Abelian LP code, Distance-balanced code

Cyclic-to-polynomial correspondence

Cyclic linear \(q\)-ary codes and their properties can be naturally formulated using the theory of polynomials. Codewords \(c_1 c_2 \cdots c_n\) of a cyclic \(q\)-ary code can be thought of as coefficients in a polynomial \(c_1+c_2 x+\cdots+c_n x^{n-1}\) in the set of polynomials with \(q\)-ary coefficients, \(\mathbb{F}_q[x]\) with \(\mathbb{F}_q=GF(q)\). Polynomials corresponding to codewords of a linear cyclic code form an ideal (i.e., are closed under multiplication and addition) in the ring \(\mathbb{F}_q[x]/(x^n-1)\) (i.e., the set of equivalence classes of polynomials congruent modulo \(x^n-1\)). Multiplication of a codeword polynomial \(c(x)\) by \(x\) in such a ring corresponds to a cyclic shift of the corresponding codeword string.

Defined in: Cyclic linear \(q\)-ary code

Referenced in: Binary BCH code, Binary duadic code, Binary quadratic-residue (QR) code, Cyclic redundancy check (CRC) code, Bose–Chaudhuri–Hocquenghem (BCH) code, \(q\)-ary duadic code, \(q\)-ary quadratic-residue (QR) code, Lattice stabilizer code, La-cross code

Weight enumerator

Determining protection and bounds on code parameters can also be done using the code's weight enumerator (cf. quantum weight enumerators), \begin{align} \begin{split} A(x,y)&=\sum_{j=0}^{n}A_{j}x^{n-j}y^{j}\\ A_{j}&=\text{number of wt-}j\text{ codewords}~. \end{split} \tag*{(3)}\end{align} The weight enumerator and it's Fourier transform the dual weight enumerator satisfy the MacWilliams identity [3,4]; see [1; Ch. 5].

The distance of the code is the value of the first nonzero coefficient \(A_j\), while the dual distance is the first nonzero coefficient of the dual weight enumerator. The number of the code is the number of nonzero \(A_j\)'s, corresponding to the number of distinct nonzero distances between codewords. The external distance is the number of nonzero coefficients of the dual weight enumerator. The distance, dual distance, number and external distance make up the four fundamental parameters of a code [5][1; Ch. 5].

Other types of weight enumerators includes the Hamming weight enumerator, Lee weight enumerator, joint weight enumerator, split weight enumerator, and biweight enumerator [1].

Defined in: \(q\)-ary code

Referenced in: Binary code, Combinatorial design, Poset code, Dual linear code, Orthogonal array (OA), Completely regular code, Uniformly packed code, Two-weight code, Qubit code

Gilbert-Varshamov (GV) bound

The Gilbert-Varshamov [6,7], or Gilbert-Shannon-Varshamov, bound states that the maximum size \(K\) of a \(q\)-ary code with distance \(d\) satisfies \begin{align} K\sum_{j=0}^{d-1}{n \choose j}(q-1)^{j}\geq q^{n}~. \tag*{(4)}\end{align} In other words, if the left-hand side of the above is less than or equal to the right-hand side, then a code with such parameters exists. The GV bound gives rise to the asymptotic GV bound (i.e., GV bound in the \(n\to\infty\) limit), expressed in terms of the maximum achievable rate \(R\) and relative distance \(\delta\), \begin{align} R\geq 1-h_{q}(\delta)~, \tag*{(5)}\end{align} where \(h_q\) is the \(q\)-ary entropy function, \begin{align} h_{q}(\delta)=-\delta\log_{q}\frac{\delta}{q-1}-(1-\delta)\log_{q}(1-\delta)~. \tag*{(6)}\end{align}

Defined in: \(q\)-ary code

Referenced in: Kopparty-Meir-Ron-Zewi-Saraf (KMRS) code, Ta-Shma zigzag code, Regular binary Tanner code, Hsu-Anastasopoulos LDPC (HA-LDPC) code, Concatenated code, Random code, Algebraic-geometry (AG) code, Generalized RS (GRS) code, Cartier code, Residue AG code, Tsfasman-Vladut-Zink (TVZ) code, Linear \(q\)-ary code, Wozencraft ensemble code, Block quantum code

Lifting

Given the incidence matrix \(A\) of a protograph, each non-zero entry is replaced by a sum of \(\ell\)-dimensional permutation matrices while each zero entry is replaced by the \(\ell\)-dimensional zero matrix. The resulting matrix is called a lift of \(A\). The permutation matrices can be chosen randomly or deterministically, with a deterministic lift also called a permutation voltage assignment in the theory of theory of voltage graphs [8,9].

The matrices can come from a group \(G\) or its group algebra \(\mathbb{F}_q G\), in which case the lift is often called a \(G\)-lift. In this case, matrix entries of a \(\mathbb{F}_q\)-valued matrix \(A\) are substitited with matrices forming the regular representation of \(\mathbb{F}_q G\) according to some rule.

For example, the lift of a binary two-dimensional incidence matrix using two-dimensional permutation matrices associated with the group \(\mathbb{Z}_2\) is as follows: \begin{align} \begin{pmatrix}1 & 1\\ 0 & 1 \end{pmatrix}\to\left(\begin{smallmatrix}0 & 1 & 0 & 1\\ 1 & 0 & 1 & 0\\ 0 & 0 & 1 & 0\\ 0 & 0 & 0 & 1 \end{smallmatrix}\right)~. \tag*{(7)}\end{align} Here, the two non-zero entries in the top row are replaced by the exchange permutation while the bottom non-zero entry is replaced by the trivial permutation.

Defined in: \(q\)-ary protograph LDPC code

Referenced in: Array-based LDPC (AB-LDPC) code, Quasi-cyclic LDPC (QC-LDPC) code, Spatially coupled LDPC (SC-LDPC) code, B-code, Subsystem lifted-product (SLP) code, Lifted-product (LP) code, Abelian LP code

Antipodal mapping

The antipodal mapping, also known as a Euclidean-space image or \(Y_2\) construction), is a component-wise mapping from binary space into Euclidean space. Each coodinate of a binary string is mapped into a sign, \(0\to +1\) and \(1 \to -1\) [10; Example 1.2.1].

Defined in: Binary antipodal code

Referenced in: Linear binary code, Binary code, Golay code, \([2^m-1,m,2^{m-1}]\) simplex code, \([7,3,4]\) simplex code, Kerdock code, \([2^m,m+1,2^{m-1}]\) First-order RM code, Slepian group-orbit code, Binary PSK (BPSK) code, Biorthogonal spherical code, Simplex spherical code, Kerdock spherical code, Spherical code, Spherical design

Group-based error basis

There are two types of \(X\)-type operators, corresponding to left and right group multiplication. These act on computational basis states \(|h\rangle\) as \begin{align} \overrightarrow{X}_{g}|h\rangle&=|gh\rangle\tag*{(8)}\\ \overleftarrow{X}_{g}|h\rangle&=|hg^{-1}\rangle \tag*{(9)}\end{align} for any group elements \(h,g\). The \(Z\)-type operators can be thought of as matrix-product operators (MPOs) [11] whose virtual dimension is the dimension \(d_{\lambda}\) of their corresponding irrep. The are diagonal in the group-valued basis, yielding the \(d_{\lambda}\)-dimensional irrep matrix \(Z_{\lambda}(g)\) evaluated at the given group element, \begin{align} \hat{Z}_{\lambda}\otimes|g\rangle=Z_{\lambda}(g)\otimes|g\rangle~. \tag*{(10)}\end{align} Each matrix element of this irrep matrix is a generally non-unitary operator on the group-valued qudit. For one-dimensional irreps, the matrix reduces to a single unitary \(Z\)-type operator, and the direct-product symbol is no longer needed.

Defined in: Group-based quantum code

Referenced in: Group-based cluster-state code, Group GKP code, Group-based QPC, Group-based quantum repetition code, Knill code, Calderbank-Shor-Steane (CSS) stabilizer code, \([[5,1,3]]_{\mathbb{Z}_q}\) modular-qudit code

Rotor generalized Pauli strings

For a single rotor, its elements are products of exponentials of the rotor's angular position (\(\hat\phi\)) and angular momentum (\(\hat L\)) operators, acting on the rotor's angular position states \(|\phi\rangle\) for \(\phi\in U(1)\) as \begin{align} e^{-i\varphi\hat{L}}\left|\phi\right\rangle =\left|\phi+\varphi\right\rangle \,\,\text{ and }\,\,e^{i\ell\hat{\phi}}\left|\phi\right\rangle =e^{i\ell\phi}\left|\phi\right\rangle ~, \tag*{(11)}\end{align} where \(\varphi\in U(1)\) and \(\ell\in\mathbb{Z}\). For multiple rotors, error set elements are tensor products of elements of the single-rotor error set, characterized by vectors of angle and integer coefficients multiplying vectors of angular momentum \(\hat{\boldsymbol{L}}\) and angular position \(\hat{\boldsymbol{\phi}}\) operators.

Defined in: Rotor code

Displacement operators

For a single mode, its elements are products of exponentials of the mode's position and momentum operators, acting on the mode's position states \(|y\rangle\) for \(y\in\mathbb{R}\) as \begin{align} e^{-iq\hat{p}}\left|y\right\rangle =\left|y+q\right\rangle \,\,\text{ and }\,\,e^{iq\hat{x}}\left|y\right\rangle =e^{iq y}\left|y\right\rangle ~, \tag*{(12)}\end{align} where \(q\in\mathbb{R}\). The former is also called a translation, while the latter is called a modulation in signal processing. For multiple modes, error set elements are tensor products of elements of the single-oscillator error set, characterized by the vector of coefficients \(\xi\in\mathbb{R}^{2n}\).

Defined in: Bosonic code

Code space complexity

One can relate robustness of an approximate quantum code to the quantum circuit complexity [12–15] of creating states in the codespace. For a family of block codes, scaling as order \(O(k/n)\) of a code parameter called the subsystem variance characterizes the transition between code subspaces with low and high circuit complexity [16].

Defined in: Approximate quantum error-correcting code (AQECC)

Referenced in: Topological code, Random quantum code, Conformal-field theory (CFT) code, Circuit-to-Hamiltonian approximate code, Eigenstate thermalization hypothesis (ETH) code

Amplitude damping noise

The amplitude damping (AD) channel is a bosonic channel that models loss of particles in a bosonic mode (a.k.a. photon loss, pure loss, or fiber attenuation). Its Kraus operators are proportional to powers of a mode's annihilation operator \(a\), with the power signifying the number of particles lost during the error, \begin{align} E_{\ell}=\left(\frac{\gamma}{1-\gamma}\right)^{\ell/2}\frac{a^{\ell}}{\sqrt{\ell!}}\left(1-\gamma\right)^{\hat{n}/2}\,, \tag*{(13)}\end{align} where \(\gamma\in[0,1)\) is the noise rate [17,18]. For multiple modes, error set elements are tensor products of elements of the single-mode error set.

Restricting the channel to the first two Fock states \(\{|0\rangle,|1\rangle\}\) yields the non-Pauli qubit AD channel, which requires protecting against the loss error \(E_1\propto X+iY\) (instead of \(X\) and \(Y\) Pauli errors individually). Both channels are called AD since the context makes clear which one is being referred to. Other extension to qudits are also known [19].

Defined in: Amplitude-damping (AD) code

Referenced in: Binary PSK (BPSK) code, Polar c-q code, Chuang-Leung-Yamamoto (CLY) code, Dual-rail quantum code, Fock-state bosonic code, Binomial code, Bosonic code, Concatenated bosonic code, Quantum spherical code (QSC), Gottesman-Kitaev-Preskill (GKP) code, Tiger code, Approximate quantum error-correcting code (AQECC), Permutation-invariant (PI) code, Constant-excitation (CE) code, Jump code, Self-complementary quantum code, Amplitude-damping CWS code, Post-selected PI code, Qudit GNU PI code, Concatenated qubit code, Qubit code, Numerically optimized four-qubit AD code, \([[4,2,2]]\) Four-qubit code, Quantum parity code (QPC), Qubit CSS code, Qubit stabilizer code

Quantum GV bound

The quantum GV bound [20] (see also Refs. [21–25]) for Galois qudits states that a pure \([[n,k,d]]_q\) Galois-qudit stabilizer code exists if \begin{align} \frac{q^{n-k+2}-1}{q^{2}-1}>\sum_{j=1}^{d-1}(q^{2}-1)^{j-1}\binom{n}{j}~. \tag*{(14)}\end{align} The bound gives rise to the asymptotic quantum GV bound (i.e., quantum GV bound in the \(n\to\infty\) limit), expressed in terms of the maximum achievable rate \(R\) and relative distance \(\delta\), \begin{align} R\geq 1-\delta\log_q(q+1) - h_{q}(\delta)~, \tag*{(15)}\end{align} where \(h_q\) is the \(q\)-ary entropy function.

Defined in: Block quantum code

Referenced in: Alternant code, Concatenated quantum code, Random stabilizer code, EA qubit code, Qubit CSS code, Qubit stabilizer code, Quantum Goppa code, Galois-qudit GRS code

Eastin-Knill theorem

Transversal gates are logical gates on block codes that can be realized as tensor products of unitary operations acting on subsets of subsystems whose size is independent of \(n\). For subsets of size one, gates are sometimes called strongly transversal the single-subsystem unitaries are identical and weakly transversal otherwise. A universal gate set for a finite-dimensional block quantum code cannot be transversal for any code that detects single-block errors due to the Eastin-Knill theorem [26].

Defined in: Block quantum code

Referenced in: Covariant block quantum code, W-state code

Absolutely maximally entangled (AME) state

A state on \(n\) subsystems is \(d\)-uniform [27,28] (a.k.a. \(d\)-undetermined [29] or \(d\)-maximally mixed [30]) if all reduced density matrices on up to \(d\) subsystems are maximally mixed. A \(K\)-dimensional subspace of \(d-1\)-uniform states of \(q\)-dimensional subsystems is equivalent to a pure \(((n,K,d))_q\) code [31,32]. An AME state (a.k.a. maximally multi-partite entangled state [33,34]) is a \(\lfloor n/2 \rfloor\)-uniform state, corresponding to a pure \(((n,1,\lfloor n/2 \rfloor + 1))_{\mathbb{Z}_q}\) code. The rank-\(n\) tensor formed by the encoding isometry of such codes is a perfect tensor (a.k.a. multi-unitary tensor), meaning that it is proportional to an isometry for any bipartition of its indices into a set \(A\) and a complementary set \(A^{\perp}\) such that \(|A|\leq|A^{\perp}|\).

Defined in: Perfect-tensor code

Referenced in: Hexacode, Quantum maximum-distance-separable (MDS) code, Holographic tensor-network code, Five-qubit perfect code, Hermitian qubit code, Pastawski-Yoshida-Harlow-Preskill (HaPPY) code, Surface-code-fragment (SCF) holographic code, Six-qubit-tensor holographic code, \(((3,6,2))_{\mathbb{Z}_6}\) Euler code, \([[5,1,3]]_{\mathbb{Z}_q}\) modular-qudit code, Three-qutrit code, Modular-qudit cluster-state code

TQO conditions

The TQO-1 condition states that the distance of the ground-state-subspace code is macroscopic, i.e., grows as a positive power of the lattice size [35]. The TQO-2 condition relates the ground states of restrictions of the Hamiltonian to some geometrically local region to those of the full Hamiltonian. Let \(\Pi_{N(X)}\) be the ground-state subspace projector of the Hamiltonian that includes all terms with at least some support on a geometrically local region \(X\), with \(N(X)\) consisting of the smallest region containing the support of all included terms. TQO-2 states that any operator \(O_X\) that annihilates the codespace projector \(\Pi\) also has to annihilate the local projector \(\Pi_{N(X)}\), \begin{align} O_{A}\Pi=0\quad\Rightarrow\quad O_{A}\Pi_{N(A)}=0~. \tag*{(16)}\end{align} This condition implies that any operator supported solely on \(A\) cannot distinguish the global projector from the local one [36,37].

Defined in: Topological code

Referenced in: Commuting-projector Hamiltonian code, Frustration-free Hamiltonian code, Hamiltonian-based code, Quantum LDPC (QLDPC) code, Cluster-state code, Kitaev surface code

Nice error basis

A nice error basis [38–40] for an \(q\)-dimensional vector space is a set \(\{E_g~,~g\in G\}\) of unitary operators, where \(G\) is a (not necessarily Abelian) group of order \(q^2\), and where \begin{align} \text{tr}(E_{g})&=q\delta^{G}_{g,1}\tag*{(17)}\\ E_{g}E_{h}&=\omega_{g,h}E_{gh} \tag*{(18)}\end{align} for all group elements \(g,h\). Above, \(\delta^{G}_{g,1}\) is the group Kronecker-delta function. A basis is called very nice if \(\omega\) is a root of unity. This definition can naturally be extended to continuous groups.

Defined in: Knill code

Referenced in: Group-representation code, Stabilizer code, Qubit code, Modular-qudit code, Galois-qudit code

Pseudo-threshold (a.k.a. break-even point)

The ultimate goal of error correction is to make sure that the logical error rate is greater than the underlying physical error rate. For a noise model parameterized by a single physical error rate \(p\), the pseudo-threshold or break-even point is the smallest \(p\) at which the logical error rate after error correction is equal to \(p\).

Defined in: Quantum error-correcting code (QECC)

Referenced in: \([[144,12,12]]\) gross code, Bivariate bicycle (BB) code, Surface-17 code, Triangular surface code

Knill-Laflamme conditions

The Knill-Laflamme error-correction conditions [41–43][44; Thm. 10.1] are necessary and sufficient conditions for a code to successfully correct a set of errors in a finite-dimensional Hilbert space. A code (defined by a partial isometry \(U\)) with code space projector \(\Pi = U U^\dagger\) can correct a set of errors \(\{ E_j \}\) if and only if \begin{align} \Pi E_i^\dagger E_j \Pi = c_{ij}\, \Pi\qquad\text{for all \(i,j\),} \tag*{(19)}\end{align} where the QEC matrix elements \(c_{ij}\) are arbitrary complex numbers.

Defined in: Finite-dimensional quantum error-correcting code

Referenced in: Error-correcting code (ECC), Graph quantum code, Hybrid QECC, Approximate quantum error-correcting code (AQECC), Amplitude-damping (AD) code, Error-corrected sensing code, Metrological code, Quantum error-correcting code (QECC), Post-selected PI code, Quantum error-transmuting code (QETC), Qubit code, Qubit stabilizer code, Subsystem qubit stabilizer code

Degeneracy

A code is degenerate with respect to a noise model if different errors map code states to the same error subspace. For a linearly independent error set \(\cal{E}\), degeneracy is equivalent to \(\text{rank}(c_{ij}) < |\cal{E}|\) [45].

Defined in: Finite-dimensional quantum error-correcting code

Referenced in: Perfect quantum code, Qubit code, \([[8, 3, 3]]\) Eight-qubit Gottesman code, Qubit CSS code, Qubit stabilizer code, Galois-qudit CSS code, Approximate secret-sharing code, Galois-qudit RS code

Complementary channel

A complementary channel \(\mathcal{E}^C\) is obtained from a channel \(\mathcal{E}\) that acts on a system by interpreting the channel as coming from a unitary operation acting on a larger system-environment tensor-product space (i.e., performing an isometric extension) and then tracing out the system factor (instead of the second environmental factor) [46; Sec. 5.2.2]. A noise channel \({\cal E}(\cdot)=\sum_{j}E_{j}(\cdot)E_{j}^{\dagger}\) admits a complementary channel of the form \begin{align} {\cal E}^{C}(\cdot)=\sum_{j,k}\text{Tr}\{E_{j}(\cdot)E_{k}^{\dagger}\}|j\rangle\langle k|~. \tag*{(20)}\end{align}

Defined in: Finite-dimensional quantum error-correcting code

Referenced in: Approximate operator-algebra QECC, Approximate quantum error-correcting code (AQECC)

Pauli-to-polynomial mapping

A single modular- or Galois-qudit Pauli operator can be specified by the lattice coordinate of the site and the symplectic vector representation of the Pauli operator within the site. In an extension of the sympletic representation, each lattice coordinate can be represented by a Laurent monomial of \(D\) formal variables. For example, when \(D=2\) and \(m=1\), the product of an \(X\) acting on the qubit at lattice coordinate \((-1,2)\) and a \(Z\) acting on the qubit at \((1,0)\) can be represented by the vector \( (x^{-1} y^2 | x) \). The multiplicative group of finitely supported Pauli operators modulo phase factors on the lattice of dimension \(D\) with \(m\) prime-dimensional qubits per site is isomorphic to the additive group of Laurent polynomial column vectors of length \(2m\) in \(D\) formal variables (see Ref. [47] and Sec. IV of Ref. [48]).

For periodic boundary conditions, this mapping can be thought of as a quantum extension of the cyclic-to-polynomial correspondence. For open boundary conditions, this mapping extends the mapping used in quantum convolutional codes to multiple spatial dimensions.

Defined in: Lattice stabilizer code

Referenced in: Quantum spatially coupled (SC-QLDPC) code

BPT bound

Lattice qubit codes are limited by the Bravyi-Poulin-Terhal (BPT) bound [49] (see also [50–52]), which states that \(d \leq O(n^{1-1/D})\) and \(k d^{2/D-1} = O(n)\) for \(D\)-dimensional lattice geometries. The Bravyi-Terhal (BT) bound states that \(d = O(L^{D-1})\) [50]. Codes on a \(D\)-dimensional homogeneous Riemannian manifold with diameter \(L\) satisfy \(k = O(L^{D-2})\) [53]. Some non-locality is necessary to circumvent these bounds [54].

Defined in: Lattice stabilizer code

Referenced in: Newman-Moore code, Classical fractal liquid code, Approximate quantum error-correcting code (AQECC), Good QLDPC code, Quantum LDPC (QLDPC) code, Layer code, 2D color code, Hyperbolic color code, Stellated color code, Kitaev surface code, Hyperbolic surface code, Twist-defect surface code

Bravyi-Koenig bound

Logical gates implemented via constant-depth quantum circuits on a \(D\)-dimensional lattice stabilizer code whose distance increases at least logarithmically with \(n\) lie in the \(D\)th level of the Clifford hierarchy [55]. A refinement can be made that expresses the bound in terms of higher-group symmetries of the topological phases underlying the codes [56; Sec. 5.4.2]. Conversely, the distance of a code on an \(L^{D}\) lattice is upper bounded by order \(O(L^{D+1-\nu})\) if the code implements an \(\nu\)th-level Clifford hierarchy gate [57]. The code capacity threshold of such a code family is upper bounded by \(1/\nu\) [57].

Defined in: Lattice stabilizer code

Referenced in: Lattice subsystem code, Dynamical automorphism (DA) code, Modular-qudit color code

Subsystem BT bound

The subsystem BT bound is an upper bound of \(d = O(L^{D-1})\) on the distance [50] of lattice subsystem stabilizer codes arranged in a \(D\)-dimensional lattice of length \(L\) with \(n=L^D\). In particular, \(D=2\)-dimensional subsystem codes satisfy \(kd = O(n)\) [51]. More generally, there is a tradeoff theorem [58] stating that, for any logical operator, there is an equivalent logical operator with weight \(\tilde{d}\) such that \(\tilde{d}d^{1/(D-1)}=O(L^{D})\).

Defined in: Lattice subsystem code

Referenced in: Spacetime circuit code, Subsystem spacetime circuit code

Subsystem PYBK bound

The Bravyi-Koenig bound can be extended to subsystem codes by Pastawski and Yoshida. Namely, logical gates implemented via constant-depth quantum circuits on a \(D\)-dimensional lattice subsystem code whose distance increases at least logarithmically with \(n\) lie in the \(D\)th level of the Clifford hierarchy [57].

Defined in: Lattice subsystem code

Dicke states

For \(n\)-qubit block codes, an often used basis for the \(n+1\)-dimensional PI subspace consists of the Dicke states \(|D^n_w\rangle\) -- normalized PI states of \(w\) excitations, i.e., a normalized sum over all binary-string basis elements with \(w\) ones and \(n - w\) zeroes. For example, the single-excitation Dicke state on three qubits is \begin{align} |D_{1}^{3}\rangle=\frac{1}{\sqrt{3}}\left(|001\rangle+|010\rangle+|100\rangle\right)~. \tag*{(21)}\end{align} The \(n+1\)-dimensional PI space can be thought of as a standalone spin-\(n/2\) quantum system, yielding a way to convert between permutation-invatiant qubit codes and \(SU(2)\) spin codes. A single-spin code for the \(SU(2)\) group correcting spherical tensors can be mapped into a PI qubit code with an analogous distance [59][60; Thm. 1].

Defined in: PI qubit code

Referenced in: Binomial code, Covariant block quantum code, Eigenstate thermalization hypothesis (ETH) code, Combinatorial PI code, Four-qubit single-deletion code, GNU PI code, Qudit GNU PI code, \(((9,2,3))\) Ruskai code, \(((7,2,3))\) Pollatsek-Ruskai code, \(((n,1,2))\) Bravyi-Lee-Li-Yoshida PI code, Æ code, Clifford spin code, Single-spin code

Pauli strings

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}~. \tag*{(22)}\end{align} For multiple qubits, error set elements are tensor products of elements of the single-qubit error set. Tensor products of \(X\) (\(Z\)) Paulis acting on different qubits are called \(X\)-type (\(Z\)-type) Pauli strings. Combining the \(X\)-type and \(Z\)-type strings with \(i\) forms a group called the Pauli group on \(n\) qubits, while combining them with \(-1\) forms the real Pauli group.

Defined in: Qubit code

Referenced in: Bosonic code, Spacetime circuit code, Operator-algebra (OA) qubit stabilizer code, Quantum error-transmuting code (QETC), \([[8, 3, 3]]\) Eight-qubit Gottesman code, Qubit stabilizer code, Subsystem spacetime circuit code, Subsystem qubit stabilizer code

Quantum weight enumerator

Determining protection and bounds on code parameters can also be done using the code's Shor-Laflamme quantum weight enumerator [61] (cf. weight enumerators) \begin{align} \begin{split} A(x)&=\sum_{j=0}^{n}A_{j}x^{j}\\ A_{j}&=\frac{1}{K^{2}}\sum_{\text{wt-}j\text{ Paulis }P}\left|\text{tr}(P\Pi)\right|^{2}~, \end{split} \tag*{(23)}\end{align} where \(\Pi\) is the code projection, and where the sum is over the Pauli group modulo the subgroup of phases (hence, the dagger below is necessary in case the coset representative is not Hermitian).

Defined in: Qubit code

Referenced in: \(q\)-ary code, Approximate quantum error-correcting code (AQECC), Block quantum code, Quantum maximum-distance-separable (MDS) code, Tensor-network code, Perfect-tensor code, \([[9,1,3]]\) Shor code, \([[11,1,5]]\) quantum dodecacode, Quantum data-syndrome (QDS) code, Cluster-state code, Surface-17 code, \([[9,1,5]]_3\) quantum Glynn code, Quantum quadratic-residue (QR) code, Galois-qudit quantum RM code

Clifford group

The Clifford group is the normalizer of the Pauli group. The group consists of the Pauli group as well as elements that permute Pauli operators amongst themselves. Up to any phases and Pauli strings, the group is equivalent to the symplectic group \(Sp(2n,\mathbb{Z}_2)\). See Refs. [45,62–64] for generators, relations, and normal form. The group cannot be expressed as a semidirect product of the Pauli and symplectic groups [65]. There is a canonical form for Clifford circuits [66,67]. Restricting the group to real-valued elements yields the real Clifford group. Single-qubit Clifford gates, together with Paulis, realize a group with \(192\) elements. Modding out phases yields the \(48\)-element \(2O\) binary octahedral subgroup of \(SU(2)\). Further modding out the Pauli group, which corresponds to the quaternion group \(Q\), yields the permutation group \(S_3\), which consists of permutations of the three non-identity single-qubit Pauli matrices. Subgroups of the two-qubit Clifford group have been classified [68].

Defined in: Qubit code

Referenced in: Barnes-Wall (BW) lattice, \(t\)-design, Real-Clifford subgroup-orbit code, Disphenoidal 288-cell code, Clifford subgroup-orbit QSC, Clifford group-representation QSC, Monitored random-circuit code, Holographic tensor-network code, Random stabilizer code, Haar-random qubit code, Local Haar-random circuit qubit code, \([[2m,2m-2,2]]\) error-detecting code, \([[5,1,2]]\) rotated surface code, \([[7,1,3]]\) Steane code, \([[7,1,3]]\) twist-defect surface code, Hermitian qubit code, Pastawski-Yoshida-Harlow-Preskill (HaPPY) code, Generalized quantum divisible code, Quantum divisible code, Triorthogonal code, \([[23, 1, 7]]\) Quantum Golay code, Cluster-state code, Qubit stabilizer code, \([[15,1,3]]\) quantum Reed-Muller code, \([[30,8,3]]\) Bring code, Kitaev surface code, Quantum quadratic-residue (QR) code, Clifford spin code

Clifford hierarchy

The Clifford hierarchy [69–73] is a tower of gate sets which includes Pauli and Clifford gates at its first two levels, and non-Clifford gates at higher levels. The \(k\)th level is defined recursively by \begin{align} C_k = \{ U | U P U^{\dagger} \in C_{k-1} \}~, \tag*{(24)}\end{align} where \(P\) is any Pauli matrix, where \(C_1\) is the Pauli group, and where \(C_2\) is the Clifford group.

Defined in: Qubit code

Referenced in: Lattice stabilizer code, Lattice subsystem code, Dynamical automorphism (DA) code, Binary dihedral PI code, Generalized quantum divisible code, Quantum divisible code, Quantum rainbow code, Triorthogonal code, Hypergraph product (HGP) code, Qubit CSS code, Qubit stabilizer code, \([[2^r-1,1,3]]\) simplex code, Quantum Reed-Muller code, Color code, Quasi-hyperbolic color code, Quantum AG code

Effective distance and hook errors

Decoders are characterized by an effective distance (a.k.a. circuit-level distance), the minimum number of faulty operations during syndrome measurement that is required to make an undetectable error. A code is distance-preserving if it admits a decoder whose circuit-level distance is equal to the code distance. A particularly dangerous class of syndrome measurement circuit faults are hook errors, which are ancilla faults that cause more than one data-qubit error [74]. Hook errors occur at specific places in a syndrome extraction circuit and can sometimes be removed by re-ordering the gates of the circuit. If not, the use of flag qubits (see [45]) to detect hook errors may be necessary to yield fault-tolerant decoders.

Defined in: Qubit code

Referenced in: Quantum LDPC (QLDPC) code, Hypergraph product (HGP) code, Bivariate bicycle (BB) code, Qubit CSS code, Color code, Rotated surface code, Kitaev surface code, Triangular surface code, Distance-balanced code

Computational threshold

A fault-tolerant computational threshold is the maximum noise rate in a particular single-parameter noise model below which any logical computation of size \(M\) can be executed on a physical-qubit architecture to arbitrary accuracy and with an overhead of order \(O(M\text{polylog}M)\). The first methods to achieve a computational threshold use recursively concatenated stabilizer code families [75–81]; such a threshold is called a concatenated threshold. Such methods require constant-space and polylogarithmic-time overhead, but concatenations using quantum Hamming codes improve this to quasi-polylogarithmic time [82]. Subsequently, thresholds were determined for infinite families of lattice stabilizer codes, starting with the toric code [74]; such a threshold is colloquially called a topological threshold. Fault-tolerant computations with no notion of locality can be made local on a 2D or 3D geometry with minimal overhead [83].

Defined in: Qubit code

Referenced in: Asymmetric quantum code, Concatenated qubit code, Five-qubit perfect code, Concatenated Steane code, Qubit BCH code, \([[15,1,3]]\) quantum Reed-Muller code, Kitaev surface code, Bacon-Shor code, \([[9,1,3,3]]\) Nine-qubit Bacon-Shor code

Measurement threshold

One can derive conditions quantifying how many random single-qubit measurements can be made without destroying the logical information [84]. The measurement threshold is the maximum total probability that a single qubit is measured in a random \(X\), \(Y\), or \(Z\) basis at which the logical information is still recoverable. The measurement threshold is at least as large as the erasure threshold [84; Thm. 4].

Defined in: Qubit code

Referenced in: Haar-random qubit code, Concatenated qubit code, Five-qubit perfect code, Pastawski-Yoshida-Harlow-Preskill (HaPPY) code, Concatenated Steane code, \([[2^r-1, 2^r-2r-1, 3]]\) quantum Hamming code, Honeycomb (6.6.6) color code, \([[15,1,3]]\) quantum Reed-Muller code, Toric code, Bacon-Shor code

Qubit CSS-to-homology correspondence

CSS codes and their properties can be formulated in terms of homology theory, yielding a powerful correspondence between codes and chain complexes, the primary homological structures. There exists a many-to-one mapping from size three chain complexes to CSS codes [85–88] that allows one to extract code properties from topological features of the complexes. Codes constructed in this manner are sometimes called homological CSS codes, but they are equivalent to CSS codes. This mapping of codes to manifolds allows the application of structures from topology to error correction, yielding various QLDPC codes with favorable properties.

Defined in: Qubit CSS code

Referenced in: Homological rotor code, Rotor stabilizer code, Homological number-phase code, Generalized homological-product code, Generalized homological-product CSS code, Homological product code, Modular-qudit CSS code, Galois-qudit CSS code

Steane enlargement

An \([[n,2k-n,d]]\) CSS code can be converted to a \([[n,k+k^{\prime}−n,\min(d,\left\lceil 3d^{\prime}/2\right\rceil )]]\) code for particular \(k^{\prime}\) and \(d^{\prime}\) via the Steane enlargement construction [89].

Defined in: Qubit CSS code

Referenced in: Union stabilizer (USt) code, \(((2^m,2^{2^m−5m+1},8))\) Goethals-Preparata code, Galois-qudit BCH code

Symplectic representation

In the symplectic representation, the single-qubit identity, \(X\), \(Y\), or \(Z\) Pauli matrices represented using two bits as \((0|0)\), \((1|0)\), \((1|1)\), and \((0|1)\), respectively. In other words, the single-qubit Pauli string \(X^a Z^b\) is converted to the vector \(a|b\). The multi-qubit version follows naturally.

Defined in: Qubit stabilizer code

Referenced in: Dual linear code, Majorana stabilizer code, Generalized quantum divisible code, Quantum divisible code, \(k\)-orthogonal code, Triorthogonal code, \([[49,1,5]]\) triorthogonal code, Qubit CSS code

\(GF(4)\) representation

An \(n\)-qubit Pauli stabilizer can be represented as a length-\(n\) quaternary vector using the one-to-one correspondence between the four Pauli matrices \(\{I,X,Y,Z\}\) and the four elements \(\{0,1,\omega^2,\omega\}\) of the quaternary Galois field \(GF(4)\).

Defined in: Qubit stabilizer code

Referenced in: Dual linear code, Dual additive code, Hermitian qubit code

Encoder-respecting form

In an encoder-respecting form, each qubit stabilizer code [90] (see also Ref. [91]) is represented by a semi-bipartite graph with \(k\) input and \(n\) output nodes in which the \(k\) input nodes are not connected to each other. Conversion between stabilizer tableaus and graphs is achieved using ZX calculus and takes time that is polynomial in \(n\). Properties of the underlying graph are related to properties of the code [90].

Defined in: Qubit stabilizer code

Referenced in: \([2^r-1,2^r-r-1,3]\) Hamming code, Dodecahedron code, Icosahedron code, Hypercube code, \([[m 2^m / (m+1), 2^m / (m+1)]]\) Khesin-Lu-Shor code, \([[54,6,5]]\) five-covered icosahedral code, Five-qubit perfect code, \([[7,1,3]]\) Steane code, \([[16,4,3]]\) dodecahedral code, \([[9,1,3]]\) Shor code

Cleaning lemma

If all logical operators act trivially on some subset of qubits in a stabilizer code, then any logical Pauli operator can be represented on the complementary qubit subset via a stabilizer. More technically, given any subset \(M\) of qubits that is correctable (under erasure), any logical Pauli operator \(P\) can be cleaned off of \(M\) using a stabilizer \(S\) such that \(PS\) is supported on \(M^{\perp}\). More generally, for any \(M\), we have \(g(M)+g(M^{\perp}) = 2k\), where \(g(M)\) is the number of logical-\(X\) and logical-\(Z\) Pauli operators supported fully on \(M\) (up to stabilizers). The Cleaning Lemma was originally proven [50], where an analogous result is states for subsystem codes; see also Ref. [92].

Defined in: Qubit stabilizer code

Referenced in: Topological code

Destabilizers

A Clifford encoding circuit maps the first \(r = n-k\) qubits to the logical qubits of the code, and the Pauli \(Z\) operators of those first \(r\) qubits are mapped into a set of stabilizer generators. The set of Pauli \(X\) operators of the first \(r\) qubits that are mapped into a set of generators for the destabilizer group [93,94]. Each such generator anticommutes with only one stabilizer generator while commuting with the rest of the stabilizer generators.

Defined in: Qubit stabilizer code

Referenced in: Dynamical automorphism (DA) code

Modular-qudit Pauli strings

For a single qudit, this set consists of products of powers of the modular-qudit Pauli matrices \(X\) and \(Z\), which act on computational basis states \(|k\rangle\) for \(k\in\mathbb{Z}_q\) as \begin{align} X\left|k\right\rangle =\left|k+1\right\rangle \,\,\text{ and }\,\,Z\left|k\right\rangle =e^{i\frac{2\pi}{q}k}\left|k\right\rangle ~, \tag*{(25)}\end{align} with addition performed modulo \(q\). For multiple qudits, error set elements are tensor products of elements of the single-qudit error set. Tensor products of \(X\) (\(Z\)) modular-qudit Paulis acting on different qudits are called \(X\)-type (\(Z\)-type) modular-qudit Pauli strings. Combining the \(X\)-type and \(Z\)-type strings with a primitive \(q\)th root of unity forms a group called the modular-qudit Pauli group (on \(n\) modular qudits.

Defined in: Modular-qudit code

Referenced in: Qubit stabilizer code, Modular-qudit stabilizer code, Subsystem modular-qudit stabilizer code

Qudit Clifford hierarchy

The modular-qudit Clifford hierarchy [57,69,70,95] is a tower of gate sets which includes modular-qudit Pauli and modular-qudit Clifford gates at its first two levels, and non-Clifford qudit gates at higher levels. The \(k\)th level is defined recursively by \begin{align} C_k = \{ U | U P U^{\dagger} \in C_{k-1} \}~, \tag*{(26)}\end{align} where \(P\) is any modular-qudit Pauli matrix, and \(C_1\) is the modular-qudit Pauli group.

Defined in: Modular-qudit code

Referenced in: Prime-qudit RM code, Prime-qudit triorthogonal code, \([[9m-k,k,2]]_3\) triorthogonal code, Modular-qudit stabilizer code, Modular-qudit color code

Modular symplectic representation

The single modular-qudit Pauli string \(X_{a} Z_{b}\) for \(a,b\in \mathbb{Z}_q\) is converted to the vector \((a|b)\in \mathbb{Z}_q^2\). The multi modular-qudit version follows naturally.

Defined in: Modular-qudit stabilizer code

Stabilizer code switching, code deformation, or update rule

Code switching is a map between stabilizer codes that is done using a stabilizer group \(\mathsf{F}\) of the \(n\)-modular-qudit Pauli group, \begin{align} \mathsf{S}\to\mathsf{N}_{\left\langle \mathsf{S},\mathsf{F}\right\rangle }\left(\mathsf{F}\right)~, \tag*{(27)}\end{align} where \(\mathsf{Z}\) denotes taking the center of a group (e.g., see [44,84] for proofs). Code switching may not preserve the logical information and instead implement logical measurements; conditions on \(\mathsf{S}\) and \(\mathsf{F}\) such that qubit stabilizer code switching preserves logical information are derived in [96; Prop. II.1]. Clifford operations and Pauli measurements can be expressed as sequences of code switching [97]. In the context of stabilizer codes realizing Abelian topological phases, code switching implements anyon condensation of any anyons represented by operators in the group \(\mathsf{F}\). Code switching can be done using only transversal gates for qubit stabilizer codes [98].

Defined in: Modular-qudit stabilizer code

Referenced in: Compactified \(\mathbb{R}\) gauge theory code, Analog surface code, \(U(1)_{2n} \times U(1)_{-2m}\) Chern-Simons GKP code, GKP-surface code, Abelian topological code, 2D lattice stabilizer code, Lattice stabilizer code, Quantum LDPC (QLDPC) code, Dynamical automorphism (DA) code, Floquet color code, \([[7,1,3]]\) Steane code, \([[10,1,2]]\) CSS code, Quantum divisible code, Qubit stabilizer code, Quantum Reed-Muller code, 2D color code, 3D color code, \([[15,1,3]]\) quantum Reed-Muller code, Kitaev surface code, Modular-qudit DA code, Double-semion stabilizer code, Abelian quantum-double stabilizer code, Modular-qudit surface code, Abelian TQD stabilizer code, \(\mathbb{Z}_q^{(1)}\) subsystem code, Chiral semion subsystem code

Symplectic doubling

Any \([[n,k,r,d]]_{\mathbb{Z}_q}\) subsystem stabilizer code can be mapped onto a \([[2n,2k,2r,\geq d]]_{\mathbb{Z}_q}\) subsystem CSS code, with the mapping preserving geometric locality of a code up to a constant factor [99] (see also [100][101; Thm. 1]). In the modular symplectic representation, the gauge-group generator matrix of the former is mapped into that of latter as follows, \begin{align} \begin{pmatrix}G_{X} & G_{Z}\end{pmatrix} \to \begin{pmatrix} 0 & 0 & G_{Z} & -G_{X}\\ G_{X} & G_{Z} & 0 & 0 \end{pmatrix}~, \tag*{(28)}\end{align} where the first two columns of the latter matrix correspond to the \(X\)-type part of the gauge-group generator matrix of the output subsystem CSS code. In the case of a stabilizer code, the stabilizer generator matrix is mapped instead to yield a two-block CSS code (see [101; Thm. 1] for the case of qubit stabilizer codes). For geometrically local 2D stabilizer codes with twist defects, this mapping yields a twisted double cover of the underlying qudit geometry [65].

Defined in: Subsystem modular-qudit CSS code

Referenced in: Qubit CSS code, Qubit stabilizer code, Twist-defect surface code, Subsystem CSS code, Subsystem qubit stabilizer code, Modular-qudit CSS code, Modular-qudit stabilizer code, Subsystem modular-qudit stabilizer code, Two-block CSS code, Generalized bicycle (GB) code

Gauge fixing

Gauge fixing is a map between subsystem codes that is done using an Abelian subgroup \(\mathsf{F}\subseteq\mathsf{G}\), \begin{align} \begin{split} \mathsf{S}&\to\left\langle \mathsf{S},\mathsf{F}\right\rangle \\ \mathsf{G}&\to\mathsf{N}_{\mathsf{G}}\left(\mathsf{F}\right)~, \end{split} \tag*{(29)}\end{align} where \(\mathsf{N}_{\mathsf{G}}\left(\mathsf{F}\right)\) is the normalizer of the stabilizer group within \(\mathsf{G}\).

Defined in: Subsystem modular-qudit stabilizer code

Gauging out

Gauging out is a map between subsystem codes that is done using a subgroup \(\mathsf{F}\subseteq\mathsf{P}_n\), \begin{align} \begin{split} \mathsf{S}&\to\mathsf{Z}\left(\left\langle \mathsf{G},\mathsf{F}\right\rangle \right)\\ \mathsf{G}&\to\left\langle \mathsf{G},\mathsf{F}\right\rangle ~. \end{split} \tag*{(30)}\end{align} The stabilizer group of the output subsystem code is a subgroup of that of the input code, \(\mathsf{Z}\left(\left\langle \mathsf{G},\mathsf{F}\right\rangle \right)\subseteq\mathsf{Z}\left(\mathsf{G}\right)\). When \(\mathsf{F}\) is a subgroup of the logical Pauli group, this is also called gauging. If \(\mathsf{F}\) is itself a Pauli group of \(m\) logical qudits of the original subsystem code, then gauging out those qudits is equivalent to treating them as gauge qubits. Gauging out should not be confused with gauging (or ungauging) symmetries [102–105], a different process rooted in gauge theory which can be done to stabilizer or subsystem codes and which can change \(n\).

Defined in: Subsystem modular-qudit stabilizer code

Referenced in: Abelian topological code, Lattice subsystem code, Spacetime circuit code, Qubit stabilizer code, \([[15, 7, 3]]\) quantum Hamming code, \([[15,1,3]]\) quantum Reed-Muller code, Kitaev surface code, Subsystem spacetime circuit code, Subsystem qubit stabilizer code, Kitaev honeycomb code, Three-fermion (3F) subsystem code, Double-semion stabilizer code, Abelian quantum-double stabilizer code, Modular-qudit surface code, \(\mathbb{Z}_q^{(1)}\) subsystem code, Chiral semion subsystem code, \(\mathbb{Z}_3\times\mathbb{Z}_9\)-fusion subsystem code

Galois-qudit Pauli strings

For a single Galois qudit, this set consists of products of \(X\)-type and \(Z\)-type operators labeled by elements \(\beta \in GF(q)\), which act on computational basis states \(|\gamma\rangle\) for \(\gamma\in GF(q)\) as \begin{align} X_{\beta}\left|\gamma\right\rangle =\left|\gamma+\beta\right\rangle \,\,\text{ and }\,\,Z_{\beta}\left|\gamma\right\rangle =e^{i\frac{2\pi}{p}\text{tr}(\beta\gamma)}\left|\gamma\right\rangle~, \tag*{(31)}\end{align} where \(\text{tr}\) is the field trace. For multiple Galois qudits, error set elements are tensor products of elements of the single-qudit error set. Tensor products of \(X\) (\(Z\)) Galois-qudit Paulis acting on different qudits are called \(X\)-type (\(Z\)-type) Galois-qudit Pauli strings. Combining the \(X\)-type and \(Z\)-type strings with a \(p\)th root of unity forms a group called the Galois-qudit Pauli group (on \(n\) Galois qudits.

Defined in: Galois-qudit code

Galois symplectic representation

The single Galois-qudit Pauli string \(X_{a} Z_{b}\) for \(a,b\in GF(q)\) is converted to the vector \((a|b)\in GF(q)^2\). The multi Galois-qudit version follows naturally.

Defined in: Galois-qudit stabilizer code

Referenced in: Dual additive code, Linear \(q\)-ary code, Modular-qudit CSS code, Modular-qudit stabilizer code, Subsystem modular-qudit CSS code, Galois-qudit CSS code, True Galois-qudit stabilizer code, Hermitian Galois-qudit code

\(GF(q^2)\) representation

An \(n\)-qubit Galois-qudit Pauli stabilizer can be represented as a length-\(n\) vector over \(GF(q^2)\) using the one-to-one correspondence between the \(q^2\) Galois-qudit Pauli matrices and elements of \(GF(q^2)\). Given a basis \((\beta,\beta^q)\) for \(GF(q^2)\) over \(GF(q)\), the vector \((a|b)\in GF(q)^2\) (representing a Galois-qudit Pauli string in the Galois symplectic representation) is in one-to-one correspondence with element \(a \beta + b \beta^q \in GF(q^2)\) [106][107; Thm. 27.3.8].

Defined in: Galois-qudit stabilizer code

Referenced in: Dual linear code, Dual additive code, Hermitian Galois-qudit code

Weight reduction

A related procedure called weight reduction [108,109] takes in a CSS stabilizer code and outputs a longer CSS code that admits a set of stabilizer generators whose weight is independent of the number of qubits \(n\).

Defined in: Distance-balanced code

Referenced in: GKP CV-cluster-state code, Quantum LDPC (QLDPC) code, Qubit stabilizer code