Constructing the Extended Binary Golay Code

Ben Adlam
Harvard University
adlam@college.harvard.edu
August 9, 2011
1 Introduction
Coding theory is the subject which is concerned with how information can be sent over a noisy
channel. A code then is a collection of codewords which are strings of a xed number of letters
from an alphabet. Some of these strings are codewords others are not. When a codeword is sent
over a channel there is a probability less than
1
/
2
that each letter in the codeword will be changed,
thus introducing errors into the received codeword. To counter this codes build redundancy into the
information they propagate which hopefully makes them resistant to these errors. So, if a received
codeword has only a small number of errors, then when it is decoded hopefully we obtain the correct
original sent codeword. We formalize these notions in the next subsection.
Probably the most famous binary (an alphabet of two letters) codes are the binary Golay codes.
They exhibit some astounding qualities and are highly symmetrical objects. The codes have a huge
number of constructions and this paper is concerned with examining some of those constructions.
Section 1.1 introduces the basic notions that will be required to develop the binary Golay codes.
Section 2 gives the rst construction of the extended binary Golay code and proves some of the codes
basic properties. Section 3 gives several more constructions of the extended binary Golay code.
1.1 Preliminaries
A linear code ( is a linear subspace of the vector space F
n
q
, where F
q
is the nite eld of q elements.
Each point in this linear subspace ( is called a codeword and denoted as a string of n letters drawn
from the alphabet 1, 2, . . . , q. Since a linear code is a linear subspace of a vector space it has a basis
containing k vectors from F
n
q
, a matrix that contains these vectors as rows is called a generator
matrix of the code (. Any code has a generator matrix G which can be expressed in the standard
form [I
k
P], by using row and column operations, where I
k
is the identity matrix of dimension
k and P is an (n k) k matrix representing the redundancy of the code. A code can also be
expressed as the kernel of a linear transformation. Denote such a linear transformation by H, then
( = ker(H) = x : Hx = 0. This linear transformation can be expressed as a matrix, which we
call a parity check matrix. Given a generator matrix [I
k
P], one possible parity check matrix is
[P
T
I
nk
], since [I
k
P][P
T
I
nk
]
T
= P P = 0.
We dene the Hamming distance between two codewords x = x
1
. . . x
n
and y = y
1
. . . y
n
:
d(x, y) := [i : x
i
,= y
i
[
Note that:
d(x, y) 0
d(x, y) = 0 x = y
d(x, y) = d(y, x).
It can also be shown by induction that d satises d(x, y) + d(y, z) d(x, z).
1
Hence, d is a metric. Using the Hamming distance we dene the weight of a codeword x as:
wt(x) := d(0, x)
and the minimum distance d of a code as:
mind(x, y) : x, y ( and x ,= y.
Note that the minimum distance of a linear code is identical to the minimum weight of the
non-zero codewords, since d(x, y) = d(0, y x) = wt(y x). A common way to summarize the key
information about a linear code with length n, dimension k, and minimum distance d is by writing
[n, k, d] (sometimes the minimum distance will be omitted to get [n, k]). The weight enumerator of
a code ( is a polynomial in x and y:
W
C
(x, y) :=
n

i=0
A
i
(()x
i
y
ni
where A
i
(() = [x ( : wt(x) = i[.
Dene the dual code (

of a [n, k] code ( as:

(

:= x F
n
q
: y ( x, y = 0.
It is easy to show this produces a [n, n k] code (

. An equivalent denition for the dual code

of a code ( with parity check matrix H is the code obtained when H is used as a generator matrix.
We call a code self-dual if ( = (

.
Finally, we dene a function A
q
(n, d) which returns the maximum number of codewords possible
for a code with length n and minimum distance d over F
q
. One upper bound on the value of A
q
(n, d)
is called the Hamming Bound, which we state below:
A
q
(n, d)
q
n

d1
2

k=0

n
k

(q 1)
k
.
If a code gives equality for this bound, then we call it perfect.
2 Constructing the Code
The rst construction we give of the extended binary Golay code follows [5] and uses the generator
matrix G = [I
12
[A], where:
A :=

0 1 1 1 1 1 1 1 1 1 1 1
1 1 1 0 1 1 1 0 0 0 1 0
1 1 0 1 1 1 0 0 0 1 0 1
1 0 1 1 1 0 0 0 1 0 1 1
1 1 1 1 0 0 0 1 0 1 1 0
1 1 1 0 0 0 1 0 1 1 0 1
1 1 0 0 0 1 0 1 1 0 1 1
1 0 0 0 1 0 1 1 0 1 1 1
1 0 0 1 0 1 1 0 1 1 1 0
1 0 1 0 1 1 0 1 1 1 0 0
1 1 0 1 1 0 1 1 1 0 0 0
1 0 1 1 0 1 1 1 0 0 0 1

A has an interesting construction: consider the matrix A

obtained by deleting the rst row and

column of A. If we label the columns of A

from left to right 0, 1, 2, . . . , 10, then the rst row is

obtained by writing a 1 in the columns whose labels are quadratic residues modulo 11. Subsequent
rows are obtained by consecutively shifting the entries of the rst row to the left and wrapping the
rst entry of the row to the last entry. Then we form A:
2
A =

0 1
1
T
A

.
A is a bordered reverse circulant matrix [5]. G generates a linear code of length 24 and dimension
12.
2.1 Basic Properties of the Extended Binary Golay Code
Lemma 1: The inner product of any two rows of G is 0 modulo 2.
Proof: Note rst that all rows of G have either weight 8 or 12. Thus, the inner product of any row
with itself is 0, since this is just the weight of the row. Also, the inner product of any row with the
rst row of G is also 0, since the weight of each row of A

is 6. To take the inner product of two

distinct rows neither of which is the rst, we can assume without loss of generality that one of the
rows is the second row, due to the construction of A

. That is, the inner product of rows m

1
and
m
2
is the same as the inner product of rows 2 and m
2
m
1
+ 2. Now we simply observe that the
inner product of any row with row 2 is 0.
Lemma 2: Every codeword has weight divisible by 4.
Proof: Every codeword can be expressed as a linear combination of rows of the generator matrix
(since we are working over F
2
this reduces to sums of rows). We proceed by induction: for the base
case a single row of G has weight divisible by 4 by inspection. Now assume that x is a sum of m
rows of G with weight divisible by 4 and y is a row of G, then:
wt(x +y) = wt(x) + wt(y) 2wt(x y) = wt(x) + wt(y) 2x, y
So, 4 divides both wt(x) and wt(y)wt(x) by assumption and wt(y) by observation. Using Lemma
1 we get that 2x, y is divisible by 4. Hence, wt(x + y) is divisible by 4. This completes the
induction.
Lemma 3: G
24
is self-dual.
Proof: We know from Lemma 1 that a, b G
24
a, b = 0. Hence, G
24
G
T
24
. We know further
that G
T
24
must be a [24, 12] code. If G
24
was a proper subset of G
T
24
, then it must have dimension at
least 13 as G
24
has dimension 12. Thus, we must have G
24
= G
T
24
.
Theorem 4: G
24
is a [24, 12, 8] code.
Proof: We have already noted above that (
24
has length 24 and dimension 12, so it only remains
to show that the minimum distance is 8. (
24
is a linear code, thus the minimum distance is equal
to the minimum weight of the non-zero codewords. From Lemma 2 we know there cannot be any
codewords of weights 1, 2, 3, 5, 6, or 7. So, if we can disprove the existence of any codewords of
weight 4 and exhibit a codeword of weight 8 we are done.
Recall from above that A = A
T
. Recall also, that since (
24
is self-dual, [A
T
[I
12
] = [A[I
12
] is
also a generator matrix for (
24
. So, for any x, y F
12
2
if (x, y) (
24
, then (y, x) (
24
and clearly
wt((x, y)) = wt((y, x)). So, we can assume that a non-zero vector of minimum weight is such that
wt(x) wt(y). We can rule out the existence of any codewords of weight 4. There are three cases,
since 0 + 4 = 4, 1 + 3 = 4, and 2 + 2 = 4. First assume x has weight 0 and y has weight 4. Then,
x = 0 and since G is in standard form y = 0. Which contradicts our assumption about the weight of
(y, x). Second assume x has weight 1 and y has weight 3. Then, (y, x) is a row of G, again since G
3
is in standard form. However no row of G has weight 4, so we have reached a contradiction. Assume
nally that x and y have weight 2. Then, (y, x) is the sum of two rows of G. We can once more
exploit the circulant nature of G to check a small number of sums of two rows to see that none have
weight 4. Thus, the nal case ends in contradiction. Thus, there are no codewords of weight 4 and
we can deduce that G
24
has minimum distance 8 as there are codewords of weight 8, for example
(0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0).
Theorem 5: The weight enumerator of (
24
is
W
G24
(x, y) = y
24
+ 759x
8
y
16
+ 2576x
12
y
12
+ 579x
16
y
8
+ x
24
.
We state this for completeness but as it is nonessential to our results we omit a proof (one can
be found in both [5, 6]).
Theorem 6: There is a unique linear [24, 12, 8] code, namely the extended binary Golay code.
In this paper we will assume this without proof, as the result takes some time and will make
the paper overlong (again a proof can be found in both [5, 6]). Theorem 6 essentially provides the
strategy we will use to construct the extended binary Golay code in several ways: we will construct
a [24, 12, 8] code over F
2
which we know to be the Golay code by uniqueness.
2.2 The Binary Golay Code
So far we have worked only with the extended binary Golay code but there is a regular binary Golay
code which has length 23, dimension 12, and minimum distance 7. It is easy to move between these
two codes: the regular binary Golay code can be obtained by puncturing the extended binary Golay
code on any coordinate (removing that coordinate from every vector in F
24
2
) to produce several
permutation equivalent codes. Similarly, the extended binary Golay code can be obtained from the
regular binary Golay code by simply adding a parity check bitthat is adding a 1 or 0 in the 24th
coordinate of each codeword to ensure they all have even weight. So, a construction of either code
gives a construction of the other. We will focus primarily on the extended code in this paper.
The regular binary Golay code is perfectthat is, taking spheres of radius 3 around each of the
codewords partitions the vector space F
23
2
in to disjoint sets. We know this, since the Hamming
bound is an equality in the case of the binary Golay code. Using the Hamming bound we know that:
A
2
(23, 7)
2
23

3
k=0

23
k
=
2
23
2
11
= 2
12
.
The binary Golay code has dimension 12 giving it a total of 2
12
codewords, thus achieving this
bound. The relationship between the two binary Golay codes is continued when we consider their
automorphism groups, which are the Mathieu groups M
23
and M
24
for the binary Golay code and
the extended binary Golay code respectively. M
23
is a subgroup of M
24
, so the extended binary
Golay code is in some sense more important than the regular binary Golay code.
3 More Constructions
3.1 The Miracle Octad Generator
Curtiss Miracle Octad Generator (MOG) [4] provides a second construction of (
24
. The construction
we follow was rst elucidated by Conway [3]. The MOG is 4 6 grid able to describe any point in
F
24
2
. For example,
4
0
1

is a subset of MOG, representing the point (1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0).

This representation of F
24
2
is invaluable as it preserves the symmetries of M
24
, which we recall is
the automorphism group of (
24
. Conway was able to form (
24
with a subset of the MOG. To dene
exactly what this subset is we must rst dene the hexacode over the eld F
4
= 0, 1, , .
Denition 1: The hexacode is a [6, 3] code over the eld F
4
with generator matrix
G =

1 0 0 1
0 1 0 1
0 0 1 1

where is the cube root of unity.

We create a code ( with all subsets of the MOG that satisfy two conditions. Label the rows of
the MOG from top to bottom with 0, 1, , and .
(1) The parities of the number of in the top row and all six columns should be equal. Consider
the above example of a subset of the MOG, the parities of the rst row and all six columns
are even.
(2) If we sum the entries of each column, then we should get a codeword from the hexacode. For
example, if we let the entries of a subset of the MOG be M
ij
, where M
ij
= 1 if there is a in
that entry and a 0 otherwise, then we wish
(0 M
11
+ 1 M
21
+ M
31
+ M
41
, , 0 M
16
+ 1 M
26
+ M
36
+ M
46
)
to be a codeword of the hexacode. In the rst example we would obtain (1, 0, , , 0, 0), which
fails to be a codeword.
Here are three examples of subsets of the MOG which satisfy the two conditions:

The parity condition is easily checked for all three matrices. The hexacodewords obtained are
(0, 0, 0, 0, 0, 0), (0, 0, 0, 0, 0, 0), and (1, 1, 1, 1, 0, 0) respectively. We wish to show all the subsets of
the MOG which satisfy the above two conditions form a [24, 12, 8] code, to do this we will need
several propositions.
Lemma 7: ( is a linear code with length 24 over F
2
, which is closed under complementation.
The codes linearity follows from the linearity of conditions (1) and (2), since if we take two
subsets of the MOG that satisfy (1), then their sum satises (1). Similarly, condition (2) is linear,
since the hexacode is linear. The code is closed under complement for the same reasons: given a
subset of the MOG taking the complement will still produce a subset of the MOG which satises
(1) and (2). The length of the code is simply the size of the MOG
Proposition 8: If a column has an even number of and sums to 0, then it contains either zero or
four . If a column has an odd number of and sums to 0, then it contains a in the top entry if
5
and only if the column contains one (else the column contains three ). If a column has an even
number of and does not sum to 0, then it contains two . If a column has an odd number of and
does not sum to 0, then it contains a in the top entry if and only if the column contains exactly
three (else the column contains one ).
All of these facts can be checked easily by checking the 2
4
= 16 combinations that can occur in
a column of the MOG.
Lemma 9: All the codewords of ( have weight divisible by 4.
Proof: There are two cases: either the codewords have columns all of even weight or all of odd
weight, since they must have the same parity. First, assume that the columns all have even weight.
Then, the sum of all the column weights must be divisible by 4, since there are six columns.
Now suppose that all the columns of a codeword c have odd weight. Let f
1
denote the number
of columns weight 1 and the top entry lled. Let f
3
denote the number of columns weight 3 and
the top entry lled. Let e
1
denote the number of columns weight 1 and the top entry empty. Let
e
3
denote the number of columns weight 3 and the top entry empty. Condition (1) implies that
2 ,[f
1
+f
3
. The number of zero coordinates in the hexacodeword produced by a subset of the MOG
is equal to f
1
+e
3
. We know this quantity must be even by examining the possible codeword of the
hexacode, so 2[f
1
+ e
3
. This implies that f
3
+ e
3
. There are six columns, so f
1
+ f
3
+ e
1
+ e
3
= 6.
Manipulating these facts we get:
wt(c) = 3f
3
+ 3e
3
+ f
1
+ e
1
= 3f
3
+ 3e
3
+ f
1
+ (6 f
1
f
3
e
3
)
= 2(f
3
+ e
3
) + 6
= 0 (mod 4)
Thus, all codewords have weight congruent to 0 modulo 4.
Lemma 10: The minimum distance of ( is 8.
Proof: The code is linear from Lemma 7, so the minimum distance is equal to the minimum weight
of the nonzero codewords. We know from Lemma 9 that ( cannot have any codewords of weight not
divisible by 4, hence the minimum distance of ( cannot be 1,2,3,5,6, or 7. Thus, it only remains to
rule out any codewords of weight 4 and exhibit a codeword of weight 8.
A codeword of weight 4 must have columns of even parity, since if we are to have columns of
odd parity we need at least six . We cannot have all four in one column, since then the top
row will have odd parity. Thus, we must have two columns with two in each. This will result in
a codeword with at least four 0s in the derived hexacodeword from the four empty columns. The
only hexacodeword with at least four zeros is the zero codeword, but we cannot have the other two
columns with two produce 0s. Thus, a codeword of ( cannot have weight 4.
Consider the rst subset of the MOG given as an example of a codeword of (, it has weight 8.
Therefore, ( has minimum distance 8
Lemma 11: ( has dimension 12.
Proof: ( is a linear code and (1) imposes six linear conditions on the code. (2) imposes a further
six linear conditions on the code. Thus, the code has dimension 24 6 6 = 12.
6
We can also nd the weight enumerator of ( by counting all the codewords of weights 0, 8, 12,
16, 20, and 24. There is only one codeword of weight 0, the zero codeword and it is easy to check
this is a codeword. The same is true for the codeword of weight 24. There are no codewords of
weight 20, since if there were we could add this codeword to the weight 24 codeword, to produce
another codeword (by linearity) that has weight 4. Which is a contradiction. By a similar argument
the number of codewords of weight 8 is the same as the number of codewords of weight 16. Using
Proposition 8 and the properties of the hexacode we nd there are 759 hexacodewords of weight 8
and thus weight 16 too. In a similar way we nd there are 2576 codewords of weight 12.
In total that is 1 + 759 + 2576 + 759 + 1 = 4096 = 2
12
codewords, and produces the weight
enumerator
W
G24
(x, y) = y
24
+ 759x
8
y
16
+ 2576x
12
y
12
+ 579x
16
y
8
+ x
24
,
as seen in Theorem 5.
Putting together Lemmata 7,10, and 11 we get that ( is a [24, 12, 8] code. We know from Theorem
6 that there is a unique code with these parameters, namely the extended binary Golay code. Thus,
the above is a construction of (
24
.
3.2 Mogul
The extended binary Golay code provides the optimal strategy for the mathematical game of Mogul.
Denition 2: Mogul is a two-player game, which is won by the player who makes the last legal
move. A position in the game of Mogul consists of a row of twenty-four coins, that may be oriented
as heads or tails. To begin with all coins are oriented as head. A legal move can ip at most seven
coins with the left most of the ipped coins ipping from heads to tails. The two players take turns
until no legal move is possible.
The optimal strategy derived from the extended binary Golay code is a winning strategy for the
second player, which instructs that player to move always to a Golay codeword (where we interpret
heads as 1, tails as 0, and positions as vectors in F
24
2
).
Proposition 12: This is a winning strategy for the second player.
Proof: Note rst that the starting position is a word in (
24
, namely the all ones vector. Thus, the
rst player must move to a vector not in (
24
, because the minimum distance of (
24
is 8 and a single
move can only move to a vector up to 7 away in terms of the Hamming distance. The second player
is now free to move to another word in (
24
, which is always possible, since we can puncture on the
left most heads coin and ip this to a tails. Then we are left with a vector in F
23
2
which we can
transform into a Golay codeword, since (
23
is perfect. The rst player is now in the same position as
before and must move to a vector not in (
24
, leaving the second player to move back to a vector in
(
24
. Ultimately, the second player will at some point move to the zero vector, as it is in (
24
. From
this position the rst player has no legal moves and hence loses the game. This must happen in a
nite number of moves as if we think of a position as a binary number, then the condition which
states that the left most ipped coin goes from heads to tails ensures that each position decreases
in value and this value can only go as low as 0.
This strategy ensure a win for the second player and is the only strategy to do so, as assume there
is another winning strategy for the second player. Then at some point the second player must move
away from (
24
(as the strategies are distinct), leaving the rst player free to move to a codeword of
(
24
and assume the wining strategy above. Forcing the second player to lose. So, if one asks for a
wining strategy for Mogul this uniquely denes the extended binary Golay code.
7
3.3 Lexicographical Codes
Lexicographical codes are codes ( with minimum distance d constructed by ordering the vectors
of F
n
2
lexicographically to form L = v
0
, v
1
, . . . , v
2
n
1
and then performing the following greedy
algorithm:
(
i 0
for i 2
n
1 do
if v
j
( d(v
i
, v
j
) d then
( ( v
i

end if
end for
return (
The algorithm runs through the ordered list of vectors adding those to the code which are at
least Hamming distance d away from all other vectors already in the code. Remarkably, many useful
and interesting codes are, in fact, lexicographical codes and strangely this process results in linear
codes ( = c
0
, c
1
, . . . , c
2
k
1
. One example is the extended binary golay code.
By lexicographically ordering the vectors of F
24
2
and applying the appropriate algorithm with
d = 8 we obtain a code of length 24 and minimum distance 8, clearly. So, all that remains is to
verify the code is linear and that it has dimension 12. This can be demonstrated by simply carrying
out the algorithm or we can apply the more general theorem from [5] which states that the above
algorithm always produces linear codes with c
0
, c
1
, . . . , c
2
i as basis vectors. In the case of (
24
, the
code produced has 12 vectors as a basis:
000000000000000011111111
000000000000111100001111
000000000011001100110011
000000000101010101010101
000000001001011001101001
000000110000001101010110
000001010000010101100011
000010010000011000111010
000100010001000101111000
001000010001001000011101
010000010001010001001110
100000010001011100100100
3.4 The Icosahedron
The Icosahedron is one of the Platonic solids, composed of twenty equilateral triangles making thirty
edges and twelve vertices. We can use this highly geometrical object to give yet another construction
of the extended binary Golay code.
8
Denition 3: Let G = (V, E) be a graph. An adjacency matrix of a graph is a [V [ [V [ matrix
with coordinates A
ij
, where:
A
ij
=

1 if (i, j) E
0 otherwise
Consider, the adjacency matrix A of the Icosahedron; this is a 12 12 matrix. Take the comple-
ment of A to get

A, then form the generator matrix G := [I
12

A].
G =

1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 1 0 1 0 1 0 1
0 1 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 0 1 0 1 0 1 0
0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 1 0 1 0 0 1
0 0 0 1 0 0 0 0 0 0 0 0 1 0 1 1 1 0 0 1 0 1 1 0
0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 1 1 1 0 1 1 0 1 0
0 0 0 0 0 1 0 0 0 0 0 0 1 0 1 0 1 1 1 0 0 1 0 1
0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 1 1 1 0 1 1 0
0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 1 1 0 1 1 1 0 0 1
0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 1 0 0 1 1 1 0 1
0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 1 0 1 1 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 1 1 0 1 0 0 1 1 1
0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 1 0 1 1 0 1 1

We can use a similar strategy as that employed in Section 2.1: rst we prove the code is a
[24, 12, 8] code and then using uniqueness we nd this is the Golay code. It is clear that the code has
length 24 and dimension 12. Once again all the rows have weight divisible by 4 and and taking the
inner product of any two rows gives an even number, which is 0 modulo 2. From this we can deduce,
in the same way as before, that all codewords have weight divisible by 4. Now we wish to show that
no codeword can have weight 4. Notice that

A is symmetric about the leading diagonal, so

A =

A
T
.
We know from above that the code is self-dual, hence [

A
T
I
12
] = [

A I
12
] is also a generator matrix.
Now, the argument runs in the same way as in Section 2.1 ruling out any codewords of weight 4.
Hence, we have a [24, 12, 8] code, which by Theorem 6 is the extended binary Golay code. So, we
have yet another construction of (
24
.
References
[1] E.R. Berlekamp, J.H. Conway, and R.K. Guy. Winning Ways for Your Mathematical Plays,
Volume 3. Natick, Massachusetts: A K Peters, 2003.
[2] A.E. Brouwer. The Witt designs, Golay codes and Mathieu groups.
http://www.win.tue.nl/ aeb/2WF02/Witt.pdf.
[3] J.H. Conway and N.J.A Sloane. Sphere Packings, Lattices and Groups. New York: Springer-
Verlag, 1992.
9
[4] R.T. Curtis. A New Combinatorial Approach to M
24
. Mathematical Proceedings of the Cam-
bridge Philosophical Society, 79 (1): 2542, 1976.
[5] W.C. Human and V. Pless. Introduction to Coding Theory. Cambridge: Cambridge University
Press, 2010.
[6] J.H. van Lint. Introduction to Coding Theory. New York: Springer, 1999.
[7] F.J. MacWilliams and N.J.A. Sloane. The Theory of Error-Correcting Codes: Part I. Amsterdam:
North-Holland Mathematical Library, 1977.
[8] F.J. MacWilliams and N.J.A. Sloane. The Theory of Error-Correcting Codes: Part II. Amster-
dam: North-Holland Mathematical Library, 1977.
10