diff --git a/codes/quantum/qubits/stabilizer/qubit_stabilizer.yml b/codes/quantum/qubits/stabilizer/qubit_stabilizer.yml index 72a494fa6..aa10d7305 100644 --- a/codes/quantum/qubits/stabilizer/qubit_stabilizer.yml +++ b/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}.' diff --git a/codes/quantum/qubits/stabilizer/stabilizer_over_gf4.yml b/codes/quantum/qubits/stabilizer/stabilizer_over_gf4.yml index dc3478b2a..d78400996 100644 --- a/codes/quantum/qubits/stabilizer/stabilizer_over_gf4.yml +++ b/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 diff --git a/codes/quantum/qubits/subsystem/subsystem_stabilizer.yml b/codes/quantum/qubits/subsystem/subsystem_stabilizer.yml index db2292638..4548cd26b 100644 --- a/codes/quantum/qubits/subsystem/subsystem_stabilizer.yml +++ b/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 diff --git a/codes/quantum/qudits_galois/evaluation/galois_bch.yml b/codes/quantum/qudits_galois/evaluation/galois_bch.yml index c23f7d621..947c5523c 100644 --- a/codes/quantum/qudits_galois/evaluation/galois_bch.yml +++ b/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 diff --git a/codes/quantum/qudits_galois/evaluation/galois_grs.yml b/codes/quantum/qudits_galois/evaluation/galois_grs.yml index 481c34267..5fba1ac6c 100644 --- a/codes/quantum/qudits_galois/evaluation/galois_grs.yml +++ b/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 diff --git a/codes/quantum/qudits_galois/stabilizer/galois_stabilizer.yml b/codes/quantum/qudits_galois/stabilizer/galois_stabilizer.yml index 17d27e770..d4afd5814 100644 --- a/codes/quantum/qudits_galois/stabilizer/galois_stabilizer.yml +++ b/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}. diff --git a/codes/quantum/qudits_galois/stabilizer/galois_true_stabilizer.yml b/codes/quantum/qudits_galois/stabilizer/galois_true_stabilizer.yml index e2b45f2cf..ecb722ae7 100644 --- a/codes/quantum/qudits_galois/stabilizer/galois_true_stabilizer.yml +++ b/codes/quantum/qudits_galois/stabilizer/galois_true_stabilizer.yml @@ -16,10 +16,8 @@ description: | The number of generators \(r\) for a true stabilizer code is a multiple of \(m\) (recall that \(q=p^m\) for Galois qudits). As a result, the number \(k=n-r/m\) of logical qudits is an integer. - 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. + Each code can be represented by a stabilizer generator matrix \(H=(A|B)\), where each row \((a|b)\) is the Galois symplectic representation of a stabilizer generator. - A Hermitian self-orthogonal linear \([n,k,d]_{q^2}\) code can be used to construct an \([[n,n-2k]]_q\) true stabilizer code with distance no less than \(d\). - This \textit{Hermitian construction} was first proven via the symplectic representation (showing self-orthogonality under the trace-symplectic inner product; see Ref. \cite{doi:10.1109/18.959288}, Corr. 1), and later proven via the \hyperref[code:stabilizer_over_gfqsq]{stabilizer-over-\(GF(q^2)\)} construction (showing self-orthogonality under the trace-alternating inner product; see Ref. \cite{arxiv:quant-ph/0508070}, Corr. 19). There is an isomorphism between the symplectic and stabilizer-over-\(GF(q^2)\) representations \cite[Thm. 27.3.8]{preset:HKSquantum}. The Hermitian construction has been extended to \(q^{2m}\)-ary Hermitian self-orthogonal linear codes \cite{arxiv:2012.11998} and similar constructions exist \cite{arxiv:1002.4088}. # Many quantum codes have been constructed this way (e.g., see Refs. \cite{doi:10.1142/S0219749919500060,doi:10.26421/QIC13.1-2-3,doi:10.1007/s11128-020-02921-0,arxiv:1507.08355,arxiv:1604.05823,arXiv:2007.13309}). # Since classical length-\(n\) Hermitian self-orthogonal linear codes over \(GF(q^2)\) can be converted into length-\(2n\) symplectic self-orthogonal linear codes over \(GF(q)\) (\cite{doi:10.1002/(SICI)1520-6610(2000)8:3<174::AID-JCD3>3.0.CO;2-T}, Thm. 1), and since symplectic self-orthogonal codes are also trace-symplectic self-orthogonal, @@ -36,12 +34,6 @@ relations: cousins: - code_id: q-ary_linear detail: 'A true Galois-qudit stabilizer code is the closest quantum analogue of a linear code over \(GF(q)\) because the \(q\)-ary vectors corresponding to the symplectic representation of the stabilizers form a linear subspace.' - - code_id: dual - detail: 'Hermitian self-orthogonal linear codes over \(GF(q^2)\) yield true stabilizer codes via either the symplectic representation (showing self-orthogonality under the trace-symplectic inner product; see Ref. \cite{doi:10.1109/18.959288}, Corr. 1) or the \hyperref[code:stabilizer_over_gfqsq]{stabilizer-over-\(GF(q^2)\)} construction (showing self-orthogonality under the trace-alternating inner product; see \cite[Corr. 19]{arxiv:quant-ph/0508070}\cite[Thm. 27.3.8]{preset:HKSquantum}.' - - code_id: quantum_mds - detail: 'Many MDS codes are constructed from Hermitian self-orthogonal codes over \(GF(q^2)\) using the Hermitian construction \cite{arxiv:quant-ph/0312164,arxiv:0906.2509,arxiv:1507.08355,arxiv:1803.07927}, in particular from cyclic \cite{doi:10.1109/TIT.2011.2159039}, constacyclic \cite{doi:10.1109/TIT.2014.2308180,doi:10.1109/TIT.2015.2388576} and negacyclic \cite{doi:10.1109/TIT.2012.2220519} codes.' - - code_id: matrix_product - detail: 'Hermitian self-orthogonal matrix-product codes over \(GF(q^2)\) can be used to construct true stabilizer codes \cite{doi:10.1007/s11128-020-02921-0,arxiv:1604.05823}.' # - code_id: constacyclic # detail: 'The stabilizer-over-\(GF(q^2)\) can yield quantum MDS codes from Hermitian self-orthogonal constacyclic codes \cite{arxiv:1803.07927}.' diff --git a/codes/quantum/qudits_galois/stabilizer/stabilizer_over_gfqsq.yml b/codes/quantum/qudits_galois/stabilizer/stabilizer_over_gfqsq.yml index 188a61c61..71a3984f1 100644 --- a/codes/quantum/qudits_galois/stabilizer/stabilizer_over_gfqsq.yml +++ b/codes/quantum/qudits_galois/stabilizer/stabilizer_over_gfqsq.yml @@ -10,23 +10,45 @@ logical: galois name: 'Stabilizer code over \(GF(q^2)\)' introduced: '\cite{arXiv:quant-ph/0508070}' +alternative_names: + - 'Hermitian-construction code' + description: | - An \([[n,k,d]]_q\) Galois-qudit stabilizer code constructed from a classical code over \(GF(q^2)\) using the one-to-one correspondence between the Galois-qudit Pauli matrices and elements of the Galois field \(GF(q^2)\). + An \([[n,k,d]]_q\) true Galois-qudit stabilizer code constructed from a Hermitian self-orthogonal linear code over \(GF(q^2)\) using the one-to-one correspondence between the Galois-qudit Pauli matrices and elements of the Galois field \(GF(q^2)\). + + Galois-qudit stabilizer codes are 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}. + Hermitian self-orthogonal linear codes over \(GF(q^2)\) are automatically trace-alternating self-orthogonal, and applying this construction to such codes yields stabilizer codes over \(GF(q^2)\) \cite[Corr. 19]{arxiv:quant-ph/0508070}. + A Hermitian self-orthogonal linear \([n,k,d]_{q^2}\) code yields an \([[n,n-2k]]_q\) true stabilizer code with distance no less than \(d\); this is called the \textit{Hermitian construction}. + + The Hermitian construction was first proven via the symplectic representation (showing self-orthogonality under the trace-symplectic inner product; see Ref. \cite{doi:10.1109/18.959288}, Corr. 1), and later proven via the \hyperref[code:stabilizer_over_gfqsq]{stabilizer-over-\(GF(q^2)\)} construction (showing self-orthogonality under the trace-alternating inner product; see Ref. \cite{arxiv:quant-ph/0508070}, Corr. 19). + There is an isomorphism between the symplectic and stabilizer-over-\(GF(q^2)\) representations \cite[Thm. 27.3.8]{preset:HKSquantum}. + + It has also been extended to \(q^{2m}\)-ary Hermitian self-orthogonal linear codes \cite{arxiv:2012.11998}, and similar constructions were formulated in Ref. \cite{arxiv:1002.4088}. - An \(n\) Galois-qudit Pauli stabilizer can be represented as a length-\(n\) vector over \(GF(q^2)\). The stabilizer commutation condition corresponds to a zero trace-alternating inner product between the corresponding vectors. Stabilizer codes over \(GF(q^2)\) can thus be constructed from classical trace-alternating self-orthogonal additive codes over \(GF(q^2)\) \cite{arXiv:quant-ph/0508070}. - Hermitian self-orthogonal linear codes over \(GF(q^2)\) are automatically trace-alternating self-orthogonal, and applying this construction to such codes yields a class of true stabilizer codes. +# An \(n\) Galois-qudit Pauli stabilizer can be represented as a length-\(n\) vector over \(GF(q^2)\). The stabilizer commutation condition corresponds to a zero trace-alternating inner product between the corresponding vectors. # The classical code corresponds to the stabilizer group \(\mathsf{S}\) while \(C^{\perp}\) corresponds to the normalizer \(\mathsf{N(S)}\). relations: parents: - code_id: galois_true_stabilizer - detail: 'Trace-alternating self-orthogonal linear codes over \(GF(q^2)\) are equivalent to a class of true stabilizer codes \cite{preset:GottesmanBook}. Hermitian self-orthogonal linear codes over \(GF(q^2)\) are automatically trace-alternating self-orthogonal and can be used to construct true stabilizer codes via the \hyperref[code:stabilizer_over_gfqsq]{stabilizer-over-\(GF(q^2)\)} construction (\cite{arxiv:quant-ph/0508070}, Corr. 19).' + detail: 'Stabilizer code over \(GF(q^2)\) are true stabilizer codes because they are based on Hermitian self-orthogonal linear (as opposed to additive) codes over \(GF(q^2)\).' cousins: - - code_id: dual_additive - detail: 'The stabilizer commutation condition for stabilizer codes over \(GF(q^2)\) can equivalently be stated in the representation of stabilizers as vectors over \(GF(q^2)\). - A pair of \(n\) Galois-qudit stabilizers commute iff the trace-alternating inner product of their their corresponding vectors is zero. - Stabilizer codes over \(GF(q^2)\) can thus be constructed from trace-alternating self-orthogonal additive codes over \(GF(q^2)\).' + - code_id: dual + detail: 'Stabilizer codes over \(GF(q^2)\) are constructed from Hermitian self-orthogonal linear codes over \(GF(q^2)\) via the \hyperref[topic:gfqsq-representation]{\(GF(q^2)\) representation}.' + - code_id: quantum_mds + detail: 'Many MDS codes are constructed from Hermitian self-orthogonal codes over \(GF(q^2)\) using the Hermitian construction \cite{arxiv:quant-ph/0312164,arxiv:0906.2509,arxiv:1507.08355,arxiv:1803.07927}, in particular from cyclic \cite{doi:10.1109/TIT.2011.2159039}, constacyclic \cite{doi:10.1109/TIT.2014.2308180,doi:10.1109/TIT.2015.2388576} and negacyclic \cite{doi:10.1109/TIT.2012.2220519} codes.' + - code_id: matrix_product + detail: 'Hermitian self-orthogonal matrix-product codes over \(GF(q^2)\) can be used to construct stabilizer codes over \(GF(q^2)\) \cite{doi:10.1007/s11128-020-02921-0,arxiv:1604.05823}.' + - code_id: galois_subsystem_stabilizer + detail: 'The Hermitian construction has been extended to subsystem Galois-qudit stabilizer codes \cite{arxiv:quant-ph/0610153}.' + + + +# - code_id: dual_additive +# detail: 'The stabilizer commutation condition for stabilizer codes over \(GF(q^2)\) can equivalently be stated in the representation of stabilizers as vectors over \(GF(q^2)\). +# A pair of \(n\) Galois-qudit stabilizers commute iff the trace-alternating inner product of their their corresponding vectors is zero. +# Stabilizer codes over \(GF(q^2)\) can thus be constructed from trace-alternating self-orthogonal additive codes over \(GF(q^2)\).' # Begin Entry Meta Information diff --git a/codes/quantum/qudits_galois/subsystem/galois_subsystem_css.yml b/codes/quantum/qudits_galois/subsystem/galois_subsystem_css.yml index 8f783960d..146ffdf82 100644 --- a/codes/quantum/qudits_galois/subsystem/galois_subsystem_css.yml +++ b/codes/quantum/qudits_galois/subsystem/galois_subsystem_css.yml @@ -16,7 +16,7 @@ alternative_names: description: | Galois-qudit subsystem stabilizer code which admits a set of gauge-group generators which consist of either all-\(Z\) or all-\(X\) Galois-qudit Pauli strings. - These codes can be constructed from classical codes via a generalization of the CSS construction or the Hermitian construction \cite{arxiv:quant-ph/0604161,arxiv:quant-ph/0610153}. + These codes can be constructed from classical codes via a subsystem generalization of the CSS construction or the Hermitian construction \cite{arxiv:quant-ph/0604161,arxiv:quant-ph/0610153}. relations: parents: @@ -24,6 +24,8 @@ relations: cousins: - code_id: galois_css detail: 'Subsystem Galois-qudit CSS codes reduce to (subspace) Galois-qudit CSS codes when there is no gauge subsystem.' + - code_id: stabilizer_over_gfqsq + detail: 'Subsystem Galois-qudit codes constructed using the subsystem generalization of the Hermitian construction reduce to (subspace) stabilizer codes over \(GF(q^2)\) when there is no gauge subsystem.' # Begin Entry Meta Information