Projection decoding of some binary optimal linear codes of lengths 36 and 40

Practically good error-correcting codes should have good parameters and efficient decoding algorithms. Some algebraically defined good codes such as cyclic codes, Reed-Solomon codes, and Reed-Muller codes have nice decoding algorithms. However, many optimal linear codes do not have an efficient decoding algorithm except for the general syndrome decoding which requires a lot of memory. Therefore, it is a natural question whether which optimal linear codes have an efficient decoding. We show that two binary optimal $[36,19,8]$ linear codes and two binary optimal $[40,22,8]$ codes have an efficient decoding algorithm. There was no known efficient decoding algorithm for the binary optimal $[36,19,8]$ and $[40,22,8]$ codes. We project them onto the much shorter length linear $[9,5,4]$ and $[10, 6, 4]$ codes over $GF(4)$, respectively. This decoding algorithms, called {\em projection decoding}, can correct errors of weight up to 3. These $[36,19,8]$ and $[40,22,8]$ codes respectively have more codewords than any optimal self-dual $[36, 18, 8]$ and $[40,20,8]$ codes for given length and minimum weight, implying that these codes more practical.

A linear [n, k] code over GF (q) or F q is a k-dimensional subspace of F n q . The dual of C is C ⊥ = {x ∈ F n q | x · c = 0 for any c ∈ C}, where the dot product is either a usual inner product or a Hermitian inner product. A linear code C is called self-dual if C = C ⊥ . If q = 2, then C is called binary. A binary selfdual code is called doubly-even if all codewords have weight ≡ 0 (mod 4) and singly-even if some codeword has a weight ≡ 2 (mod 4). If q = 4, let GF (4) = {0, 1, ω, ω}, where ω = ω 2 = ω + 1. It is more natural to consider the Hermitian inner product , on GF (4) n : for x = (x 1 , x 2 , . . . , x n ) and y = (y 1 , y 2 , . . . , y n ) in GF (4) n , x, y = n i=1 x i y i , where a = a 2 . Researchers have tried to find an efficient decoding algorithms for some optimal linear codes of lengths up to 40. For example, Pless [9] showed an efficient decoding of the [24, 12, 8] extended binary self-dual Golay code by projecting it onto the [6,3,4] hexacode over GF (4). Later, Gaborit, Kim and Pless [4,8] showed that a similar projection can be done for some singly even and doublyeven self-dual binary [32, 16,8] codes including the binary Reed Muller code. Recently, Kim and Lee [6] gave two algorithms for the projection decoding of a binary extremal self-dual code of length 40. The idea was to use the projection of the said code onto a Hermitian self-dual code over GF (4). One of the two algorithms called syndrome decoding uses the syndrome decoding of the shorter code over GF (4). Most examples for the projection decoding were extremal selfdual codes. Therefore it is natural to ask whether such a projection decoding can be done for a non-self-dual code which has larger dimension than a self-dual code with the same length and minimum distance. In this paper, we show that this is possible.
The purpose of this paper is to show how to decode efficiently a binary optimal [36, 19,8] linear code and a binary optimal [40,22,8] code by projecting them onto the much shorter length linear [9,5,4] and [10, 6,4] codes over GF (4), respectively. This decoding algorithm, which we will call projection decoding can correct errors of weight up to ⌊ (8−1) 2 ⌋ = 3. It can be seen that the decoding algorithm presented in this paper is a generalization of the syndrome projection decoding in [6] since this algorithm can be used to decode any linear code with a projection into an additive or a linear code over GF (4) for errors of weight at most 3. Our decoding is the first time to decode those two optimal [36, 19,8] and [40,22,8] codes, whose parameters are better than any optimal self-dual [36,18,8] and [40,20,8] codes. This paper is organized as follows. In Section 2, we introduce a way to project a binary code of length 4n into an additive code of length n over GF (4). We also mention some properties of this projection as given in [1,7]. In Section 3, we show explicitly how to construct [36,19,8] and [40,22,8] binary optimal codes having projections onto additive codes over GF (4). Using this projection, we give a handy decoding algorithm to decode the said binary optimal codes in Section 4. This decoding algorithm exploits the properties of codes with projection onto an additive code over GF (4) to locate the errors in the noisy codewords, assuming not more than 3 errors occurred. This algorithm has low complexity and can be done with hand. In Section 5, we conclude by showing working examples of how the decoding is carried out.

Projection of binary linear codes
Let v ∈ GF (2) 4m . We associate to v a rectangular array v of zeros and ones. If we label the rows of the array with the elements of GF (4), then the inner product of a column of the array with the row labels is an element of GF (4). Thus, we obtain a corresponding element of GF (4) m , which we call the projection of v, denoted Proj(v). We show this by the following example. Let v = (1000 0100 0010 0001 0110 1110 0101 0111 1111) ∈ GF (2) 36 . Then we write v column-wisely as follows. We define the parity of the column to be even (or odd) if an even (or odd) number of ones exits in the column, and the parity of the first row is defined similarly. We call C 4 ⊂ GF (4) n an additive code of length n over GF (4) if it is closed under addition. Therefore, a linear code over GF (4) is automatically additive, but not the converse. Definition 1. Let S be a subset of GF (2) 4m and C 4 an additive code over GF (4) of length m. Then S is said to have a projection O onto C 4 if for any v ∈ S, (ii) the columns of v are of the same parity, i.e., the columns are either all even or all odd (iii) the parity of the first row of v is the same as the parity of the columns The main advantage of this projection is that we can decode the long binary code by decoding its projection, thus generally decreasing the complexity of the decoding process. Several authors have exhibited this fact.
Another similar projection is defined in [7], called projection E.
Definition 2. Using the same notation as in Definition 1, S is said to have a projection E onto C 4 if conditions (i) and (ii) are satisfied together with the additional condition: (iii)' the parity of the first row of v is always even.
Let C 4 be an additive code of length m over GF (4). Consider the map φ : GF (4) → GF (2) 4 such that φ(0) = 0000, φ(1) = 0011, φ(ω) = 0101, and φ(ω) = 0110. Define Let d be the code consisting of all even sums of weight 4 vectors whose ones appear in the same column in the projection, together with one additional vector d 1 = (1000 1000 . . . 1000) if m is odd and d 2 = (1000 1000 . . . 0111) if m is even. In [7], the following constructions were given: The following result also was also given in [7]. In this section, we apply the constructions given in the previous section to construct binary optimal codes of lengths 36 and 40. We were able to obtain two inequivalent codes for each length. Let C 9 4 be a (9, 2 10 ) additive code over GF (4) with the following generator matrix In fact the rows consisting of the odd indexed rows of G(C 9 4 ) form a [9, 5, 4]linear code over GF (4) which can be found in MAGMA with the name of BKLC(GF (4), 9,5). The code C 9 4 has weight distribution A 4 = 51, A 5 = 135, A 6 = 210, A 7 = 318, A 8 = 234, A 9 = 75.
Let C 10 4 be the (10, 2 12 ) additive code over GF (4) generated by the following matrix The minimum distance of both of these codes is 4.

Denote by C 36
O and C 40 O the binary linear codes obtained from the additive codes C 9 4 and C 10 4 , respectively, over GF (4) by construction O. That is, . Their generator matrices are given below. These two codes constructed are inequivalent and both have projection O on to C 9 4 and C 10 4 , respectively. 100000010001000100010010010001110010  010000010001000100010100011101001110  001000010001000100010001000100101000  000100010001000100010111001000011011  000010010000000000000110001101011111  000001010000000000000101011000110000  000000110000000000000011010101100000  000000001001000000000000011000111010  000000000101000000000000010101100011  000000000011000000000000001101010110  000000000000100100000101010100001001  000000000000010100000011001100000101  000000000000001100000110011000000011  000000000000000010010110001101101001  000000000000000001010101011001010101  000000000000000000110011010100110011  000000000000000000001111000000001111  000000000000000000000000111100001111 Similarly, we apply construction E on the codes C 9 4 and C 10 4 . We obtain two inequivalent codes C 36 E = ρ E (C 9 4 ) and C 40 E = ρ E (C 10 4 ) with projection E on to C 9 4 and C 10 4 , respectively. Their generator matrices are as follows. 100000010001000100010010010001111101  010000010001000100010100011101000001  001000010001000100010001000100100111  000100010001000100010111001000010100  000010010000000000000110001101011111  000001010000000000000101011000110000  000000110000000000000011010101100000  000000001001000000000000011000111010  000000000101000000000000010101100011  000000000011000000000000001101010110  000000000000100100000101010100001001  000000000000010100000011001100000101  000000000000001100000110011000000011  000000000000000010010110001101101001  000000000000000001010101011001010101  000000000000000000110011010100110011  000000000000000000001111000000001111 000000000000000000000000111100001111 000000000000000000000000000011111111  Proof. Since C 9 4 is an additive (9, 2 10 ) code over GF (4), it follows from Theorem 1 that C 36 O = ρ O (C 9 4 ) and C 36 E = ρ E (C 9 4 ) are binary [36, 19] linear codes. It remains to show that the minimum distance is 8. It is known that codes of these parameters are optimal [2].
Note that any codeword c ∈ C 36 O can be written as c = a + b + d where a ∈ φ(C 9 4 ), b is an even sum of weight 4 vectors whose ones appear in the same column in the projection and d is equal to either d 1 = (1000 . . . 1000) or the zero vector. Since the minimum distance of C 9 4 is 4 and thus φ(C 9 4 ) is of minimum Since at least 4 blocks c i are nonzero, we conclude that wt(c) ≥ 8. Hence the minimum distance of this code is 8.
The case of C 36 E is proved similarly. Finally, the codes C 36 O and C 36 E have different weight distributions given in Tables 1 and 2

Projection decoding
Let v ∈ GF (2) 4m and v its associated array, defined in Section 2. From this, we can partition the elements of GF (2) 4 with respect to its inner product with the row labels, as follows:   (4) From Definitions 1 and 2, we know that if v ∈ C, where C is a code with projection O on to C 4 , then the columns of v, as well as the first row have the same parity. Before we give the decoding algorithm, we first take note of the following observations regarding the error positions in the array v.

Remarks
1. An error on the first row of v preserves Proj(v).
2. An error on the coordinate that is not in the first row definitely changes Proj(v).
3. Two errors in the same column definitely changes Proj(v).

Three errors in the same column preserves Proj(v) if and only if the first entry is not changed.
We now present a simple decoding algorithm, which we will call the projection decoding, that can be used for any binary linear code with projection O or projection E onto some additive code C 4 over GF (4). This decoding algorithm can correct errors of weight up to three. The idea is to use syndrome decoding in C 4 , which has shorter length to locate errors in the binary codeword. The decoding is then completed by changing the columns in the array corresponding to the corrected entry in the projection, by using Table 5.
Let C be a binary linear code of length 4n with projection O or projection E onto C 4 , an additive code over GF (4). Let y be the received vector and assume that y is a noisy codeword of C with at most 3 errors. Let y be the associated array and y = Proj(y). Denote by y i the ith column of y and by y i the ith entry of y. Let H be the parity-check matrix of C 4 and denote the ith column of H by H i . The projection decoding of C is carried out as follows.
Projection decoding algorithm 1. Check the parity of the columns and the first row of y.
2. Let y o , y e be the number of columns of y with odd or even parity, resp., and let p = min(y o , y e ).
3. Depending on p, perform the following: (a) If p = 0, compute the syndrome s = yH T .
i. If s = 0, then we say that no error occurred.
ii. If s = 0, the syndrome is a scalar multiple of one of the columns of H, say s = e i H i for some e i ∈ GF (4). Hence, the two errors occurred on the ith column of y. Replace the ith coordinate of y by y i + e i ∈ GF (4) and replace the ith column of y with the vector corresponding to y i + e i (see Table 5) such that the parity conditions are satisfied.
(b) If p = 1, let y i be the column with the different parity. Compute the syndrome s = yH T .
i. If s = 0, check the parity of the first row.
A. If the parity of the first row is the same as the parity of y i , then one error occurred on the first entry of y i . Change this entry to decode y. B. If the parity of the first row is different from the parity of y i , then three errors occurred on the 2nd to 4th entries of y i . Change these entries to decode y. ii. If 0 = s = e i H i , then one or three errors occurred in the ith column of y. Replace the ith coordinate of y by y i + e i ∈ GF (4) and replace the ith column of y with the vector corresponding to y i + e i such that the parity conditions are satisfied. iii. If s = e j H j for some j = i, then two errors occurred in column j and one error in the first entry of column i. Replace the jth coordinate of y by y j + e j ∈ GF (4) and replace the jth column of y with the vector corresponding to y j + e j having the same parity as y j and of distance 2 from y j . Finally, replace the first entry of y i and check that the parity conditions are satisfied.
(c) If p = 2, let y i , y j be the columns with the different parity. Compute the syndrome s = yH T . We know that s = e i H i + e j H j .
i. If s = 0, then the two errors occurred on the first coordinates of y i and y j . Replace both coordinates and check if the parity conditions are satisfied. ii. If e i = 0 and e j = 0, then error occurred in the ith column of y and the first coordinate of y j . Replace the first coordinate of y j . Then replace the ith coordinate of y by y i + e i ∈ GF (4) and replace the ith of y with the vector corresponding to y i + e i such that the parity conditions are satisfied.
iii. If e i , e j = 0, then error occurred in the ithand jth column of y. Replace the ith coordinate of y by y i + e i ∈ GF (4) and the jth coordinate by y j + e j ∈ GF (4) then replace the ith and jth columns of y with the corresponding vectors such that the parity conditions are satisfied. (d) If p = 3, let y i , y j and y k be the columns with different parity. Then there are one error each on these columns. Compute the syndrome s = yH T . We know that s = e i H i + e j H j + e k H k i. If s = 0, then the three errors occurred on the first coordinates of y i , y j and y k . Replace the first coordinates in these columns and check if the parity conditions are satisfied. ii. If e i = 0 and e j , e k = 0, then one error occurred in the ithcolumn of y and and one error each on the the first coordinates of y j and y k . Replace the first coordinates of y j and y k . Then replace the ith coordinate of y by y i + e i ∈ GF (4) and replace the ith column of y with the vector corresponding to y i + e i such that the parity conditions are satisfied. iii. If e i = 0, e j = 0 and e k = 0, then one error each occurred in the ith and jth column of y and the first coordinate of y k . Replace the first coordinate of y k . Then replace the ith coordinate of y by y i + e i ∈ GF (4) and the jth coordinate by y j + e j ∈ GF (4) then replace the ith and jth columns of y with the corresponding vectors such that the parity conditions are satisfied. iv. If e i , e j , e k = 0, then let y ′ = y + e where e is the vector of length 9 with e i , e j and e k on the i, j and kth coordinate and zero elsewhere. Replace one coordinate each in the i, j, k columns of y so that it becomes y ′ and the parity conditions are satisfied.
Remarks We remark that our algorithm for codes C 36 O , C 36 E , C 40 O , and O 40 E is complete and ending because we have considered all possible number of column parities p = min(y o , y e ) ≤ 3 and adjusted at most three errors according to the top row parity so that Propositions 1 and 2 are satisfied.

Examples
In this section, we provide examples to illustrate how the given decoding algorithm works. Even though these are samples, most remaining cases are done similarly.
The following two examples illustrate how to decode C 36 O by hand. As a linear code over GF (4), C 9 4 has the following parity check matrix. All the columns have odd parity except for the 5th and 6th columns, and hence p = 2. Then we have the syndrome Therefore we proceed to ii of Step 3(c) with e 5 = ω and e 6 = 0. We replace  Table 5 corresponding to 0 closest to it. Finally, we replace the first entry of y 6 . So there are two errors in y. Therefore, we have decoded y as Note that p = 1 and the parity of the 8th column differs from the rest of the column, i.e. i = 8 in Step 3(b). We then compute the syndrome: So we have j = 5 = i and e 5 = ω. Proceeding with iii of Step 3(b), we replace  Table 5 corresponding to 0 which is of the same parity and distance 2 from y 5 . Then we change the first entry of y 8 . There are three errors in y. We have decoded y as Since s = 0, by ii of Step 3(a) with e 4 = ω, two errors occurred on the 4th column of y. We replace y 4 = ω by y 4 + e 4 = ω + ω = 0 and replace the fourth column y 4 by the vector in Table 5 corresponding to 0 and of distance 2 from Hence, from iii of Step 3(d), we have e 8 = 1, e 10 = ω and e 3 = 0. So we replace y 8 by y 8 + e 8 = ω + 1 = ω and y 8 by the vector corresponding to ω in Table 5 closest to  Table 5. Finally we replace the first entry of column 3. There are three errors in y. Therefore, y is decoded as Remark The most time consuming part (or the dominating complexity part of the algorithm) is to decode the projected vector y in the linear code C 9 4 or C 10 4 using the syndrome decoding. However, since we know which positions (or columns) have errors, this syndrome decoding can be done in at most 3×3×3 = 27 possible ways because there are scalar multiples in the syndrome equation involving three nonzero scalars in Step (d) of the algorithm.

Conclusion
In this paper, we have described how to decode binary optimal [36, 19,8] and [40,22,8] codes by projecting them onto the linear [9,5,4] and [10, 6, 4] codes over GF (4). Even though there were similar decoding for self-dual codes of lengths 24, 32, 40, there was no known efficient decoding algorithm for these non-self-dual optimal codes. Actually our algorithm works for any linear code with a projection onto a linear or additive code over GF (4) for errors of weight at most 3.