Low-complexity quantum codes designed via codeword-stabilized framework

# Low-complexity quantum codes designed via codeword-stabilized framework

Alexey A. Kovalev Department of Physics & Astronomy, University of California, Riverside, California 92521, USA    Ilya Dumer Department of Electrical Engineering, University of California, Riverside, California 92521, USA    Leonid P. Pryadko Department of Physics & Astronomy, University of California, Riverside, California 92521, USA
July 12, 2019
###### Abstract

We consider design of the quantum stabilizer codes via a two-step, low-complexity approach based on the framework of codeword-stabilized (CWS) codes. In this framework, each quantum CWS code can be specified by a graph and a binary code. For codes that can be obtained from a given graph, we give several upper bounds on the distance of a generic (additive or non-additive) CWS code, and the lower Gilbert-Varshamov bound for the existence of additive CWS codes. We also consider additive cyclic CWS codes and show that these codes correspond to a previously unexplored class of single-generator cyclic stabilizer codes. We present several families of simple stabilizer codes with relatively good parameters.

## I Introduction

It was the invention of quantum error correcting codes Shor (1995); Knill and Laflamme (1997); Bennett et al. (1996) (QECCs) that opened quantum computing (QC) as a theoretical possibility. However, high precision required for error correction Knill et al. (1998); Rahn et al. (2002); Dennis et al. (2002); Steane (2003); Fowler et al. (2004a, b); Fowler (2005); Knill (2005a, b); Raussendorf and Harrington (2007) combined with the large number of auxiliary qubits necessary to implement it, have so far inhibited any practical realization beyond proof-of-the-principle demonstrationsVandersypen et al. (2000, 2001); Gulde et al. (2003); Chiaverini et al. (2004); Friedenauer et al. (2008); Martinis (2009); Kim et al. (2010).

In any QECC, one needs to perform certain many-body quantum measurements in order to decide how to correct the encoded state. The practical difficulty is that a generic code requires measurements which are both complicated and frequent at the same time. It is therefore clear that a quantum computer can only be build via a thorough optimization at every step of the design. In particular, code optimization targets codes that combine good parameters with fairly simple measurements. It is also desirable to parallelize these measurements given a specific on-chip layout of a QC architecture.

To date, the main focus of the QECC-research has been on finding good codes with the traditional code parameters, which are the block length , code dimension , and code distance (or code rate and the relative distance ). For stabilizer codes Gottesman (1997); Calderbank et al. (1998), we also consider the number of encoded qubits .

A number of stabilizer codesGrassl (2007) have been designed that meet or nearly achieve the existing bounds on distance for the given and . Code parameters can be further refined by going beyond the family of stabilizer codes. One example is a recently introduced framework of codeword-stabilized (CWS) quantum codesSmolin et al. (2007); Cross et al. (2009); Chuang et al. (2009); Chen et al. (2008). A qubit CWS code (in standard form) is determined by a graph and a classical binary code . CWS codes include all stabilizer codes as a subclass (the corresponding binary code must be linear), but also the codes which have been proved to have parameters superior to those of any stabilizer codeCross et al. (2009); Yu et al. (2008, 2007); Grassl and Roetteler (2008a, b); Grassl et al. (2009). Unfortunately, typical gains in code dimension correspond to a fraction of a qubit. Moreover, error-correcting algorithms known for general non-additive CWS codes have exponential complexityLi et al. (2010a, b), as opposed to polynomial complexity of the stabilizer codes.

Even for the relatively simple additive codes, their optimization is a very difficult problem that has exponential complexity. This is one of the main reasons as to why the two relatively simple code families are almost exclusively used among stabilizer codes to estimate the threshold accuracy required for scalable quantum computation: the concatenated codesKnill et al. (1998); Rahn et al. (2002); Steane (2003); Fowler et al. (2004a, b); Fowler (2005); Knill (2005a, b) and the surface codesDennis et al. (2002); Raussendorf and Harrington (2007) which originated from the toric codesKitaev (2003). Both families have very low code rates that scale as inverse powers of code distance.

In this work we explore how the framework of CWS codes can be used to relegate the design of quantum stabilizer codes to classical binary linear codes in order to simplify the overall design. In particular, we formulate several theorems framing the parameters of an additive CWS code which can be obtained from a given graph. We also suggest a simple decomposition of the generator matrix corresponding to the stabilizer in terms of the graph adjacency matrix and the parity check matrix of the binary code. Finally, we design several graph families corresponding to regular lattices which result in some particularly good codes. These include graphs with circulant adjacency matrix which can be used to construct single-generator cyclic additive codes, a class of codes overlooked in previous publications. In particular, we prove the existence of single-generator cyclic additive codes with the parameters , and (version of toric codes). Note that these code families have distances that are not bounded, unlike any CWS code families constructed previouslyCross et al. (2009); Looi et al. (2008).

The paper is organized as follows. In Sec. II, we introduce the notations and briefly review some known results for quantum and classical codes. In Sec. III, we establish several upper bounds on general CWS codes. In Sec. IV we give a CWS decomposition of the matrix corresponding to the stabilizer generators. In Sec. V, we formulate the Gilbert-Varshamov (GV) bounds for additive CWS codes which can be obtained from a given graph. Cyclic additive CWS and more general single-generator additive cyclic codes are considered in Sec. VI where we discuss their properties and give several examples. We give our conclusions in Sec. VII.

## Ii Notations and some known results

### ii.1 Classical and quantum error correcting codes

A classical -ary block error-correcting code is a set of length- strings over an alphabet with symbols. Different strings represent distinct messages which can be transmitted. The (Hamming) distance between two strings is the number of positions where they differ. Distance of the code is the minimum distance between any two different strings from .

In the case of linear codes, the elements of the alphabet must form a Galois field ; all strings form -dimensional vector space . A linear error-correcting code is a -dimensional subspace of . The distance of a linear code is just the minimum weight of a non-zero vector in the code, where weight of a vector is the number of non-zero elements. A basis of the code is formed by the rows of its generator matrix . All vectors that are orthogonal to the code form the corresponding -dimensional dual code, its generator matrix is the parity-check matrix of the original code.

For a binary code , the field is just . For a quaternary code , the field is , with

 ω2=ω+1,ω3=1,and¯¯¯ω≡ω2. (1)

For non-binary codes, there is also a distinct class of additive classical codes, defined as subsets of closed under addition (in the binary case these are just linear codes). A code is cyclic if inclusion implies that . Codes that are both linear and cyclic are particularly simple: by mapping vectors to polynomials in the natural way, , it is possible to show that any such code consists of polynomials which are multiples of a single generator polynomial , which must divide (using the algebra corresponding to the field ). The quotient defines the check polynomial ,

 h(x)g(x)=xn−1 (2)

which is the generator polynomial of the dual code. The degree of the generator polynomial is . The corresponding generator matrix can be chosen as (the first rows of) the circulant matrix formed by subsequent shifts of the vector that corresponds to .

Qubit quantum error correcting codes are defined in the complex Hilbert space , where is the Hilbert space of a single two-level system. is formed by all vectors with , and the inner product such that the two states are orthonormal, , . Any operator acting in can be represented as a linear combination of Pauli operators which form the -qubit Pauli group of size ,

 Pn=im{I,X,Y,Z}⊗n,m=0,…,3, (3)

where , , and are the usual Pauli matrices, and is the identity matrix. The weight of a Pauli operator is the number of non-identity terms in the corresponding tensor product.

All Pauli operators are unitary; they are also Hermitian with eigenvalues when the phase factor in Eq. (3) is real-valued, . A state is stabilized by a Hermitian Pauli operator if . A linear space is stabilized by a set of operators if each vector in is stabilized by every operator in .

An quantum error-correcting code is a -dimensional subspace of the Hilbert space . Such a subspace can be described by an orthonormal basis . Let be some set of Pauli errors. A QECC detects all errors if and only if Nielsen and Chuang (2000); Gottesman (1997)

 ⟨j|E|i⟩=CEδij, (4)

where only depends on the error , but is independent of the basis vectors. A QECC has distance if it can detect all Pauli errors of weight , but not all errors of weight . The errors in the set can be corrected if and only if all the nontrivial pairwise combinations of errors from are detectable Bennett et al. (1996); Knill and Laflamme (1997). Thus a distance- code corrects all errors of weight .

The code is non-degenerate if linearly-independent errors from produce corrupted spaces that are linearly independent. Otherwise, the code is degenerate, implying the existence of at least two mutually degenerate linearly independent operators which act identically on .

The code is called pure if linearly independent errors from produce corrupted spaces that are not only linearly independent, but also mutually orthogonal. For all codes considered in this work, non-degenerate codes are also pureCalderbank et al. (1998); Li et al. (2010b).

Two codes are considered equivalent if they differ just by qubit order, and/or discrete rotations leaving each of the single-qubit Pauli groups invariant. The latter are called local Clifford (LC) transformations.

### ii.2 Stabilizer quantum error correcting codes

Here we briefly review the well-known family of stabilizer codes Gottesman (1997). An stabilizer code is a -dimensional subspace of the Hilbert space stabilized by an Abelian group with Hermitian Pauli generators, . Explicitly,

 (5)

Such a code exists only if . The group is called the stabilizer of the code. Changing the sign(s) of one or several of the generators results in replacing with one of equivalent codes whose direct sum (together with ) is the entire space .

The normalizer of is a set of Pauli operators generating unitary transformations that leave invariant,

 N≡{U∈Pn:U†SU=S,∀S∈S}. (6)

Elements of the normalizer form a group commuting with but not necessarily with each other. It is possible to construct logical operators , , belonging to with the usual commutation relations that generate the normalizer when the generators of are included Gottesman (1997); Wilde (2009). The Abelian subgroup of , , becomes a maximal Abelian subgroup of when the generator is also included.

The group stabilizes a unique stabilizer state , an stabilizer code, while the operators generate the basis of the code, i.e.,

 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯|c1…ck⟩=¯¯¯¯¯Xc11…¯¯¯¯¯Xckk|s⟩. (7)

By convention, the stabilizer state is considered non-degenerate, and its distance is the minimum weight of a non-trivial member of the group .

For stabilizer codes, phases of (Hermitian) Pauli operators are only needed to choose one of the equivalent codes in Eq. (5), as well as to introduce the commutation relations. It is convenient to drop the phases and map the Pauli operators to two binary strings, Calderbank et al. (1998),

 U≡im′XvZu→(v,u), (8)

where , , and is generally different from that in Eq. (3). This map preserves the operator algebra, with a product of two Pauli operators and corresponding to a sum of the corresponding binary vectors and .

The map (8) can be taken one step furtherCalderbank et al. (1998) to quaternary codes, by introducing vectors [see Eq. (1); note that this mapping differs slightly from that in Ref. Calderbank et al., 1998]. We will denote this combined map as a function . Note that up to a phase this association also allows us to define . To be specific, for the Pauli operator we will set in Eq. (8), which corresponds to in Eq. (3).

It is easy to check that two Pauli operators commute if and only if the symplectic scalar product vanishes (). In terms of the corresponding , this corresponds to the vanishing of the trace inner product

 e1∗e2≡e1⋅¯¯¯e2+¯¯¯e1⋅e2, (9)

where , .

A dual code to an additive code (equipped with trace inner product) is defined as Calderbank et al. (1998)

 C⊥={e′∈Fn4:e′∗e=0,foralle∈C}. (10)

If , one says is self-orthogonal. A classical additive code corresponding to a set of operators is self-orthogonal if and only if is an Abelian group. Thus any quantum stabilizer code can be described as a self-orthogonal classical additive code over . The following theorem is applicable to additive codes (variant of Theorem 2 from Ref. Calderbank et al. (1998)):

###### Theorem 1.

Suppose is an additive self-orthogonal code in , containing vectors, such that there are no vectors of weight in . Then defines a stabilizer of an additive QECC with parameters .

###### Example 1.

The well-known Calderbank-Shor-Steane (CSS) code Calderbank and Shor (1996); Steane (1996) has the stabilizer with the generatorsGottesman (1997)

 XXXXIII, XXIIXXI, XIXIXIX, ZZZZIII, ZZIIZZI, ZIZIZIZ, (11)

and the logical operators

 ¯¯¯¯¯X=ZZZZZZZ,¯¯¯¯Z=XXXXXXX. (12)

As any CSS code, this code is linear. Qubit permutations also give an equivalent cyclic linear code with the generator polynomial ; is a factor of . The corresponding check polynomial is .

### ii.3 Codeword stabilized codes

CWS codes Cross et al. (2009) represent a general class of nonadditive QECCs. A general CWS code is defined in terms of a stabilizer state and a set of mutually commuting codeword operators . Explicitly [cf. Eq. (7)],

 Q=span({Wi|s⟩}Ki=1). (13)

For non-trivial CWS codes, this construction coincides with union-stabilizer (USt) codesGrassl and Beth (1997), restricted to the zero-dimensional originating code.

Any stabilizer state is LC-equivalent to a graph state Grassl et al. (2002); Schlingemann (2002); Van den Nest et al. (2004); Hein et al. (2005), a stabilizer state with the stabilizer group whose generators are determined by the adjacency matrix of a (simple) graph ,

 Si=XiZri, (14)

where , denotes the -th row of . In fact, such a graph is usually not unique, even after accounting for graph isomorphisms. The full set of LC-equivalent graph states can be generated by a sequence of local complementations, operations on a graph where the subgraph corresponding to a neighborhood of a particular vertex is inverted. Such graphs are called locally equivalentBouchet (1993).

Any CWS code is LC equivalent to a CWS code in standard form, defined by an order- graph and a classical binary code containing binary words. The graph defines the graph state, while the vectors of the classical code are used to generate the code word operators, . Thus,

 Q=span({Zci|s⟩}Ki=1). (15)

It is customary to use notation for CWS codes in standard form.

The key simplification of the CWS construction comes from the fact that the basis states are eigenvectors of the graph stabilizer generators,

 SiWi|s⟩=±Wi|s⟩,Si∈SG. (16)

Thus, a Pauli operator in the form (8) can be transformed to a -only operator , where the graph image of the operator is the binary vector

 ClG(U)≡u+n∑i=1viri(mod2). (17)

The error correcting properties of a quantum CWS code and the classical code are related by the following

###### Theorem 2.

(after Theorem 3 from Ref. Cross et al. (2009)) Consider a CWS code . An error such that , is detectable in if and only if the binary vector is detectable within the code . An error such that is detectable in if and only if for all .

The case corresponds to pure (non-degenerate) errors, while indicates that the error is in the graph stabilizer group ; the corresponding detectability condition is a requirement that the error must be degenerate.

While in general CWS codes are non-additive, they include all stabilizer codes as a subclass. A CWS code is additive if is a linear codeCross et al. (2009). The stabilizer of an additive CWS code in standard form is a subgroup of the graph stabilizer ; it can be obtained from the graph-stabilizer generators by a symplectic Gram-Schmidt orthogonalization procedureLi et al. (2010b). Conversely, the representation (7) of an additive code corresponds to a general CWS code; an LC transformation may be needed to obtain the corresponding standard form, and one can always find a standard form where is linearChuang et al. (2009). In the following we will always assume such a representation.

###### Example 2.

The smallest single-error-correcting code is the linear cyclic codeBennett et al. (1996); Calderbank et al. (1997); Laflamme et al. (1996) with the generator polynomial which divides . This code is unique; its stabilizer generators can be obtained as cyclic permutations of a single operator, , and the logical operators are

 ¯¯¯¯¯X=ZZZZZ,¯¯¯¯Z=XXXXX. (18)

The corresponding CWS codeCross et al. (2009) can be generated from the -ring graph in Fig. 1 (left), and the binary code has a single generator . Note that both the graph and the binary code preserve the original cyclic symmetry.

###### Example 3.

There exist only two inequivalent single-correcting codes ; both are degenerateCalderbank and Shor (1996). One of the codes is obtained from the code in Example 2 by adding a qubit; the graph of the corresponding CWS code can be chosen as a -ring [Fig. 1 left] and a disconnected vertex ; the binary code is generated by . The degeneracy group is generated by . The stabilizer generators for the second code are listed in Ref. Calderbank and Shor (1996). This code corresponds to the graph in Fig. 1 (center), while the binary code is generated by . While there are three bits which are not involved with the classical code, they cannot be dropped as they are part of the entangled state. The degeneracy group is generated by (the equivalence follows from the fact that the first two vertices of share all of their neighbors).

###### Example 4.

The linear cyclic CSS code from the Example 1 is LC equivalent to a CWS code with the graph in Fig. 1 (Right). The corresponding classical code is given by . Note that neither the graph nor the binary code is explicitly symmetric with respect to cyclic permutations of the qubits. Note also that an inequivalent CWS cyclic code exists; we constructed such a code among others in Example 12, see Table 1.

## Iii Upper bounds for CWS codes

In this section we give upper bounds on general CWS codes in terms of the properties of the corresponding graph and the binary code .

###### Lemma 1.

The distance of the CWS code cannot exceed that of .

###### Proof.

Indeed, any “classical” error in the form is mapped by Eq. (17) to the binary vector . If is detectable by , should be detectable by . ∎

Lemma 1 concerns with errors which are dealt with by the binary code. On the other hand, a CWS code is an enlargement of the code formed by the graph state. The following observation has been made in Ref. Grassl et al. (2009):

###### Lemma 2.

The distance of a nondegenerate CWS code is limited by the distance of the graph stabilizer state, .

It follows from the fact that any member of the graph stabilizer is either a degenerate error, or it is a non-detectable error. Note, however, as illustrated by the Example 3, in general, the distance of a CWS code can actually be bigger than that of the graph stabilizer state.

For a binary code , we will say that the -th bit is involved in the code if there are vectors in the code for which the value of -th bit differ, . Alternatively, if the all-zero vector is in the code (which can always be arranged), the condition is that there is a vector where -th bit is non-zero, .

###### Lemma 3.

For a CWS code with , let us assume that -th bit is involved in the code . Then the graph-stabilizer generator violates the error detection condition in Theorem 2.

###### Proof.

Since the generator is in the graph stabilizer, , one has to check the degenerate condition in Theorem 2. The commutativity of with a given is determined by the -th bit of ; conditions of the Lemma ensure that only one of the two vectors commute with . ∎

Note that this means that the code distance cannot exceed that of any corresponding to bits involved in the binary code. Since at least bits must be involved in the binary code, Lemma 3 guarantees the following bound

###### Theorem 3.

The distance of a CWS code cannot exceed the -th largest weight of , minimized over all graphs that are locally-equivalent to .

We will also be using the following

###### Corollary 3.1.

For a graph with all vertices of the same degree , the distance of a CWS code cannot exceed .

In particular, for any ring graph , which gives , for any double-ring graphChuang et al. (2009) , and for a large enough square lattice wrapped into a torus, .

Obviously, to maximize the distance of a CWS code, one may want to maximize the distance of the binary code . To this end, it is a good idea to make sure that every bit is involved in . For such codes, we have

###### Theorem 4.

The distance of a CWS code where the binary code involves all bits cannot exceed the minimum weight of , minimized over all graphs that are locally-equivalent to .

## Iv Additive CWS codes and quaternary codes

The stabilizer of an additive CWS code is a subgroup of the Abelian graph stabilizer , and its generators can be expressed as products of graph stabilizer generators Cross et al. (2009); Li et al. (2010b). Explicitly,

 Gi=n∏j=1SPijj, (19)

where is the corresponding matrix of binary coefficients. With the help of Eq. (14), we obtain the following decomposition for the generator matrix of the associated additive code ,

 G=P(ω\openone+R), (20)

where is the symmetric graph adjacency matrix with zeros along the diagonal, and is the identity matrix. The relation between the binary code and the quaternary code is explicitly given by the following

###### Lemma 4.

The additive code with the generator matrix (20) is the map of the stabilizer of the additive CWS code generated by the graph with the adjacency matrix and the linear binary code if and only if is the parity check matrix of .

###### Proof.

Use the basis vectors in the form (15) and the commuting operators (19) corresponding to the rows of the matrix [Eq. (20)]. Direct calculation gives

 GiZc|s⟩=n∏j=1SPijjZc|s⟩=(−1)PijcjZc|s⟩, (21)

were summation over repeated indices is assumed. The statement of the Lemma (both ways) follows from the definition of the parity check matrix. ∎

We can now easily relate the error detection conditions for additive codes in Theorems 1 (codes over ) and 2 (CWS codes). The code in Theorem 1 is given by additive combinations of the rows of the generator matrix (20). Evaluating the outer trace product of the generator matrix (20) with a vector , we obtain the condition for the vector to be in

 0=G∗e=P(u+Rv). (22)

This uniform linear system of equations with variables has linearly-independent solutions. The corresponding basis can be chosen as a set of linearly-independent “classical” vectors , where and the corresponding , , plus linearly-independent vectors such that , . Some linear combinations of the latter vectors are actually in . These can be found using the identity : the corresponding have to satisfy , which precisely corresponds to the degenerate case, , in Theorem 2.

General theory of CWS codes guarantees that generator matrix of a quantum code equivalent to any additive self-orthogonal code over can be decomposed in the form (20). Conversely, any matrix in the form (20) with binary matrices and generates a self-orthogonal code over as long as the matrix is symmetric. We use it in the following section to prove the lower Gilbert-Varshamov (GV) bound for the parameters of an additive CWS code which can be obtained from a given graph.

## V GV bound for the additive CWS codes with a given graph

The GV bound is a counting argument which non-constructively proves the existence of codes with parameters exceeding certain threshold. The argument is based on the fact that the set of possible codes (vector spaces) vastly outnumbers the set of vectors. Then, if we count all codes of a given length , and then subtract the number of codes that contain any vector of weight or less, the remaining codes (if any) will all have distance or more. This “greedy” argument ignores any possible double counting of codes that contain several small-weight vectors. Note that the GV bound necessarily gives asymptotically good codes with relative distance and code rate bounded away from as .

For the entire class of pure stabilizer codes, the asymptotic GV boundFeng and Ma (2004) states that there exist codes of length such that

 δlog23+H2(δ)≥1−R, (23)

where is the binary entropy function. We are going to prove that the same bound also holds for pure CWS codes corresponding to a given graph , as long as [see Lemma 2]. We are using Eq. (20) to parameterize the stabilizer matrices; the resulting codes are automatically self-orthogonal. Let be the number of CWS codes that have length , dimension at least , and correspond to a given graph . Let also be the number of such codes which contain a given vector , , in [see Eq. (20)]. The corresponding condition (10) is given by the trace inner product (22). For , the binary vector is always non-zero (which also guarantees that ). As a result, and represent the corresponding numbers for the binary codes.

Then the standard counting arguments MacWilliams and Sloane (1981) show that

 (2n−1)NGe,n,k=(2k−1)NGn,k (24)

Here we use the fact that each of vectors belongs to the same number of binary codes; also each of binary codes contains nonzero vectors . The number of quaternary vectors of weight is . Thus, for any graph , there exists a distance- CWS code as long as

 NGe,n,kd−1∑s=13s(ns)

Now we see that there exist CWS codes for the graph with distance

 d=min{dGV,dmax}, (26)

where is the distance of the graph state and

 dGV=maxd:d−1∑s=13s(ns)<2n−12k−1. (27)

Note that thus obtained quantum codes are always pure, since the summation in the l.h.s. can only be extended up to . Apart from this latter condition, Eq. (27) is identical to the quantum Gilbert-Varshamov boundFeng and Ma (2004) for pure stabilizer codes, and takes the asymptotic form (23) as .

The exact GV bound for pure stabilizer codes (without the restriction on the distance) is recovered if we go over different graphs. Indeed, the GV bound (23) also applies for the special case of , corresponding to stabilizer states or self-dual codesRains and Sloane (1998). The GV bound on the relative distance is monotonous in and reaches its maximum at

 δk=0≈0.189. (28)

Then for given and one can always find a suitable graph such that the GV bound becomes more restrictive than the condition .

In practice, graphs with large distance are complicated (have too many edges). It is much easier to come up with graph families corresponding to a fixed graph-state distance . For , the corresponding code families approach the maximum rate and have asymptotic redundancy defined by Eq. (27):

 r≤dlog23+nH2(d/n). (29)

It is readily verified that the r.h.s of estimate (29) has the order of if =const and .

###### Example 5.

Graphs in the form of sufficiently large finite square lattice fragments [Fig. 2] have maximum distance , but this requires that the bits in the corners and around the perimeter be not involved in the classical code. Somewhat better redundancy can be achieved by avoiding only the bits in the corners, which gives . Consider the family of classical codes where the codewords are obtained by taking all translations of the pattern shown in Fig. 2 with open symbols. The weight of any linear combination of such codewords is at least 4. The lattice shown corresponds to the code , while general lattice gives the code with the parameters . Asymptotically, the redundancy for is , , which is bigger than the logarithm in Eq. (29). However, the fraction of auxiliary qubits vanishes as for large . The code distance can be increased with higher-dimensional generalizations, e.g., we can generalize this construction to -dimensional hypercubic lattice with nearest neighbors so that the distance is in full analogy with the two dimensional case. The corresponding redundancy will scale with the area of the boundary.

While the code in Fig. 2 serves as a good illustration of the concept of lattice codes with simple stabilizer structure, it is still far from optimal. On the square lattice we have constructed numerically a code with weight- codewords which can be mapped into each other by translations and rotations. This design is only one logical qubit short of the best-known generic code .

###### Example 6.

Consider graphs in the form of square lattices wrapped into tori due to periodic boundary conditions. For , these graphs have the distance . GV bound (25) shows that the CWS codes with the following parameters can be obtained for these graphs: , , , , , ….

###### Example 7.

Consider graphs in the form of triangular lattices wrapped into tori due to periodic boundary conditions. These graphs have the distance . GV bound (25) shows that the CWS codes with the following parameters can be obtained for these graphs: , , , , ….

## Vi Single-generator additive cyclic codes

Example 4 shows that a cyclic additive code does not necessarily preserve its symmetry when converted to CWS standard form. By a cyclic additive CWS code we just mean a code which is cyclic in standard form, with a circulant graph. For such a code, Eq. (20) can be rewritten as the generator polynomial,

 g(x)=p(x)[ω+r(x)], (30)

where the polynomials and are binary, is the parity-check polynomial of a binary cyclic code (and therefore must divide ), while corresponds to a symmetric circulant matrix,

 r(xn−1)=r(x)(modxn−1). (31)

Any such symmetric polynomial leads to a valid self-orthogonal additive code. The dimension of the quantum code corresponding to the generator polynomial (30) is .

Previously, the additive cyclic QECCs were introduced in Theorem 14 of Ref. Calderbank et al. (1998), stating that any such code has two generators. A single-generator additive code described by Eq. (30) represents a new setting, in which the second generator is equal to zero. This condition gives a self-orthogonal additive code [see Sec. II.2] with no binary codewords (any , , has ).

A somewhat wider class of single-generator cyclic additive codes can be also defined via Eq. (30), without requiring the symmetry (31) of . Then two codes and that have a generator polynomial in the form (30) with the same are equivalent if and only if

 r(x)=r′(x)modq(x), (32)

where is the generator polynomial of the binary codeCalderbank et al. (1998). Such a polynomial (30) generates a self-orthogonal code if and only if Calderbank et al. (1998)

 p(x)p(xn−1)r(xn−1)=p(x)p(xn−1)r(x)(modxn−1). (33)

This guarantees self-orthogonality for any as long as

 p(x)p(xn−1)=0modxn−1. (34)

An alternative formulation of this sufficient condition is that the corresponding generator polynomial must contain no more than one root from each pair of mutually conjugate  th roots of unity, . In particular, a self-reciprocal (palindromic) polynomial111In the literature such polynomials have also been called “symmetric”. We prefer to reserve this term for the polynomials (31) which correspond to symmetric circulant matrices. Palindromic polynomials have reflection symmetry with respect to their “centers”, while Eq. (31) corresponds to a symmetry with respect to the free term, with an implicit circulant symmetry.,

 xdegq(x)q(1/x)=q(x), (35)

always contains roots in pairs and . For such polynomials Eq. (34) always fails (including the special case of which has only one root ).

### vi.1 Single-generator cyclic codes from a binary code

The algebraic condition (2) on check polynomials for linear cyclic codes makes them simpler to implement but also dramatically restricts their number. In particular, the general counting approach to finding CWS codes [see Sec. V], where one first chooses a graph, and then searches for a suitable binary code can hardly be applied to cyclic CWS codes. Even for classical binary cyclic codes, there are no counting arguments known to date that yield asymptotically good codes, let alone the stronger GV bound (see Research Problem 9.2 in Ref. MacWilliams and Sloane, 1981). Also, long BCH codes—one of the major subclasses of cyclic codes—are asymptotically bad and have a slowly declining relative distance for any code rate . On the other hand, binary cyclic codes often achieve the best known parameters (exceeding the GV bound) on short lengths . Thus, using simple cyclic codes in quantum design can yield both good parameters and feasible implementation on the short blocks.

To better evaluate code distance of single-generator quantum cyclic codes (30), we will modify our counting approach of Sec. V and begin with a binary cyclic code. Namely, we will fix some parity-check polynomial with a desired degree among the binary factors of . Then we will search for a polynomial , either corresponding to a cyclic graph [see Eq. (31)], or satisfying the more general orthogonality condition (33). However, this transition will show that the parameters of quantum codes generated this way strongly depend on the chosen binary code. We will concentrate exclusively on the binary codes with irreducible generator polynomial . We will show that the distance of such a cyclic CWS code is limited from below by the GV bound (or the variants thereof) and from above by the distance of the classical cyclic code. Since GV bound always produces asymptotically good codes, the parameters of our quantum codes will be mostly limited (at least, for long blocks) by their binary counterparts.

We begin with analyzing the condition (22) for a cyclic CWS code. For a vector to be in this condition can be rewritten in terms of the corresponding polynomials,

 p(x)[u(x)+r(x)v(x)]=0modxn−1, (36)

where the coefficients of the (reversed for notational convenience) polynomial are given by the components of the vector . Since binary divides , we can rewrite this in terms of the corresponding generator polynomial for the binary code ,

 u(x)+r(x)v(x)=0modq(x). (37)

Now, if is mutually prime with , Eq. (37) can be just solved for . In this case the answer is unique . On the other hand, multiple solutions for are possible when . In this work, we avoid the complications caused in the latter case222For polynomials with multiple factors, distance estimates of quantum codes lead to the estimates of weight spectra of classical cyclic codes which contain the code generated by , which is beyond the scope of this work. and only consider irreducible polynomials .

Overall, for any irreducible and any with and , Eq. (37) has a unique solution for such that . Respectively, there is no more than one additive quantum code such that . Generally, only some of thus obtained correspond to self-orthogonal codes, see Eq. (33).

Below we complete the greedy argument by counting the polynomials corresponding to self-orthogonal codes, Eq. (33). We consider separately the case when the irreducible polynomial is palindromic [see Eq. (35)] in Lemma 7 below, and when it is not in

###### Lemma 5.

Consider a cyclic binary code with the generator polynomial which is both irreducible and non-palindromic, . Then there exists a single-generator additive cyclic code with distance

 d=min(dC,dGV),

restricted by both the distance of the binary code and the following variant of GV bound

 dGV=maxd:d−1∑s=1(3s−3)gcd(s,n)n(ns)≤2n−k−2. (38)
###### Proof.

The non-palindromic generator polynomial is one of the factors in which also contains its reciprocal, . This implies that the corresponding parity-check polynomial satisfies Eq. (33). Further, since is irreducible, the solution of Eq. (37) is unique assuming and , which gives the exponential term in the r.h.s. of Eq. (38). Eq. (38) improves on the standard GV inequality (27) by discarding a few sets of vectors. The first set are vectors with , which implies . The second set are vectors with , which all give . The third set are non-zero vectors with , which can never be in corresponding to the generator (30). Finally, note that any error vector of weight produces at least different cyclic shifts. All of these cyclic shifts give the same polynomial and can be discounted. The condition comes from Lemma 1. ∎

Note. The lhs of bound (38) limits the number of cyclic classes for -ary vectors of weight Most of these vectors have the maximum period Therefore, it can be proven that the term in (38) can be replaced with the smaller term that rapidly tends to 1/n for large n. In turn, bound (38) adds about information qubits to bound (27) but tends to the standard quantum GV bound (23) as .

In the following example, this bound coincides with inequality , which uniquely sets code distance .

###### Example 8.

The family of the binary codes with the parameters , , constructed in Ref. Ding et al., 2002, has irreducible non-palindromic generator polynomials as required in Lemma 5. For the sum in Eq. (38) has just one term at ; for odd . Explicit calculation confirms that the parameters of these codes satisfy inequality (38), which proves the existence of single-generator cyclic quantum codes with exactly the same parameters, , but not necessarily cyclic CWS codes. The smallest of these codes, , corresponds to a polynomial (unique up to a reversal) and can be obtained from an order- circulant graph corresponding to . This particular combination of parameters gives the best existing codeGrassl (2007).

###### Example 9.

According to the BCH bound MacWilliams and Sloane (1981), a cyclic code has distance ( is the “designed” distance) if the corresponding generator polynomial has consecutive roots, e.g., , where is the primitive th root of unity. A polynomial which has root , necessarily has distinct roots for all if is the smallest number such that . We say that the code has zeros , where exponents form the set The code generated by has designed distance if or, equivalently, if for some . The polynomial is non-palindromic if . We can further obtain codes with irreducible non-palindromic generators and designed distances , , etc., by imposing additional conditions, e.g., , , etc. The values of for which this is possible form an infinite set, , where the subscripts indicate the designed distances. In fact, the first three codes represent the well known quadratic-residue codes with the higher distances (exceeding the BCH bound) equal to 7, 11, and 11, respectively. GV bound proves the existence of additive quantum CWS codes with the parameters , , , , , , etc. The first three codes have the parameters as good as any known codes with such and .

Now let us consider the case of a palindromic polynomial . First, we prove

###### Lemma 6.

Consider a binary code generated by a palindromic polynomial such that . Then any quantum code (30) which satisfies self-orthogonality condition (33) is equivalent to a cyclic CWS code with a symmetric polynomial , see Eq. (31).

###### Proof.

The corresponding check polynomial is symmetric, thus the condition (33) can be rewritten as

 r(x)+r(xn−1)=0modq(x). (39)

The condition guarantees that the palindromic polynomial has odd weight and even degree , in which case the “central” monomial has non-zero coefficient . Given the block length , let us choose an equivalent code [see Eq. (32)] with such that the coefficients

 rm+1=rm+2=…=rn−m=0. (40)

The coefficients of the polynomial in the l.h.s. of Eq. (39) satisfy the same condition, except for the term , which has coefficient . The coefficients are arranged in such a way that the l.h.s. of Eq. (39) can only equal zero or . However, the latter possibility can be excluded by comparing the corresponding coefficients of the free term . The only remaining case corresponds to a symmetric . ∎

It is now clear that for a palindromic irreducible generator polynomial , one should reduce the count in the r.h.s. of Eq. (38) by replacing with , the number of symmetric polynomials that satisfy Eq. (40). This gives the following version of GV bound,

 dGV=maxd:d−1∑s=1(3s−3)gcd(s,n)n(ns)≤2(n−k)/2−2. (41)

While the resulting estimate is much weaker than the GV bound (38), it still gives asymptotically good codes. A better (especially, for small ) bound is given in the following

###### Lemma 7.

Consider a cyclic binary code with and the generator polynomial which is both palindromic and irreducible. Then there exists a cyclic CWS code with the distance , where :

 d−1∑s=1(3⌈s/2⌉−3)gcd(s,n)n(⌊n/2⌋⌊s/2⌋)≤2(n−k)/2−2. (42)
###### Proof.

The restriction on the distance guarantees that , and therefore satisfies the conditions of Lemma 6; in particular, is even. The inequality just corresponds to symmetric polynomials and the errors that are also symmetric, . The statement of the Lemma follows from the fact that for any general error , there is a symmetric error whose weight is even and is limited by . ∎

###### Example 10.

Among classical codes, the largest distance is obtained for the repetition codes, with the parameters . The parity-check polynomial is ; the generator polynomial is irreducible and palindromic for , and for all that satisfy the condition , where is the multiplicative order of modulo . This includes the following :

 {3,5,11,13,19,29,37,53,59,61,67,83,…}. (43)

Lemma 7 shows that for from the set (43), additive cyclic CWS codes with parameters exist, where is obtained from Eq. (42) with . Asymptotically, at large , this corresponds to cyclic codes with the relative distance given by half of that given by Eq. (28).

###### Example 11.

(Cyclic analogs of the toric code) In the setting of the previous example, cyclic CWS codes , , , with were obtained numerically. The corresponding graph-state generators are for , for , etc. We obtain a family of cyclic codes with the weight- generators, , , etc. Codes with generators , , , and have the same parameters (the corresponding graphs are somewhat more complicated). The latter family can be generalized to codes with , , , ; the corresponding stabilizer generators having identity operators separating and