# [

###### Abstract

Quantum stabilizer states over can be represented as self-dual additive codes over . 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 . In this paper we classify self-dual additive codes over , , and . Assuming that the classical MDS conjecture holds, we are able to classify all self-dual additive MDS codes over 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.

Classification of self-dual additive codes]Graph-based classification of self-dual additive codes over finite fields
Lars Eirik Danielsen]
\subjclassPrimary: 94B05, 05C30; Secondary: 94B60, 05C50
^{†}^{†}thanks: The author is supported by the Research Council of Norway.

Lars Eirik Danielsen

Department of Informatics

University of Bergen

PO Box 7803, N-5020 Bergen, Norway

## 1 Introduction

It is well-known that *self-orthogonal additive codes* over
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 corresponds to a self-orthogonal *additive
code* over . 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 self-dual additive codes over 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 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 , , and 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 , 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.

## 2 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 ,
where is the probability of observing the value 0 when we measure the qubit,
and is the probability of observing the value 1. More generally, data could be
stored in -level *qudits*, described by vectors from . Measuring such a
qudit would give a result from an alphabet with 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 vectors , , form an orthonormal basis of .

An error operator that can affect a single qudit is represented by a complex *unitary* matrix,
i.e., a matrix such that , where means conjugate transpose.
A state of qudits is represented by a vector
from .
Assuming that errors act independently on each qubit, this state is
affected by error operators described by -fold tensor products of unitary matrices.
In the case of qubits (), we only need to consider errors from the *Pauli group*,

due to the fact that these matrices form a basis of all unitary matrices.
The error is called a *bit-flip*, since .
The error is known as a *phase-flip*, since .
For general qudits that take their values from , we consider the *generalized Pauli group*,
, also known as the *discrete Heisenberg-Weyl group*.
When our alphabet is a finite field, we must have , where is a prime and .
The errors contained in the generalized Pauli group are *shift errors*, ,
and *phase errors*, , where ,
is a complex -th root of unity, and is the trace
function, .
If is a prime, i.e., , the generalized Pauli group is generated by

where is a complex -th root of unity, and is the identity matrix of specified dimension.^{1}^{1}1The
set of generators also contains the scalar ,
except for the case , where it contains , a 4-th root of unity.
This overall phase factor can be ignored for our purposes. The operators and
are obtained by taking the -th and -th powers of and , respectively.
Even if is not prime, we can still define qudits that take values from the cyclic group ,
and use the same error operators as defined above. However, when 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 , where ,
we use the error group [16],
i.e., the operators are -fold tensor products of Pauli matrices from the group .
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* and *dimension*
adds redundancy by encoding qudits using 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 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 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 , due to the commutativity
properties of the generalized Pauli matrices.
A stabilizer generated by a set of error operators defines a zero-dimensional
quantum code, also known as a *stabilizer state*.^{2}^{2}2Stabilizer states
could also be called one-dimensional quantum codes, since they are one-dimensional Hilbert subspaces. We use
the term dimension to mean the number of qudits the code can encode.
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 tensor components that are different from the identity matrix.
A quantum code of length , dimension , and minimum distance , over the alphabet , is
denoted an code. Stabilizer states are therefore codes.
If the minimum distance, , 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 *self-dual additive codes*.

###### Example 1.

A stabilizer state is obtained from the stabilizer generated by the following error operators.

## 3 Self-dual additive codes

We can represent a stabilizer state over by an matrix [1]. The submatrix represents shift errors, such that if occurs in the -th tensor component of the -th error operator in the set of generators. Similarly, the submatrix represents phase errors.

###### Example 2.

The matrix corresponding to the stabilizer state in Example 1 is

The matrix generates a code , and this code is a representation of a
stabilizer state. The fact that a stabilizer is an Abelian group translates into the requirement that
must be *self-dual* with respect to a *symplectic inner product*, i.e.,

We define the *symplectic weight* of a codeword as the number of
positions where , , 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 defined above to an additive code
over of length . The representation of binary stabilizer codes as self-dual additive codes
over 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, , over of length is defined as an
-linear subgroup of . The code contains codewords,
and can be defined by an generator matrix, , with entries from ,
such that any -linear combination of rows from is a codeword.^{3}^{3}3For additive codes over
, each codeword is a sum of rows of the generator matrix. However, we also use the
name “additive code” in this more general case.
To get from the stabilizer representation to the generator matrix , we simply take
, where is a primitive element of .
The code will be self-dual, , where the dual is defined
with respect to the *Hermitian trace inner product*, .
When is prime, the Hermitian trace inner product of two vectors over of length ,
and , is given by

When is not a prime, we use a modification of the Hermitian trace inner product [16],

where is a primitive element of .

The *Hamming weight* of a codeword , denoted ,
is the number of nonzero components of .
The *Hamming distance* between and
is .
The *minimum distance* of the code is the minimal Hamming distance
between any two distinct codewords of . Since is an additive code,
the minimum distance is also given by the smallest nonzero weight of any codeword in .
A code over with minimum distance is called an code.
The *weight distribution* of the code is the sequence
, where is the number of codewords of weight .
The *weight enumerator* of is the polynomial

For an additive code over , all must be divisible by .

###### Example 3.

The stabilizer state in Example 1 corresponds to the following generator matrix of a self-dual additive code.

We define two self-dual additive codes, and over , to be
*equivalent* if the codewords of can be mapped onto the codewords
of 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 . Let each element
be represented as .
We can then premultiply this element by a matrix. (We could equivalently have
applied transformations to pairwise columns of the matrix .)
It was shown by Rains [22] that by applying matrices
from the *symplectic group* to each coordinate, we preserve the properties of the code.
(This group contains all matrices with elements in and determinant one.)
For self-dual additive codes over , these symplectic operations can be represented more
simply as multiplication by nonzero elements from and conjugation of coordinates.
(Conjugation of elements in maps to .)
Combined, there are six possible transformations that are equivalent to the six permutations of the
elements in the coordinate.
The corresponding symplectic group is

where represents multiplication by and represents conjugation. Including coordinate permutations, there are a total of maps for a code of length .

For codes over , we observe that is a group of order 24 generated by

where represents multiplication by and represents the map . By taking powers of , we see that we are allowed to multiply a coordinate by only if . However, if we also conjugate the coordinate, we may multiply by where . Note that conjugation on its own is not allowed. The 8 operations just described may be combined with the operations represented by and to give a total of 24 operations. In all there are maps that take a self-dual additive code over to an equivalent code. In general, for codes over , the number of maps is .

A transformation that maps to itself is called an *automorphism* of .
All automorphisms of make up an *automorphism group*, denoted .
The number of distinct codes equivalent to a self-dual additive code over , , is then
given by .
The *equivalence class* of contains all codes that are equivalent to .
By adding the sizes of all equivalence classes of codes of length , we find the total number of distinct codes
of length , denoted . The number is also given by a *mass formula*. The mass formula
for self-dual additive codes over was found by Höhn [15]. This result is easily generalized
to .

###### Theorem 3.1.

where is the number of equivalence classes of codes of length , and is a representative from each equivalence class.

###### Proof.

Let be the total number of self-orthogonal codes. One such code, , can be extended to a self-orthogonal code in ways by adding an extra codeword from . Each code can be obtained in this way from different codes. It follows that

Starting with , the recursion gives us the number of self-dual codes,

By assuming that all codes of length have a trivial automorphism group, we get the following lower bound on , the total number of inequivalent codes. Note that when is large, most codes have a trivial automorphism group, so the tightness of the bound increases with . Also note that this bound is much tighter than a bound that was derived from results in graph theory by Bahramgiri and Beigi [2].

###### Theorem 3.2.

where if is even, and if is odd.

###### Proof.

When is even, the trivial automorphism group includes only the identity permutation, and the result follows from Theorem 3.1. When is odd, where is a prime, the trivial automorphism group also contains the transformation that applies the symplectic operation to all coordinates. This operation is equivalent to multiplying each codeword by , 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 . A tighter bound for codes over 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 is the *Hexacode*.
Ketkar et al. [16, Thm. 63] proved that a self-dual additive MDS code must
satisfy . If the famous MDS conjecture holds, then ,
or when is even and or .
Grassl, Rötteler, and Beth [24] showed that MDS codes of length always exist.

Self-dual *linear* codes over are a subset of the self-dual additive codes.
Only additive codes that satisfy certain constraints can be linear. Such constraints
for codes over 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 , of a linear code must be divisible by , whereas for an additive
code they need only be divisible by .

## 4 Correspondence to weighted graphs

A *graph* is a pair where is a set of *vertices* and
is a set of *edges*.
Let an *-weighted graph* be a triple where is a set of weights from .
Each edge has an associated non-zero weight. (An edge with weight zero is the same as a non-edge.)
An -weighted graph with vertices can be represented by an *adjacency matrix* ,
where the element if , and otherwise.
We will only consider *simple* *undirected* graphs whose adjacency matrices are symmetric with
all diagonal elements being 0. The *neighbourhood* of , denoted ,
is the set of vertices connected to by an edge. The number of vertices adjacent to , ,
is called the *degree* of . The *induced subgraph* of on
contains vertices and all edges from whose endpoints are both in .
The *complement* of a 2-weighted graph is found by replacing with
, i.e., the edges in are changed to non-edges, and the non-edges to edges.
Two graphs and are *isomorphic* if and only if
there exists a permutation of such that . We also require that weights are preserved, i.e., .
A *path* is a sequence of vertices, , such that
.
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 that has a generator matrix of the form
, where is the identity matrix, is a primitive element of ,
and is the adjacency matrix of a simple undirected -weighted graph.

###### Theorem 4.2.

Every self-dual additive code over is equivalent to a graph code.

###### Proof.

The generator matrix, , of a self-dual additive code over corresponds to an matrix with elements from , such that . We must prove that an equivalent code is generated by , where is the identity matrix and is the adjacency matrix of a simple undirected -weighted graph. A basis change can be accomplished by , where is an invertible matrix with elements from . If has full rank, the solution is simple, since . We obtain after changing the diagonal elements of to 0, by appropriate symplectic transformations. Any two rows of will be orthogonal with respect to the symplectic inner product, which means that , and it follows that will always be a symmetric matrix. In the case where has rank , we can perform a basis change to get

where is a matrix with full rank, and also has size . Since the row-space of defines a self-dual code, and contains an all-zero row, it must be true that . must have full rank, and the row space of must be the orthogonal complement of the row space of . We assume that where is a invertible matrix. We also write where has size . Assume that there exists an such that . Then the vector of length satisfies . Since the row space of is the orthogonal complement of the row space of , we can write for some . We see that , and since has full rank, it must therefore be true that . This means that , which proves that is an invertible matrix. Two of the symplectic operations that we can apply to columns of a generator matrix are and . This means that we can interchange column of and column of if we also multiply one of the columns by . In this way we swap the -th columns of and for to get . Since and are invertible, must also be an invertible matrix. We then find , and set all diagonal elements of to 0 by symplectic transformations. ∎

###### Example 4.

Note that Theorem 4.2 is a generalization of the same theorem for codes over [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 -weighted graph represents a self-dual additive code over , and that every self-dual additive code over can be represented by an -weighted graph. It follows that we can, without loss of generality, restrict our study to codes with generator matrices of the form , where is an adjacency matrix of an unlabeled simple undirected -weighed graph.

## 5 Graph equivalence and code equivalence

Swapping vertex and vertex of a graph with adjacency matrix can be accomplished by exchanging column and column of and then exchanging row and row of . We call the resulting matrix . Exactly the same column and row operations map to , 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 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 of length up to 12 [7].

###### Definition 5.1 ([3]).

Given a graph and a vertex , let be the neighbourhood of .
*Local complementation* (LC) on transforms into by replacing the induced subgraph
of on by its complement.

###### Theorem 5.2 ([3, 9, 20, 21]).

Two self-dual additive codes over , and , with graph representations and , are equivalent if and only if there is a finite sequence of not necessarily distinct vertices , such that is isomorphic to .

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 , i.e., self-dual additive codes over , can
be described in terms of graph operations.^{4}^{4}4Bahramgiri and Beigi [2] only
state their theorem for where is prime, but the result holds for any finite field,
as their proof does not depend on being prime.

###### Definition 5.3 ([2]).

Given an -weighted graph and a vertex ,
*weight shifting* on by transforms into
by multiplying the weight of each edge incident on by .

###### Definition 5.4 ([2]).

Given an -weighted graph and a vertex ,
*generalized local complementation* on by transforms
into . Let and be the adjacency matrices of and , respectively.
Then , for all , and
for all .

###### Theorem 5.5 ([2]).

Two self-dual additive codes over , and , with graph representations and , are equivalent if and only if we get a graph isomorphic to by applying some finite sequence of weight shifts and generalized local complementations to .

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 .

###### Definition 5.6.

The *LC orbit* of a weighted graph is the set of all non-isomorphic graphs that
can be obtained by performing any sequence of weight shifts and generalized LC operations on .

###### Theorem 5.7.

The minimum distance of a self-dual additive code is equal to , where is the minimum vertex degree over all graphs in the associated LC orbit.

###### Proof.

A vertex with degree in the LC orbit corresponds to a codeword of weight , and we will now show that such a vertex always exists. Choose any graph representation of the code and let be the corresponding generator matrix. Find a codeword of weight generated by . Let the -th row of be one of the rows that is linearly dependent on. Apply symplectic transformations to the coordinates of the code such that is mapped to with in coordinate , and with in all other of the last coordinates. Since we do not care about changes in the corresponding first coordinates, as long as the symplectic weight of is preserved, there will always be transformations that achieve this. Apply the same transformations to the columns of , and then replace the -th row with , to get . Note that the right half of still has full rank, so we can transform into a matrix of the form by Gaussian elimination, where the symplectic weight of the -th row is . Finally, we set all diagonal elements of to zero by appropriate symplectic transformations. Vertex of the graph with adjacency matrix has degree . ∎

## 6 Classification

It follows from Theorem 5.5 that two self-dual additive codes over
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 be the set consisting of all non-isomorphic simple undirected connected
-weighted graphs on 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 be an code and an code. The
direct sum, ,
where means concatenation, is an code.
It follows that all decomposable codes of length can be classified easily once
all indecomposable codes of length less than are known.

The set of all distinct LC orbits of connected -weighted graphs on vertices is a partitioning of
into disjoint sets.
is also the number of indecomposable self-dual additive codes over of length ,
up to equivalence. Let be a set containing one representative from each
LC orbit of connected -weighted graphs on vertices.
The simplest algorithm for finding such sets of representatives is to start with the set
and generate LC orbits of its members until we have a partitioning of .
The following more efficient technique is based on a method described by Glynn et al. [9].
Let the *extensions* of an -weighted graph on 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 , containing graphs,
is formed by making all possible extensions of all graphs in .

###### Theorem 6.1.

, i.e., the set will contain at least one representative from each LC orbit of connected -weighted graphs on vertices.

###### Proof.

Let , and choose any subset of vertices. By doing weight shifts and generalized LC operations on vertices in , we can transform the induced subgraph of on into one of the graphs in that were extended when was constructed. It follows that for all , some graph in the LC orbit of must be part of . ∎

The set will be much smaller than , so it will be more efficient to search for a set of LC orbit representatives within . 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
, , and up to lengths 8, 6, and 6, respectively.
Table 1 gives the values of , the number of distinct LC orbits
of connected -weighted graphs on vertices, which is also the number of inequivalent indecomposable
self-dual additive codes over of length .
The total number of inequivalent codes of length , ,
is shown in Table 2 together with lower bounds derived from Theorem 3.2.
The numbers are easily derived from the numbers by using the *Euler transform* [27],

Tables 3, 4, and 5 list by minimum distance the numbers of indecomposable codes over , , and . 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 , we refer to previous work [7], and the web page http://www.ii.uib.no/~larsed/vncorbits/.

1 | 1 | 1 | 1 | 1 |
---|---|---|---|---|

2 | 1 | 1 | 1 | 1 |

3 | 1 | 1 | 1 | 1 |

4 | 2 | 3 | 3 | 3 |

5 | 4 | 5 | 6 | 7 |

6 | 11 | 21 | 25 | 38 |

7 | 26 | 73 | ||

8 | 101 | 659 | ||

9 | 440 | |||

10 | 3,132 | |||

11 | 40,457 | |||

12 | 1,274,068 |

1 | 1 | 1 | 1 | 1 |

2 | 2 | 2 | 2 | 2 |

3 | 3 | 3 | 3 | 3 |

4 | 6 | 7 | 7 | 7 |

5 | 11 | 13 | 14 | 15 |

6 | 26 | 39 | 44 | 58 |

7 | 59 | 121 | ? | ? |

8 | 182 | 817 | 946 |
21,161 |

9 | 675 | 9,646 |
458,993 |
38,267,406 |

10 | 3,990 | 2,373,100 |
||

11 | 45,144 | |||

12 | 1,323,363 | |||

13 | 72,573,549 |

2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | |
---|---|---|---|---|---|---|---|---|---|

2 | 1 | 1 | 2 | 4 | 15 | 51 | 388 | ? | ? |

3 | 1 | 1 | 5 | 20 | 194 | ? | ? | ||

4 | 1 | 2 | 77 | ? | ? | ||||

5 | 4 | ? | |||||||

6 | 1 | ||||||||

All | 1 | 1 | 3 | 5 | 21 | 73 | 659 | ? | ? |

2 | 3 | 4 | 5 | 6 | |
---|---|---|---|---|---|

2 | 1 | 1 | 2 | 4 | 16 |

3 | 1 | 2 | 6 | ||

4 | 3 | ||||

5 | |||||

6 | |||||

All | 1 | 1 | 3 | 6 | 25 |

2 | 3 | 4 | 5 | 6 | |
---|---|---|---|---|---|

2 | 1 | 1 | 2 | 4 | 21 |

3 | 1 | 3 | 11 | ||

4 | 6 | ||||

5 | |||||

6 | |||||

All | 1 | 1 | 3 | 7 | 38 |

Note that applying the graph extension technique described previously is equivalent to
*lengthening* [8] a self-dual additive code. Given an code,
we add a row and column to its generator matrix to obtain an code,
where . If follows that given a classification of all codes of length and minimum distance ,
we can classify all codes of length and minimum distance . All length 8 codes over
have been classified as described above. By extending the 77 codes,
we found 4 codes, and from those we obtained a single code.
Assuming that the MDS conjecture holds, there are no self-dual additive MDS codes over
with length above 10. This would mean that the three MDS codes with parameters ,
, and are the only non-trivial self-dual additive MDS codes
over . The and are constructed as circulant codes in
Section 7. A generator matrix for the code is given in Example 4.
In fact, a code, for any , is generated by

where . This code has weight enumerator .

There are four codes, all with weight enumerator . None of these are equivalent to circulant graph codes. The generator matrices are:

The two codes, the three , and five of the six codes are equivalent to circulant graph codes generated in Section 7. The last code has weight enumerator and generator matrix

## 7 Circulant graph codes

It is clearly infeasible to study all self-dual additive codes of lengths much higher than those
classified in the previous section. We therefore restrict our search space to the
codes over of length corresponding to graphs
with *circulant* adjacency matrices. A matrix is circulant if the -th row is equal to the
first row, cyclically shifted times to the right.
We have performed an exhaustive search of such
graphs, the result of which is summarized in Table 6.
This table shows the highest found minimum distance of self-dual additive codes
over various alphabets. A code with the given minimum distance has been found in our search,
except for the cases marked , where a better code is obtained in some other way and does not have a
circulant graph representation,^{5}^{5}5See the web page http://www.codetables.de/ for details
on how codes over of length 18 and 21 can be obtained.
and cases marked , which are not circulant, but obtained by
a trivial *shortening* [8] of a longer circulant code.
Minimum distances printed in bold font are optimal according to the quantum singleton bound.
If is even and the quantum singleton bound is satisfied with equality, we have an MDS code.

2 | ||||

3 | ||||

4 | 2 | |||

5 | ||||

6 | ||||

7 | 3 | |||

8 | 4 | 4 | 4 | 4 |

9 | 4 | |||

10 | 4 | |||

11 | 5 | |||

12 | 6 | 6 | 6 | 6 |

13 | 5 | 6 | 6 | |

14 | 6 | 6 | 7 | |

15 | 6 | 6 | 7 | 7 |

16 | 6 | 6 | 8 | 8 |

17 | 7 | 7 | 8 | |

18 | 8 | 8 | ||

19 | 7 | 8 | ||

20 | 8 | 8 | ||

21 | 8 | |||

22 | 8 | 9 | ||

23 | 8 | 9 | ||

24 | 8 | 9 | ||

25 | 8 | |||

26 | 8 | |||

27 | ||||

28 | 10 | |||

29 | 11 | |||

30 | 12 |

We here give the first row of a circulant generator matrix for those codes classified in Section 6 that are equivalent to circulant graph codes. There is a unique code with weight enumerator generated by . There are two inequivalent codes generated by and , both with weight enumerator . There is a unique code with weight enumerator generated by . There are three inequivalent codes with weight enumerator generated by , , and , where is a primitive element of . There are five inequivalent codes generated by , , , , and