Welcome to the Galois-qudit Kingdom.

Galois-qudit code[1][2]
Also called a \(GF(q)\)- or \(\mathbb{F}_q\)-qudit code. Encodes \(K\)-dimensional Hilbert space into a \(q^n\)-dimensional (\(n\)-qudit) Hilbert space, with canonical qudit states \(|k\rangle\) labeled by elements \(k\) of the Galois field \(GF(q)\) and with \(q\) being a power of a prime \(p\). A Galois field can be thought of as a vector space whose basis vectors are the \(m\) roots of some polynomial and whose coefficients (i.e., field) are \(p\)th roots of unity. Codes can be denoted as \(((n,K))_{GF(q)}\) or \(((n,K,d))_{GF(q)}\), whenever the code's distance \(d\) is defined. This notation differentiates between Galois-qudit and modular-qudit codes, although the same notation, \(((n,K,d))_q\), is usually used for both.
Protection: A convenient and often considered error set is the Galois-qudit analogue of the Pauli string set for qubit codes. 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~,
\end{align}
where the trace maps elements of the field to elements of \(\mathbb{Z}_p\) as
\begin{align}
\text{tr}(\gamma)=\sum_{k=0}^{m-1}\gamma^{p^{k}}~.
\end{align}
For multiple Galois qudits, error set elements are tensor products of elements of the single-qudit error set.
Parents:
Finite-dimensional quantum error-correcting code.
Parent of:
Galois-qudit non-stabilizer code.
Cousins:
Modular-qudit code.

Galois-qudit stabilizer code[3][2]
An \(((n,K,d))_{GF(q)}\) Galois-qudit code whose logical subspace is the joint eigenspace of commuting Galois-qudit Pauli operators forming the code's stabilizer group \(\mathsf{S}\). Traditionally, the logical subspace is the joint \(+1\) eigenspace, and the stabilizer group does not contain \(e^{i \phi} I\) for any \(\phi \neq 0\). The distance \(d\) is the minimum weight of a Galois-qudit Pauli string that implements a nontrivial logical operation in the code.
Protection: Detects errors on up to \(d-1\) qudits, and corrects erasure errors on up to \(d-1\) qudits. Corrects errors on \(\left\lfloor (d-1)/2 \right\rfloor\) qudits.
Parents:
Stabilizer code, Galois-qudit non-stabilizer code.
Parent of:
Stabilizer code over \(GF(q^2)\), True Galois-qudit stabilizer code.
Cousins:
Modular-qudit stabilizer code, Additive \(q\)-ary code.

Galois-qudit non-stabilizer code[4]
The projection onto a stabilizer code is proportional to an equal sum over all elements of the stabilizer group \(\mathsf{S}\).
Non-stabilizer codes generalize stabilizer codes by modifying the code projection with elements of a subset \(\mathsf{B}\subset\mathsf{S}\) called the Fourier description (see proof of Thm. 2.7 in Ref. [4]). When \(\mathsf{B}\) is a subgroup of \(\mathsf{S}\), then the code reduces to an ordinary stabilizer code.
Parents:
Galois-qudit code.
Parent of:
Galois-qudit stabilizer code.

Stabilizer code over \(GF(q^2)\)[2]
Stub.
Parents:
Galois-qudit stabilizer code.
Cousins:
Additive \(q\)-ary code, Stabilizer code over \(GF(4)\).

True Galois-qudit stabilizer code
Also called a linear stabilizer code. A \([[n,k,d]]_{GF(q)}\) stabilizer code whose stabilizer's symplectic representation forms a linear subspace. In other words, the set of \(q\)-ary vectors representing the stabilizer group is closed under both addition and multiplication by elements of \(GF(q)\). In contrast, Galois-qudit stabilizer codes admit sets of vectors that are closed under addition only.
Protection: Detects errors on up to \(d-1\) qudits, and corrects erasure errors on up to \(d-1\) qudits.
Parents:
Galois-qudit stabilizer code.
Parent of:
Galois-qudit CSS code.
Cousins:
Linear \(q\)-ary code.

Galois-qudit CSS code[5][6]
An \([[n,k,d]]_{GF(q)} \) Galois-qudit true stabilizer code admitting a set of stabilizer generators that
are either \(Z\)-type or \(X\)-type Galois-qudit Pauli strings.
The stabilizer generator matrix, taking values from \(GF(q)\), is of the form
\begin{align}
H=\begin{pmatrix}0 & H_{Z}\\
H_{X} & 0
\end{pmatrix}
\label{eq:parityg}
\end{align}
such that the rows of the two blocks must be orthogonal
\begin{align}
H_X H_Z^T=0~.
\label{eq:commG}
\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:
True Galois-qudit stabilizer code.
Parent of:
Approximate secret-sharing code, Binary quantum Goppa code, Galois-qudit polynomial code (QPyC), Lifted-product (LP) code, Skew-cyclic CSS code.
Cousins:
Calderbank-Shor-Steane (CSS) stabilizer code, Linear \(q\)-ary code.

Approximate secret-sharing code[7]
A family of \( [[n,k,d]]_{GF(q)} \) CSS codes approximately correcting errors on up to \(\lfloor (n-1)/2 \rfloor\) qubits, i.e., with approximate distance approaching the no-cloning bound \(n/2\). Constructed using a non-degenerate CSS code, such as a polynomial quantum code, and a classical authentication scheme. The code can be viewed as an \(t\)-error tolerant secret sharing scheme. Since the code yields a small logical subspace using large registers that contain both classical and quantum information, it is not useful for practical error correction problems, but instead demonstrates the power of approximate quantum error correction.
Protection: Corrects up to \(\lfloor (n-1)/2 \rfloor\) errors with fidelity exponentially lose to 1.
Parents:
Galois-qudit CSS code.
Cousins:
Approximate quantum error-correcting code (AQECC), Galois-qudit polynomial code (QPyC), Reed-Solomon (RS) code.
Cousin of:
Three qutrit code.

Binary quantum Goppa code[8][9]
Also known as a quantum AG code. Binary quantum Goppa codes are a family of \( [[n,k,d]]_{GF(q)} \) CSS codes for \( q=2^m \), generated using classical Goppa codes.
Protection: Protects against weight \(t\) errors where \( 0 < t \leq \lfloor \frac{d^*-g-1}{2} \rfloor \) where \( d^* = \text{deg} G + 2 -2g \) and \(g\) is the genus of the function field and \(d \geq n - \lfloor \frac{deg G}{2} \rfloor\).
Parents:
Galois-qudit CSS code.
Cousins:
Goppa code.

Galois-qudit polynomial code (QPyC)[10]
Also called quantum Reed-Solomon code. An \([[n,k,n-k+1]]_{GF(q)}\) (with \(q>n\)) Galois-qudit CSS code constructed using two Reed-Solomon codes over \(GF(q)\). Let \(C_1\) be a \([n,k_1,d_1]_q\) Reed-Solomon code and \(C_2^\perp\) be a \([n,k_2,d_2]_q\) Reed-Solomon code, modified such that \(C_2^\perp \subseteq C_1\) and \(0\le k_2 \le k_1 \le n\). Then, a polynomial code is a non-degenerate \([[n,k_2,d]]_{GF(q)}\) Galois-qudit CSS code with \(d=\min(n-k_1+1,k_1-k_2+1)\). The polynomial code is the span of the basis codewords over GF(\(q\)) \begin{align} |\overline{\beta_0,\cdots,\beta_{k_2-1}}\rangle = \sum_{(\beta_{k_2},\cdots,\beta_{k_1-1})\in GF(q) } \bigotimes_{i=1}^{n} \left|\sum_{j=0}^{k_1-1} \beta_j \alpha_i^j \right\rangle, \end{align} where \((\alpha_1, \cdots, \alpha_n)\) are \(n\) distinct points chosen for code \(C_1\) from \(GF(q)\setminus \{0\}\).
Parents:
Galois-qudit CSS code.
Cousins:
Prime-qudit polynomial code (QPyC), Reed-Solomon (RS) code, Cyclic code, Quantum maximum-distance-separable (MDS) code.
Cousin of:
Approximate secret-sharing code.

Lifted-product (LP) code[11][12]
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 [13].
Parents:
Balanced product code, Galois-qudit CSS code.
Parent of:
Expander lifted-product code, Hypergraph product code.
Cousins:
Kitaev surface code, Haah cubic code.

Expander lifted-product code[12]
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 [12].
Protection: Code performance strongly depends on \(G\). Certain nonabelian groups yield asymptotically good QLDPC codes with parameters \([[n, k = \Theta(n), d = \Theta(n)]]\) [12]. 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)]]\) [13]; this construction can be derandomized by being reformulated as a balanced product code [15].
Parents:
Lifted-product (LP) code.
Cousins:
Tanner code, Random code.
Cousin of:
Quantum Tanner code.

Hypergraph product code[16][17]
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, XYZ product code.

Quantum expander code[18]
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.

## References

- [1]
- J. Bierbrauer and Y. Edel, “Quantum twisted codes”, Journal of Combinatorial Designs 8, 174 (2000). DOI
- [2]
- Avanti Ketkar et al., “Nonbinary stabilizer codes over finite fields”. quant-ph/0508070
- [3]
- Alexei Ashikhmin and Emanuel Knill, “Nonbinary Quantum Stabilizer Codes”. quant-ph/0005008
- [4]
- V. Arvind, Piyush P Kurur, and K. R. Parthasarathy, “Nonstabilizer Quantum Codes from Abelian Subgroups of the Error Group”. quant-ph/0210097
- [5]
- M. GRASSL, T. BETH, and M. RÖTTELER, “ON OPTIMAL QUANTUM CODES”, International Journal of Quantum Information 02, 55 (2004). DOI; quant-ph/0312164
- [6]
- J.-L. Kim and J. Walker, “Nonbinary quantum error-correcting codes from algebraic curves”, Discrete Mathematics 308, 3115 (2008). DOI
- [7]
- Claude Crepeau, Daniel Gottesman, and Adam Smith, “Approximate Quantum Error-Correcting Codes and Secret Sharing Schemes”. quant-ph/0503139
- [8]
- Annika Niehage, “Quantum Goppa Codes over Hyperelliptic Curves”. quant-ph/0501074
- [9]
- A. Niehage, “Nonbinary Quantum Goppa Codes Exceeding the Quantum Gilbert-Varshamov Bound”, Quantum Information Processing 6, 143 (2006). DOI
- [10]
- Dorit Aharonov and Michael Ben-Or, “Fault-Tolerant Quantum Computation With Constant Error Rate”. quant-ph/9906129
- [11]
- P. Panteleev and G. Kalachev, “Degenerate Quantum LDPC Codes With Good Finite Length Performance”, Quantum 5, 585 (2021). DOI; 1904.02703
- [12]
- Pavel Panteleev and Gleb Kalachev, “Asymptotically Good Quantum and Locally Testable Classical LDPC Codes”. 2111.03654
- [13]
- P. Panteleev and G. Kalachev, “Quantum LDPC Codes With Almost Linear Minimum Distance”, IEEE Transactions on Information Theory 68, 213 (2022). DOI; 2012.04068
- [14]
- H. Q. Dinh et al., “A class of skew cyclic codes and application in quantum codes construction”, Discrete Mathematics 344, 112189 (2021). DOI
- [15]
- N. P. Breuckmann and J. N. Eberhardt, “Balanced Product Quantum Codes”, IEEE Transactions on Information Theory 67, 6653 (2021). DOI; 2012.09271
- [16]
- 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
- [17]
- 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
- [18]
- 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