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

\[G_1 = A + \lambda B,\]

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 ExtendedFormat is set true, then \(S\) is interpreted as being in extended format, that is, a length \(2n\) additive code over \(GF(q)\).

Example: Simple Quant Constr (ex-1cf7b5)

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]

Run in calculatorCopy input

Example: Simple Quant Extended Constr (ex-ddc82a)

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 (Example: Simple Quant Constr) 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]

Run in calculatorCopy input

Example: Simple Quant Self Dual Constr (ex-ca78b6)

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]

Run in calculatorCopy input

Example: Simple Quant Additive Constr (ex-f692ec)

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

Run in calculatorCopy input

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]

Run in calculatorCopy input

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 ExtendedFormat is set true, then \(M\) will be interpreted as being in extended format, that is, a matrix whose rows are length \(2n\) vectors over \(GF(q)\).

Example: Simple Quant Constr Mat (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 Example: Simple Quant Additive Constr 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]

Run in calculatorCopy input

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 Quant (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)

Run in calculatorCopy input

Example: Dodecacode Quant (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 [Danielsen, 2005]. 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)

Run in calculatorCopy input

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 Quant Constr (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]

Run in calculatorCopy input

Subcode(Q, k): CodeQuantum, RngIntElt -> CodeQuantum

Given a quantum code \(Q\) of dimension \(k_Q \ge k\) then return a subcode of \(Q\) of dimension \(k\).

Construction of Special Quantum Codes

Hexacode() -> CodeQuantum

Return the \([[6,0,4]]\) self-dual quantum hexacode.

Dodecacode() -> CodeQuantum

Return the \([[12,0,6]]\) self-dual quantum dodecacode.

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 [Calderbank and Shor, 1996, Steane, 1996, Steane, 1996].

Example: CSS Quant Constr (ex-37614f)

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]

Run in calculatorCopy input

Cyclic Quantum Codes

Cyclic quantum codes are those having cyclic stabilizer codes. Conditions are listed in [Calderbank et al., 1998] 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 LinearSpan is set to true, then the linear span will be taken.

Example: Cyclic Quant Codesimple (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)

Run in calculatorCopy input

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 LinearSpan is set to true, then the linear span will be taken.

Example: Cyclic Quant Code Poly (ex-87e469)

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)

Run in calculatorCopy input

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 Quant Code GF4GF2 (ex-088686)

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)

Run in calculatorCopy input

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 LinearSpan is set to true, 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 LinearSpan is set to true, then the linear span of the shifts will be used, else the additive span will be used (default).

Example: Quasi Cyclic Quant Code (ex-efccba)

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)

Run in calculatorCopy input