A Projection Decoding of a Binary Extremal Self-Dual Code of Length $40$
Jon-Lark Kim, Nari Lee

TL;DR
This paper introduces two efficient decoding algorithms for a specific extremal binary self-dual code of length 40, utilizing projections onto a Hermitian self-dual code over GF(4) to simplify decoding.
Contribution
The paper presents novel projection-based decoding algorithms for a binary extremal self-dual code, reducing complexity by leveraging a Hermitian self-dual code over GF(4).
Findings
Two new decoding algorithms for the [40,20,8] code.
Algorithms are implementable by hand, unlike syndrome decoding.
Decoding complexity is reduced through projection onto a smaller code.
Abstract
As far as we know, there is no decoding algorithm of any binary self-dual code except for the syndrome decoding applied to the code directly. This syndrome decoding for a binary self-dual code is not efficient in the sense that it cannot be done by hand due to a large syndrome table. The purpose of this paper is to give two new efficient decoding algorithms for an extremal binary doubly-even self-dual code by hand with the help of a Hermitian self-dual code over . The main idea of this decoding is to project codewords of onto so that it reduces the complexity of the decoding of . The first algorithm is called the representation decoding algorithm. It is based on the pattern of codewords of . Using certain automorphisms of , we show that only eight…
| No. | Type of codewords for | Number of this type | Weight | |||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| (i) | 1 | 1 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 4 | |
| (ii) | 1 | 0 | 1 | 0 | 1 | 0 | 1 | 0 | 6 | |||
| (iii) | 1 | 1 | 0 | 0 | 0 | 0 | 60 | 6 | ||||
| (iv) | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 0 | 0 | 8 | |
| (v) | 1 | 1 | 1 | 1 | 0 | 0 | 8 | |||||
| (vi) | 1 | 0 | 1 | 0 | 8 | |||||||
| (vii) | 10 | |||||||||||
| (viii) | 1 | 1 | 1 | 1 | 1 | 1 | 10 | |||||
|
|
|
||||||
|---|---|---|---|---|---|---|---|---|
| 0 | (0;) | |||||||
| 1 | ) | |||||||
| 2 | (2;) | |||||||
| 3 | ) | |||||||
| ) | ||||||||
| (0;) |
| Case |
|
|
|
in | |||||||
| I | (i) (0;) errors | 10 | (0,0) | Yes | |||||||
| (ii) (2;) | (9) out of 10 | (1,0) | Yes | ||||||||
| (iii) (4;) | (9) out of 10 | (1,0) | Yes | ||||||||
| (iv) (2,2;) | (8) out of 10 | (2,0) | No | ||||||||
| (v) (2,2,2;) | (7) out of 10 | (3,0) | No | ||||||||
| II | (i) ) | 9 | (0,1) | Yes | |||||||
| (ii) ) | 9 | (0,1) | Yes | ||||||||
| (iii) ) | (8) out of 9 | (1,1) | Yes | ||||||||
| (iv)) | (7) out of 9 | (2,1) | No | ||||||||
| (v) ) | (6) out of 9 | (3,1) | No | ||||||||
| III | (i) ) | 8 | (0,2) | Yes | |||||||
| (ii) | 8 | (0,2) | Yes | ||||||||
| (iii) | (7) out of 8 | (1,2) | No | ||||||||
| (iv) ) | (7) out of 8 | (1,2) | No | ||||||||
| (v) ) | (6) out of 8 | (2,2) | No | ||||||||
| IV | (i) (0;) | 7 | (0,3) | Yes | |||||||
| (ii) ) | 7 | (0,3) | Yes | ||||||||
| (iii) ) | (6) out of 7 | (1,3) | No | ||||||||
| (iv) ) | (6) out of 7 | (1,3) | No | ||||||||
| (v) ) | (6) out of 7 | (1,3) | No | ||||||||
| (vi) ) | (5) out of 7 | (2,3) | No |
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
Taxonomy
TopicsCoding theory and cryptography · graph theory and CDMA systems · Cellular Automata and Applications
A Projection Decoding of a Binary
Extremal Self-Dual Code of Length
Jon-Lark Kim
Department of Mathematics
Sogang University
Seoul, 121-742, South Korea
Nari Lee
Department of Mathematics
Sogang University
Seoul 121-742, South Korea
Abstract
As far as we know, there is no decoding algorithm of any binary self-dual code except for the syndrome decoding applied to the code directly. This syndrome decoding for a binary self-dual code is not efficient in the sense that it cannot be done by hand due to a large syndrome table. The purpose of this paper is to give two new efficient decoding algorithms for an extremal binary doubly-even self-dual code by hand with the help of a Hermitian self-dual code over . The main idea of this decoding is to project codewords of onto so that it reduces the complexity of the decoding of . The first algorithm is called the representation decoding algorithm. It is based on the pattern of codewords of . Using certain automorphisms of , we show that only eight types of codewords of can produce all the codewords of . The second algorithm is called the syndrome decoding algorithm based on . It first solves the syndrome equation in and finds a corresponding binary codeword of .
Key Words: decoding algorithm, projection, self-dual codes, syndrome decoding method
MSC 2010 Codes: 94B05
1 Introduction
Self-dual codes have been one of the most active research topics in algebraic coding theory because they have wide connections with mathematical areas including groups, designs, lattices, modular forms, and invariant theory (see [16], [17], [22]).
Pless [20] started the classification of binary self-dual codes of lengths up to . There are many papers devoted for the classification of binary self-dual codes (see [7], [15]). Anguilar-Melchor, et al. [1] classified all extremal binary self-dual codes of length 38. Shortly after, it was shown [3] that there are exactly 16470 extremal doubly-even self-dual binary codes of length 40. Then, it has been shown [4] that there are exactly 10200655 extremal singly-even self-dual codes of length 40.
However, from a viewpoint of decoding, only a few self-dual codes have efficient decoding algorithms. In particular, we are interested in decoding self-dual codes of reasonable length by hand, i.e., decoding without using computers. For example, Pless [21] showed how to decode the extended binary Golay code by hand. The hexacode over was used here to decode the extended Golay code. Later, Gaborit-Kim-Pless [12] suggested two handy decoding algorithms for three doubly-even self-dual codes such as the binary Reed-Muller code and two other doubly-even self-dual codes denoted by (or ) and (or ) in the notation of [20]. As far as we know, there is no efficient decoding algorithm by hand for binary self-dual codes. (The best known binary linear code has and has no efficient decoding yet.) For example, the usual syndrome decoding to decode requires coset leaders. Hence the comparison of the syndrome of a received vector and the look-up table of coset leaders needs much space and time. It has been remarked as a research problem [16, Research Problem 9.7.8] to find an efficient decoding algorithm that can be used on all self-dual codes or on a large family of such codes. Thus decoding self-dual codes by hand will be an efficient decoding algorithm.
In this paper, we describe two new efficient decoding algorithms for an extremal self-dual code by hand with the help of a Hermitian self-dual code over . The algorithm is called the representation decoding algorithm. It is based on the pattern of codewords of . Using the automorphisms of we show that certain eight types of codewords of produce all the codewords of . The other algorithm is called the syndrome decoding algorithm. It first solves the syndrome equation in and finds a corresponding binary codeword of . The main idea of this decoding is to generalize the decoding of the binary Golay code of length 24 whose codewords are arranged as a matrix and are projected onto the Hexacode over (see [21]). We give a detailed explanation of these algorithms and show how these algorithms work by showing explicit examples.
2 Preliminaries
A linear code over is a -dimensional subspace of . The dual of is \mbox{\cal C}^{\perp}=\{x\in\mathbb{F}_{q}^{n}~{}|~{}x\cdot c=0{\mbox{ for any }}c\in\mbox{\cal C}\}, where the dot product is either a usual inner product or a Hermitian inner product. A linear code is called self-dual if \mbox{\cal C}=\mbox{\cal C}^{\perp}. If , then is called binary. If , let GF(4)=\{0,1,\mbox{\omega},\mbox{\overline{\omega}}\}, where \mbox{\overline{\omega}}=\mbox{\omega}^{2}=\mbox{\omega}+1. It is more natural to consider the Hermitian inner product on : for and in , , where .
Besides linear codes over or , we introduce additive codes. For basic definitions about additive codes, we refer to [10], [14], [11]. An additive code over of length is an additive subgroup of . Since is a vector space over , it has a -basis consisting of vectors whose entries are in . We call an code. A generator matrix of is a matrix with entries in whose rows are a -basis of . The weight wt(c) of c in is the number of nonzero components of c. The minimum weight of is the smallest weight of any nonzero codeword in . If is an additive code of minimum weight , is called an code. In order to define an inner product on additive codes we define the trace map, i.e., for in , . We now define a non-degenerate trace inner product of two vectors and in to be
[TABLE]
where denotes the conjugate of . Note that if and only if and are nonzero distinct elements in .
If is an additive code, its dual, denoted by \mbox{\cal C}^{\bot}, is the additive code \{{\bf x}\in GF(4)^{n}\mid{\bf x}\star{\bf c}=0\mbox{ for all }{\bf c}\in\mbox{\cal C}\}. If is an code, then \mbox{\cal C}^{\bot} is an code. As usual, is called self-dual if \mbox{\cal C}=\mbox{\mbox{}^{\bot}}. We note that if is self-dual, is an code. In binary codes there are two types of self-dual codes which are doubly-even and singly-even such that weights of all the codewords and weights of some codewords , respectively. So are in additive codes over . A self-dual additive code is called Type II (or even) if all codewords have even weight, and Type I if some codeword has odd weight. It is well known [6] that a linear self-dual code over under the Hermitian inner product (i.e., a Hermitian self-dual code over ) is a Type II self-dual additive code over .
Höhn [14] presents two constructions that begin with a self-dual additive code and produce a self-dual binary code of length . We describe these two (Constructions A and B) and recall a third (C) from [11].
If is a self-dual additive code over , let \widehat{\mbox{\cal C}} be the binary linear code obtained from by mapping each component to a 4-tuple in as follows : , , \mbox{\omega}\rightarrow 0101, and \mbox{\overline{\omega}}\rightarrow 0110. Let be the binary linear code . Let be the binary linear code consisting of all codewords of weights divisible by 8 from the code , where denotes a direct sum of n copies of . Let be the code generated by
[TABLE]
and the binary code generated by .
Construction A: Define \rho_{A}(\mbox{\cal C})=\widehat{\mbox{\cal C}}+d_{4}^{n}.
Construction B: Assume that is even. Define \rho_{B}(\mbox{\cal C})=\widehat{\mbox{\cal C}}+(d_{4}^{n})_{0}+e_{B}.
Construction C: Assume that . Define \rho_{C}(\mbox{\cal C})=\widehat{\mbox{\cal C}}+(d_{4}^{n})_{0}+e_{C}.
We give a brief remark on the classification of additive self-dual codes. Gaborit et al. [11] showed that there are at least Type I self-dual additive codes and at least Type II self-dual additive codes. Later, Bachoc-Gaborit [2] showed that there are exactly Type II additive codes. Finally, Danielsen-Parker [8] classified that there are exactly Type I self-dual codes.
Theorem 1**.**
Suppose is a Type II self-dual additive code. Then \rho_{C}(\mbox{\cal C}) is a singly-even self-dual binary code. Similarly, \rho_{B}(\mbox{\cal C}) is a doubly-even self-dual binary code.
Proof.
Note that \rho_{C}(\mbox{\cal C})=\widehat{\mbox{\cal C}}+(d_{4}^{n})_{0}+e_{C} and that \rho_{B}(\mbox{\cal C})=\widehat{\mbox{\cal C}}+(d_{4}^{n})_{0}+e_{B} since . It follows from Theorem 5.1 in [11] that \rho_{C}(\mbox{\cal C}) (\rho_{B}(\mbox{\cal C}) respectively) is a singly-even self-dual (doubly-even self-dual, respectively) binary code by construction. Thus it remains to show the minimum distance of \rho_{C}(\mbox{\cal C}) (\rho_{B}(\mbox{\cal C}) respectively) is equal to 8.
For the first statement, the minimum distance of \rho_{C}(\mbox{\cal C}) is less than or equal to 8 by construction. Let {\bf a}\in\widehat{\mbox{\cal C}}, , and . It suffices to show that any linear combination of these vectors has weight at least 8.
To do this, for , let be a subset of coordinates . Clearly wt(a), wt(b), and wt(c) are greater than or equal to 8. Since wt wt(a) , wt. The weight of {\bf v}\in\rho_{C}(\mbox{\cal C}) restricted to is denoted by wt. Since wt, we have wt. Since wt, we have wt. Finally, observe that wt, hence that wt. This implies that wt. Therefore the minimum distance of \rho_{C}(\mbox{\cal C}) is 8, as desired.
For the second statement, let , {\bf a}\in\widehat{\mbox{\cal C}}, and . By construction the minimum distance of \rho_{B}(\mbox{\cal C}) is less than or equal to 8. It suffices to show that any linear combination of these vectors has weight at least 8.
Let be defined as above. Clearly wt(a), wt(b), and are greater than or equal to 8. Since wt wt(a) , wt. The weight of {\bf v}\in\rho_{B}(\mbox{\cal C}) restricted to is denoted by wt. Since wt, we have wt. Since wt, we have wt. Finally, wt, hence that wt. This implies that wt. Therefore the minimum distance of \rho_{B}(\mbox{\cal C}) is 8, as desired. ∎
Now, one natural question is whether it is possible to decode some (or all) of these singly-even or doubly-even self-dual binary codes.
3 Construction of a doubly-even (or singly-even) code
In this section, we describe how to construct a singly-even or doubly-even self-dual binary code which can be decoded easily.
As mentioned above, there are exactly Type II self-dual additive codes. Hence by applying Theorem 1, we can get singly-even self-dual binary codes and doubly-even self-dual binary codes, all of which are inequivalent by Magma. Not all such binary codes can be decoded efficiently. Since Hermitian self-dual codes over are Type II self-dual additive codes, we use the classification of Hermitian self-dual linear codes. In fact, there are exactly two non-equivalent Hermitian self-dual linear codes, denoted by and in the notation of [19]. Their weight enumerator is by [19]. We rewrite each generator matrix as a -basis, where the first five rows form a basis for a Hermitian self-dual linear code over .
[TABLE]
Applying Theorem 1, we obtain the following theorem.
Theorem 2**.**
Each of generator matrices for and generates a singly-even self-dual code. 2. 2.
Each of generator matrices for and generates a doubly-even self-dual code.
Let {\mbox{\cal C}}_{40,1}^{DE}=\rho_{B}(E_{10}), {\mbox{\cal C}}_{40,2}^{DE}=\rho_{B}(B_{10}), and {\mbox{\cal C}}_{40,1}^{SE}=\rho_{C}(E_{10}), {\mbox{\cal C}}_{40,2}^{SE}=\rho_{C}(B_{10}). Then we describe some properties of {\mbox{\cal C}}_{40,i}^{DE} and {\mbox{\cal C}}_{40,i}^{SE} for . The following computation has been done by Magma.
The weight distribution of {\mbox{\cal C}}_{40,1}^{DE} is . The order of the automorphism group of {\mbox{\cal C}}_{40,1}^{DE} is . Its covering radius is . The generator matrix G({\mbox{\cal C}}_{40,1}^{DE}) of {\mbox{\cal C}}_{40,1}^{DE} is given below.
The weight distribution of {\mbox{\cal C}}_{40,1}^{SE} is . We recall that any singly-even self-dual code has the following weight enumerator [7, 13].
[TABLE]
where . It is useful to know the weight enumerator of {\mbox{\cal C}}_{40,2}^{SE} in terms of . Hence {\mbox{\cal C}}_{40,1}^{SE} has with . The order of the automorphism group of {\mbox{\cal C}}_{40,1}^{SE} is . Its covering radius is . The generator matrix of {\mbox{\cal C}}_{40,1}^{SE} is obtained by replacing the last row of G({\mbox{\cal C}}_{40,1}^{DE}) by the vector from Construction .
Similarly, the weight distribution of {\mbox{\cal C}}_{40,2}^{DE} is the same as that of . The order of the automorphism group of {\mbox{\cal C}}_{40,2}^{DE} is . Its covering radius is . The generator matrix G({\mbox{\cal C}}_{40,2}^{DE}) of {\mbox{\cal C}}_{40,2}^{DE} is given below.
The weight distribution of {\mbox{\cal C}}_{40,2}^{SE} is the same as that of {\mbox{\cal C}}_{40,1}^{SE}. The order of the automorphism group of {\mbox{\cal C}}_{40,2}^{SE} is . Its covering radius is . The generator matrix of {\mbox{\cal C}}_{40,i}^{SE} is obtained by replacing the last row of G({\mbox{\cal C}}_{40,i}^{DE}) by the vector in Construction .
[TABLE]
In what follows, we describe how the four codes {\mbox{\cal C}}_{40,i}^{DE} and {\mbox{\cal C}}_{40,i}^{SE} for are obtained in terms of column and row parities.
To do this, we recall basic terms from [12] and [18].
Let be a binary vector of length 40. We identify it with a array with zeros and ones in it. Let \left[\begin{array}[]{c}v_{1}\\ v_{2}\\ v_{3}\\ v_{4}\\ \end{array}\right] be any column of the array of (where or for ).
Label the four rows of the array with the elements of GF(4):0,1,\mbox{\omega},\mbox{\overline{\omega}}. If we take the inner product of a column of our array with the row labels, we get 0\cdot v_{1}+1\cdot v_{2}+\mbox{\omega}\cdot v_{3}+\mbox{\overline{\omega}}\cdot v_{4} which is an element of . This defines a linear map called from the set of binary vectors of length to the set of quaternary vectors of length .
For instance, let = (1,1,1,0, 1,0,0,0, 1,1,0,0, 0,1,0,1, 1,0,0,1, 1,1,0,0, 0,0,1,0, 0,1,0,0, 1,1,1,1, 0,1,1,0) be the binary vector of length 40. Then
[TABLE]
is projected to the quaternary vector {\bf w}=(\mbox{\overline{\omega}},0,1,\mbox{\omega},\mbox{\overline{\omega}},1,\mbox{\omega},1,0,\mbox{\overline{\omega}}) of length 10. Hence we have .
Let the parity of a column be either even or odd if an even or an odd number of ones exist in the column. Define the parity of the top row in a similar fashion. Thus columns 1,2,7, and 8 of the above array have odd parity, and the rest have even parity. The top row has even parity.
Let be a set of binary vectors of length and \mbox{\cal C}_{4} a quaternary additive code of length . Then is said to have \mbox{\cal C}_{4} if the following conditions are satisfied:
- (i)
For any vector , Proj({\bf v})\in\mbox{\cal C}_{4}. Conversely, for any vector {\bf w}\in\mbox{\cal C}_{4}, all vectors such that are in .
- (ii)
The columns of the array of any vector of are either all even or all odd.
- (iii)
The parity of the top row of the array of any vector of is the same as the column parity of the array.
Using the same notation as above, is said to have \mbox{\cal C}_{4} if the conditions (i) and (ii), as well as the following third condition (iii*′*), are satisfied:
- (iii*′*)
The parity of the top row of the array of any vector of is always even.
Now we have a result similar to [12, Lemma 2].
In an analogous way, we obtain the following theorem.
Theorem 3**.**
Let {\mbox{\cal C}}_{1}=E_{10} and {\mbox{\cal C}}_{2}=B_{10}. Let . Then {\mbox{\cal C}}_{40,i}^{DE} has projection onto \mbox{\cal C}_{i}.
Proof.
Let . Let be a set of binary vectors of length 40 having projection onto \mbox{\cal C}_{i}. Since we denoted {\mbox{\cal C}}_{40,1}^{DE}=\rho_{B}(E_{10}), {\mbox{\cal C}}_{40,2}^{DE}=\rho_{B}(B_{10}) before, we want to show that \rho_{B}(\mbox{\cal C}_{i})=\mathcal{I}.
Note that in condition (i) of projection is linear, i.e., if for , then . Thus any set satisfying condition (i) is linear. It is easy to see that sum of any two vectors of even(odd, respectively) parities for columns and top row also has even(even, respectively) parities for columns and top row. Sum of a vector of even parity and a vector of odd parity has odd parities for columns and top row. Thus any set satisfying the condition (ii) and (iii) of projection is also linear. Since is assummed to have projection onto \mbox{\cal C}_{i}, satisfies conditions (i), (ii), and (iii) by the definition of \mbox{\cal C}_{4}. Thus is a binary linear code. We note that \mbox{\cal C}_{i} as a linear code over has an information set which consists of some five linearly independent columns over of G(\mbox{\cal C}_{i}). (One such information set is the set of columns 1, 2, 4, 5, and 7 of G(\mbox{\cal C}_{1}) (resp. 1, 5, 6, 7, and 10 of G(\mbox{\cal C}_{2})) where G(\mbox{\cal C}_{i}) is introduced previously.) So the other columns of G(\mbox{\cal C}_{i}) are linear combinations of the columns in the information set. Using this, we will compute the size of .
As before, we identify a binary vector of length 40 with a array. First suppose that all columns of our arrays in are even and first row is even. Recall that has projection onto \mbox{\cal C}_{i}. Then each column in the information set can be even eight times out of 16 choices. There are 2 choices to have even parity for each column outside the information set, except the last one which is automatically determined because of top row parity. Hence there are vectors when all columns and top row are even. For the same reason we obtain vectors when all columns and top row are odd. Therefore there are vectors, which implies that is a linear code. By Theorem 1 \rho_{B}(\mbox{\cal C}_{i}) gives a doubly-even self-dual code. Since \rho_{B}(\mbox{\cal C}_{i}) is a binary linear code of dimension 20 satisfying properties (i), (ii), and (iii) of projection and is the largest linear code of dimension 20 satisfying (i), (ii), and (iii) of projection , we have that \rho_{B}(\mbox{\cal C}_{i})=\mathcal{I} as desired. ∎
Remark 1**.**
Let {\mbox{\cal C}}_{1}=E_{10} and {\mbox{\cal C}}_{2}=B_{10}. Let . Then {\mbox{\cal C}}_{40,i}^{SE} has projection onto .
The proof of the remark is analogous to Theorem 3. Considering only even top parity instead even and odd top row parities, we get the same result.
Since our self-dual codes have minimum distance , it can correct up to three errors. In what follows, we show that these can be done very quickly.
4 Decoding a doubly-even (or singly-even) code
Because of the simple structure of the generator matrix of , we focus on the decoding of the doubly-even self-dual binary code {\mbox{\cal C}}_{40,1}^{DE}. The singly-even self-dual binary code {\mbox{\cal C}}_{40,1}^{SE} is decoded similarly. We will represent all the codewords in by only 8 vectors together with certain automorphisms of .
We call positions , and blocks of . In [19] the order of the monomial group of is with generators . It implies that this representation is invariant under all permutations of these five blocks and under all even numbers of interchanges within the blocks. So we can partition all vectors of , except the zero vector, into the eight vectors in Table 1 up to those invariant operations. The following shows how we applied those invariant operations to vectors in .
- (i)
The number of the first type codewords is considering block permutations and scalar multiplication of \{1,\mbox{\omega},\mbox{\overline{\omega}}\}. It is meaningless to consider the interchanges within blocks since the components in a block are identitcal.
- (ii)
The number of the second type codewords is . Consideirng only block permutations there are cases. Considering interchanges within 2 blocks there are cases for the type (01~{}01~{}10~{}10~{}\mbox{\omega}\mbox{\overline{\omega}}) and cases for the type (01~{}10~{}10~{}10~{}\mbox{\omega}\mbox{\overline{\omega}}). Considering interchanges within 4 blocks there are cases for the type (01~{}01~{}01~{}01~{}\mbox{\omega}\mbox{\overline{\omega}}) and cases for the type (01~{}01~{}01~{}10~{}\mbox{\overline{\omega}}\mbox{\omega}). Considering the scalar multiplication and the total number of these cases, we get our result.
- (iii)
The number of the third type codewords is . For this type we only need to consider block permutations since a codeword with scalar multiplication matches to one of the codewords with block permutations. It is meaningless to consider the interchanges within blocks since the components in a block are identitcal.
- (iv)
The number of the fourth type codewords is considering block permutations and scalar multiplications. It is meaningless to consider the interchanges within blocks since the components in a block are identitcal.
- (v)
The number of the fifth type codewords is considering block permutations and scalar multiplications. It is meaningless to consider the interchanges within blocks since the components in a block are identitcal.
- (vi)
The number of the sixth type codewords is . Considering only block permutations there are cases. Considering interchanges within 2 blocks there are cases for the type (\mbox{\omega}\mbox{\overline{\omega}}~{}\mbox{\omega}\mbox{\overline{\omega}}~{}10~{}10~{}\mbox{\omega}\mbox{\overline{\omega}}), cases for the type (\mbox{\omega}\mbox{\overline{\omega}}~{}\mbox{\overline{\omega}}\mbox{\omega}~{}01~{}10~{}\mbox{\omega}\mbox{\overline{\omega}}), cases for the type (\mbox{\overline{\omega}}\mbox{\omega}~{}\mbox{\overline{\omega}}\mbox{\omega}~{}01~{}01~{}\mbox{\omega}\mbox{\overline{\omega}}), and cases for the type (\mbox{\overline{\omega}}\mbox{\omega}~{}\mbox{\overline{\omega}}\mbox{\omega}~{}01~{}10~{}\mbox{\overline{\omega}}\mbox{\omega}). Considering interchanges within 4 blocks there are cases for the type (\mbox{\omega}\mbox{\overline{\omega}}~{}\mbox{\omega}\mbox{\overline{\omega}}~{}01~{}01~{}\mbox{\omega}\mbox{\overline{\omega}}). Considering the scalar multiplication and the total number of these cases, we get our result.
- (vii)
The number of the seventh type codewords is . Considering only block permutations there are cases. Considering interchanges within 2 blocks there are case for the type (\omega$$\overline{\omega} \omega$$\overline{\omega} \omega$$\overline{\omega} \omega$$\overline{\omega} \omega$$\overline{\omega}) and cases for the type (\overline{\omega}$$\omega \overline{\omega}$$\omega \overline{\omega}$$\omega \overline{\omega}$$\omega \omega$$\overline{\omega}). Considering the scalar multiplication and the total number of these cases, we get our result.
- (viii)
The number of the eighth type codewords is considering block permutations and scalar multiplications. It is meaningless to consider the interchanges within blocks since the components in a block are identical.
As an example, if there is a codeword (0\mbox{\overline{\omega}}~{}\mbox{\omega}1~{}\mbox{\omega}1~{}\mbox{\overline{\omega}}0~{}\mbox{\omega}1), it is easy to find its type since its weight is 8 and there are 3 distinct nonzero components. It tells us that this is the sixth type of Table 1. Using this table we can easily check and correct at most three errors and there are many other examples for this in Sec. 4.3.
In what follows, we introduce a lemma in order to describe how many errors and erasures in over can be corrected. By an erasure, we mean that we know an error position but we do not know a correct value.
Lemma 1**.**
([16, p. 45])* Let be an code over . If a codeword is sent and is received where errors and erasures have occurred, then is the unique codeword in closest to provided .*
In Sec. 3 we showed how we arranged the binary vectors of length 40 in columns to do the projection onto . Table 2 shows all the possible cases of errors up to “three” that we can have for binary vectors of length 40. There is no other case that we can decode to a unique codeword in than the cases listed in Table 2. The notation we used in the second column of Table 2 denotes that columns have the same parity and columns the other and may assume that . In many cases we can detect errors by checking the column parities since our code can correct up to three errors. In some cases, however, column parities do not give enough information about errors since an even number of errors in a column do not change the parity. We considered this kind of errors and their combinations as well.
For a binary vector with column parity, the notation (; ) denotes errors in columns, and errors in columns. For (0;), it means that there is no error in any of the columns. For (0;), it means that there is no error in any of nine columns of one parity but an error in the column of the other parity. This error is easy to find since one error changes the column parity. For (2;), it means that two errors lie in one of the ten columns. It is easy to see that these errors do not change the column parity. For (0;), it means that there is no error in any of eight columns of one parity but an error each in two columns of the other parity. For (2;), it means that there are two errors in one of the nine columns of one parity and an error in the column with the other parity. For (0;), it means that there are no error in any of seven columns of one parity but an error each in three columns of the other parity.
Table 3 shows all the possible cases of errors that can occur for the parity of columns in Table 2. In the second column of Table 3, we listed all the column parities in Table 2. The third column of Table 3 shows all the possible errors that can occur in each case. However some situations cannot occur such as 4 errors in one column and 1, 2, or 3 in another (i.e., , , , repectively). We can directly check from that we can always have weight 8 codewords whose -th and -st columns consist of all ones for . Thus adding these codewords to those errors would correspond to case, respectively, giving a coset leader of weight 3, 2, 1, repectively. The fourth column shows correct columns. For example, the case II(iii) (8) out of 9 implies that 8 columns out of nine columns with one parity are correct, even though which 8 columns are correct are not decided.
Now we move to the fifth column of Table 3. It represents the possible cases of errors and erasures that can occur in codewords for using Lemma 1. When a column parity of a codeword for is changed by (an) error(s), then the corresponding component in the codeword for is regarded as an erasure. For the case such that a column parity is not changed by errors the corresponding component in the codeword for is regarded as an error.
We can get the fifth column of Table 3 from the third column of Table 3 just by checking the number of numbers without bar and with bar. If the number of errors in is (0;), then the corresponding in is since zero is without bar and three ones are with bar. If the number of errors in is (), then the corresponding in is . The sixth column of Table 3 shows that if at most three errors occurred in then we can obtain a unique vector in since all the cases of such errors satisfy the inequality in Lemma 1.
Table 2 shows all the cases that are decodable to a unique codeword in . Table 3 shows all the kind of errors that can occur for the cases of column parities in Table 2. Any other cases not on the list of Table 3 definitely have more than three errors, which is regardless in our case since our code can correct up to three errors. We will introduce two kinds of algorithms as follows, one is representation decoding algorithm and the other syndrome docoding algorithm. When consider for the cases not in Table 3, we declare it has more than three errors and not decodable on Step 1 in both algorithms. Thus both algorithms halt for these cases. For the cases in Table 3, when we exit from the loop either we have decoded as a codeword of or declared that has more than three errors. Executing the if statement at the end of two algorithms returns the proper value and this satisfies the output condition. Thus both algorithms halt for the cases in Table 3.
4.1 Representation decoding algorithm
In this section we describe the representation decoding algorithm. A main idea of this algorithm is that given a received vector written as a binary matrix, we project it to a quaternary vector of length 10 and decode this quaternary vector using with the help of Table 1 and then obtain a codeword of with the help of Table 3.
Input: A received vector written as a binary matrix.
Output: Either produce a correct codeword of or say that more than three errors occurred.
Representation decoding algorithm:
- Step 1
Compute the parities of the columns of and determine which case of Table 3 we are in. If no case is found, we say that “more than three errors occurred” and exit. Otherwise, go to Step 2-I-(i).
- Step 2-I-(i)
If the parity of is the case I, then consider it as a case I-(i). Else, go to Step 2-II-(i).
Compute the projection of onto , call it . If there is any type in Table 1 matching after the action of the automorphism groups and scalar multiplication, then we compute the parity of the top row and columns of . If such is not found, then we consider it as a case I-(ii) and go to Step2-I-(ii).
If the parities of columns are all same and top row parity is same as the column parity, we say that “no errors have occurred” and is a “codeword of ” and exit. Else (i.e., case I-(iii)), we say that “more than three errors occurred” and exit.
- Step 2-I-(ii)
We use Table 1 to find the closest vector to by changing only one element of after the action of the automorphism groups and scalar multiplication.
If is found, then use to correct by changing two elements of in the column where the errors occurred according to the condition that all the columns and top row have the same parity.
Else (i.e., case I-(iv), (v)), we say that “more than three errors occurred” and exit.
After this, we say is decoded as a “codeword of ” and exit.
- Step 2-II-(i)
If the parity of is the case II, then consider it as a case II-(i). Else, go to Step 2-III-(i).
Compute the projection of onto , call it . Since we know the error column position, it is easy to find the closest vector to in Table 1 by changing only one element of after the action of the automorphism groups and scalar multiplication. If such is not found (i.e., case II-(iii), (iv), (v)), go to Step II-(iii).
We use to correct by changing one element in the column where the error occurred according to the condition that all the columns and top row have the same parity. Then we say is decoded as a “codeword of ” and exit. Else, go to Step 2-II-(ii).
- Step 2-II-(ii)
Now we use to correct by changing three elements in the column where the errors occurred according to the condition that all the columns and top row have the same parity. Then we say is decoded as a “codeword of ” and exit.
- Step 2-II-(iii)
We use Table 1 to find the closest vector to by changing two elements of after the action of the automorphism groups and scalar multiplication.
If is found, then we use to correct by changing two elements in two columns where the errors occurred according to the condition that all the columns and top row have the same parity. Else (case II-(iv), (v)), we say that “more than three errors occurred” and exit.
After this, we say is decoded as a “codeword of ” and exit.
- Step 2-III-(i)
If the parity of is the case III, then consider it as a case III-(i). Else, go to Step 2-IV-(i).
Compute the projection of onto , call it . Since we know the error column positions, it is easy to find the closest vector to in Table 1 by changing two elements of after the action of the automorphism groups and scalar multiplication. If such is not found (i.e., case III-(iii), (iv), (v)), we say that “more than three errors occurred” and exit.
We use to correct by changing two elements in two columns where the errors occurred according to the condition that all the columns and top row have the same parity. Then we say is decoded as a “codeword of ” and exit. Else, we are in (case III-(ii)), so we say that “more than three errors occurred” and exit.
- Step 2-IV-(i)
If the parity of is the case IV, then consider it as a case IV-(i). Compute the projection of onto , call it . Since we know the error column positions, it is easy to find the closest vector to in Table 1 by changing three elements of after the action of the automorphism groups and scalar multiplication. If such is not found (i.e., case IV-(iii), (iv), (v), (vi)), we say that “more than three errors occurred” and exit.
We use to correct by changing three elements in three columns where the errors occurred according to the condition that all the columns and top row have the same parity. Then we say is decoded as a “codeword of ” and exit. Else, we are in (case IV-(ii)), so we say that “more than three errors occurred” and exit.
The following columns yield the elements in .
[TABLE]
[TABLE]
As we can see above, we have four choices for each element in and two choices for even parity and two for odd. Thus after the correct projection is found, we change elements in columns of to satisfy . Considering the column and top row parity, we are left with only one choice out of four. After changing elements according to the steps in the representation decoding algorithm, we can say is decoded to a unique vector in .
4.2 Syndrome decoding algorithm
In this section, we give a syndrome decoding algorithm based on . A main idea of this algorithm is that given a received vector written as a binary matrix, we project it to a quaternary vector of length 10 and decode this quaternary vector using the syndrome decoding of and then obtain a codeword of with the help of Table 3.
Let be a parity check matrix of consisting of the first five rows of in Section 3. We use the first five rows of since we are considering it as a parity check matrix of a linear self-dual code over .
Input: A vector as a binary matrix.
Output: Either produce a correct codeword of or say that more than three errors occurred.
Syndrome decoding algorithm algorithm:
- Step 1
Compute the parities of the columns of and determine which case of Table 3 we are in. If no case is found, we say that “more than three errors occurred” and exit. Otherwise, go to Step 2-I-(i).
- Step 2-I-(i)
If the parity of is the case I, then consider it as a case I-(i). Else, go to Step 2-II-(i).
Compute the projection of onto , call it . If the syndrome of is zero, then we compute the parity of the top row and columns of . Else, go to Step2-I-(ii). When we get the syndrome of , we use as a parity check matrix of .
If the parities of columns are all same and top row parity is the same as the column parity, we say that “no errors have occurred” and exit. Else (i.e., case I-(iii)), we say that “more than three errors occurred” and exit.
- Step 2-I-(ii)
If the syndrome is a scalar multiple of an -th column of the parity check matrix , then the -th coordinate of the error vector is and elsewhere zeros. Else (i.e., case I- (iv), (v)), we say that “more than three errors occurred” and exit.
By adding to , we get the correct projection . Now we use to correct by changing two elements in the column where the errors occurred according to the condition that all the columns and top row have the same parity. Then we say is decoded as a “codeword of ”, then exit.
- Step 2-II-(i)
If the parity of is the case II, then consider it as a case II-(i). Else, go to Step 2-III-(i).
Compute the projection of onto , call it . If the syndrome is a scalar multiple of an -th column of , then the -th coordinate of the error vector is and elsewhere zeros. Else, go to Step 2-II-(iii).
By adding to , we get the correct projection . We use to correct by changing one element in the column where the error occurred according to the condition that all the columns and top row have the same parity. Now we say is decoded as a “codeword of ”, then exit. Else, go to Step 2-II-(ii).
- Step 2-II-(ii)
We use to correct by changing three elements in the column where the errors occurred according to the condition that all the columns and top row have the same parity. Now we say is decoded as a “codeword of ”, then exit.
- Step 2-II-(iii)
If the syndrome is written as a linear combination of two columns in , then we can get an error vector and obtain a correct projection . Else (i.e, case II-(iv), (v)), we say that “more than three errors occurred” and exit.
Since we know the correct projection now, we use to correct by changing three elements in three columns where the errors occurred according to the condition that all the columns and top row have the same parity. Now we say is decoded as a “codeword of ”, then exit.
- Step 2-III-(i)
If the parity of is the case III, consider it as a case III-(i). Else, go to Step 2-IV-(i).
Compute the projection of onto , call it . If the syndrome is written as a linear combination of two columns in , then we can get an error vector and obtain a correct projection . Else (i.e., case III-(iii), (iv), (v)), we say that “more than three errors occurred” and exit.
We use to correct by changing two elements in two columns where the errors occurred according to the condition that all the columns and top row have the same parity. Now we say is decoded as a “codeword of ”, then exit. Else (i.e, case III-(ii)), we say that “more than three errors occurred” and exit.
- Step 2-IV-(i)
If the parity of is the case IV, then consider it as a case IV-(i). Compute the projection of onto , call it . If the syndrome is written as a combination of three columns in , then we can get an error vector and obtain a correct projection . Else (i.e., case IV-(iii), (iv), (v), (vi)), we say that “more than three errors occurred” and exit.
We use to correct by changing three elements in three columns where the errors occurred according to the condition that all the columns and top row have the same parity. Now we say is decoded as a “codeword of ”, then exit. Else (i.e., case IV-(ii)), we say that “more than three errors occurred” and exit.
To see this algorithm more clearly we give several examples.
4.3 Examples
The steps in these examples are the ones in Section 4.2.
Example 1** (Case I).**
*All the columns have the same parity.
[TABLE]
**(a) Representation Decoding **
- Step 1
Compute the parities of the columns of and determine which case of Table 3 we are in. Since all the columns have one parity, this is the case I. Thus we move to the Step 2-I-(i).
- Step 2-I-(i)
Compute the projection of onto , call it . Note that there is no type matching in Table 1 after the action of the automorphism groups and scalar multiplication since has four zeros in four blocks each and the same non-zero elements of in a block. Thus we move to Step 2-I-(ii).
- Step 2-I-(ii)
We use Table 1 to find the closest vector to by changing only one element of after the action of the automorphism groups and scalar multiplication. We can find a unique codeword closest to of weight 6 by correcting only one element, i.e. (1,0,1,0,1,0,0,1,\mbox{\boldmath\mbox{\overline{\omega}}},\mbox{\omega}) (see Type 2 in Table 1).
Now we use to correct by changing two elements of in the column where the errors occurred according to the condition that all the columns and top row have the same parity.
Finally is decoded as a “codeword of ”. We uniquely decode as follows:
[TABLE]
Then we exit.
**(b) Syndrome Decoding **
- Step 1
Same as the Step 1 in representation decoding.
- Step 2-I-(i)
Compute the projection of onto , call it . Since the syndrome of is not zero as below, we move to the Step2-I-(ii).
[TABLE]
- Step 2-I-(ii)
Since the syndrome is the ninth column of (see in Sec. 3), we can get our error vector giving a codeword {\bf y^{\prime}}={\bf y}+{\bf e}=(1,0,1,0,1,0,0,1,\mbox{\boldmath\mbox{\overline{\omega}}},\mbox{\omega}).
Now we can use to correct by changing two elements of in the column where the errors occurred according to the condition that all the columns and top row have the same parity.
Finally is decoded as a “codeword of ”. Then we exit.
Example 2** (Case II).**
Nine columns have one parity, and one left has the other parity.
[TABLE]
**(a) Representation Decoding **
- Step 1
Compute the parities of the columns of and determine which case of Table 3 we are in. Since nine columns have one parity and one left has the other parity, this is the case II. Thus we move to the Step 2-II-(i).
- Step 2-II-(i)
If the parity of is the case II, then consider it as a case II-(i). Compute the projection of onto , call it . We cannot find the closest to in Table 1 by changing only one element of {\bf y}=(1,0,\mbox{\overline{\omega}},1,-,\mbox{\omega},1,0,\mbox{\omega},\mbox{\overline{\omega}}) after the action of the automorphism groups and scalar multiplication since it does not match to any of codewords of weight 8 with three distinct nonzero elements . It implies that one column among nine odd columns of is not correct. Thus we move to the Step 2-II-(iii).
- Step 2-II-(iii)
We use Table 1 to find the closest vector to by changing two elements of after the action of the automorphism groups and scalar multiplication and find the unknown error position. In this case, it is the fourth position. Now we change it to (Type 6 of Table 1). Now we use to correct by changing three elements in two columns where the errors occurred according to the condition that all the columns and top row have the same parity. Thus is uniquely decoded as a “codeword of ”.
[TABLE]
Then we exit.
**(b) Syndrome Decoding **
- Step 1
Same as the Step 1 in representation decoding.
- Step 2-II-(i)
If the parity of is the case II, then consider it as a case II-(i). Compute the projection of onto , call it . Since the fifth column of is the only one with odd parity, we check whether the syndrome is the scalar multiple of fifth column of or not. In this case, the syndrome is not a scalar multiple of column of as below. We let denote the error vector and a conjugate of .
[TABLE]
So we move to the Step 2-II-(iii).
- Step 2-II-(iii)
We consider the syndrome as a linear combination of the fifth column and one of the remaining nine columns. We let denote the -th column of .
[TABLE]
Since the first entry of the syndrome is and the first entry of the fifth column of is 0, the first entry of must be non-zero. So should be one of 1,2,3, or 4. From the fact that non-zero first entries are all 1, we get as follows:
[TABLE]
Now we check the third entries on both sides. Since the third entries of and are all zeros, we get
[TABLE]
Next we check the second entries.
[TABLE]
For the last we check the fifth entries.
[TABLE]
Thus and this tells us , i.e., .
Thus we have the codeword
[TABLE]
Next we use to correct by changing three elements in two columns where the errors occurred according to the condition that all the columns and top row have the same parity. Then we exit.
Example 3** (Case III).**
Eight columns have one parity and remaining two columns have the other parity.
[TABLE]
**(a) Representation Decoding **
- Step 1
Compute the parities of the columns of and determine which case of Table 3 we are in. Since eight columns have one parity and remaining two columns have the other parity, this is the case III. Thus we move to the Step 2-III-(i).
- Step 2-III-(i)
If the parity of is the case III, then consider it as a case III-(i). Compute the projection of onto , call it . Since we know the error column positions, it is easy to find the closest vector to in Table 1 by changing two elements of {\bf y}=(\mbox{\omega},\mbox{\omega},\mbox{\overline{\omega}},\mbox{\overline{\omega}},-,-,1,1,0,0) after the action of the automorphism groups and scalar multiplication.
Since there are three distinct nonzero elements in and each block has identical elements, we cannot find a matching type for weight 8 in Table 1. Now we try with weight 6 (Type 3 of Table 1). Finally we find {\bf y^{\prime}}=(\mbox{\omega},\mbox{\omega},\mbox{\overline{\omega}},\mbox{\overline{\omega}},{\bf 0},{\bf 0},1,1,0,0) which is the closet vector to after the action of the automorphism groups and scalar multiplication.
We use to correct by changing two elements in two columns where the errors occurred according to the condition that all the columns and top row have the same parity as follows :
[TABLE]
Now is decoded as a “codeword of ”. We exit.
**(b) Syndrome Decoding **
- Step 1
Same as the Step 1 in representation decoding.
- Step 2-III-(i)
If the parity of is the case III , then consider it as a case III-(i). Compute the projection of onto , call it . Since we know the fifth and sixth columns of are the only ones with even parity, we know these two columns have an error each. Next we check whether the syndrome is a linear combination of the fifth and sixth columns of or not. A simple calculation tells us that the syndrome is indeed a linear combination of these two columns of . Thus we get \overline{e}_{5}=\mbox{\overline{\omega}} and \overline{e}_{6}=\mbox{\overline{\omega}}.
[TABLE]
So we can get a correct projection
[TABLE]
We use to correct by changing two elements in two columns where the errors occurred according to the condition that all the columns and top row have the same parity. Then we say is uniquely decoded as a “codeword of ” and exit.
Example 4** (Case IV).**
Seven columns have one parity and remaining three columns have the other parity.
[TABLE]
**(a) Representation Decoding **
- Step 1
Compute the parities of the columns of and determine which case of Table 3 we are in. Since seven columns have one parity and remaining three columns have the other parity, this is the case IV. Thus we move to the Step 2-IV-(i).
- Step 2-IV-(i)
If the parity of is the case IV, then consider it as a case IV-(i). Compute the projection of onto , call it . Since we know the error column positions, it is easy to find the closest vector to in Table 1 by changing three elements of {\bf y}=(\mbox{\overline{\omega}},-,\mbox{\overline{\omega}},\mbox{\omega},-,-,\mbox{\omega},\mbox{\overline{\omega}},\mbox{\omega},\mbox{\overline{\omega}}) after the action of the automorphism groups and scalar multiplication.
We see from Table 1 that {\bf y^{\prime}}=(\mbox{\overline{\omega}},\mbox{\omega},\mbox{\overline{\omega}},\mbox{\omega},\mbox{\omega},\mbox{\overline{\omega}},\mbox{\omega},\mbox{\overline{\omega}},\mbox{\omega},\mbox{\overline{\omega}}) (Type 7 of Table 1). Hence we use to correct by changing three elements in three columns where the errors occurred according to the condition that all the columns and top row have the same parity as follows:
[TABLE]
Now is decoded as a “codeword of ” and we exit.
**(b) Syndrome Decoding **
- Step 1
Same as the Step 1 in representation decoding.
- Step 2-IV-(i)
If the parity of is the case IV , then consider it as a case IV-(i). Compute the projection of onto , call it . Since we know the second, fifth, and sixth columns of are the only ones with even parities, we know these three columns have an error each. Next we check whether the syndrome is a linear combination of the second, fifth, and sixth columns of or not. A simple calculation tells us that the syndrome is indeed a linear combination of these three columns of .
[TABLE]
We do some calculations from the first entry of the syndrome as follows:
[TABLE]
Now we know . Calculating on the fifth entry of the syndrome, we get
[TABLE]
Now we know \overline{e}_{5}=\mbox{\omega}. Calculating on the third entry of the syndrome, we get
[TABLE]
Now we know \overline{e}_{6}=\mbox{\omega} as well.
Thus we know the error vector from \overline{e}_{2}=0,\overline{e}_{5}=\mbox{\omega}, and \overline{e}_{6}=\mbox{\omega} and get a correct projection as follows:
[TABLE]
Now we use to correct by changing three elements in three columns where the errors occurred according to the condition that all the columns and top row have the same parity. Finally is decoded as a “codeword of ” and we exit.
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1[1] Aguilar-Melchor C., Gaborit P., Kim J.-L., Sok L., Solé P.: Classification of extremal and s 𝑠 s -extremal binary self-dual codes of length 38 38 38 . IEEE Trans. Inform. Theory 58 , (4) 2253–2262 (2012).
- 2[2] Bachoc C., Gaborit P.: On extremal additive GF ( 4 ) 4 (4) -codes of lengths 10 10 10 to 18 18 18 . J. Théorie Nombres Bordeaux 12 , 225–72 (2000).
- 3[3] Betsumiya K., Harada M., Munemasa A.: A complete classification of doubly even self-dual codes of length 40, Electronic journal of combinatorics 19 , 3 # P 18 # 𝑃 18 \#P 18 (2012).
- 4[4] Bouyuklieva S., Bouyukliev I., Harada M.: Some extremal self-dual codes and unimodular lattices in dimension 40. Finite Fields and Their Applications 21 , 67–83 (2013).
- 5[5] Buyuklieva S., Yorgov V.: Singly-even self-dual codes of length 40. Designs, Codes and Cryptography 9 131–141 (1996).
- 6[6] Calderbank, A.R., Rains E.M., Shor P.W., Sloane N.J.A.: Quantum error correction via codes over GF(4). IEEE Trans. Inform. Theory 44 , 1369–1387 (1998).
- 7[7] Conway J.H., Sloane N.J.A.: A new upper bound on the minimal distance of self-dual code. IEEE Trans. Inform. Theory 36 , 1319-1333 (1990).
- 8[8] Danielsen L.E., Parker M.G.: On the classification of all self-dual additive codes over GF(4) of length up to 12. J. of Combin. Theory, Ser. A 113 , (7) 1351–1367 (2006).
