Heuristic construction of codeword stabilized codes

The family of codeword stabilized codes encompasses the stabilizer codes as well as many of the best known nonadditive codes. However, constructing optimal $n$-qubit codeword stabilized codes is made difficult by two main factors. The first of these is the exponential growth with $n$ of the number of graphs on which a code can be based. The second is the NP-hardness of the maximum clique search required to construct a code from a given graph. We address the second of these issues through the use of a heuristic clique finding algorithm. This approach has allowed us to find $((9,97\leq K\leq100,2))$ and $((11,387\leq K\leq416,2))$ codes, which are larger than any previously known codes. To address the exponential growth of the search space, we demonstrate that graphs that give large codes typically yield clique graphs with a large number of nodes. The number of such nodes can be determined relatively efficiently, and we demonstrate that $n$-node graphs yielding large clique graphs can be found using a genetic algorithm. This algorithm uses a novel spectral bisection based crossover operation that we demonstrate to be superior to more standard crossover operations. Using this genetic algorithm approach, we have found $((13,18,4))$ and $((13,20,4))$ codes that are larger than any previously known code. We also consider codes for the amplitude damping channel. We demonstrate that for $n\leq9$, optimal codeword stabilized codes correcting a single amplitude damping error can be found by considering standard form codes that detect one of only three of the $3^{n}$ possible equivalent error sets. By combining this error set selection with the genetic algorithm approach, we have found $((11,68))$ and $((11,80))$ codes capable of correcting a single amplitude damping error and $((11,4))$, $((12,4))$, $((13,8))$, and $((14,16))$ codes capable of correcting two amplitude damping


I. INTRODUCTION
Quantum codes can be used to protect quantum information against the effects of a noisy channel. An n-qubit code is a subspace Q ⊆ (C 2 ) ⊗n of dimension K. If Q can detect any arbitrary error on fewer than d qubits, but not some error on d qubits, then Q is said to have distance d and is called an ((n, K)) or ((n, K, d)) code. Equivalently, a code has distance d if it can detect the set E of all Pauli errors of weight less than d but cannot detect some weight d Pauli error [1]. A well understood family of codes is the stabilizer (additive) codes, which are codes defined using an abelian subgroup of the n-qubit Pauli group [2]. However, codes outside of the stabilizer framework, called nonadditive codes, can potentially encode a larger subspace while still detecting the same error set [3][4][5][6][7][8]. Codeword stabilized (CWS) codes encompass both the stabilizer codes and many of the best known nonadditive codes [9,10]. In general, an ((n, K)) CWS code is defined using an n-qubit stabilizer state, which is a stabilizer code of dimension one, and a set of K nqubit Pauli operators called word operators [9]. A standard form CWS code Q is one where the stabilizer state is defined by a simple undirected n-node graph G (that is, it is a graph state) and the word operators are defined by a binary classical code C ⊆ GF(2) n with |C| = K [9]. For Q to detect an error set E, C must detect the classical error set Cl G (E) ⊆ GF(2) n induced by the graph. An appropriate classical code of maximum size can be found by constructing a clique graph and performing a * alex.rigby@utas.edu.au maximum clique search [10].
The error set that must be detected by an ((n, K, d)) code Q is invariant under any permutation of the Pauli matrices X, Y , and Z on any subset of qubits. As a result of this symmetry, we call ((n, K, d)) codes symmetric codes. This symmetry also means that if Q ′ is local Clifford (LC) equivalent to Q (that is, if Q ′ = U Q for some LC operator U ), then Q ′ is also an ((n, K, d)) code. It follows from the LC equivalence of every stabilizer state to a graph state [11][12][13] that every CWS code is LC equivalent to one in standard form [9]. It is therefore sufficient to consider only standard form codes when attempting to construct an optimal ((n, K, d)) CWS code. In fact, it is sufficient to consider only codes based on graph states that are not LC equivalent up to a permutation of qubit labels [10]. This corresponds to considering only graphs that are not isomorphic up to a series of local complementations [11]. For n ≤ 12, this set of inequivalent graphs, denoted L n , has been enumerated [14][15][16] and in theory can be exhaustively searched to construct an optimal code. Such a search of L 10 has previously yielded the well known ((10, 24,3)) code [5]. For distance two codes, searching L n quickly becomes prohibitive with increasing n due to the rapidly growing clique graphs and the NP-hardness of finding a maximum clique [17]. To address this, we employ the heuristic Phased Local Search (PLS) clique finding algorithm [18]. Using this approach, we have found ((9, 97 ≤ K ≤ 100, 2)) and ((11, 387 ≤ K ≤ 416, 2)) codes that are larger than the best known nonadditive codes presented in Ref. [6] and Ref. [7] respectively.
The apparent exponential growth of |L n | with increasing n means that even if L n were enumerated for n ≥ 13, an exhaustive search would be prohibitive. As such, other search strategies are required for constructing codes. To aid this search, we demonstrate a relationship between the code size and the order (number of nodes) of the clique graph yielded by a given graph. In particular, we show that the clique graph orders exhibit clustering and that the graphs yielding the best codes tend to belong to the highest clique graph order cluster. This reduces the search to finding graphs that yield large clique graphs, and we show that such graphs can be generated using a genetic algorithm to search the set of all distinct n-node graphs. This genetic algorithm uses a novel crossover operation based on spectral bisection, which we show to be significantly more effective than standard single-point, two-point, and uniform crossover operations. Using this genetic algorithm approach, we have found (( 13,18,4)) and (( 13,20,4)) codes. These codes are larger than an optimal ((13, 16,4)) stabilizer code, and to the best of our knowledge they are the first d ≥ 4 codes to achieve this (we note that there is a family of d = 8 nonadditive codes that are larger than the best known, but not necessarily optimal, stabilizer codes [8]).
For asymmetric codes, the error set E that they detect is no longer invariant under Pauli matrix permutation. This means that if Q detects E, then there is no guarantee that an LC-equivalent code Q ′ = U Q also detects E. However, if Q detects the LC-equivalent error set U † EU , then Q ′ will detect E. As a result, when attempting to construct an optimal ((n, K)) code CWS code detecting E, it is sufficient to consider standard form codes based on elements of L n that detect one of the up to 6 n possible LC-equivalent error sets [19] (the 6 n value stems from there being six possible permutations of the Pauli matrices on each of the n qubits). Such an asymmetric error set arises when constructing codes that correct amplitude damping errors. In this case, a partial symmetry reduces the number of LC-equivalent error sets to 3 n ; however, this is still large enough to make an exhaustive search prohibitive for n ≥ 10. Again, we therefore require different search strategies for constructing codes. We demonstrate that for n ≤ 9, optimal CWS codes correcting a single amplitude damping error can be found by considering only codes based on nonisomorphic graphs that detect one of three LC-equivalent error sets. By combining this error set selection with the genetic algorithm approach, we have found ((11, 68)) and ((11, 80)) codes capable of correcting a single amplitude damping error. These are larger than the best known stabilizer codes detecting the same error set [2]. We have also found ((11, 4)), ((12, 4)), ((13, 8)), and (( 14,16)) stabilizer codes capable of correcting two amplitude damping errors.
The paper is organized as follows. Section II gives an introduction to undirected graphs, genetic algorithms, classical codes, and quantum codes. Section III details our search strategies for symmetric codes and presents the new codes we have found. This is then extended to asymmetric codes for the amplitude damping channel in Sec. IV. The paper is concluded in Sec. V.

A. Undirected graphs
A simple undirected graph G = (N, E) of order n consists of a set of nodes N = {v 1 is an unordered pair that connects the nodes v i , v j ∈ N , which are called the endpoints of e. A graph is typically drawn with the nodes depicted as circles that are joined by lines representing the edges. An example of such a drawing is given in Fig. 1. G can be represented by the symmetric n × n adjacency matrix Γ where of v i is the number of nodes to which it is connected. The n × n degree matrix D has elements contains all the edges in E that have both endpoints in N I . A walk is a sequence whose elements alternate between connected nodes and the edges that connect them. For example, 1 is a walk in the graph shown in Fig. 1. The length of a walk is the number of edges it contains. A path is a walk containing no repeated nodes or edges with the exception that the first and last node can be the same, in which case the path is called a cycle. A graph such as the one shown in Fig. 1 where all nodes belong to a single cycle is called a cycle graph. A graph is connected if there is a path between any two of its nodes. A connected component of G is a maximal connected subgraph Two graphs G 1 = (N 1 , E 1 ) and G 2 = (N 2 , E 2 ) are isomorphic if they differ only up to a relabeling of nodes. Formally, they are isomorphic if there exists an isomorphism from G 1 to G 2 , which is a bijection f : to itself is called an automorphism. The set of all all automorphisms of G forms a group Aut(G) under composition. There are a number of packages, such as NAUTY [20,21], available for determining the automorphism group of a given graph. We denote the set of all distinct n-node graphs with nodes N = {1, 2, . . . , n} as D n , the size of which grows exponentially with |D n | = 2 ( n 2 ) . D n can be partitioned up to isomorphism to give the set G n ; |G n | also grows exponentially with n [22], as shown in Table I for n ≤ 12. The size of some g ∈ G n with representative G ∈ D n is n!/|Aut(G)| [22].
with its complement. If two graphs G 1 , G 2 ∈ D n differ by a series of local complementations, then we say they are LC equivalent. If a series of local complementations applied to G 1 yields a graph G ′ 2 that is isomorphic to G 2 , then we say that G 1 and G 2 are LC-isomorphic. Partitioning D n up to LC-isomorphism gives the set L n , which has been enumerated for n ≤ 12 [14][15][16] and also seems to grow exponentially with n as shown in Table I. Any two graphs that are isomorphic are necessarily LC-isomorphic, and therefore any element l ∈ L n is the union l = ∪ i g i of elements g i ∈ G n . These g i can be determined from any representative of l using Algorithm 5.1 of Ref. [14]. If a subset A ⊆ D n contains graphs that are representatives of m different elements of G n (L n ), then we say m of the graphs in A are noniso-morphic (non-LC-isomorphic).
A graph G = (N, E) is complete if every node is connected to every other node; that is, if for someÑ ⊆ N is complete, thenÑ is called a clique. A clique of maximum size in G is called a maximum clique. Finding a maximum clique in a graph is is NP-hard [17]; however, there are a number of heuristic algorithms that can find large, if not maximum, cliques. One such algorithm is the Phased Local Search (PLS) [18], which performs well compared to other heuristic algorithms in terms of both speed and clique finding ability [23]. The PLS algorithm constructs a clique by initially selecting a node at random. It then iteratively selects nodes to add to the current clique (potentially replacing an existing node in the clique) until a maximum number of selections is reached. To ensure good performance on graphs with varying structures, PLS cycles through multiple different selection methods. The search is repeated for a prescribed number of attempts, after which the largest clique found is returned.
A bipartition of G = (N, E) divides the nodes into two disjoint subsets N 1 and N 2 . A bipartition is called a bisection if |N 1 | = |N 2 | for even |N | or if ||N 1 | − |N 2 || = 1 for odd |N |. An optimal bisection is one that minimizes the number of edges connecting nodes in N 1 to those in N 2 . Finding such an optimal bisection is NP-hard [24]; however, approximate heuristic approaches are available. One such approach is spectral bisection [25][26][27][28], which is based on the graph's Laplacian matrix L = D − Γ. L is positive semidefinite and as such has real, nonnegative eigenvalues. The eigenvector u = (u 1 , . . . , u n ) corresponding to the second smallest eigenvalue is called the Fiedler vector [29]. The Fiedler vector can be used to bisect N , with the indices of the ⌊n/2⌋ smallest components of u dictating the nodes in N 1 and N 2 simply being N 2 = N \N 1 .

B. Genetic algorithms
Suppose we wish to determine which element in a set A is optimal in some sense. This can be expressed as finding the a ∈ A that maximizes a fitness function f : A → R. The brute force approach to this problem is to determine the fitness of every element a ∈ A. This is called an exhaustive search and quickly becomes impractical if the search space A is large and/or evaluating the fitness of elements is computationally intensive. In such cases, heuristic search algorithms can be used to find good, but potentially not optimal, elements of A. The simplest such approach is a random search, where fitness is calculated only for the elements in a randomly selected subset B ⊂ A. Another heuristic search strategy is the genetic algorithm, which is inspired by natural evolution [30,31]. There are many genetic algorithm variants; a simple implementation is as follows. Initially, the child population, which is an N element subset of A, is ran-domly generated. This is followed by a calculation of each child's fitness (a child being an element of the child population). The genetic algorithm then iterates for some predetermined number of maximum generations. In each generation the previous generation's child population becomes the current generation's parent population (whose elements are called parents). A new child population is then formed by selecting two parents at a time and producing two children from them. The parents are selected according to their fitness, with high fitness parents having a higher chance of selection. With probability p c , the two children will be produced via crossover, which combines attributes of the two parents; otherwise, they will simply be duplicates of their parents. Each child is then subjected to mutation (random alteration) with probability p m before being added to the child population. Once the child population again contains N children, their fitnesses are calculated and a new generation begins.
Tournament selection is a simple and commonly used method of selecting parents based on their fitness. First, a subset of the parent population is chosen at random, then the fittest parent within this subset is selected. The size of the subset chosen is called the tournament size; it controls the selection pressure of the genetic algorithm, which is a measure of how dependent selection is on having high fitness. If the tournament size is large, then there is high selection pressure, meaning that the highest fitness parents tend to be selected. This greedy/exploitative approach gives faster convergence; however, the search is more likely to become stuck at a suboptimal local maximum [32]. Conversely, a small tournament size will lead to greater exploration of the search space at the cost of potentially slow convergence. A common modification to the genetic algorithm is the inclusion of elitist selection, which involves adding some number of the fittest parents to the child population at the start of each generation. This preserves the best elements; however, the increased selection pressure can again increase the probability of convergence to a suboptimal local maximum.
The crossover and mutation operations used depend on how elements of A are represented. A standard representation involves encoding elements as bit strings of fixed length b. A common and simple mutation operation in this case involves flipping any given bit in a child bit string with some probability (this probability is often taken to be 1/b [31]). Standard crossover methods include single-point, two-point, and uniform crossover. In single-point crossover, an index 1 ≤ i ≤ b is chosen, and the values beyond this point are exchanged between the two parent bit strings to form two child bit strings. In two-point crossover, two such indices are selected and all values between them are exchanged. In uniform crossover, each individual bit is exchanged between the two parents with some probability p e .
In some cases, representations other than bit strings are more natural. For example, it may be possible represent elements as graphs. Crossover becomes more com-plicated with such a representation. A potential method is presented in Ref. [33] and is as follows. First, each of the parent graphs P 1 and P 2 are each split into two subgraphs, called fragments, to produce disconnected parents P 1D and P 2D . To split a parent graph, first an edge {v i , v j } is chosen at random. In an iterative process, the shortest path between v i and v j is determined, and a randomly selected edge in this path is removed (in the first iteration, this will simply be the edge {v i , v j }). This continues until no path exists between v i and v j . The connected component containing v i is the fragment F 1 , and the subgraph induced by the remaining nodes is the fragment F 2 . In the next step, disconnected children C 1D and C 2D are formed by exchanging a fragment, say F 1 , between of each of the parent graphs. The two fragments in each disconnected child are then combined to produce children C 1 and C 2 . This combination process involves iteratively selecting a node from each fragment and joining them with an edge. The probability of a node being selected is proportional to the difference in its current degree to its degree in its initial parent graph. This process of adding edges is repeated until all of the nodes in one of the fragments, say F 1 , have the same degree as they did in their initial parent graph. If a node v l in F 2 has degree lower than its initial degree by some amount δ l , then in a process repeated δ l times, it will be connected to a randomly selected node in F 1 with 50% probability. As outlined in Ref. [34], the splitting process presented here has some undesirable attributes. Firstly, it tends to produce two fragments with a vastly different number of nodes. Secondly, it often removes a large number of edges from within the larger fragment; these are edges that did not have to be removed to split the parent graph.

C. Classical codes
A classical channel is a map Φ : A x → A y , where A x is the set of possible inputs and A y is the set of possible outputs. We are concerned with channels where the input and outputs are binary; that is, A x = A y = GF (2). In this case, the action of the channel can be expressed as where x ∈ GF(2) is the channel input, y ∈ GF(2) is the channel output, and e ∈ GF(2) is an error (or noise) symbol. A code can be used to protect against the noise introduced by the channel. A length n binary code is a subset C ⊆ GF(2) n whose elements are called codewords. Codewords are transmitted as n sequential uses of Φ or, equivalently, as a single use of the combined channel Φ n , which is comprised of n copies of Φ. The action of Φ n on some input x ∈ C is where y ∈ GF(2) n is the channel output and e ∈ GF(2) n is an error "vector". The weight of an error is the number of nonzero components from which it comprised.
We say that a code C can detect a set of errors E ⊆ GF(2) if for all e ∈ E and x i , x j ∈ C, where x i = x j . That is, the errors in E can be detected if they do not map one codeword to another. Furthermore, we say that C can correct E if for all e k , e l ∈ E and x i , This condition simply ensures that two codewords cannot be mapped to the same y ∈ GF(2) n , in which case the transmitted codeword cannot be inferred with certainty. C is said to have distance d if it can detect any error of weight less than d but is unable to detect some weight d error.
Note that C can correct E if and only if it can detect E + E = {e k + e l : e k , e l ∈ E}, meaning that a distance d code can correct any error of weight t = ⌊(d − 1)/2⌋ or less. A length n code C of size |C| = K and distance d is called an (n, K) or (n, K, d) code. If C forms a vector space, then it is called linear and has K = 2 k . A linear code encodes the state of k bits and is called an Finding a code C of maximum size that detects an error set E can be expressed as a clique finding problem. This is achieved by constructing a graph G E = (N E , E E ) whose nodes are potential codewords; that is, if there is not an error mapping one to the other). Any clique C in G E is a code detecting E, and a code of maximum possible size is a maximum clique in G E . Note that if a code C detects E, then so does C ′ = x + C for any x ∈ C. As 0 ∈ C ′ and |C| = |C ′ |, this means there is always an optimal code (that is, a maximum size code detecting E) that contains the all zero codeword. The clique search can be restricted to such codes by taking N E = GF(2) n \E.

D. Quantum codes
The action of a quantum channel Φ on a quantum state described by the density operator ρ is where the A k , called Kraus operators, satisfy k A † k A k = I (the identity operator) [35]. The channel can be interpreted as mapping ρ → A k ρA † k (up to normalization) with probability tr(A k ρA † k ) [36]. If ρ = |φ φ| (that is, if the input state is pure), then then this becomes the mapping |φ → A k |φ (up to normalization) with corresponding probability φ|A † k A k |φ . In this paper we are interested in qubit systems; that is, systems where states |φ belong to a two dimensional Hilbert space H ∼ = C 2 .
Similar to the classical case, the noise introduced by a quantum channel can be protected against by employing a code. A quantum (qubit) code of length n is a subspace Q ⊆ (C 2 ) ⊗n . Codewords |φ ∈ Q are transmitted across the combined n-qubit channel Φ ⊗n .
Suppose a code Q has an orthonormal basis B = {|φ 1 , . . . , |φ K }, and take E = {E 1 , . . . , E r } to be the basis for some complex vector space of linear n-qubit operators (called error operators). We say that Q can detect any error in the span of E if for all E ∈ E and |φ i , |φ j ∈ B, where C E is a scalar that depends only on E [2]. Furthermore, we say that Q can correct any error in the span of E if for all E k , E l ∈ E and |φ i , |φ j ∈ B, where C is an r × r Hermitian matrix [1].
meaning that a distance d quantum code can also correct any error of weight t = ⌊(d − 1)/2⌋ or less. A length n code of dimension K and distance d is called an ((n, K)) or ((n, K, d)) code (the double brackets differentiate from the classical case). A code Q correcting E is called nondegenerate if the spaces E k Q and E l Q are linearly independent (that is, their intersection is trivial) for any E k , E l ∈ E, where E k = E l . If all such spaces are orthogonal, then Q is called pure.
The Pauli matrices in the computational {|0 , |1 } basis are X can be viewed as a bit flip operator as X|0 = |1 and X|1 = |0 . Z can be viewed as a phase flip as Z|0 = |0 and Z|1 = −|1 . Y = iXZ can be viewed as a combined bit and phase flip. The Pauli matrices are Hermitian, unitary, and anticommute with each other. Furthermore, they form a group called the Pauli group The n-qubit Pauli group P n is defined as all n-fold tensor product combinations of elements of P 1 . For example, P 8 contains the element I ⊗ I ⊗ X ⊗ I ⊗ Y ⊗ Z ⊗ I ⊗ I, which we can write more compactly as X 3 Y 5 Z 6 . The weight w(g) of some g ∈ P n is the number of elements in the tensor product that are not equal to the identity up to phase. The commutation relations of the Pauli matrices mean that elements of P n must either commute or anticommute, with two elements anticommuting if their nonidentity components differ in an odd number of places.
The Pauli matrices along with the identity form a basis for the complex vector space of all 2 × 2 matrices. It therefore follows that is a basis for all n-qubit errors of weight less than or equal to r. An equivalent definition is Two n-qubit codes Q and Q ′ are local unitary (LU) equivalent if Q ′ = U Q for some U ∈ U (2) ⊗n . These codes will have the same dimension as if B = {|φ 1 , . . . , |φ K } is an orthonormal basis for Q, then Furthermore, E is a basis for all errors of weight less than d if and only if E ′ is also such a basis. Therefore, Q and Q ′ have the same distance; that is, they are both ((n, K, d)) codes. If two codes differ by a LU operator and/or permutation of qubit labels, which also has no effect on the size or distance of the code, then they are called equivalent codes. The nor- The n-qubit local Clifford group C n 1 is comprised of all possible n-fold tensor products of elements from C 1 . Two codes are local Clifford (LC) equivalent if they are LU equivalent for some U ∈ C n 1 ⊂ U (2) ⊗n . Stabilizer codes (also called additive codes) are defined by an abelian subgroup S < P n , called the stabilizer, that does not contain −I [2]. The code Q is the space of states that are fixed by every element s i ∈ S; that is, The requirement that −I / ∈ S both means that no s ∈ S can have a phase factor of ±i, and that if s ∈ S, then −s / ∈ S. If S is generated by M = {M 1 , . . . , M m } ⊂ P n , then it is sufficient (and obviously necessary) for Q to be stabilized by every M i . Assuming that the set of generators is minimal, it can be shown that dim(Q) = 2 n−m = 2 k [36]; that is, Q encodes the state of a kqubit system. An n-qubit stabilizer code with dimension code.
An n-qubit stabilizer state |S is an [[n, 0, d]] code defined by a stabilizer S with n generators. The distance of a stabilizer state is defined to be equal to the weight of the lowest nonzero weight element in S. A graph state |G is a stabilizer state defined by a graph G ∈ D n . Each node i corresponds to a qubit and is also associated with a stabilizer generator Each graph state |G defines a basis B = {Z w |G : w ∈ GF(2) n } for (C 2 ) ⊗n [37]. An error E = X i maps the graph state |G to where r i is the ith row of the adjacency matrix for G. That is, an X error applied at node i is equivalent to Z errors being applied at its neighbors; this is called the X − Z rule [38]. It can be shown that every stabilizer state is LC equivalent to a graph state [11][12][13]. Two graph states |G 1 and |G 2 are the same up to a relabeling of qubits if and only if their corresponding graphs G 1 and G 2 are isomorphic. Furthermore, |G 1 and |G 2 are LC equivalent if and only if G 1 and G 2 are LC equivalent [11]. Therefore, |G 1 and |G 2 are equivalent (as quantum codes) if G 1 and G 2 are LC-isomorphic (the converse does not necessarily hold as two states can be LU equivalent without being LC equivalent [39]).

E. CWS codes
The family of codeword stabilized (CWS) codes contains all stabilizer codes as well as many of the best known nonadditive codes [9,10]. An ((n, K)) CWS code Q is defined using an n-qubit stabilizer state |S and a set of K word operators W = {W 1 , . . . , W K } ⊂ P n . In particular, Q is the span of the basis codewords |W i = W i |S . Note that for the |W i to actually form a basis, no two word operators differ only by a stabilizer element; that is, it cannot be the case that W i W j ∈S = ∪ α∈{±1,±i} αS. For a CWS code, the criterion for detecting an error set E becomes for all E ∈ E and W i , W j ∈ W. If E contains only Pauli errors E ∈ P n , then where α ∈ {±1, ±i}. Therefore, the i = j case of Eq. or for all W i ∈ W and some particular α ∈ {±1, ±i}. It follows from the LC equivalence of every stabilizer to a graph state that every CWS code is LC equivalent to one based on a graph state |G with word operators of the form W i = Z xi [9]. Such a code is called a standard form CWS code, and its basis codewords are simply elements of the graph basis defined by G. The set {x 1 , . . . , x K } ⊆ GF(2) n forms a classical binary code C, and without loss of generality we can take x 1 = 0 [9]. It can be shown that if C is linear, then the CWS code is additive [9]; whereas if C is not linear, then the code may be additive or nonadditive [10] (although if K = 2 k , then the CWS code must obviously be nonadditive). The effect of an error E ∝ X u Z v on one of the basis codewords |W i = Z xi |G follows from the X − Z rule with where Γ is the adjacency matrix for G and For a graph state, the only stabilizer element with no X component is the identity I = Z 0 . Equation (23) therefore reduces to x i + Cl G (E) = x j , which is simply the classical error detection criterion of Eq. (5). This means that an error E can be detected only if C detects the classical error Cl G (E). Following the same reasoning, Eq. (19) becomes x i + Cl G (E) = x i , which reduces to Cl G (E) = 0. Equation (20) becomes which reduces to E ∈ αS for x 1 = 0. If there is some W i = Z xi that anticommutes with E, then Eq. (24) becomes E ∈ −αS. This would mean that both α −1 E ∈ S and −α −1 E ∈ S, from which it follows that −I ∈ S. This cannot be the case as S is a stabilizer. Therefore, to satisfy Eq. (20) it must be the case that [Z xi , E] = 0 for all x i ∈ C. For E ∝ X u Z v , this condition is equivalent to requiring x i · u = 0 for all x i ∈ C, were a · b = i a i b i is the standard Euclidean inner product. In summary, a standard form code detects E ∝ X u Z v ∈ E if for all x i , x j ∈ C, where x i = x j , and either or for all x i ∈ C. Designing a CWS code Q for a given graph G and error set E consists of finding a classical code C that satisfies Eqs. (25) to (27) for every E ∈ E. It is convenient to express this as a clique finding problem as outlined in Ref. [10]. First, the classical set induced by the graph is determined. Also required is the set These are elements of GF(2) n that cannot be included in the code as they violate Eqs. (26) and (27). An algorithm for efficiently determining Cl G (E) and D G (E) is given in Ref. [10]. A classical code C satisfying Eqs. (25) to (27) is a clique in the graph and E E defined by the classical error set Cl G (E) as outlined in Sec. II C. That is, two nodes 10,40].

F. Code bounds
A simple, but relatively loose, upper bound on the dimension K of an n-qubit code of distance d is given by the quantum singleton bound [1] K ≤ 2 n−2(d−1) .
A tighter limit on code size is given by the linear programming bound [41]. An ((n, K, d)) code can exist only if there are homogeneous polynomials A(x, y), B(x, y), and S(x, y) such that Here C(x, y) ≥ 0 means that the coefficients of the polynomial C are nonnegative, and O(y d ) is a polynomial in y with no terms of degree less than d. A pure ((n, K, d)) code can exist only if Eqs. (32) to (38) can be satisfied along with The linear programming bound is monotonic [42], meaning that if the constraints can be satisfied for some K, then they can be satisfied for all lower code dimensions too. This monotonicity holds even if K is allowed to be a real number (rather than just an integer). Following Ref. [43], we define the real number K(n, d) as the largest K > 1 for which Eqs. (32) to (38) can be satisfied. The purity conjecture of Ref. [41] states that if the linear programming constraints hold for K = K(n, d), then A(1, y) = 1 + O(y d ). The content of this conjecture is simply that the linear programming bound for pure codes is the same as for potentially impure codes. This conjecture has been verified to hold for n ≤ 100 [43].
For stabilizer codes, bounds on maximum k are given in Table II for 1 ≤ n ≤ 15 and 2 ≤ d ≤ 5. All lower bounds are given by the best known stabilizer codes (these codes can be found at Ref. [44]). The unmarked upper bounds are given by the linear programming bound for K = 2 k (determined using YALMIP [45]). If the lower and upper bounds coincide, then a single value is given; otherwise, they are separated by a dash. In the cases marked "A", the [[7, 0, 4]], [[15, 7, 4]], and [[ 15,4,5]] codes that do not violate the linear programming bound are excluded by arguments given in Sec. 7 of Ref. [41]. In the case marked "B", the [[13, 5,4]] code that does not violate the linear programming bound is excluded by the argument of Ref. [46]. The entries marked "C" indicate cases where a code meeting the bound must be impure (also outlined in Sec. 7 of Ref. [41]). An extended version of Table II for n ≤ 256 can be found at Ref. [44]. Table III gives the bounds on maximum K for a potentially nonadditive ((n, K, d)) code where 1 ≤ n ≤ 15 and 2 ≤ d ≤ 5. All upper bounds are from the linear programming bound. The lower bounds marked "A" are from the family of nonadditive ((2α + 1, 3 × 2 2α−3 , 2)) codes of Ref. [6]. Those marked "B" are from the family of ((4α + 2β + 3, M αβ , 2)) codes of Ref. [7] where β ∈ {0, 1} and The lower bounds marked "C" and "D" correspond to the ((9, 12,3)) and ((10, 24,3)) codes of Ref. [4] and Ref. [5] respectively. All other lower bounds are given by the best known stabilizer codes.

III. SYMMETRIC CODES
An ((n, K, d)) code must detect the set E d−1 as defined in Eq. (12). Note that E 1 , and hence E d−1 more    generally, is invariant under any permutation of the Pauli matrices X, Y , and Z on any subset of qubits. As a result of this symmetry, we call ((n, K, d)) codes symmetric codes. Furthermore, as outlined in Sec. II D, this symmetry means that if some code Q detects E d−1 , then so does any equivalent code Q ′ . It is therefore sufficient to consider only standard form codes when attempting to construct an optimal symmetric CWS code. Furthermore, we need only consider standard form codes based on representatives from different elements of L n . However, as outlined in Sec. II A the size of L n appears to grow exponentially, and it has only been enumerated for n ≤ 12. Furthermore, constructing an optimal classical code for a given graph by finding a maximum clique is  Gn, and Dn that yield optimal K = 2 n−2 codes for even n ≤ 10 and d = 2. The values given for n = 8 and n = 10 are lower bounds. NP-hard as mentioned in Sec. II A. In this section we explore methods of code construction that address these two obstacles.

A. Distance two codes
First we consider distance two codes of even length. As outlined in Tables II and III, there are even length stabilizer codes with k = n−2 that saturate the singleton bound for n ≤ 14. In fact, there are stabilizer codes that saturate the bound for all even n [6]. Despite this, there is still some insight to be gained from constructing CWS codes with these parameters. For n ≤ 10, it is feasible to exhaustively search L n (that is, to construct a code based on a representative of each element of L n ). Using the code size distribution over L n , it is possible to determine the distributions over G n and D n by counting the number of nonisomorphic and distinct graphs respectively in each element of L n (see Sec. II A). As an example, the code size distributions for n = 6 are shown in Fig. 2. It can be seen that over 50%, 75%, and 80% of elements of L 6 , G 6 , and D 6 respectively yield optimal K = 16 codes. The fraction of elements of L n , G n , and D n that yield optimal codes for even 2 ≤ n ≤ 10 is shown in Table IV. For 2 ≤ n ≤ 6, the clique graphs generated are small enough for maximum cliques to be found using the exact algorithm of Ref. [47]. For n ≥ 8, we have resorted to using the approximate PLS algorithm due to the larger clique graphs. We have allowed the PLS algorithm 100 attempts, each of which used a maximum of 1, 000 selections (these are the default PLS parameters that we have employed). As a result of having used an approximate clique finding algorithm, the values given in the n = 8 and n = 10 rows of Table IV are a lower bounds. It can be seen that in each case, the fraction of elements in D n yielding an optimal code is greater than that of G n , which in turn is greater than that of L n . Furthermore, increasing n increases the fraction of optimal codes in all cases. In particular, by n = 10 over 98% of distinct graphs yield a code with an optimal K = 256. This trend suggests that for larger n, we are highly likely to find an optimal code even if we use a randomly selected graph. This goes some way to explaining the results of Ref. [48], where cycle graphs were shown to give optimal codes for even n ≤ 12. The case of odd n is somewhat more interesting. Here, as shown in Ref. [6], the linear programming bound reduces to Stabilizer codes cannot saturate this bound and are restricted to k ≤ n − 3. Again, we can construct codes based on an exhaustive search of L n for n ≤ 11. For n = 3, a single element of L 3 yields an optimal K = 1 code. Similarly, a single element of L 5 yields a code with K = 6, which matches the size of the optimal code given in Refs. [3,6]. For n = 7, there is more of a spread in the code sizes as shown in Fig. 3. It can be seen that a large number of graphs yield codes with K = 16 or K = 22, which match the size of an optimal stabilizer code and the code of Ref. [7] respectively. Furthermore, there are seven elements of L 7 that yield codes with K = 24, which match the size of the code of Ref. [6]. No graphs yield codes with K = 25 or K = 26, despite such codes not being excluded by the linear programming bound. For n = 9, an exhaustive search of L 9 is still feasible; however, we have done so using the PLS clique finder, and as such there may exist larger CWS codes than the ones reported here. Similar to the n = 7 case, the majority of graphs gave codes with K = 64, K = 93, or K = 96, which match the size of an optimal stabilizer code, the code of Ref. [7], and the code of Ref. [6] respectively. However, we have also found seven elements of L 9 that yield codes with K ≥ 97. To increase the likelihood that we have found maximum size codes for these seven graphs, we have repeated the clique search for each of them using 10,000 attempts. This has resulted in one K = 97 code, two K = 98 codes, and four K = 100 codes. Representatives of the elements of L n that yielded these codes are shown in Fig. 4. Note that we do not label the nodes as isomorphic graphs yield equivalent codes. Given below each of the drawings is the graph in graph6 format (see Ref. [21] for details). While these K ≥ 97 codes are larger than any previously known codes, they do not saturate the linear programming bound of K = 112. A classical code for each of these graphs is given in the supplementary material (this is the case for all codes presented in this paper). For n = 11, we have performed an exhaustive search of L 11 with an increased 10, 000 PLS selections to account for the larger cliques. Here we have mostly obtained codes with K = 256, K = 384, or K = 386, which match the size of an optimal stabilizer code, the code of Ref. [6], and the code of Ref. [7] respectively. We have also found 413 elements of L 11 that yield codes with K ≥ 387. As for the n = 9 case, we have repeated the clique search for these graphs using 10, 000 attempts. The resulting code size distribution is given in Table V. Representatives of elements of L 11 that yield codes with K ≥ 406 are shown in Fig. 5 (the remaining graphs are included in the supplementary material). Again, while these are the largest codes known, they do not saturate the linear programming bound of K = 460. As L n has not been enumerated for n ≥ 13, we cannot continue this exhaustive search procedure for higher n. Any (nonexhaustive) search of G n or D n is also impractical for n ≥ 13 due to the large clique graphs produced, which both makes the clique search slow and reduces the likelihood that the clique found is of maximum size. Figure 6 shows the relationship between code size and clique graph order |N E | for 4 ≤ n ≤ 11. It can be seen that the data is clustered by clique graph order; furthermore, in each case, the graphs yielding the largest codes belong to the highest |N E | cluster. This clustering behavior can be explained by considering Eq. (30), which gives It follows from Eq. (29) that GF(2) n \D G (E) is the annihilator of E ′ = {E ∈ E : Cl G (E) = 0} and is therefore a subspace of GF(2) n . If dim(GF(2) n \D G (E)) = r ≤ n, then |D G (E)| = 2 n −2 r , which gives |N E | = 2 r −|Cl G (E)|. The clusters therefore correspond to different values of r.
The codes in the highest |N E | cluster are pure as they have D G (E) = ∅. That this cluster contains codes of maximum size is not entirely surprising in light of the purity conjecture outlined in Sec. II F.

B. Distance three codes
Distance three codes are of practical interest as they allow for the correction of an arbitrary single-qubit error. For n ≤ 11, we can exhaustively search L n in the same way as we have for the distance two codes of the previous section. There are one and two elements of L 5 and L 6 respectively that give optimal K = 2 codes (note that all K = 2 CWS codes are additive [10]). Similarly, there are 18 elements of L 7 that yield K = 2 codes. As has been previously shown in Ref. [10], although the linear programming bound does not exclude them, there are no ((7, 3, 3)) CWS codes. There are six elements of L 8 that give K = 8 codes. No elements yield a K = 9 code, despite such a code not being excluded by the linear programming bound. There are eight elements of L 9 that yield K = 12 codes, which match the size of the code presented in Ref. [4]. Again, no elements yield a K = 13 code, despite such a code not being excluded by the linear programming bound. An exhaustive search of L 10 has previously been performed in Ref. [5], where it was shown that a single element yields an optimal K = 24 code. We have exhaustively searched L 11 using the PLS clique finder. This has yielded 13, 709 K = 32 codes, which match the size of an optimal stabilizer code. No larger codes were found, which is somewhat surprising given that the linear programming bound is K = 53. Figure 7 shows the relationship between code size and clique graph order for distance three codes with 8 ≤ n ≤ 11. It can be seen that there is greater spread within the clusters compared to the distance two case of Fig. 6. According to Eq. (42), this can be attributed to an increased variance in the size of Cl G (E). Despite this increased variation, the graphs yielding the best codes belong to the highest |N E | cluster in all four cases. Importantly, the best codes are not necessarily given by the graphs with the highest clique graph order within this cluster. For example, in the n = 10 case, the highest clique graph cluster contains graphs with 613 ≤ |N E | ≤ 739, while the graph yielding the K = 24 code only has |N E | = 679.
For n = 12, the size of L 12 makes an exhaustive search somewhat prohibitive. We can reduce the search space somewhat by considering the distribution of clique graph sizes as shown in Fig. 8. Note that by using Eq. (42), |N E | can be computed without actually constructing the clique graph. Our previous observations regarding the relationship between code size and clique graph order suggest that graphs yielding the best codes are highly likely to be found in the |N E | > 3, 000 cluster. We have randomly selected 50, 000 of the 663, 039 elements of L 12 in this cluster and constructed a code for each using the PLS clique finder. This has yielded 6, 325 codes with K = 64, which match the size of an optimal stabilizer code. No larger codes were found, despite the linear programming bound not excluding codes with up to K = 89. We have not pursued searches for n ≥ 13 codes as while the clique graphs produced are smaller than in the d = 2 case, they are still large enough for maximum clique searches to be unreliable.

C. Distance four codes
For d = 4, we are able to perform exhaustive searches of L n for n ≤ 12. There are one, five, and eight elements of L 6 , L 8 , and L 9 respectively that yield optimal K = 1 codes. As expected, no elements of L 7 give a nontrivial code (note that a K = 1 CWS code is a stabilizer state and hence pure; such [[n, 0, d]] codes have previously been classified in [15]). There are 10 and 3, 060 elements of L 10 and L 11 respectively that give K = 4 codes, which match the size of an optimal stabilizer code. No elements yield larger codes, despite the linear programming bound not excluding codes with up to K = 5 and K = 7 respectively. Unlike the d = 3 case, an exhaustive search of L 12 is feasible for d = 4 due to the smaller clique graphs. However, the clique graphs are still large enough that we have resorted to using the PLS clique finding algorithm. This search has yielded 1, 482 codes with K = 16, which match the size of an optimal stabilizer code. No larger codes were found, despite the linear programming bound not excluding codes with up to K = 20. The smaller clique graph sizes in the d = 4 case also make searching for codes with n = 13 and n = 14 feasible. For n = 13, we have randomly selected 100, 000 graphs from D 13 to estimate the clique graph size distribution as shown in Fig.  9. 41, 458 of these graphs belong to the |N E | > 2, 000 cluster. Of these, one yielded a K = 18 code, which is larger than an optimal K = 16 stabilizer code.
To find more n = 13 codes with K > 16, we want a more reliable way of generating graphs that yield a large clique graph. That is, we wish to search D n for graphs yielding a large clique graph in a way that is more efficient than a random search. We have found a genetic algorithm to be effective in this respect. There are a number of ways we could implement mutation and crossover in this algorithm. For mutation, we first select two nodes in the child graph at random. If these two nodes are not connected by an edge, then one is added; otherwise, if they are connected by an edge, then it is removed. If we represent the parent graphs as bit strings, then we can use standard single-point, two-point, or uniform crossover. One way to achieve this is to convert the upper triangular component of a parent adjacency matrix to a bit string row by row. Alternatively, we can use a graph based approach. However, the method of Ref. [33] outlined in Sec. II B is not appropriate for searching D n as it is not guaranteed to produce child graphs with n nodes. Furthermore, as previously mentioned, it tends to remove an unnecessarily large number of edges when splitting the parent graphs into two fragments. To address these issues, we propose splitting the parent graphs using a spectral bisection. In particular, the nodes of a parent graph P are bisected into the sets N 1 and N 2 , which define the fragments A fragment is then exchanged between each parent to form two disconnected children that are then connected following the method of Ref. [33]. An example of this procedure on two n = 10 graphs is shown in Fig. 10.
We have run 100 genetic algorithm instances using each of the potential crossover methods to compare their performance. In each instance, we have used a population size of N = 20, 100 generations, a crossover probability of p c = 0.9, a mutation probability of p m = 0.1, and a tournament size of 10. We have also incorporated elitist selection, with the fittest two parent graphs (that is, the two that yield the largest clique graphs) being added to the child population at the start of each generation. The average order of the highest order clique graph yielded in each generation is shown in Fig. 11. It can be seen that single-point, two-point, and uniform crossover (with p e = 0.5) all exhibit similar performance. However, their performance is also matched by random crossover, where the two children are simply selected at random from D n with no input from the parents. As such, the increase in fitness with successive generations when using these crossover methods is simply due to the selection pressure of the genetic algorithm. It can also be seen that spectral crossover gives significantly better performance than all other methods. We have also tested the effect of population size when using spectral crossover. In particular, we have tested population sizes of N = 10 and N = 40 in addition to the previously considered N = 20 case. We have used a tournament size of half the population size in each case and left all other parameters unchanged. It can be seen in Fig. 11 that, as expected, increasing the population size increases the average maximum fitness.
With clique graph order only serving as an indicator of code size, it is not essential for the genetic algorithm to find graphs that yield the absolute largest clique graphs. In fact, as was seen in the n = 10, d = 3 case, focusing solely on such graphs may mean that we miss the best code(s). With this in mind, we have found using 50 generations and a population size of N = 10 to be a good compromise. Using a modest population size and number of generations is also favorable from a run time perspective as determining |N E | becomes more computationally expensive with increasing code length and/or distance (both of which serve to increase the size of the error set).
The genetic algorithm we have outlined is quite greedy/exploitative. To make our search more explorative, we run a large number of genetic algorithm instances, with a code being constructed from the fittest graph found by each instance. For n = 13, we have run 50, 000 such instances, of which 352 yielded a K = 18 code and a further 175 gave a K = 20 code. The graphs that yielded codes with K = 18 and K = 20 belong to 35 and 25 different elements of L 13 respectively. A representative from each of these elements is shown in Figs. 12 and 13. Note that the graphs shown are not necessarily the exact ones found using the genetic algorithm; they are LC-equivalent graphs that can be drawn clearly using the force-directed layout method of Ref. [49]. While these K = 18 and K = 20 codes are larger than any previously known codes, they do not saturate the linear programming bound of K = 40. We have also run 50, 000 instances of the genetic algorithm for n = 14. 65 of these instances have yielded K = 64 codes, which match the size of an optimal stabilizer code. We have not found any codes with K > 64, despite the linear programming bound not excluding codes with up to K = 102.

D. Distance five codes
For d = 5, one and five elements of L 11 and L 12 respectively yield optimal K = 2 codes. For 13 ≤ n ≤ 15 we have run 50, 000 genetic algorithm instances. 46,978 instances yielded a K = 2 code for n = 13,452 instances yielded a K = 4 code for n = 14, and 14 instances yielded a K = 8 code for n = 15. No larger codes were found, despite the linear programming bound being K = 3, K = 10, and K = 18 respectively. Note that the existence of a ((13, 3,5)) CWS code has already been excluded in Ref. [10] by the same argument that excluded the ((7, 3, 3)) code.

IV. ASYMMETRIC CODES
A channel of physical interest is the amplitude damping channel where It can be shown [2, 50,51] that a sufficient condition for correcting a single amplitude damping error is the ability to detect   which is the set of errors that must be detected to guarantee the ability to correct an arbitrary weight t error. As a result, there is potential for constructing codes correcting t amplitude damping errors that are larger than those correcting t arbitrary errors. For example, the stabilizer codes presented in Ref. [2] detect E {1} and have the parameters given in Table VI (these values are taken from Ref. [52]). In all but the n = 8 case, these codes are larger than the size of an optimal d = 3 stabilizer code as given in Table II. An exhaustive search for CWS codes detecting E {1} has been performed in Ref. [19] for 5 ≤ n ≤ 9. The size of these codes is also given in Table  VI, where they can be seen to be larger than the stabilizer codes for n = 8 and n = 9. Other nonadditive codes have also been constructed that can correct a single amplitude damping error [52,53]; however, they are not directly comparable as they do so in a way that does not guarantee the detection of E {1} (that is, they cannot correct an A † 1 error). E {t} is not invariant under all possible Pauli matrix permutations. As such, two LC-equivalent CWS codes need not correct the same number of amplitude damping errors. This means that considering standard form codes based on different elements of L n no longer constitutes an exhaustive search of all CWS codes. However, as suggested in Ref. [19], a search of L n can be made exhaustive by performing it for every LC-equivalent error set of the form U † E {t} U . These sets are versions of E {t} with X, Y , and Z errors permuted on some set of qubits. If E {t} exhibited no symmetries under such permutations, then there would be 6 n such sets. However, as E {t} is invariant under the permutation X ↔ Y on any subset of qubits, this number is reduced to 3 n . Unfortunately, an exhaustive search is not practical for codes with n ≥ 10 as even for n = 10 there are 3 10 |L 10 | = 235, 605, 510 cases to test. In this section, we build on our code construction methods to address this increase in the size of the search space.

A. Single amplitude damping error
To construct new codes for the amplitude damping channel with n ≥ 10, we first consider n ≤ 9 to determine what types of codes match the bounds provided in Ref. [19]. Initially, we restrict consideration to standard form codes that detect E {1} . As E {1} (and E {t} more generally) is invariant under a permutation of qubit labels, it is sufficient to consider one representative from each element of G n . The first column of Table VII shows the number of elements of G n for 5 ≤ n ≤ 9 that yield optimal standard form CWS codes. Note that the value given for n = 9 is a lower bound as we have used the PLS clique finder in this case. It can be seen that while we are able to construct optimal codes for 5 ≤ n ≤ 7, we are unable to do so for n = 8 and n = 9. To remedy this, we consider the LC-equivalent error sets Y Z yield optimal codes for n = 8 and n = 9. For n = 10, the size of G 10 combined with the sizes of the clique graphs generated makes an exhaustive search impractical. However, we can still determine the distribution of clique graph sizes over G n for the three error sets E {1} , E  50, 000 graphs in the |N E | > 600 cluster have been selected. In each case, all 50, 000 graphs yielded K = 32 codes, which match the size of the stabilizer code presented in Ref. [2].
For n = 11, an exhaustive search of G 11 is impractical, even to simply determine clique graph sizes. We have therefore run 50, 000 instances of our genetic algorithm for each of the three error sets E {1} , E {1} XZ , and E {1} Y Z . For E {1} , this has yielded a K = 64 code in every case. These codes match the size of the stabilizer code presented in Ref. [2]. For E {1} Y Z , 1, 818 instances yielded codes with K = 68, which are larger than the best known stabilizer codes. 28 of these graphs are nonisomorphic and are shown in Fig. 15 (a simple circular node layout is used here as we do not have the freedom of picking an LCisomorphic graph that can be drawn clearly using forcedirected layout). For E {1} XZ , only nine instances yielded codes with K = 68; however, there were also 71 instances that yielded codes with K = 80. Of these, two of the K = 68 graphs are nonisomorphic and two of the K = 80 graphs are nonisomorphic; these graphs are also shown in Fig. 15. For n = 12, applying the same genetic algorithm approach has yielded codes with K = 128, which match the size of the stabilizer code presented in Ref. [2]. In particular, of the 50, 000 instances run for each error set, 21 As determined by exhaustive search in Ref. [19], there are no nontrivial CWS codes capable of detecting the error set E {2} with n ≤ 8. For n = 9, the largest CWS code that can detect E {2} has K = 2. Interestingly, an exhaustive search of G 9 fails to yield any K = 2 codes detecting E {2} . However, there are seven elements of G 9 that yield K = 2 codes detecting E  Table  VIII. Note that nearly all of these codes are stabilizer codes. For n ≤ 13, we have used an exact clique finder, whereas for n = 14 we have used PLS. The n = 11 codes are interesting due to how difficult they are to find. The two graphs found for E {2} are nonisomorphic and eight of those found for E {2} XZ are nonisomorphic. These graphs are shown in Fig. 16. It is easy to find graphs giving codes with K = 4 codes for n = 12, K = 8 for n = 13, and K = 16 for n = 14 (they can be found quickly even with a simple random search). However, to the best of our knowledge no stabilizer codes with these parameters have been previously published. Furthermore, they are all larger than an optimal d = 5 stabilizer codes that can correct two arbitrary errors. As such, we include graphs yielding codes of these sizes for E {2} Fig. 17.

V. CONCLUSION
We have demonstrated the effectiveness of a number of heuristic approaches to the construction of CWS codes. We have shown that using an approximate maximum clique finding algorithm makes finding larger codes practical. In particular, this has allowed us to find ((9, 97 ≤ K ≤ 100, 2)) and ((11, 387 ≤ K ≤ 416, 2)) codes that are larger than the best known nonadditive codes. We have demonstrated a clustering of clique graph sizes and shown a relationship between clique graph order and code size. Furthermore, we have shown that graphs yielding large clique graphs can be found using a genetic algorithm with a novel spectral bisection based crossover operation. This search strategy has yielded (( 13,18,4)) and (( 13,20,4)) codes, which are larger than any previously known code. Finally, we have shown that good asymmetric codes can be found by considering standard form codes that detect one of only three of the 3 n possible LC-equivalent error sets. Coupling this with the genetic algorithm approach, we have found ((11, 68)) and ((11, 80)) codes capable of correcting a single amplitude damping error. We have also found ((11, 4)), ((12, 4)), ((13, 8)), and (( 14,16)) stabilizer codes capable of correcting two amplitude damping errors.  50,000 run that yielded an ((n, K)) code detecting the given error set.