Self-Dual Codes over Z8 and Z9 Steven T. Dougherty Department of Mathematics University of Scranton Scranton, PA 18510, USA Email: [email protected] T. Aaron Gulliver Department of Electrical and Computer Engineering University of Victoria P.O. Box 3055, STN CSC Victoria, BC V8W 3P6 Canada Email: [email protected] John Wong Department of Electrical and Computer Engineering University of Victoria P.O. Box 3055, STN CSC Victoria, BC V8W 3P6 Canada Email: [email protected] June 22, 2011 Abstract We study self-dual codes over the rings Z8 and Z9 . We define various weights and weight enumerators over these rings and describe the groups of invariants for each weight enumerator over the rings. We examine the torsion codes over these rings to describe the structure of self-dual codes. Finally we classify self-dual codes of small lengths over Z8 .

1

1

Introduction

Self-dual codes over finite fields are a widely studied subject. Recently a great deal of attention has been given to self-dual codes over a variety of rings, see [8] and the references therein. In [3], it is shown that all self-dual codes over Zm can be found by applying the Chinese Remainder Theorem to self-dual codes over Zpe for p a prime. Hence, it is important to classify self-dual codes over the integers modulo prime powers, since this classification will give the classification over Zm . In [1], the mass formula for self-dual codes over Z9 is given and a classification of self-dual codes over Z9 for small lengths. In this work we examine the torsion codes of self-dual codes and classify self-dual codes over Z8 for small lengths. We begin with some definitions. A code C of length n over Zm is a subset of Znm and if the code is a submodule we say that the code is linear. All codes are assumed to be linear unless otherwise specified. We define a series of weights on these rings. The Hamming weight of a vector is the number of non-zero in the vector. The Euclidean weight Pnof a vector v = Pn components 2 2 (v1 , v2 , . . . , vn ) is i=1 min{vi , (2k−vi ) }. The Lee weight of a vector v is i=1 min{|vi |, |2k− vi |}. For a code C the minimum weight is the smallest of all non-zero weights in the code. The minimum Hamming, Lee and Euclidean weights of a code C are denoted by dH (C), dE (C) and dL (C) respectively. P We attach the standard inner product to the ambient space, i.e. [v, w] = vi wi . The ⊥ dual code C of C is defined by C ⊥ = {v ∈ Znm | [v, w] = 0 for all w ∈ C}.

(1)

If C ⊆ C ⊥ we say that the code is self-orthogonal and if C = C ⊥ then we say that the code is self-dual. A Type II code over Z2k is a self-dual code where each vector has Euclidean weight divisible by 4k. See [2] for a complete description of these codes. A self-dual code which is not Type II is said to be Type I. The justification for these definitions is that a Type II code constructs a Type II unimodular lattice and a Type I code constructs a Type I unimodular lattice [2]. Any code over Z8 has a generator matrix of the form:   Ik0 A0,1 A0,2 A0,3  0 2Ik1 2A1,2 2A1,3  , (2) 0 0 4Ik2 4A2,3 where the matrices Ai,j are binary matrices for i > 0. A code with a generator matrix in this form is of type {k0 , k1 , k2 } and has 8k0 4k1 2k2 vectors. Any code over Z9 has a generator matrix of the form:   Ik0 A0,1 A0,2 , (3) 0 3Ik1 3A1,2 where A1,2 is a ternary matrix. A code whose generator matrix is in this form is of type {k0 , k1 } and has 9k0 3k1 vectors. If a code over either ring has ki = 0 for i > 0 then we say that it is a free code. For undefined terms from coding theory see [7]. 2

2

Weight Enumerators

The complete weight enumerator for a code over the ring R is defined by X n (c) CW EC (x0 , x1 , x2 , . . . , x|R|−1 ) = Πi∈R xi i ,

(4)

c∈C

where there are ni (c) occurrences of i in c. For codes over Z8 and Z9 we define the symmetric weight enumerator by reducing the variables modulo multiplication by −1. For Z8 and Z9 it is given by X n0 (c) SW EC (x0 , x1 , x2 , x3 , x4 ) = Πi∈{0,1,2,3,4} xi i , (5) c∈C

where n0i (c) is the number of occurrences of an element with ±i in the vector c. For a ring R we can also consider R/ ∼ where a ∼ b if a = bu for a unit u. The ring Z8 has equivalence classes under this relation {0}, {1, 3, 5, 7}, {2, 6}, and {4}. For Z8 the symmetrized weight enumerator is then defined by X u (c) (6) Πi∈{0,1,2,4} xi i , SC (x0 , x1 , x2 , x4 ) = c∈C

where ui (c) is the number of occurrences of an element in the equivalence class with i in the vector c. The ring Z9 has equivalence classes under this relation {0}, {1, 2, 4, 5, 7, 8}, and {3, 6}. For Z9 the symmetrized weight enumerator is then defined by X u (c) SC (x0 , x1 , x3 ) = Πi∈{0,1,3} xi i , (7) c∈C

where ui (c) is the number of occurrences of an element in the equivalence class with i in the vector c. For Z8 the Euclidean weight enumerator is defined by X e (c) EC (x0 , x1 , x4 , x16 ) = Πi∈{0,1,4,16} xi i , (8) c∈C

where ei (c) is the number of occurrences of an element with Euclidean weight i in the vector c. For Z9 the Euclidean weight enumerator is defined by X e (c) Πi∈{0,1,4,7,9} xi i , EC (x0 , x1 , x4 , x7 , x9 ) = (9) c∈C

where ei (c) is the number of occurrences of an element with Euclidean weight i in the vector c. The Hamming weight enumerator of a code C over either ring is defined by X WH (C)(y, x) = y n−wt(c) xwt(c) . (10) c∈C

3

where wt(c) is the number of non-zero elements in the vector c. We can further refine the other weight enumerators to give the Lee weight enumerator X WL (C) = xLwt(c) , (11) c∈C

where Lwt(c) is the Lee weight of the vector c, and the Euclidean weight enumerator X WE (C) = xEwt(c) , (12) c∈C

where Ewt(c) is the Lee weight of the vector c. Let ξi denote a primitive complex i-th root of unity. Define the matrix M (8, C) by M (8, C)i,j = ξ8ij

(13)

M (9, C)i,j = ξ9ij .

(14)

and the matrix M (9, C) by Let M (8, SW ) be the matrix      

 1 √2 2 2 1 √ 2 0 − 2 −1  1  , 1 0 −2 0 1  √ √ 1 − 2 0 2 −1  1 −2 2 −2 1

(15)

M (8, S) be the matrix 

 1 4 2 1  1 0 0 −1     1 0 −2 1  , 1 −4 2 1

(16)

and M (8, H) be the matrix 

1 7 1 −1

 .

Let M (9, SW ) be the matrix  1 2 2 2 2  1 ξ9 + ξ98 ξ92 + ξ97 −1 ξ94 + ξ95   1 ξ92 + ξ97 ξ94 + ξ95 −1 ξ9 + ξ98   1 −1 −1 2 −1 4 5 8 2 1 ξ9 + ξ9 ξ9 + ξ9 −1 ξ9 + ξ97

(17)

   ,  

(18)

M (8, S) be the matrix 

 1 6 2  1 0 −1  , 1 −3 2 4

(19)

and M (9, H) be the matrix 

1 8 1 −1

 .

(20)

Note that ξ9 + ξ98 = 2 cos( 2π ), ξ92 + ξ97 = 2 cos( 4π ), and ξ94 + ξ95 = 2 cos( 8π ). This implies 9 9 9 that M (8, SW ) is a real matrix. These matrices are formed by specializing the variables of the matrices M (8, C) and M (9, C). The following two theorems follow from the results in [9]. Theorem 2.1. Let C be a linear code over Z8 . If ΨC (X) is a weight enumerator we have ΨC (X) =

1 Ψ(M · X) |C|

where M = M (8, C) if Ψ is the complete weight enumerator, M = M (8, SW ) if Ψ is the symmetric weight enumerator, M = M (8, S) if Ψ is the symmetrized weight enumerator, M = M (8, SW ) if Ψ is the Euclidean weight enumerator, and M = M (8, H) if Ψ is the Hamming weight enumerator. Theorem 2.2. Let C be a linear code over Z9 . If ΨC (X) is a weight enumerator we have ΨC (X) =

1 Ψ(M · X) |C|

where M = M (9, C) if Ψ is the complete weight enumerator, M = M (9, SW ) if Ψ is the symmetric weight enumerator, M = M (9, S) if Ψ is the symmetrized weight enumerator, M = M (9, SW ) if Ψ is the Euclidean weight enumerator, and M = M (9, H) if Ψ is the Hamming weight enumerator. Let D(k, n) be the n by n diagonal matrix over Zk indexed by a1 , . . . , an with diagonal 2 entries ξkai . We take ai to be the same representatives as used in the matrices in the previous theorem. Let G(8, C) = h √18 M (8, C), D(8, C), −In i, G(8, SW ) = h √18 M (8, SW ), D(8, SW ), −In i, G(8, E) = h √18 M (8, E), D(8, E), −In i, and G(8, S) = h √18 M (8, S), −In i. Then each group is the invariant group for the respective weight enumerator. The first matrix is the matrix for the MacWilliams relations, the second holds the weight enumerator invariant since each monomial represents a self-orthogonal vector and the third holds the weight enumerator invariant since the length must be even (see Theorem 4.2). Note that D(8, 4) does not hold the symmetrized weight enumerator of a self-dual code invariant. Let G(9, C) = h 31 M (9, C), D(9, C)i, G(9, SW ) = h 31 M (9, SW ), D(9, SW )i, G(9, E) = 1 h 3 M (9, E), D(9, E), i and G(9, S) = h 13 M (9, S)i. Then each group is the invariant group for the respective weight enumerator. The first matrix is the matrix for the MacWilliams relations and the second holds the weight enumerator invariant since each monomial represents a self-orthogonal vector. Note again that D(9, 3) does not hold the symmetrized weight enumerator of a self-dual code invariant. The weight enumerator of a self-dual code is then an element of the invariant ring of its respective group. The following is well known, see [8] for example. 5

Theorem 2.3. The Hamming weight enumerator of a self-dual code over Z8 is an element in the ring C[1 + 7x, 1 + 7x2 ]. The Hamming weight enumerator of a self-dual code over Z9 is an element in the ring C[1 − 2x, x(1 − x)].

2.1

Shadows

Throughout this section we let ζ denote a complex primitive 16th root of unity. Let C be a self-dual code over Z8 . Let C0 be the subcode of vectors whose Euclidean weights are 0 (mod 16). It is easy to see that C0 is a linear subcode of index 2 in C. Then the shadow S is defined by S = C0⊥ − C. Note that the shadow is a non-linear code. Lemma 2.4. Let C be a self-dual code over Z8 with C0 its doubly even subcode. Then 1 SWC0 (x, y, z, w) = (SWC0 (x0 , ζx1 , ζ 4 x2 + ζx3 , x4 ) + SWC0 (x0 , x1 , x2 , x3 , x4 )). 2

(21)

Proof. Vectors that are doubly even are counted once in the first polynomial and once in the second and so dividing by 2 counts them once. If a monomial represents a singly even vector then it is replaced with the negative of itself in the first polynomial and is unchanged in the second, hence it cancels. Let T = M (8, SW ), then we have the following. Theorem 2.5. If C is a Type I code over Z8 with shadow S then SW Es (X) =

1 SW E(T · X 0 ) |C|

(22)

where X = (x0 , x1 , x2 , x3 , x4 ) and X 0 = (x0 , ζx1 , ζ 4 x2 + ζx3 , x4 ). Proof. The usual proof applies, namely SW ES (X) = SW EC0⊥ (X) − SW EC (X) 1 1 = ( (SW EC (T · X) + SW EC (T · X 0 )) − SW EC (X) |C0 | 2 1 1 = SW EC (T · X) − SW EC (X) + SW EC (T · X 0 ) |C| |C| 1 = SW EC (T · X 0 ). |C| The orthogonality relations for the cosets and connections to unimodular lattices can be found in [5]. Similar theorems for the complete weight enumerator and the Euclidean weight enumerator can be constructed with an identical proof.

6

3

Torsion Codes

In [4] higher torsion codes were defined. We follow the definition given there. For a code C over Zpe we define the following torsion codes over the field Zp . For 0 ≤ i ≤ e, define T ori (C) = {v | pi v ∈ C}.

(23)

T or0 (C) = {v (mod p) | v ∈ C} is called the residue code and is often denoted by Res(C). In general we note that T or0 (C) ⊆ T or1 (C) ⊆ · · · ⊆ T ore (C). In particular for a code over Z8 with the following generator matrix:   Ik0 A0,1 A0,2 A0,3  0 2Ik1 2A1,2 2A1,3  , 0 0 4Ik2 4A2,3 the code Res(C) = T or0 (C) is the binary code generated by
Ik0 A0,1 A0,2 A0,3 , the code T or1 (C) is the binary code generated by   Ik0 A0,1 A0,2 A0,3 , 0 Ik1 A1,2 A1,3 and the code T or2 (C) is the binary code generated by   Ik0 A0,1 A0,2 A0,3  0 Ik1 A1,2 A1,3  . 0 0 Ik2 A2,3

(24)

(25)

(26)

(27)

(28)

Note that C has 8k0 4k1 2k2 = 23k0 +2k1 +k2 elements and that |T or0 (C)||T or1 (C)||T or2 (C)| = 2k0 2k0 +k1 2k0 +k1 +k2 = 23k0 +2k1 +k2 . Hence for a code C over Z8 we have |C| = |T or0 (C)||T or1 (C)||T or2 (C)|. For a code over Z9 with the following generator matrix:   Ik0 A0,1 A0,2 , 0 3Ik1 3A1,2 the code Res(C) = T or0 (C) is the ternary code generated by
Ik0 A0,1 A0,2 , 7

(29)

(30)

(31)

the code T or1 (C) is the ternary code generated by   Ik0 A0,1 A0,2 . 0 Ik1 A1,2

(32)

Note that C has 9k0 3k1 = 32k0 +k1 elements and that |T or0 (C)||T or1 (C)| = 3k0 3k0 +k1 = 32k0 +k1 . Hence for a code C over Z9 we have |C| = |T or0 (C)||T or1 (C)|.

(33)

Lemma 3.1. If C is a self-orthogonal code over Zep then T or0 (C) is a self-orthogonal code over the field Zp . Proof. If [v, w] = 0 in Zpe then [v (mod p), w (mod p)] = 0 in Zp .

4

Self-dual Codes over Z8

If C is a code over Z8 of type {k0 , k1 , k2 } then C ⊥ has type {n − k0 − k1 − k2 , k2 , k1 }. This gives the following. Theorem 4.1. Let C be a self-dual code over Z8 of type {k0 , k1 , k2 }. Then k1 = k2 and k0 + k1 = n2 . Proof. If C = C ⊥ then the two types must be equal giving immediately that k1 = k2 . Then applying this to the first coordinate in the type gives that k0 + k1 = n2 . Theorem 4.2. Self-dual codes of length n exist over Z8 if and only if n is even. n

Proof. If a self-dual code exists then it has 8 2 elements which is not an integer if n is odd since 8 is not a square. There exists a self-dual code of length 2, namely the one generated by   2 2 G2 = . (34) 0 4 Hence by taking direct products we obtain self-dual codes for all even lengths. Note that Theorem 4.1 together with Theorem 4.4 below implies that if C is a self-dual code over Z8 , T or1 (C) is a self-dual binary code. Since self-dual binary codes exist if and only if n is even, this provides an alternate proof of Theorem 4.2. Theorem 4.3. Type II codes of length n exist over Z8 if and only n ≡ 0 (mod 8).

8

Proof. We know from [2] that Type II codes over Z8 multiple of 8. The following matrix generates a Type length 8 which gives the result  2 0 0 0 2 2  0 2 0 0 2 2   0 0 2 0 2 0   0 0 0 2 0 2 G8,1 =   0 0 0 0 4 0   0 0 0 0 0 4   0 0 0 0 0 0 0 0 0 0 0 0

exist if and only if the length is a II self-dual code of type {0, 4, 4} of 2 0 2 2 0 0 4 0

0 2 2 2 0 0 0 4

           

(35)

For self-dual codes over Z8 we know that T or0 (C) is a self-orthogonal code of dimension k0 . We can say more in the following theorem. Theorem 4.4. For a self-orthogonal code over Z8 the code T or1 (C) is a self-orthogonal code. Proof. P We have three possibilities. If 2v and P2w are two vectors in C, then we have [2v, 2w] = 4 vi wi ≡ 0 (mod 8) which means vi wi = 0 (mod 2). If 2v and P that P w are two vectors in C, then we have [2v, w] = 2 vi wi ≡ 0 (mod 8) whichPmeans that vi wi = 0 (mod 2). If v and vi wi ≡ 0 (mod 8) which means P w are two vectors in C, then we have [v, w] = that vi wi = 0 (mod 2). For the code generated by G8,1 , T or1 (C) is the [8, 4, 4] Type II binary self-dual code of length 8.

4.1

Self-dual codes and Type II quaternary codes

Define a map Φ : Z8n → Z4n by Φ(v1 , v2 , . . . , vn ) = (v1

(mod 4), v2

(mod 4), . . . , vn

(mod 4)).

For a code C over Z8 we shall denote its image under this map by Φ(C). Lemma 4.5. The image of a self-orthogonal vector is a vector whose Euclidean weight is a multiple of 8. Proof. For vi in Z8 we have that vi2 ≡ (vi (mod 4))2 (mod 8). Lemma 4.6. For C a code over Z8 , Φ(C ⊥ ) ⊆ Φ(C)⊥ . Proof. If v ∈ C ⊥ then [v, w] = 0 for all w in C. It is easy to see that Φ(v) and Φ(w) are orthogonal in Z4n . Hence Φ(v) ∈ Φ(C)⊥ . Theorem 4.7. If C is a self-orthogonal code over Z8 then Φ(C) is a self-orthogonal code over Z4 such that the Euclidean weights of all vectors are a multiple of 8. 9

Proof. Follows from the previous lemmas. Theorem 4.8. If C is a code of type {k0 , k1 , k2 } over Z8 , then Φ(C) is a code of type {k0 , k1 } over Z4 containing 4k0 2k1 vectors. Proof. Any vector in C is a linear combination of the rows of C. Any vector in Φ(C) is a linear combination of those rows read modulo 4. Hence a generator matrix of Φ(C) is   Ik1 A B C 0 2Ik2 2D 2E making it type {k1 , k2 } which determines the number of vectors. Note that a generator matrix of a self-orthogonal code over Z4 does not necessarily generate a self-orthogonal code over Z8 since the corresponding vectors may not be orthogonal. Corollary 4.9. If C is a code of type {k0 , k1 , k2 } in Z8n with 2k1 + k0 = n, then Φ(C) is a Type II code over Z4 . Proof. The code Φ(C) is self-orthogonal by Theorem 4.7 and has type {k0 , k1 } with 2k0 +k1 = n by Theorem 4.8 and therefore is self-dual. Theorem 4.10. If C is a self-dual code over Z8 with Φ(C) a Type II code over Z4 then C is a free code. Proof. We have 2k0 + k1 = n by Corollary 4.9 and we know 3k0 + 2k1 + k2 = 3n since the 2 n code is self-dual. This gives that k0 + k1 = 2 since k1 = k2 by Theorem 4.1. Then we have k0 + (n − 2k0 ) = n2 which gives n2 = k0 and hence the code is free.

4.2

Examples

• n=2 There is only one self-dual code of length 2, namely the one generated by the matrix G2 given in (34). This is easy to see since there are no free codes that are self-dual as −1 is not a square in Z8 . Therefore the only possibility for acceptable types for a self-dual code is {0, 1, 1}. It follows immediately that the only code is the one given. The Hamming, Lee and Euclidean weight enumerators for this code are WH (G2 ) = 1 + 2x + 5x2 , WL (G2 ) = 1 + 6x4 + x8 , WE (G2 ) = 1 + 4x8 + 2x16 + x32 , respectively. • n=4 Since there are no solutions to the equation 1 + a2 + b2 + c2 = 0 in Z8 we know that k0 = 0. This means that k1 = k2 = 2 and it is easy to see that there is only one

10

self-dual code of length 4, namely the one generated by the direct sum of two copies of G2   2 0 0 2  0 2 2 0   G4 =  (36)  0 0 4 0 . 0 0 0 4 The Hamming, Lee and Euclidean weight enumerators for this code are WH (G4 ) = 1 + 4x + 14x2 + 20x3 + 25x4 , WL (G4 ) = 1 + 12x4 + 38x8 + 12x12 + x16 , WE (G4 ) = 1 + 8x8 + 20x16 + 16x24 + 6x32 + 8x40 + 4x48 + x64 , respectively. • n=6 By exhaustive search, we have determined that there are no self-dual codes with k0 > 0. This means that k1 = k2 = 3 and it is easy to see that there is only one self-dual code of length 6, namely the one generated by the direct sum of three copies of G2   2 0 0 0 0 2  0 2 0 0 2 0     0 0 2 2 0 0   . G6 =  (37)  0 0 0 4 0 0    0 0 0 0 4 0  0 0 0 0 0 4 The Hamming, Lee and Euclidean weight enumerators for this code are WH (G6 ) = 1 + 6x + 27x2 + 68x3 + 135x4 + 150x5 + 125x6 , WL (G6 ) = 1 + 18x4 + 111x8 + 252x12 + 111x16 + 18x20 + x24 , WE (G6 ) = 1 + 12x8 + 54x16 + 112x24 + 111x32 + 72x40 + 68x48 + 48x56 + 15x64 +12x72 + 6x80 + x96 , respectively. • n=8 For k0 = 0, k1 = k2 = 4, and there is one Type II self-dual code generated by G8,1 in (35), and a Type I code generated by the direct sum of four copies of G2   2 0 0 0 0 0 0 2  0 2 0 0 0 0 2 0     0 0 2 0 0 2 0 0     0 0 0 2 2 0 0 0   . G8,2 =   0 0 0 0 4 0 0 0    0 0 0 0 0 4 0 0     0 0 0 0 0 0 4 0  0 0 0 0 0 0 0 4 11

The Hamming, Lee and Euclidean weight enumerators for these codes are WH (G8,1 ) WL (G8,1 ) WE (G8,1 ) WH (G8,2 ) WL (G8,2 ) WE (G8,2 )

1 + 8x + 28x2 + 56x3 + 294x4 + 952x5 + 1372x6 + 904x7 + 481x8 , 1 + 8x4 + 252x8 + 952x12 + 1670x16 + 952x20 + 252x24 + 8x28 + x32 , 1 + 232x16 + 1180x32 + 1400x48 + 966x64 + 280x80 + 28x96 + 8x112 + x128 , 1 + 8x + 44x2 + 152x3 + 406x4 + 760x5 + 1100x6 + 1000x7 + 625x8 , 1 + 24x4 + 220x8 + 936x12 + 1734x16 + 936x20 + 220x24 + 24x28 + x32 , 1 + 16x8 + 104x16 + 352x24 + 668x32 + 752x40 + 632x48 + 576x56 + 454x64 +240x72 + 152x80 + 96x88 + 28x96 + 16x104 + 8x112 + x128 .

= = = = = =

For k0 = 1, k1 = k2 = 3, we have determined that there generator matrices G8,3 , G8,4 , G8,5 , G8,6 and G8,7 given by    1 2 2 2 1 1 0 1 1 2  0 2 0 0 2 2 2 0   0 2     0 0 2 0 2 0 2 2   0 0      G8,3 =  0 0 0 2 0 2 2 2  , G8,4 =   0 0  0 0 0 0 4 0 0 4   0 0     0 0 0 0 0 4 0 4   0 0 0 0 0 0 0 0 4 0 0 0 

G8,5

    =    

1 0 0 0 0 0 0

1 2 0 0 0 0 0

1 0 2 0 0 0 0

1 0 0 2 0 0 0

1 2 2 2 4 0 0

G8,7

1 2 2 0 0 4 0

1 2 0 2 0 0 4

1 0 2 2 4 4 4





1 0 0 0 0 0 0

3 2 0 0 0 0 0

3 0 2 0 0 0 0

    =    



         , G8,6 =         

3 0 0 2 0 0 0

1 2 0 0 4 0 0

1 0 2 0 0 4 0

are 5 self-dual codes with

2 0 2 0 0 0 0

2 0 0 2 0 0 0

5 2 2 0 4 0 0

1 2 0 2 0 4 0

0 2 2 2 0 0 4

1 0 2 2 4 4 0



1 0 0 2 0 0 0

1 2 2 2 4 0 0

1 2 2 0 0 4 0

1 2 0 2 0 0 4

1 0 2 2 4 4 4



1 0 0 0 0 0 0

5 2 0 0 0 0 0

1 0 2 0 0 0 0

1 0 0 2 0 0 4

1 0 0 0 4 4 4



    ,    

    ,    

    .    

The Hamming weight enumerators are WH (G8,3 ) WH (G8,4 ) WH (G8,5 ) WH (G8,6 ) WH (G8,7 )

= = = = =

1 + 4x + 12x2 + 28x3 + 142x4 + 636x5 + 1020x6 + 1380x7 + 873x8 1 + 4x + 12x2 + 28x3 + 142x4 + 636x5 + 1020x6 + 1380x7 + 873x8 1 + 28x2 + 182x4 + 448x5 + 700x6 + 448x7 + 2289x8 1 + 28x2 + 182x4 + 448x5 + 700x6 + 448x7 + 2289x8 1 + 36x2 + 48x3 + 238x4 + 352x5 + 564x6 + 496x7 + 2361x8

12

The Lee weight enumerators are WL (G8,3 ) = 1 + 4x4 + 180x8 + 64x10 + 764x12 + 448x14 + 1174x16 + 448x18 + 764x20 +64x22 + 180x24 + 4x28 + x32 WL (G8,4 ) = 1 + 4x4 + 16x6 + 116x8 + 144x10 + 764x12 + 352x14 + 1302x16 + 352x18 +764x20 + 144x22 + 116x24 + 16x26 + 4x28 + x32 WL (G8,5 ) = 1 + 156x8 + 896x12 + 1990x16 + 896x20 + 156x24 + x32 WL (G8,6 ) = 1 + 140x8 + 128x10 + 448x12 + 896x14 + 870x16 + 896x18 + 448x20 +128x22 + 140x24 + x32 WL (G8,7 ) = 1 + 8x4 + 132x8 + 64x10 + 664x12 + 448x14 + 1462x16 + 448x18 + 664x20 +64x22 + 132x24 + 8x28 + x32 The Euclidean weight enumerators are WE (G8,3 ) = 1 + 236x16 + 1324x32 + 1484x48 + 838x64 + 196x80 + 12x96 + 4x112 + x128 WE (G8,4 ) = 1 + 16x8 + 108x16 + 400x24 + 620x32 + 864x40 + 652x48 + 608x56 + 518x64 +144x72 + 132x80 + 16x88 + 12x96 + 4x112 + x128 WE (G8,5 ) = 1 + 16x8 + 112x16 + 448x24 + 604x32 + 1120x40 + 672x48 + 448x56 + 518x64 +16x72 + 112x80 + 28x96 + x128 WE (G8,6 ) = 1 + 240x16 + 1500x32 + 1568x48 + 646x64 + 112x80 + 28x96 + x128 WE (G8,7 ) = 1 + 16x8 + 112x16 + 400x24 + 796x32 + 936x40 + 736x48 + 512x56 + 326x64 +128x72 + 48x80 + 48x88 + 28x96 + 8x104 + x128 For G8,3 to G8,6 , T or1 (C) is the [8, 4, 4] binary self-dual code, whereas for G8,7 , T or1 (C) is an [8, 4, 2] binary self-dual code. For k0 = 2, k1 = k2 = 2,  1 0 3  0 1 6   0 0 2 G8,8 =   0 0 0   0 0 0 0 0 0

we have the code with generator matrix   2 1 0 1 0 1 0 3 2   3 0 1 0 1   0 1 6 7  0 2 2 0 2   , G8,9 =  0 0 2 0  0 0 0 2  2 2 2 2 0    0 0 0 0 0 4 0 4 0  0 0 4 0 4 0 0 0 0

1 0 2 2 4 0

0 1 2 2 0 4

1 0 0 2 4 0

0 1 2 0 0 4

    ,   

with Hamming, Lee and Euclidean weight enumerators WH (G8,8 ) = 1 + 12x2 + 86x4 + 384x5 + 684x6 + 1152x7 + 1777x8 , WH (G8,9 ) = 1 + 12x2 + 86x4 + 384x5 + 684x6 + 1152x7 + 1777x8 , WL (G8,8 ) = 1 + 124x8 + 128x10 + 512x12 + 896x14 + 774x16 + 896x18 + 512x20 +128x22 + 124x24 + x32 , WL (G8,9 ) = 1 + 8x6 + 100x8 + 104x10 + 736x12 + 400x14 + 1398x16 + 400x18 + 736x20 +104x22 + 100x24 + 8x26 + x32 WE (G8,8 ) = 1 + 240x16 + 1484x32 + 1568x48 + 678x64 + 112x80 + 12x96 + x128 WE (G8,9 ) = 1 + 16x8 + 112x16 + 424x24 + 684x32 + 992x40 + 704x48 + 528x56 + 454x64 +80x72 + 80x80 + 8x88 + 12x96 + 1x128 . 13

respectively. For both G8,8 and G8,9 , T or1 (C) is the [8, 4, 4] binary self-dual code. For k0 = 3, k1 = k2 = 1,  1 0 0  0 1 0  G8,10 =   0 0 1  0 0 0 0 0 0

we have two codes with generator   2 1 1 1 0 1 0  0 1 1 3 2 1 0     0 0 6 3 0 1 1  , G = 8,11    0 0 2 0 2 2 2  0 4 0 4 0 0 0

matrices 0 0 1 0 0

2 1 2 2 0

1 3 7 0 4

1 2 4 2 0

1 1 1 2 4

0 0 1 2 0

   ,  

with Hamming, Lee and Euclidean weight enumerators WH (G8,10 ) = 1 + 4x2 + 38x4 + 352x5 + 676x6 + 1504x7 + 1521x8 WH (G8,11 ) = 1 + 4x2 + 38x4 + 352x5 + 676x6 + 1504x7 + 1521x8 WL (G8,10 ) = 1 + 12x6 + 72x8 + 156x10 + 656x12 + 600x14 + 1102x16 + 600x18 + 656x20 +156x22 + 72x24 + 12x26 + x32 WL (G8,11 ) = 1 + 16x6 + 52x8 + 208x10 + 544x12 + 800x14 + 854x16 + 800x18 + 544x20 +208x22 + 52x24 + 16x26 + x32 WE (G8,10 ) = 1 + 16x8 + 112x16 + 412x24 + 724x32 + 928x40 + 720x48 + 568x56 + 422x64 +112x72 + 64x80 + 12x88 + 4x96 + x128 WE (G8,11 ) = 1 + 16x8 + 112x16 + 400x24 + 772x32 + 864x40 + 736x48 + 608x56 + 374x64 +144x72 + 48x80 + 16x88 + 4x96 + x128 respectively. For both G8,8 and G8,9 , T or1 (C) is the [8, 4, 4] binary self-dual code. For k0 = 4, k1 = k2 = 0,  1 0 0  0 1 0 G8,12 =   0 0 1 0 0 0

G8,14

G8,16

G8,18

we have eight inequivalent codes with   0 1 1 2 1 1 0 0  0 1 0 0 7 5 5 2  ,G = 0 6 3 1 5  8,13  0 0 1 1 3 6 7 1 0 0 0

generator matrices  0 6 1 7 1 0 1 2 3 3  , 0 5 7 2 5  1 3 7 3 2



1  0 =  0 0

0 1 0 0

0 0 1 0

0 0 0 1

6 1 5 7

1 2 7 3

7 3 2 7

  1 1 0  0 1 3  ,G = 5  8,15  0 0 2 0 0

0 0 1 0

0 0 0 1

6 1 5 1

1 2 1 3

7 3 5 2

 1 3  , 6  1



1  0 =  0 0

0 1 0 0

0 0 1 0

0 0 0 1

6 1 3 5

1 2 7 7

7 3 7 6

  1 1 0  0 1 3  ,G = 6  8,17  0 0 1 0 0

0 0 1 0

0 0 0 1

6 3 3 7

1 1 6 3

7 6 1 7

 1 3  , 1  2



0 1 0 0

0 0 1 0

0 0 0 1

3 6 1 7

2 3 7 7

7 1 3 6

  1 0 1  0 1 1  ,G = 2  8,19  0 0 3 0 0

0 0 1 0

0 0 0 1

3 1 7 2

2 3 7 7

7 2 5 7

 1 1  . 2  3

1  0 =  0 0

14

These code have identical Hamming weight enumerators WH (G8,12−19 ) = 1 + 14x4 + 336x5 + 672x6 + 1680x7 + 1393x8 , The Lee weight enumerators are WL (G8,12 ) = 1 + 14x6 + 58x8 + 182x10 + 616x12 + 700x14 + 954x16 + 700x18 + 616x20 WL (G8,13 ) = 1 + 16x6 + 48x8 + 208x10 + 560x12 + 800x14 + 830x16 + 800x18 + 560x20 +208x22 + 48x24 + 16x26 + x32 , WL (G8,14 ) = 1 + 14x6 + 58x8 + 182x10 + 616x12 + 700x14 + 954x16 + 700x18 + 616x20 +182x22 + 58x24 + 14x26 + x32 , WL (G8,15 ) = 1 + 14x6 + 58x8 + 182x10 + 616x12 + 700x14 + 954x16 + 700x18 + 616x20 +182x22 + 58x24 + 14x26 + x32 , WL (G8,16 ) = 1 + 16x6 + 48x8 + 208x10 + 560x12 + 800x14 + 830x16 + 800x18 + 560x20 +208x22 + 48x24 + 16x26 + x32 , WL (G8,17 ) = 1 + 16x6 + 48x8 + 208x10 + 560x12 + 800x14 + 830x16 + 800x18 + 560x20 +208x22 + 48x24 + 16x26 + x32 , WL (G8,18 ) = 1 + 112x8 + 128x10 + 560x12 + 896x14 + 702x16 + 896x18 + 560x20 +128x22 + 112x24 + x32 , WL (G8,19 ) = 1 + 112x8 + 128x10 + 560x12 + 896x14 + 702x16 + 896x18 + 560x20 +128x22 + 112x24 + x32 . The Euclidean weight enumerators are WE (G8,12 ) = 1 + 16x8 + 112x16 + 406x24 + 744x32 + 896x40 + 728x48 + 588x56 + 406x64 , WE (G8,13 ) = 1 + 16x8 + 112x16 + 400x24 + 768x32 + 864x40 + 736x48 + 608x56 + 382x64 +144x72 + 48x80 + 16x88 + x128 , WE (G8,14 ) = 1 + 16x8 + 112x16 + 406x24 + 744x32 + 896x40 + 728x48 + 588x56 + 406x64 +128x72 + 56x80 + 14x88 + x128 , WE (G8,15 ) = 1 + 16x8 + 112x16 + 406x24 + 744x32 + 896x40 + 728x48 + 588x56 + 406x64 +128x72 + 56x80 + 14x88 + x128 , WE (G8,16 ) = 1 + 16x8 + 112x16 + 400x24 + 768x32 + 864x40 + 736x48 + 608x56 + 382x64 +144x72 + 48x80 + 16x88 + x128 , WE (G8,17 ) = 1 + 16x8 + 112x16 + 400x24 + 768x32 + 864x40 + 736x48 + 608x56 + 382x64 +144x72 + 48x80 + 16x88 + x128 , WE (G8,18 ) = 1 + 240x16 + 1472x32 + 1568x48 + 702x64 + 112x80 + x128 , WE (G8,19 ) = 1 + 240x16 + 1472x32 + 1568x48 + 702x64 + 112x80 + x128 . As the codes generated by G8,12−19 are all free codes (k1 = k2 = 0), from Theorem 4.10, Φ(C) a free Type II code over Z4 . Thus Φ(C) must be the octacode O8 [8]. In addition, T or1 (C) is the [8, 4, 4] binary code in all cases.

Of the 19 length 8 self-dual codes, six are Type II, namely those generated by G8,1 , G8,3 , G8,6 , G8,8 , G8,18 and G8,19 .

15

5

Self-dual Codes over Z9

If C is a code over Z9 of type {k0 , k1 } then C ⊥ has type {n − k0 − k1 , k1 }. This gives the following. Theorem 5.1. If C is a self-dual code over Z8 of type {k0 , k1 } then 2k0 + k1 = n. Proof. If C = C ⊥ then the two types must be equal giving that n − k0 − k1 = k0 which implies that 2k0 + k1 = n.. Theorem 5.2. There exists self-dual codes of all lengths over Z9 . Proof. The code generated (3) is a self-dual code of length 1 which gives that there are self-dual codes of all lengths. Some of the following results parallel similar results for codes over the ring Z4 . Lemma 5.3. If C is a self-orthogonal code over Z9 then T or1 (C) ⊆ T or0 (C)⊥ . ⊥ Proof. If v ∈ T or0 (C) we know it is in T or ∈ / T or0 (C), then we P0 (C) . Assume z ∈ T or1 (C)P know [3z, v] = 0 for all v ∈ T or0 (C), so 3 zi vi ≡ 0 (mod 9) and then zi vi ≡ 0 (mod 3). Therefore z ∈ T or0 (C)⊥ .

Theorem 5.4. If C is a self-dual code over Z9 then T or0 (C) is a self-orthogonal ternary code with T or0 (C)⊥ = T or1 (C). Proof. Assume C is a self-dual code over Z9 then by Lemma 3.1, Lemma 5.3 and (24) we have T or0 (C) ⊆ T or1 (C) ⊆ T or0 (C)⊥ . (38) If C is self-dual of length n with 9k0 3k1 elements then we know that n − 2k0 = k1 . Looking at the dimensions in (38) this gives k0 ≤ k0 + k1 ≤ n − k0

(39)

The we have that dim(T or1 (C)) = k0 + k1 = k0 + n − 2k0 = n − k0 = dim(T or0 (C)⊥ ). Hence we have that T or0 (C) is a self-orthogonal ternary code with T or0 (C)⊥ = T or1 (C). Our classification of self-dual codes up to n = 6 coincides with the results in [1].

References [1] J.M.P. Balmaceda, A.L. Rowena and F.R. Nemenzo, Mass formula for self-dual codes over Zp2 , Discrete Math., (to appear). [2] E. Bannai, S.T. Dougherty, M. Harada and M. Oura, Type II codes, even unimodular lattices, and invariant rings, IEEE Trans. Inform. Theory, vol. 45, no. 4, 1999, 1194– 1205. [3] S.T. Dougherty, M. Harada and P. Sol´e, Self-dual codes over rings and the Chinese remainder theorem, Hokkaido Math. J., vol. 28, 1999, 253–283. 16

[4] S.T. Dougherty and Y.H. Park, On modular cyclic codes, submitted. [5] S.T. Dougherty, M. Harada and P. Sol´e, Shadow lattices and shadow codes, Discrete Math, vol. 219, 2000, 49–64. [6] S.T. Dougherty, M. Harada and P. Sol´e, Shadow Codes over Z4 , Finite Fields and their Applic., vol. 7, no. 4, 2001, 507–529. [7] F.J. MacWilliams and N.J.A. Sloane, The Theory of Error-Correcting Codes, NorthHolland, Amsterdam (1977). [8] E.Rains and N.J.A. Sloane, Self-dual codes, in the Handbook of Coding Theory, V.S. Pless and W.C. Huffman, eds., Elsevier, Amsterdam, 1998, 177-294. [9] J. Wood, Duality for modules over finite rings and applications to coding theory, Amer. J. Math., Vol. 121, No. 3, 1999, 555-575.

17