Constructing Quantum Codes
A quantum code of length \(n\) over \(GF(q)\) is defined in terms of a symplectic self-orthogonal stabilizer code, which is given either as a length \(n\) additive code over \(GF(q^2)\) (compact format) or as a length \(2n\) additive code over \(GF(q)\) (extended format). If \(Q\) is a quantum code with generator matrix \(G_1\) in compact format, and generator matrix \(G_2 = (A|B)\) in extended format, then
where \(\lambda\) is a fixed element returned by the function QuantumBasisElement\((GF(q))\). By default Magma assumes the compact format. However, the extended format can be flagged by setting the variable argument ExtendedFormat to true.
An \([n,k]\) symplectic self-orthogonal linear code over \(GF(q^2)\) will generate an \([[n,n/2-k]]\) quantum stabilizer code. A (compact format) additive symplectic self-orthogonal code \(C\) over \(GF(q^2)\) will give a quantum code of the same length and “dimension” \(\log_q(N)\), where \(N\) is the number of code words in \(C\).
Construction of General Quantum Codes
- QuantumCode(S): Code -> CodeQuantum
ExtendedFormat: BoolElt Default: false
Given an additive code \(S\) which is self-orthogonal with respect to the symplectic inner product, return the quantum code defined by \(S\). By default, \(S\) is interpreted as being in compact format, that is, a length \(n\) additive code over \(GF(q^2)\). If
ExtendedFormatis settrue, then \(S\) is interpreted as being in extended format, that is, a length \(2n\) additive code over \(GF(q)\).
- Example: Quantum Code from an Even Linear Code (ex-1cf7b5)
Run in calculator (opens in a new tab)
A linear code over \(GF(4)\) that is even is symplectic self-orthogonal. Note that when a quantum code is printed in Magma, an additive stabilizer matrix over \(GF(q^2)\) is displayed.
> F<w> := GF(4); > M := Matrix(F, 2, 6, [1,0,0,1,w,w, 0,1,0,w,w,1]); > C := LinearCode(M); > C; [6, 2, 4] Linear Code over GF(2^2) Generator matrix: [ 1 0 0 1 w w] [ 0 1 0 w w 1] > IsEven(C); true > IsSymplecticSelfOrthogonal(C); true > Q := QuantumCode(C); > Q; [[6, 2]] Quantum code over GF(2^2), stabilized by: [ 1 0 0 1 w w] [ w 0 0 w w^2 w^2] [ 0 1 0 w w 1] [ 0 w 0 w^2 w^2 w] > MinimumWeight(Q); 1 > Q; [[6, 2, 1]] Quantum code over GF(2^2), stabilized by: [ 1 0 0 1 w w] [ w 0 0 w w^2 w^2] [ 0 1 0 w w 1] [ 0 w 0 w^2 w^2 w]
- Example: Extended Format Stabilizer Code (ex-ddc82a)
Run in calculator (opens in a new tab)
Any stabilizer code used to construct a quantum code, may be expressed in either compact or extended format. The length \(6\) quaternary additive code \(S\) in the previous example (Quantum Code from an Even Linear Code) is equivalent to a length \(12\) binary additive code in extended format.
Note that the code will still be displayed in compact format.
> F<w> := GF(4); > C := LinearCode<GF(2), 12 | > [ 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1 ], > [ 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0 ], > [ 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0 ], > [ 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1 ] >; > C; [12, 4, 4] Linear Code over GF(2) Generator matrix: [1 0 0 0 0 1 1 1 0 0 1 1] [0 1 0 0 0 1 0 0 0 1 1 0] [0 0 0 1 0 1 1 1 0 0 0 0] [0 0 0 0 1 1 1 0 0 1 1 1] > Q := QuantumCode(C : ExtendedFormat := true); > Q; [[6, 2]] Quantum code over GF(2^2), stabilized by: [ 1 0 0 1 w w] [ w 0 0 w w^2 w^2] [ 0 1 0 w w 1] [ 0 w 0 w^2 w^2 w]
- Example: Self-Dual Quantum Code Construction (ex-ca78b6)
Run in calculator (opens in a new tab)
Any self-orthogonal code which has a rate of \(1/2\) must be self-dual, and gives rise to a dimension zero quantum code (which is also termed self-dual). In this example we construct the hexacode, which is the unique extremal length \(6\) self-dual quantum code of minimum weight \(4\).
> F<w> := GF(4); > M := Matrix(F, 3, 6, [0,0,1,1,1,1, 0,1,0,1,w,w^2, 1,0,0,1,w^2,w]); > C := LinearCode(M); > C; [6, 3, 4] Linear Code over GF(2^2) Generator matrix: [ 1 0 0 1 w^2 w] [ 0 1 0 1 w w^2] [ 0 0 1 1 1 1] > IsSymplecticSelfOrthogonal(C); true > Q := QuantumCode(C); > MinimumWeight(Q); 4 > Q; [[6, 0, 4]] self-dual Quantum code over GF(2^2), stabilized by: [ 1 0 0 1 w^2 w] [ w 0 0 w 1 w^2] [ 0 1 0 1 w w^2] [ 0 w 0 w w^2 1] [ 0 0 1 1 1 1] [ 0 0 w w w w]
- Example: Quantum Code from an Additive Code (ex-f692ec)
Run in calculator (opens in a new tab)
Stabilizer codes neither have to be linear nor even and indeed any additive code which is symplectic self-orthogonal will generate a quantum code. The following code was randomly generated.
> F<w> := GF(4); > M := Matrix(F, 3, 7, [1,w,w,w,0,0,1, w,0,1,0,w^2,0,1, 0,w^2,w,w^2,w,0,0]); > C := AdditiveCode(GF(2),M); > C; [7, 1 1/2 : 3, 4] GF(2)-Additive Code over GF(2^2) Generator matrix: [ 1 w w w 0 0 1] [ w 0 1 0 w^2 0 1] [ 0 w^2 w w^2 w 0 0] > IsSymplecticSelfOrthogonal(C); true
The code \(C\) can be shown to be neither linear nor even: in fact it has the same number of even and odd codewords.
> IsLinear(C); false > {* Weight(v) mod 2 : v in C *}; {* 0^^4, 1^^4 *} > > Q := QuantumCode(C); > MinimumWeight(Q); 1 > Q; [[7, 4, 1]] Quantum code over GF(2^2), stabilized by: [ 1 w w w 0 0 1] [ w 0 1 0 w^2 0 1] [ 0 w^2 w w^2 w 0 0]
- QuantumCode(M): ModMatRngElt -> CodeQuantum
ExtendedFormat: BoolElt Default: false
Given a matrix \(M\) over \(GF(q^2)\) for which the \(GF(q)\) additive span of its rows is a self-orthogonal code \(S\) with respect to the symplectic inner product, return the quantum code defined by \(S\). By default, \(M\) is interpreted as being in compact format, that is, a matrix whose rows are length \(n\) vectors over \(GF(q^2)\). However, if
ExtendedFormatis settrue, then \(M\) will be interpreted as being in extended format, that is, a matrix whose rows are length \(2n\) vectors over \(GF(q)\).
- Example: Quantum Code from a Stabilizer Matrix (ex-863e76)
A quantum code can be constructed directly from an additive stabilizer matrix, thereby avoiding creation of the stabilizer code. The quantum code given in example Quantum Code from an Additive Code could have also been constructed as follows:
> F<w> := GF(4); > M := Matrix(F, 3, 7, [1,w,w,w,0,0,1, w,0,1,0,w^2,0,1, 0,w^2,w,w^2,w,0,0]); > Q := QuantumCode(M); > Q; [[7, 4]] Quantum code over GF(2^2), stabilized by: [ 1 w w w 0 0 1] [ w 0 1 0 w^2 0 1] [ 0 w^2 w w^2 w 0 0]
- QuantumCode(G): Grph -> CodeQuantum
Given a graph \(G\), return the self-dual (dimension \(0\)) quantum code defined by the adjacency matrix of \(G\).
- Example: Hexacode from a Wheel Graph (ex-29ea9f)
The unique extremal \([[6,0,4]]\) hexacode can be defined in terms of a graph representing a \(5\)–spoked wheel. The graph is specified by listing the edges comprising its circumference, followed by the spokes radiating out from the center.
> G := Graph<6 | {1,2},{2,3},{3,4},{4,5},{5,1}, <6, {1,2,3,4,5}> >; > Q := QuantumCode(G); > Q:Minimal; [[6, 0]] self-dual Quantum code over GF(2^2) > MinimumWeight(Q); 4 > Q:Minimal; [[6, 0, 4]] self-dual Quantum code over GF(2^2)
- Example: Dodecacode from a Graph (ex-d4d3a5)
The unique extremal \([[12,0,6]]\) dodecacode can also be described by a graph with a nice mathematical structure. The graph construction is derived from the diagram given by Danielson in [Dan05]. In order to employ modular arithmetic, the graph vertices are numbered from \(0\) to \(11\).
> S := {@ i : i in [0 .. 11] @}; > G := Graph<S | > { {4*k+i,4*k+i+2} : i in [0..1], k in [0..2] }, > { {4*k+i,4*k+(i+1) mod 4} : i in [0..3], k in [0..2] }, > { {4*k+i,4*((k+1) mod 3)+(i+1) mod 4} : i in [0..3], k in [0..2] } >; > Q := QuantumCode(G); > MinimumWeight(Q); 6 > Q:Minimal; [[12, 0, 6]] self-dual Quantum code over GF(2^2)
- RandomQuantumCode(F, n, k): FldFin, RngIntElt, RngIntElt -> CodeQuantum
Let \(F\) be a degree \(2\) extension of a finite field \(GF(q)\). Given positive integers \(n\) and \(k\) such that \(n \ge k\), this function returns a random \([[n,k]]\) quantum stabilizer code over \(F\). The field \(F\) is assumed to be given in compact format.
- Example: Random Quantum Code (ex-27cad1)
We construct a random \([[10, 6]]\) quantum code over \(GF(4)\).
> F<w> := GF(4); > Q := RandomQuantumCode(F, 10, 6); > Q; [[10, 6]] Quantum code over GF(2^2), stabilized by: [ w 0 0 w 1 1 w w^2 w w^2] [ 0 1 0 w 1 w^2 w^2 1 w w] [ 0 w 1 1 1 0 w^2 0 0 0] [ 0 0 w 1 1 0 1 w^2 1 w]
Construction of Special Quantum Codes
CSS Codes
- CSSCode(C1, C2): Code, Code -> CodeQuantum
- CalderbankShorSteaneCode(C1, C2): Code, Code -> CodeQuantum
Given two classical linear binary codes \(C_1\) and \(C_2\) of length \(n\) such that \(C_2\) is a subcode of \(C_1\), form a quantum code using the construction of Calderbank, Shor, and Steane [CS96, Ste96a, Ste96b].
- Example: CSS Construction from a Hamming Code (ex-37614f)
Run in calculator (opens in a new tab)
Let \(C_1\) denote the \([7,4,3]\) Hamming code and \(C_2\) denote its dual. Observing that \(C_1\) contains \(C_2\), we may apply the CSS construction using \(C_1\) and \(C_2\) to obtain a \([[7,1,3]]\) code.
> F<w> := GF(4); > C1 := HammingCode(GF(2), 3); > C1; [7, 4, 3] "Hamming code (r = 3)" Linear Code over GF(2) Generator matrix: [1 0 0 0 1 1 0] [0 1 0 0 0 1 1] [0 0 1 0 1 1 1] [0 0 0 1 1 0 1] > C2 := Dual(C1); > C2; [7, 3, 4] Cyclic Linear Code over GF(2) Generator matrix: [1 0 0 1 0 1 1] [0 1 0 1 1 1 0] [0 0 1 0 1 1 1] > C2 subset C1; true > Q := CSSCode(C1, C2); > MinimumWeight(Q); 3 > Q; [[7, 1, 3]] CSS Quantum code over GF(2^2), stabilised by: [ 1 0 0 1 0 1 1] [ w 0 0 w 0 w w] [ 0 1 0 1 1 1 0] [ 0 w 0 w w w 0] [ 0 0 1 0 1 1 1] [ 0 0 w 0 w w w]
Cyclic Quantum Codes
Cyclic quantum codes are those having cyclic stabilizer codes. Conditions are listed in [CRSS98] for generating polynomials which give rise to symplectic self-orthogonal stabilizer codes.
- QuantumCyclicCode(v): ModTupFldElt -> CodeAdd
- QuantumCyclicCode(Q): [ModTupFldElt] -> CodeAdd
LinearSpan: BoolElt Default: false
Given either a single vector \(v\) or sequence of vectors \(Q\) defined over a finite field \(F\), return the quantum code generated by the span of the cyclic shifts of the supplied vectors. The span must be self-orthogonal with respect to the symplectic inner product. By default, the additive span is taken over the prime field, but if the variable argument
LinearSpanis set totrue, then the linear span will be taken.
- Example: Cyclic Quantum Code from a Vector (ex-0477fe)
A large number of good cyclic quantum codes exist. For example, the best known binary self-dual quantum code of length \(15\) is cyclic.
> F<w> := GF(4); > v := VectorSpace(F, 15) ! [w,1,1,0,1,0,1,0,0,1,0,1,0,1,1]; > Q := QuantumCyclicCode(v); > MinimumWeight(Q); 6 > Q:Minimal; [[15, 0, 6]] self-dual Quantum code over GF(2^2)
- QuantumCyclicCode(n, f): RngIntElt, RngUPolElt -> CodeAdd
- QuantumCyclicCode(n, Q): RngIntElt, [RngUPolElt] -> CodeAdd
LinearSpan: BoolElt Default: false
Let \(n\) be a positive integer. Given either a single polynomial \(f\) or a sequence of polynomials \(Q\) over some finite field \(F\), return the quantum code of length \(n\) generated by the additive span of their cyclic shifts. The additive span must be symplectic self-orthogonal. By default, the additive span is taken over the prime field, but if the variable argument
LinearSpanis set totrue, then the linear span will be taken.
- Example: Cyclic Quantum Codes from Polynomials (ex-87e469)
Run in calculator (opens in a new tab)
Since classical cyclic codes correspond to factors of cyclotomic polynomials it is frequently convenient to specify a cyclic code in terms of polynomials. Here we construct the best known binary quantum codes with parameters \([[23,12,4]]\) and \([[25,0,8]]\).
> F<w> := GF(4); > P<x> := PolynomialRing(F); > f := x^16 + x^15 + x^13 + w*x^12 + x^11 + w*x^10 + x^9 + x^8 + w^2*x^7 + > x^6 + x^5 + w*x^4 + w^2*x^3 + w*x^2 + w^2*x + w^2; > Q := QuantumCyclicCode(23, f); > MinimumWeight(Q); 4 > Q:Minimal; [[23, 12, 4]] Quantum code over GF(2^2) > > f := x^12 + x^11 + x^10 + x^8 + w*x^6 + x^4 + x^2 + x + 1; > Q := QuantumCyclicCode(25, f); > MinimumWeight(Q); 8 > Q:Minimal; [[25, 0, 8]] self-dual Quantum code over GF(2^2)
- QuantumCyclicCode(v4, v2): ModTupFldElt, ModTupFldElt -> CodeAdd
In the important case of \(GF(2)\)-additive codes over \(GF(4)\), any cyclic code can be specified by two generators. Given vectors \(v4\) and \(v2\) both of length \(n\), where \(v_4\) is over \(GF(4)\) and \(v_2\) is over \(GF(2)\), this function returns the length \(n\) quantum code generated by the additive span of their cyclic shifts. This span must be self-orthogonal with respect to the symplectic inner product.
- Example: Cyclic Quantum Code from Quaternary and Binary Vectors (ex-088686)
Run in calculator (opens in a new tab)
Any cyclic binary quantum code of length \(n\) is determined by a cyclic stabilizer code, which can be defined uniquely in terms of an \(n\)-dimensional vector over \(GF(4)\) together with an \(n\)-dimensional vector over \(GF(2)\). We construct the best known \([[21,0,8]]\) and \([[21,5,6]]\) cyclic binary quantum codes.
> F<w> := GF(4); > v4 := RSpace(F, 21) ! [w^2,w^2,1,w,0,0,1,1,1,1,0,1,0,1,1,0,1,1,0,0,0]; > v2 := RSpace(GF(2),21) ! [1,0,1,1,1,0,0,1,0,1,1,1,0,0,1,0,1,1,1,0,0]; > Q := QuantumCyclicCode(v4,v2); > MinimumWeight(Q); 8 > Q:Minimal; [[21, 0, 8]] self-dual Quantum code over GF(2^2) > > v4 := RSpace(F, 21) ! [w,0,w^2,w^2,w,w^2,w^2,0,w,1,0,0,1,0,0,0,0,1,0,0,1]; > v2 := RSpace(GF(2), 21) ! [1,0,1,1,1,0,0,1,0,1,1,1,0,0,1,0,1,1,1,0,0]; > Q := QuantumCyclicCode(v4,v2); > MinimumWeight(Q); 6 > Q:Minimal; [[21, 5, 6]] Quantum code over GF(2^2)
Quasi-Cyclic Quantum Codes
Quasi-cyclic quantum codes are those having quasi-cyclic stabilizer codes.
- QuantumQuasiCyclicCode(n, Q): RngIntElt, SeqEnum[RngUPolElt] -> CodeAdd
LinearSpan: BoolElt Default: false
Given an integer \(n\), and a sequence \(Q\) of polynomials over some finite field \(F\), let \(S\) be the quasi-cyclic classical code generated by the span of the set of vectors formed by concatenating cyclic blocks generated by the polynomials in \(Q\). Assuming that \(S\) is self-orthogonal with respect to the symplectic inner product, this function returns the quasi-cyclic quantum code with stabiliser code \(S\). If the span of the vectors is not symplectic self-orthogonal, an error will be flagged.
By default the additive span is taken over the prime field, but if the variable argument
LinearSpanis set totrue, then the linear span will be taken.
- QuantumQuasiCyclicCode(Q): SeqEnum[ModTupFldElt] -> CodeAdd
LinearSpan: BoolElt Default: false
Given a sequence \(Q\) of vectors, return the quantum code whose additive stabilizer matrix is constructed from the length \(n\) cyclic blocks generated by the cyclic shifts of the vectors in \(Q\). If the variable argument
LinearSpanis set totrue, then the linear span of the shifts will be used, else the additive span will be used (default).
- Example: Quasi-Cyclic Quantum Codes (ex-efccba)
Run in calculator (opens in a new tab)
Most quasi-cyclic quantum codes currently known are linear, since this is where most research on quasi-cyclic codes has been focused. In this example we construct the best known quasi-cyclic binary quantum codes with parameters \([[14,0,6]]\) and \([[18,6,5]]\).
> F<w> := GF(4); > V7 := VectorSpace(F, 7); > v1 := V7 ! [1,0,0,0,0,0,0]; > v2 := V7 ! [w^2,1,w^2,w,0,0,w]; > Q := QuantumQuasiCyclicCode([v1, v2] : LinearSpan := true); > MinimumWeight(Q); 6 > Q:Minimal; [[14, 0, 6]] self-dual Quantum code over GF(2^2) > > V6 := VectorSpace(F, 6); > v1 := V6 ! [1,1,0,0,0,0]; > v2 := V6 ! [1,0,1,w^2,0,0]; > v3 := V6 ! [1,1,w,1,w,0]; > Q := QuantumQuasiCyclicCode([v1, v2, v3] : LinearSpan := true); > MinimumWeight(Q); 5 > Q:Minimal; [[18, 6, 5]] Quantum code over GF(2^2)