Graph-Based Classification of Self-Dual Additive Codes over Finite Fields

Quantum stabilizer states over GF(m) can be represented as self-dual additive codes over GF(m^2). These codes can be represented as weighted graphs, and orbits of graphs under the generalized local complementation operation correspond to equivalence classes of codes. We have previously used this fact to classify self-dual additive codes over GF(4). In this paper we classify self-dual additive codes over GF(9), GF(16), and GF(25). Assuming that the classical MDS conjecture holds, we are able to classify all self-dual additive MDS codes over GF(9) by using an extension technique. We prove that the minimum distance of a self-dual additive code is related to the minimum vertex degree in the associated graph orbit. Circulant graph codes are introduced, and a computer search reveals that this set contains many strong codes. We show that some of these codes have highly regular graph representations.


Introduction
It is well-known that self-orthogonal additive codes over F 4 can be used to represent a class of quantum error-correcting codes known as binary stabilizer codes [4]. Although the binary stabilizer codes have been studied most, several authors have considered nonbinary stabilizer codes over finite fields [1,11,12,16,22,25], cyclic groups [14], and Abelian groups in general [26]. We will focus mainly on codes over finite fields, and exploit the fact that a stabilizer code over F m corresponds to a self-orthogonal additive code over F m 2 . Quantum codes of dimension zero are known as stabilizer states, which are entangled quantum states with several possible applications. Stabilizer states correspond to self-dual additive codes. It is known that such codes can be represented as graphs [12,26]. It is also known that two selfdual additive codes over F 4 are equivalent if and only if their corresponding graphs are equivalent, up to isomorphism, with respect to a sequence of local complementations [3,9,20,21]. We have previously used this fact to devise a graph-based algorithm with which we classified all self-dual additive codes over F 4 of length up to 12 [7]. Recently, the representation of equivalence classes as graph orbits was generalized to self-dual additive codes over any finite field [2]. In this paper we use graph-based algorithms to classify all self-dual additive codes over F 9 , F 16 , and F 25 up to lengths 8, 6, and 6, respectively. We also give upper bounds on the number of codes, derived from mass formulas. By using a graph extension technique we find that there are only three non-trivial self-dual additive MDS codes over F 9 , assuming that the classical MDS conjecture holds. We prove that the minimum distance of a self-dual additive code is related to the minimum vertex degree in the associated graph orbit. Finally, we perform a search of circulant graph codes, a subclass of the self-dual additive codes, which is shown to contain many codes with high minimum distance. The highly regular graph structures of some of these codes are described.

Stabilizer states
Data in a classical computer are typically stored in bits that have values either 0 or 1. Similarly, we can envisage a quantum computer where data are stored in quantum bits, also known as qubits, i.e., two-level quantum systems. One qubit can then be described by a vector |x = α β ∈ C 2 , where |α| 2 is the probability of observing the value 0 when we measure the qubit, and |β| 2 is the probability of observing the value 1. More generally, data could be stored in m-level qudits, described by vectors from C m . Measuring such a qudit would give a result from an alphabet with m symbols. In general, this alphabet could be any finite Abelian group, but we will focus on the case where the alphabet is a finite field. The m vectors |x , x ∈ F m , form an orthonormal basis of C m .
An error operator that can affect a single qudit is represented by a complex unitary m×m matrix, i.e., a matrix U such that U U † = I, where † means conjugate transpose. A state of n qudits is represented by a vector from C m n = C m ⊗· · ·⊗C m . Assuming that errors act independently on each qubit, this state is affected by error operators described by n-fold tensor products of unitary m × m matrices. In the case of qubits (m = 2), we only need to consider errors from the Pauli group, due to the fact that these matrices form a basis of all unitary 2 × 2 matrices. The error X is called a bit-flip, since X |x = |x + 1 . The error Z is known as a phaseflip, since Z |x = (−1) x |x . For general qudits that take their values from F m , we consider the generalized Pauli group, P m , also known as the discrete Heisenberg-Weyl group. When our alphabet is a finite field, we must have m = p r , where p is a prime and r ≥ 1. The errors contained in the generalized Pauli group are shift errors, X(a) |x = |x + a , and phase errors, Z(b) |x = ω tr m/p (bx) |x , where a, b ∈ F m , ω is a complex p-th root of unity, and tr m/p : F m → F p is the trace function, tr m/p (c) = r−1 i=0 c p i . If m = p is a prime, i.e., r = 1, the generalized Pauli group is generated by where ω is a complex p-th root of unity, and I is the identity matrix of specified dimension. 1 The operators X(a) and Z(b) are obtained by taking the a-th and b-th powers of X(1) and Z(1), respectively. Even if m is not prime, we can still define qudits that take values from the cyclic group Z m , and use the same error operators as defined above. However, when m is a prime power, we get much better codes by using a finite field as our alphabet. When we work with qudits that take values from F p r , where r > 1, we use the error group 16], i.e., the operators are r-fold tensor products of Pauli matrices from the group P p . The error bases that we use are examples of nice error bases [17].
Quantum codes are designed to add redundancy in order to protect quantum states against errors due to interference from the environment. A code of length n and dimension k adds redundancy by encoding k qudits using n qudits. One type of code that exploits the fact that the generalized Pauli group forms a basis for all possible errors is the stabilizer code [10]. A stabilizer is an Abelian group generated by a set of n − k commuting error operators. An error is detected by measuring the eigenvalues of these operators. If a state is a valid codeword that has not been affected by error, we will observe the eigenvalue +1 for all operators. The quantum code, i.e., the set of all valid codewords, is therefore a joint eigenspace of the stabilizer. If there is a detectable error, some eigenvalues would be different from +1, due to the commutativity properties of the generalized Pauli matrices. A stabilizer generated by a set of n error operators defines a zero-dimensional quantum code, also known as a stabilizer state. 2 The minimum distance of a zero-dimensional stabilizer code is simply the minimum nonzero weight of all error operators in the stabilizer. The weight of an error operator is the number of m × m tensor components that are different from the identity matrix. A quantum code of length n, dimension k, and minimum distance d, over the alphabet F m , is denoted an [[n, k, d]] m code. Stabilizer states are therefore [[n, 0, d]] m codes. If the minimum distance, d, is high, the stabilizer state is robust against error, which indicates that it is highly entangled. Entangled quantum states have many potential applications, for instance in cryptographic protocols, or as graph states [23] which can be used as a resource for quantum computations. In the next section we will also see that zero-dimensional stabilizer codes correspond to an interesting class of classical codes, known as selfdual additive codes. [4,0,3]] 3 stabilizer state is obtained from the stabilizer generated by the following error operators.

Self-dual additive codes
We can represent a stabilizer state over F m by an n × 2n matrix (A | B) [1]. The submatrix A represents shift errors, such that A (i,j) = a if X(a) occurs in the j-th tensor component of the i-th error operator in the set of generators. Similarly, the submatrix B represents phase errors. The matrix (A | B) generates a code C, and this code is a representation of a stabilizer state. The fact that a stabilizer is an Abelian group translates into the requirement that C must be self-dual with respect to a symplectic inner product, i.e., We define the symplectic weight of a codeword (a | b) ∈ C as the number of positions i where a i , b i , or both are nonzero. (This is the same as the weight of the corresponding Pauli error operator. ) We can also map the linear code of length 2n defined above to an additive code over F m 2 of length n. The representation of binary stabilizer codes as self-dual additive codes over F 4 was first demonstrated by Calderbank et al. [4], and generalized to qudits by Ashikhmin and Knill [1], and by Ketkar et al. [16]. An additive code, C, over F m 2 of length n is defined as an F m -linear subgroup of F n m 2 . The code C contains m n codewords, and can be defined by an n × n generator matrix, C, with entries from F m 2 , such that any F m -linear combination of rows from C is a codeword. 3 To get from the stabilizer representation (A | B) to the generator matrix C, we simply take C = A + ωB, where ω is a primitive element of F m 2 . The code C will be self-dual, C = C ⊥ , where the dual is defined with respect to the Hermitian trace inner product, C ⊥ = {u ∈ F n m 2 | u * c = 0 for all c ∈ C}. When m = p is prime, the Hermitian trace inner product of two vectors over F p 2 of length n, u = (u 1 , u 2 , . . . , u n ) and v = (v 1 , v 2 , . . . , v n ), is given by When m = p r is not a prime, we use a modification of the Hermitian trace inner product [16], where ω is a primitive element of F m 2 .
The Hamming weight of a codeword u ∈ C, denoted wt(u), is the number of nonzero components of u. The Hamming distance between u and v is wt(u − v). The minimum distance of the code C is the minimal Hamming distance between any two distinct codewords of C. Since C is an additive code, the minimum distance is also given by the smallest nonzero weight of any codeword in C. A code over F m 2 with minimum distance d is called an (n, m n , d) code. The weight distribution of the code C is the sequence (A 0 , A 1 , . . . , A n ), where A i is the number of codewords of weight i. The weight enumerator of C is the polynomial For an additive code over F m 2 , all A i must be divisible by m − 1.
Example 3. The stabilizer state in Example 1 corresponds to the following generator matrix of a self-dual additive (4, 3 4 , 3) code.
We define two self-dual additive codes, C and C ′ over F m 2 , to be equivalent if the codewords of C can be mapped onto the codewords of C ′ by a map that preserves the properties of the code, including self-duality. A permutation of coordinates, or columns of a generator matrix, is such a map. Other operations can also be applied to the coordinates of C. Let each element a + ωb ∈ F m 2 be represented as We can then premultiply this element by a 2 × 2 matrix. (We could equivalently have applied transformations to pairwise columns of the 2n × n matrix (A | B).) It was shown by Rains [22] that by applying matrices from the symplectic group Sp 2 (m) to each coordinate, we preserve the properties of the code. (This group contains all 2 × 2 matrices with elements in F m and determinant one.) For self-dual additive codes over F 4 , these symplectic operations can be represented more simply as multiplication by nonzero elements from F 4 and conjugation of coordinates. (Conjugation of elements in F p 2 maps x to x p .) Combined, there are six possible transformations that are equivalent to the six permutations of the elements {1, ω, ω 2 } in the coordinate. The corresponding symplectic group is where A 1 represents multiplication by ω and A 2 represents conjugation. Including coordinate permutations, there are a total of 6 n n! maps for a code of length n. For codes over F 9 , we observe that Sp 2 (3) is a group of order 24 generated by where A 1 represents multiplication by ω 2 and A 2 represents the map a + ωb → a + b + ωb. By taking powers of A 1 , we see that we are allowed to multiply a coordinate by x ∈ F 9 only if xx = 1. However, if we also conjugate the coordinate, we may multiply by x ∈ F 9 where xx = 2. Note that conjugation on its own is not allowed. The 8 operations just described may be combined with the operations represented by A 2 and A 2 2 to give a total of 24 operations. In all there are 24 n n! maps that take a self-dual additive code over F 9 to an equivalent code. In general, for codes over F m 2 , the number of maps is | Sp 2 (m)| n n!.
A transformation that maps C to itself is called an automorphism of C. All automorphisms of C make up an automorphism group, denoted Aut(C). The number of distinct codes equivalent to a self-dual additive code over F m 2 , C, is then given by | Sp 2 (m)| n n! | Aut(C)| . The equivalence class of C contains all codes that are equivalent to C. By adding the sizes of all equivalence classes of codes of length n, we find the total number of distinct codes of length n, denoted T n . The number T n is also given by a mass formula. The mass formula for self-dual additive codes over F 4 was found by Höhn [15]. This result is easily generalized to F m 2 .
where t n is the number of equivalence classes of codes of length n, and C j is a representative from each equivalence class.
Proof. Let M (n, k) be the total number of self-orthogonal (n, m k ) codes. One such code, C, can be extended to a self-orthogonal (n, m k+1 ) code in m 2(n−k) − 1 ways by adding an extra codeword from C ⊥ . Each (n, m k+1 ) code can be obtained in this way from m 2(k+1) − 1 different (n, m k ) codes. It follows that Starting with M (n, 0) = 1, the recursion gives us the number of self-dual (n, m n ) codes, By assuming that all codes of length n have a trivial automorphism group, we get the following lower bound on t n , the total number of inequivalent codes. Note that when n is large, most codes have a trivial automorphism group, so the tightness of the bound increases with n. Also note that this bound is much tighter than a bound that was derived from results in graph theory by Bahramgiri and Beigi [2].
where c = 1 if m is even, and c = 2 if m is odd.
Proof. When m is even, the trivial automorphism group includes only the identity permutation, and the result follows from Theorem 3.1. When m = p r is odd, where p is a prime, the trivial automorphism group also contains the transformation that applies the symplectic operation p − 1 0 0 p − 1 to all coordinates. This operation is equivalent to multiplying each codeword by p − 1, and will therefore map an additive code to itself.
It follows from the quantum singleton bound [18,22] that any self-dual additive code must satisfy 2d ≤ n + 2. A tighter bound for codes over F 4 was given by Calderbank et al. [4]. Codes that satisfy the singleton bound with equality are known as maximum distance separable (MDS) codes. Self-dual MDS codes must have even length, and MDS codes of length two are trivial and exist for all alphabets. The only non-trivial MDS code over F 4 is the (6, 2 6 , 4) Hexacode. Ketkar et al. [16,Thm. 63] proved that a self-dual additive (n, m n , d) MDS code must satisfy n ≤ m 2 + d − 2 ≤ 2m 2 − 2. If the famous MDS conjecture holds, then n ≤ m 2 + 1, or n ≤ m 2 + 2 when m is even and d = 4 or d = m 2 . Grassl, Rötteler, and Beth [24] showed that MDS codes of length n ≤ m + 1 always exist.
Self-dual linear codes over F m 2 are a subset of the self-dual additive codes. Only additive codes that satisfy certain constraints can be linear. Such constraints for codes over F 4 were described by Van den Nest [20] and by Glynn et al. [9]. An obvious constraint is that all coefficients of the weight enumerator, except A 0 , of a linear code must be divisible by m 2 − 1, whereas for an additive code they need only be divisible by m − 1.

Correspondence to weighted graphs
Let an m-weighted graph be a triple G = (V, E, W ) where W is a set of weights from F m . Each edge has an associated non-zero weight. (An edge with weight zero is the same as a non-edge.) An m-weighted graph with n vertices can be represented by an n × n adjacency matrix Γ, where the element j} ∈ E, and Γ (i,j) = 0 otherwise. We will only consider simple undirected graphs whose adjacency matrices are symmetric with all diagonal elements being 0. The neighbourhood of v ∈ V , denoted N v ⊂ V , is the set of vertices connected to v by an edge. The number of vertices adjacent to v, |N v |, is called the degree of v. The induced subgraph of G on U ⊆ V contains vertices U and all edges from E whose endpoints are both in U . The complement of a 2-weighted graph G is found by replacing E with V × V − E, i.e., the edges in E are changed to non-edges, and the non-edges to edges. Two graphs G = (V, E) and G ′ = (V, E ′ ) are isomorphic if and only if there exists a permutation π of V such that {u, v} ∈ E ⇐⇒ {π(u), π(v)} ∈ E ′ . We also require that weights are preserved, i.e., A graph is connected if there is a path from any vertex to any other vertex in the graph. A complete graph is a graph where all pairs of vertices are connected by an edge. A clique is a complete subgraph.
Definition 4.1. A graph code is an additive code over F m 2 that has a generator matrix of the form C = Γ + ωI, where I is the identity matrix, ω is a primitive element of F m 2 , and Γ is the adjacency matrix of a simple undirected m-weighted graph.
Theorem 4.2. Every self-dual additive code over F m 2 is equivalent to a graph code.
Proof. The generator matrix, C, of a self-dual additive code over F m 2 corresponds to an n × 2n matrix (A | B) with elements from F m , such that C = A + ωB. We must prove that an equivalent code is generated by (Γ | I), where I is the identity matrix and Γ is the adjacency matrix of a simple undirected m-weighted graph. A basis change can be accomplished by ( where M is an n × n invertible matrix with elements from F m . If B has full rank, the solution is simple, since B −1 (A | B) = (Γ ′ | I). We obtain (Γ | I) after changing the diagonal elements of Γ ′ to 0, by appropriate symplectic transformations. Any two rows of (Γ | I) will be orthogonal with respect to the symplectic inner product, which means that ΓI T − IΓ T = 0, and it follows that Γ will always be a symmetric matrix. In the case where B has rank k < n, we can perform a basis change to get where B 1 is a k × n matrix with full rank, and A 1 also has size k × n. Since the rowspace of (A ′ | B ′ ) defines a self-dual code, and B ′ contains an all-zero row, it must be true that A 2 B T 1 = 0. A 2 must have full rank, and the row space of B 1 must be the orthogonal complement of the row space of A 2 . We assume that B 1 = (B 11 | B 12 ) where B 11 is a k × k invertible matrix. We also write A 2 = (A 21 | A 22 ) where A 22 has size (n − k) × (n − k). Assume that there exists an x ∈ F n−k m such that Since the row space of B 1 is the orthogonal complement of the row space of A 2 , we can write v = yB 1 for some y ∈ F k m . We see that yB 11 = 0, and since B 11 has full rank, it must therefore be true that y = 0. This means that x = 0, which proves that  This means that the stabilizer state from Example 1 is equivalent to the graph code generated by C = Γ + ωI. The graph defined by Γ is depicted in Fig. 1.
Note that Theorem 4.2 is a generalization of the same theorem for codes over F 4 [7], which was proved by Van den Nest et al. [21]. The fact that stabilizer codes can be represented by graphs was also shown by Schlingemann and Werner [26] and by Grassl, Klappenecker, and Rötteler [12].
We have seen that every m-weighted graph represents a self-dual additive code over F m 2 , and that every self-dual additive code over F m 2 can be represented by an m-weighted graph. It follows that we can, without loss of generality, restrict our study to codes with generator matrices of the form Γ + ωI, where Γ is an adjacency matrix of an unlabeled simple undirected m-weighed graph.

Graph equivalence and code equivalence
Swapping vertex i and vertex j of a graph with adjacency matrix Γ can be accomplished by exchanging column i and column j of Γ and then exchanging row i and row j of Γ. We call the resulting matrix Γ ′ . Exactly the same column and row operations map Γ+ωI to Γ ′ +ωI, which are generator matrices for equivalent codes. It follows that two codes are equivalent if their corresponding graphs are isomorphic. However, the symplectic transformations that map a code to an equivalent code do not in general produce isomorphic graphs, but we will see that they can be described as graph operations. It is known that two self-dual additive codes over F 4 are equivalent if and only if their corresponding graphs are equivalent, up to isomorphism, with respect to a sequence of local complementations [3,9,20,21]. We have previously used this fact to devise a graph-based algorithm with which we classified all self-dual additive codes over F 4 of length up to 12 [7].
The LC operation can be generalized to weighted graphs, and it was first shown by Bahramgiri and Beigi [2] that the equivalence of nonbinary stabilizer states over F m , i.e., self-dual additive codes over F m 2 , can be described in terms of graph operations. 4

Figure 4: Example of Generalized Local Complementation
A proof of Theorem 5.5 was given by by Bahramgiri and Beigi [2], as a generalization of the proof given by Van den Nest et al. [21] for self-dual additive codes over F 4 .
Definition 5.6. The LC orbit of a weighted graph G is the set of all non-isomorphic graphs that can be obtained by performing any sequence of weight shifts and generalized LC operations on G.
Theorem 5.7. The minimum distance of a self-dual additive (n, m n , d) code is equal to δ + 1, where δ is the minimum vertex degree over all graphs in the associated LC orbit.
Proof. A vertex with degree d − 1 in the LC orbit corresponds to a codeword of weight d, and we will now show that such a vertex always exists. Choose any graph representation of the code and let G = (Γ | I) be the corresponding generator matrix. Find a codeword c of weight d generated by G. Let the i-th row of G be one of the rows that c is linearly dependent on. Apply symplectic transformations to the coordinates of the code such that c is mapped to c ′ with 1 in coordinate n + i, and with 0 in all other of the last n coordinates. Since we do not care about changes in the corresponding first n coordinates, as long as the symplectic weight of c is preserved, there will always be transformations that achieve this. Apply the same transformations to the columns of G, and then replace the i-th row with c ′ , to get G ′ . Note that the right half of G ′ still has full rank, so we can transform G ′ into a matrix of the form (Γ ′ | I) by Gaussian elimination, where the symplectic weight of the i-th row is d. Finally, we set all diagonal elements of Γ ′ to zero by appropriate symplectic transformations. Vertex i of the graph with adjacency matrix Γ ′ has degree d − 1.

Classification
It follows from Theorem 5.5 that two self-dual additive codes over F m 2 are equivalent if and only if their graph representations are in the same LC orbit. The LC orbit of a graph can easily be generated by a recursive algorithm. We have used the program nauty [19] to check for graph isomorphism.
Let G n,m be the set consisting of all non-isomorphic simple undirected connected m-weighted graphs on n vertices. Note that connected graphs correspond to indecomposable codes. A code is decomposable if it can be written as the direct sum of two smaller codes. For example, let C be an (n, m n , d) code and C ′ an (n ′ , m n ′ , d ′ ) code. The direct sum, C ⊕ C ′ = {u||v | u ∈ C, v ∈ C ′ }, where || means concatenation, is an (n + n ′ , m n+n ′ , min{d, d ′ }) code. It follows that all decomposable codes of length n can be classified easily once all indecomposable codes of length less than n are known.
The set of all distinct LC orbits of connected m-weighted graphs on n vertices is a partitioning of G n,m into i n,m disjoint sets. i n,m is also the number of indecomposable self-dual additive codes over F m 2 of length n, up to equivalence. Let L n,m be a set containing one representative from each LC orbit of connected m-weighted graphs on n vertices. The simplest algorithm for finding such sets of representatives is to start with the set G n,m and generate LC orbits of its members until we have a partitioning of G n,m . The following more efficient technique is based on a method described by Glynn et al. [9]. Let the m n − 1 extensions of an m-weighted graph on n vertices be formed by adding a new vertex and joining it to all possible combinations of at least one of the old vertices, using all possible combinations of edge weights. The set E n,m , containing i n−1,m (m n−1 − 1) graphs, is formed by making all possible extensions of all graphs in L n−1,m . Theorem 6.1. L n,m ⊂ E n,m , i.e., the set E n,m will contain at least one representative from each LC orbit of connected m-weighted graphs on n vertices.
Proof. Let G = (V, E, W ) ∈ G n,m , and choose any subset U ⊂ V of n − 1 vertices. By doing weight shifts and generalized LC operations on vertices in U , we can transform the induced subgraph of G on U into one of the graphs in L n−1,m that were extended when E n,m was constructed. It follows that for all G ∈ G n,m , some graph in the LC orbit of G must be part of E n,m .
The set E n,m will be much smaller than G n,m , so it will be more efficient to search for a set of LC orbit representatives within E n,m . Another fact that simplifies our classification algorithm is that weight shifting and generalized local complementation commute. This means that to generate the LC orbit of a weighted graph, we may first generate the orbit with respect to generalized local complementation only, and then apply weight shifting to the resulting set of graphs.
Using the described techniques, we were able to classify all self-dual additive codes over F 9 , F 16 , and F 25 up to lengths 8, 6, and 6, respectively. Table 1 gives the values of i n,m , the number of distinct LC orbits of connected m-weighted graphs on n vertices, which is also the number of inequivalent indecomposable self-dual additive codes over F m 2 of length n. The total number of inequivalent codes of length n, t n , is shown in Table 2 together with lower bounds derived from Theorem 3.2. The numbers t n are easily derived from the numbers i n by using the Euler transform [27], Tables 3, 4, and 5 list by minimum distance the numbers of indecomposable codes over F 9 , F 16 , and F 25 . A database containing one representative from each equivalence class is available at http://www.ii.uib.no/~larsed/nonbinary/. For the classification of self-dual additive codes over F 4 , we refer to previous work [7], and the web page http://www.ii.uib.no/~larsed/vncorbits/. Note that applying the graph extension technique described previously is equivalent to lengthening [8] a self-dual additive code. Given an (n, m n , d) code, we add a row and column to its generator matrix to obtain an (n + 1, m n+1 , d ′ ) code, where d ′ ≤ d+ 1. If follows that given a classification of all codes of length n and minimum distance d, we can classify all codes of length n + 1 and minimum distance d + 1. All length 8 codes over F 9 have been classified as described above. By extending the 77 (8, 3 8 , 4) codes, we found 4 (9, 3 9 , 5) codes, and from those we obtained a single (10, 3 10 , 6) code. Assuming that the MDS conjecture holds, there are no selfdual additive MDS codes over F 9 with length above 10. This would mean that the three MDS codes with parameters (4, 3 4 , 3), (6, 3 6 , 4), and (10, 3 10 , 6) are the only non-trivial self-dual additive MDS codes over F 9 . The (6, 3 6 , 4) and (10, 3 10 , 6) are constructed as circulant codes in Section 7. A generator matrix for the (4, 3 4 , 3) code is given in Example 4. In fact, a (4, m 4 , 3) code, for any m ≥ 3, is generated by     There are four (9, 3 9 , 5) codes, all with weight enumerator W (1, y) = 1 + 252y 5 + 1176y 6 + 3672y 7 + 7794y 8 + 6788y 9 . None of these are equivalent to circulant graph The two (7, 3 7 , 4) codes, the three (6, 4 6 , 4), and five of the six (6, 5 6 , 4) codes are equivalent to circulant graph codes generated in Section 7. The last (6, 5 6 , 4) code has weight enumerator W (1, y) = 1+360y 4 +3024y 5 +12240y 6 and generator matrix
For circulant graph codes of higher length that are optimal according to the quantum singleton bound, we find that all codes of the same length have the same weight enumerator. In the list below, we give the first row of one generator matrix for each weight enumerator.
As mentioned in the introduction, stabilizer codes can be defined over any Abelian group, not only finite fields. For comparison, we also generated circulant codes over Z 2 4 . As expected, the minimum distance of these codes are much worse than for codes over F 16 . We found a (7, 4 7 , 4)-code over Z 2 4 , but for all other lengths up to 16, the best minimum distance was equal to the best minimum distance of codes over F 4 of the same length.
Gulliver and Kim [13] performed a computer search of circulant self-dual additive codes over F 4 of length up to 30. Their search was not restricted to graph codes, so our search space is a subset of theirs. It is interesting to note that for every length, the highest minimum distance found was the same in both searches. This suggests that the circulant graph code construction can produce codes as strong as the more general circulant code construction. Besides a smaller search space, the special form of the generator matrix of a graph code makes it easier to find the minimum distance, since any codeword obtained as a linear combination of i rows of the generator matrix must have weight at least i. If, for example, we want to determine whether a code has minimum distance at least d, we only need to consider combinations of d or fewer rows of its generator matrix.
Circulant graphs must be regular, i.e., all vertices must have the same number of neighbours. We have previously discovered [5,6] that many strong circulant selfdual additive codes over F 4 can be represented as highly structured nested clique graphs. Some of these graphs are shown in Fig. 5. For instance, Fig. 5b shows a graph representation of the (12, 2 12 , 6) "Dodecacode" consisting of three 4-cliques. The remaining edges form a Hamiltonian cycle, i.e., a cycle that visits every vertex of the graph exactly once. Notice that all graphs shown in Fig. 5 have minimum regular vertex degree, i.e., each vertex has d − 1 neighbours, where d is the minimum distance of the corresponding code.
We have discovered some new highly structured weighted graph representations of self-dual additive codes over F 9 and F 16 . Fig. 6 shows two interconnected 5cliques where all edges have weight one, and a 10-cycle where all edges have weight two. The sum of these two graphs, such that no edges overlap, corresponds to the (10, 3 10 , 6) code. Up to isomorphism, there is only one way to add a Hamiltonian cycle of weight two edges to the double 5-clique, since there cannot be both weight one and weight two edges between the same pair of vertices. The first row of a circulant generator matrix corresponding to this graph is (ω012111210).
As a second example, Fig. 7 shows two pairs of 4-cliques, each of which is connected by a length 8 cycle, and two 16-cycles where all edges have weight α and α 2 , respectively, where α = ω 5 is a primitive element of F 4 . The (16, 4 16 , 8) code generated by (ω0α 2 1α100010001α1α 2 ) corresponds to a sum of these three graphs.  Figure 6: Two Graphs Whose Sum Corresponds to the (10, 3 10 , 6) Code Note that the vertices of the graphs corresponding to circulant (10, 3 10 , 6) and (16, 4 16 , 8) graph codes have degree higher than d − 1. We have tried to obtain similar graph representations for other codes in Table 6, but without success. Many of the circulant graph codes have vertex degree much higher than d − 1, for instance the (14, 5 14 , 8) code generated by (ω1221202021221), and the (18, 5 18 , 10) code generated by (ω12134242124243121).