Hermitian construction = stabilizer over GF(q^2)

codes/quantum/qubits/stabilizer/qubit_stabilizer.yml

@@ -15,19 +15,34 @@ description: |
 
   \begin{defterm}{Binary symplectic representation}
   \label{topic:binary-symplectic-representation}
+  In the binary 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.
+  \end{defterm}
+
   Each stabilizer code can be represented by a \((n-k) \times 2n\) \textit{check matrix} (a.k.a. \textit{stabilizer generator matrix}) \(H=(A|B)\), where each row \((a|b)\) is the binary symplectic representation of an element from a set of generating elements of the stabilizer group.
-  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.
   The check matrix can be brought into standard form via Gaussian elimination \cite{doi:10.1017/CBO9780511976667}.
-  \end{defterm}
 
-  The stabilizer commutation condition can equivalently be stated in the symplectic representation. A pair of \(n\)-qubit stabilizers with symplectic representations \((a|b)\) and \((a^{\prime}|b^{\prime})\) commute iff their symplectic inner product is zero,
+  A pair of \(n\)-qubit stabilizers with symplectic representations \((a|b)\) and \((a^{\prime}|b^{\prime})\) commute iff their symplectic inner product is zero,
   \begin{align}
     a \cdot b^{\prime} + a^{\prime}\cdot b = \sum_{j=1}^{n} a_j b^{\prime}_j + a^{\prime}_i b_i = 0~.
   \end{align}
-  Binary symplectic representations of stabilizer group elements thus form a self-orthogonal subspace of \(GF(2)^{2n}\) with respect to the symplectic inner product.
+  The set of all binary symplectic vectors form a symplectic self-orthogonal binary linear code of length \(2n\).
+
+  Another correspondence between qubit Pauli matrices and elements of the Galois field \(GF(4)\) yields the one-to-one correspondence between qubit stabilizer codes and trace-Hermitian self-orthogonal additive quaternary codes.
+
+  \begin{defterm}{\(GF(4)\) representation}
+  \label{topic:gf4-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,\alpha^2,\alpha\}\) of the quaternary field \(GF(4)\).
+  \end{defterm}
+
+  The sets of \(GF(4)\)-represented vectors for all generators yield a trace-Hermitian self-orthogonal additive quaternary code.
+  This classical code corresponds to the stabilizer group \(\mathsf{S}\) while its trace-Hermitian dual corresponds to the normalizer \(\mathsf{N(S)}\).
 
   Alternative representations include the \textit{decoupling representation}, in which Pauli strings are represented as vectors over \(GF(2)\) using three bits \cite{arxiv:2305.17505}, or the representation over \(GF(4)\) (see stabilizer codes over \(GF(4)\)).
 
+# More technically, let \(\phi\) be a bijection from a linear binary subspace to \(GF(4)^n\). Let \(C\) be a trace-Hermitian self-orthogonal additive subcode over \(GF(4)\), containing \(2^{n-k}\) vectors, such that there are no vectors of weight less than \(d\) in \(C^{\perp}\setminus C\). Then, any eigenspace of the inverse map \(\phi^{-1}(C)\) is an \([[n, k, d]]\) stabilizer code over \(GF(4)\).
+
 
 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 Pauli 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}}\).
@@ -54,6 +69,7 @@ features:
     - 'Generalized belief propagation (GBP) \cite{arxiv:2212.03214} based on a classical version \cite{manual:{J. S. Yedidia, W. T. Freeman, and Y. Weiss, Generalized belief propagation, in NIPS, Vol. 13 (2000) pp. 689–695.}}.'
 
   fault_tolerance:
+    - 'Characterizing fault-tolerant multi-qubit gates under the \hyperref[topic:gf4-representation]{\(GF(4)\) representation} may involve characterizing all global automorphisms of some number of copies of a code that preserve the symplectic inner product \cite[pg. 9]{arxiv:quant-ph/9703048}.'
     - 'Logical Bell measurements can be done transversally, and thus fault tolerantly, by performing bitwise Bell measurements for each pair of qubits (with each member of the pair taken from one of the two code blocks) and processing the result.'
     - 'With pieceable fault-tolerance, any nondegenerate stabilizer code with a complete set of fault-tolerant single-qubit Clifford gates has a universal set of non-transversal fault-tolerant gates \cite{arXiv:1603.03948}.'
     - 'Fault-tolerant error correction scheme by Shor \cite{arXiv:quant-ph/9605011}, which is based on repeated measurements. A modification uses adaptive measurements \cite{arxiv:2208.05601}.'
@@ -98,7 +114,9 @@ relations:
       Any binary linear code can be thought of as a qubit stabilizer code with \(Z\)-type stabilizer generators \cite[Table I]{arxiv:quant-ph/0610088}.
       The stabilizer generators are extracted from rows of the parity-check matrix, while logical \(X\) Paulis correspond to rows of the generator matrix.'
     - code_id: dual
-      detail: 'Binary symplectic representations of stabilizer group elements form a linear code over \(GF(2)\) that is self-orthogonal with respect to the symplectic inner product \cite[Thm. 27.3.6]{preset:HKSquantum}.'
+      detail: 'Qubit stabilizer codes are in one-to-one correspondence with symplectic self-orthogonal binary linear codes of length \(2n\) via the \hyperref[topic:binary-symplectic-representation]{binary symplectic representation}.'
+    - code_id: dual_additive
+      detail: 'Qubit stabilizer codes are in one-to-one correspondence with trace-Hermitian self-orthogonal additive quaternary codes of length \(n\) via the \hyperref[topic:gf4-representation]{\(GF(4)\) representation}.'
     - code_id: single_shot
       detail: 'Any stabilizer code can be single shot if sufficiently non-local high-weight stabilizer generators are used for syndrome measurements.  These can be obtained with a Gaussian elimination procedure \cite{arxiv:1805.09271}.'
 

codes/quantum/qubits/stabilizer/stabilizer_over_gf4.yml

@@ -10,24 +10,17 @@ logical: qubits
 name: 'Stabilizer code over \(GF(4)\)'
 introduced: '\cite{arXiv:quant-ph/9608006}'
 
-description: |
-  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)\).
-
-  An \(n\)-qubit Pauli stabilizer can be represented as a length-\(n\) quaternary vector. The stabilizer commutation condition corresponds to a zero trace-Hermitian inner product between the corresponding vectors. Stabilizer codes over \(GF(4)\) can thus be constructed from classical trace-Hermitian self-orthogonal additive quaternary codes and Hermitian self-orthogonal linear quaternary codes (since the latter are automatically trace-Hermitian self-orthogonal).
-  The classical code corresponds to the stabilizer group \(\mathsf{S}\) while its trace-Hermitian dual corresponds to the normalizer \(\mathsf{N(S)}\).
+alternative_names:
+  - 'Hermitian-construction qubit code'
 
-  Stabilizer codes over \(GF(4)\) can be constructed as follows. Let \(\phi\) be a bijection from a linear binary subspace to \(GF(4)^n\). Let \(C\) be a trace-Hermitian self-orthogonal additive subcode over \(GF(4)\), containing \(2^{n-k}\) vectors, such that there are no vectors of weight less than \(d\) in \(C^{\perp}\setminus C\). Then, any eigenspace of the inverse map \(\phi^{-1}(C)\) is an \([[n, k, d]]\) stabilizer code over \(GF(4)\).
+description: |
+  An \([[n,k,d]]\) stabilizer code constructed from a Hermitian self-orthogonal linear quaternary 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)\).
 
+  Stabilizer codes over \(GF(4)\) are in one-to-one correspondence with trace-Hermitian self-orthogonal additive codes via the \hyperref[topic:gf4-representation]{\(GF(4)\) representation}.
   Quaternary linear codes are Hermitian self-orthogonal (self-dual) iff they are trace-Hermitian self-orthogonal (self-dual) additive \cite[Thm. 27.4.1]{preset:HKSquantum} (\cite[Thm. 9.10.3]{doi:10.1017/CBO9780511807077}).
   In other words, if the underlying quaternary code is linear, then the extra trace operation can be removed from the definition of inner product.
 
 
-features:
-  fault_tolerance:
-    - 'Characterizing fault-tolerant multi-qubit gates may involve characterizing all global automorphisms of some number of copies of a code that preserve the symplectic inner product \cite[pg. 9]{arxiv:quant-ph/9703048}.'
-
-protection: 'Detects errors on \(d-1\) qubits, corrects errors on \(\left\lfloor (d-1)/2 \right\rfloor\) qubits.'
-
 notes:
   - 'Tables of \([[n,0,d]]\) codes, corresponding to a self-dual \(GF(4)\) representation, at \href{http://www.ii.uib.no/~larsed/vncorbits/}{this website}.'
 
@@ -37,10 +30,8 @@ relations:
     - code_id: stabilizer_over_gfqsq
       detail: 'Stabilizer codes over \(GF(q^2)\) for \(q=2\) are stabilizer codes over \(GF(4)\).'
   cousins:
-    - code_id: dual_additive
-      detail: 'The stabilizer commutation condition for stabilizer codes over \(GF(4)\) can equivalently be stated in the representation of stabilizers as quaternary vectors.
-      A pair of \(n\)-qubit stabilizers commute iff the trace-Hermitian inner product of their corresponding vectors is zero.
-      Stabilizer codes over \(GF(4)\) can thus be constructed from trace-Hermitian self-orthogonal additive quaternary codes.'
+    - code_id: dual
+      detail: 'Stabilizer codes over \(GF(4)\) are constructed from Hermitian self-orthogonal linear codes over \(GF(4)\) via the \hyperref[topic:gf4-representation]{\(GF(4)\) representation}.'
 
 
 # Begin Entry Meta Information

codes/quantum/qubits/subsystem/subsystem_stabilizer.yml

@@ -58,9 +58,9 @@ relations:
     - code_id: qubit_stabilizer
       detail: 'Subsystem stabilizer codes reduce to stabilizer codes when there are no gauge qubits.'
     - code_id: q-ary_bch
-      detail: 'BCH codes yield subsystem stabilizer codes via the subsystem extension of the Hermitian construction \cite[Exam. 1]{arxiv:quant-ph/0610153}.'
+      detail: 'BCH codes yield subsystem stabilizer codes via the subsystem extension of the Hermitian construction to subsystem codes \cite[Exam. 1]{arxiv:quant-ph/0610153}.'
     - code_id: reed_solomon
-      detail: 'Primitive RS codes yield subsystem stabilizer codes via the subsystem extension of the Hermitian construction \cite[Exam. 3]{arxiv:quant-ph/0610153}.'
+      detail: 'Primitive RS codes yield subsystem stabilizer codes via the subsystem extension of the Hermitian construction to subsystem codes \cite[Exam. 3]{arxiv:quant-ph/0610153}.'
 
 
 # Begin Entry Meta Information

codes/quantum/qudits_galois/evaluation/galois_bch.yml

@@ -21,11 +21,13 @@ notes:
 relations:
   parents:
     - code_id: galois_true_stabilizer
-      detail: 'Galois-qudit BCH codes constructed via the CSS construction are Galois-qudit CSS codes, and the rest are true stabilizer codes.'
+      detail: 'Galois-qudit BCH codes constructed via the CSS construction are Galois-qudit CSS codes, and those constructed via the Hermitian construction are stabilizer codes over \(GF(q^2)\).'
   cousins:
     - code_id: q-ary_bch
     - code_id: galois_css
-      detail: 'Some Galois-qudit BCH codes are CSS.'
+      detail: 'Galois-qudit BCH codes constructed via the CSS construction are Galois-qudit CSS codes.'
+    - code_id: stabilizer_over_gfqsq
+      detail: 'Galois-qudit BCH codes constructed via the Hermitian construction are stabilizer codes over \(GF(q^2)\).'
 
 
 # Begin Entry Meta Information

codes/quantum/qudits_galois/evaluation/galois_grs.yml

@@ -17,14 +17,15 @@ description: |
 relations:
   parents:
     - code_id: galois_true_stabilizer
-      detail: 'Galois-qudit GRS codes constructed via the CSS construction are Galois-qudit CSS codes, and the rest are true stabilizer codes.'
+      detail: 'Galois-qudit GRS codes constructed via the CSS construction are Galois-qudit CSS codes, and those constructed via the Hermitian construction are stabilizer codes over \(GF(q^2)\).'
   cousins:
     - code_id: generalized_reed_solomon
-      detail: 'Hermitian self-orthogonal GRS codes are used to construct Galois-qudit GRS codes in the Hermitian construction.'
     - code_id: quantum_mds
       detail: 'Some Galois-qudit GRS codes are quantum MDS \cite{arxiv:1311.3009}.'
     - code_id: galois_css
-      detail: 'Some Galois-qudit GRS codes are CSS.'
+      detail: 'Galois-qudit GRS codes constructed via the CSS construction are Galois-qudit CSS codes.'
+    - code_id: stabilizer_over_gfqsq
+      detail: 'Galois-qudit GRS codes constructed via the Hermitian construction are stabilizer codes over \(GF(q^2)\).'
 
 
 # Begin Entry Meta Information

codes/quantum/qudits_galois/stabilizer/galois_stabilizer.yml

@@ -15,13 +15,30 @@ description: |
 
   A Galois-qudit stabilizer code encoding an integer number of qudits (\(K=q^k\)) is denoted as \([[n,k]]_q\) or \([[n,k,d]]_q\). This notation differentiates between Galois-qudit and modular-qudit \([[n,k,d]]_{\mathbb{Z}_q}\) stabilizer codes, although the same notation is usually used for both. Galois-qudit stabilizer codes need not encode an integer number of qudits, with \(K=q^{n-\frac{r}{m}}\), where \(r\) is the number of generators of the stabilizer group, and \(q=p^m\) given prime \(p\) for all Galois qudits. As a result, \([[n,k,d]]\) notation is often used with non-integer \(k=\log_q K\).
 
-  The stabilizer commutation condition can equivalently be stated in the symplectic representation. A pair of Galois-qudit stabilizers on \(n\) Galois qudits with symplectic representation vectors \((a|b)\) and \((a^{\prime}|b^{\prime})\) commute iff their \textit{trace symplectic inner product} is zero,
+  \begin{defterm}{Galois symplectic representation}
+  \label{topic: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\).
+  The multi Galois-qudit version follows naturally.
+  \end{defterm}
+
+  A pair of Galois-qudit stabilizers on \(n\) Galois qudits with symplectic representation vectors \((a|b)\) and \((a^{\prime}|b^{\prime})\) commute iff their \textit{trace symplectic inner product} is zero,
   \begin{align}
   \text{tr}(a \cdot b^{\prime} - a^{\prime}\cdot b) = \sum_{j=1}^{n} \text{tr}(a_j b^{\prime}_j - a^{\prime}_i b_i) = 0~.
   \end{align}
-  Symplectic representations of stabilizer group elements thus form a self-orthogonal subspace of \(GF(q)^{2n}\) with respect to the trace-symplectic inner product.
+  Symplectic representations of stabilizer group elements form a trace-symplectic self-orthogonal linear code over \(GF(q)^{2n}\).
+  The trace-symplectic inner product reduces to the \textit{symplectic inner product} when the trace is removed, and a symplectic self-orthogonal set of vectors is automatically trace-symplectic self-orthogonal.
+
+  Another correspondence between Galos-qudit Pauli matrices and elements of the Galois field \(GF(q^2)\) yields the one-to-one correspondence between Galois-qudit stabilizer codes and trace-alternating self-orthogonal additive codes over \(GF(q^2)\) \cite{arXiv:quant-ph/0508070}.
+
+  \begin{defterm}{\(GF(q^2)\) representation}
+  \label{topic:gfqsq-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)\).
+  \end{defterm}
+
+  The sets of \(GF(q^2)\)-represented vectors for all generators yield a trace-alternating self-orthogonal additive code over \(GF(q^2)\).
 
-  Note that the above trace-symplectic inner product reduces to the \textit{symplectic inner product} when the trace is removed, and a symplectic self-orthogonal set of vectors is automatically trace-symplectic self-orthogonal. More generally, any additive classical code whose self-orthogonality under some inner product (such as Hermitian, Euclidean, or symplectic) implies trace-symplectic self-orthogonality of an equivalent code can be used to construct a Galois-qudit stabilizer code (see children).
+
+# More generally, any additive classical code whose self-orthogonality under some inner product (such as Hermitian, Euclidean, or symplectic) implies trace-symplectic self-orthogonality of an equivalent code can be used to construct a Galois-qudit stabilizer code (see children).
 
 #  Each code can be represented by a stabilizer generator matrix \(H=(A|B)\), where each row \((a|b)\) is the \(GF(q)\)-valued symplectic representation of a stabilizer generator. # Leonid comment: "Usually, if the group is additive, we have to list all generators explicitly.  But if it is linear over some field F (subfield of F_q or F_q itself) we may list the generators as would be expected for that group -fewer of them, as the number of generators is the rank of the matrix over that field (or additive rank).  All may have different values.  I think the explicit specification is needed to reduce any confusion."
 
@@ -57,8 +74,11 @@ relations:
     - code_id: q-ary_additive
       detail: 'Galois-qudit stabilizer codes are the closest quantum analogues of additive codes over \(GF(q)\) because addition in the field corresponds to multiplication of stabilizers in the quantum case.'
     - code_id: dual_additive
-      detail: 'An additive code of length \(2n\) over \(GF(q)\) that is self-orthogonal with respect to the trace-symplectic inner product corresponds to symplectic representations of an \(n\) Galois-qudit stabilizer group \cite{doi:10.1109/18.959288}.
-      Moreover, any additive code whose self-orthogonality under some inner product (such as Hermitian, Euclidean, or symplectic) implies trace-symplectic self-orthogonality of an equivalent code can be used to construct a Galois-qudit stabilizer code.'
+      detail: 'Galois-qudit stabilizer codes are in one-to-one correspondence with trace-symplectic self-orthogonal additive codes of length \(2n\) over \(GF(q)\) via the \hyperref[topic:galois-symplectic-representation]{Galois symplectic representation} \cite{doi:10.1109/18.959288}.
+      They are also in one-to-one correspondence with trace-alternating self-orthogonal additive codes of length \(n\) over \(GF(q^2)\) via the \hyperref[topic:gfqsq-representation]{\(GF(q^2)\) representation}.'
+
+# Moreover, any additive code whose self-orthogonality under some inner product (such as Hermitian, Euclidean, or symplectic) implies trace-symplectic self-orthogonality of an equivalent code can be used to construct a Galois-qudit stabilizer code.
+
 #For example, an additive code of length \(n\) over \(GF(q^2)\) that is self-orthogonal with respect to the trace-alternating inner product corresponds to \hyperref[code:stabilizer_over_gfqsq]{stabilizer-over-\(GF(q^2)\)} representations of an \(n\) Galois-qudit stabilizer group \cite{arxiv:quant-ph/0508070}.