Chapter 3

Linear Codes

In order to define codes that we can encode and decode efficiently, we add more
structure to the codespace. We shall be mainly interested in linear codes. A
linear code of length n over the field F is a subspace of F n . Thus the words of linear code
the codespace F n are vectors, and we often refer to codewords as codevectors. codevectors
In the first section we develop the basics of linear codes, in particular we
introduce the crucial concept of the dual of a code. The second and third sections
then discuss the general principles behind encoding and decoding linear codes.
We encounter the important concept of a syndrome.

3.1 Basics
If C is a linear code that, as a vector space over the field F , has dimension k,
then we say that C is an [n, k] linear code over F , or an [n, k] code, for short. [n, k] linear code
There is no conflict with our definition of the dimension of C as a code, since
|C| = |F |k . (Indeed the choice of general terminology was motivated by the
special case of linear codes.) In particular the rate of an [n, k] linear code is
k/n. If C has minimum distance d, then C is an [n, k, d] linear code over F .
The number n k is again the redundancy of C. redundancy
We begin to use F2 in preference to {0, 1} to denote our binary alphabet,
since we wish to emphasize that the alphabet carries with it an arithmetic
structure. Similar remarks apply to ternary codes.
Examples. (i) The repetition code of length n over F is an [n, 1, n]
linear code.
(ii) The binary parity check code of length n is an [n, n 1, 2] linear
code.
(iii) The [7, 4], [8, 4], and [4, 2] Hamming codes of the introduction
were all defined by parity considerations or similar equations. We shall
see below that this forces them to be linear.
(iv) The real Reed-Solomon code of our example is a [27, 7, 21] linear
code over the real numbers R.

31
 32 CHAPTER 3. LINEAR CODES

( 3.1.1) Theorem. (Shannons theorem for linear codes.) Let F be a

field with m elements, and consider a mSC(p) with p < 1/m. Set

L = { linear codes over F with rate at least }.

Then L is a Shannon family provided < Cm (p). 2

Forney (1966) proved a strong version of this theorem which says that we need
only consider those linear codes of length n with encoder/decoder complexity
on the order of n4 (but at the expense of using very long codes). Thus there
are Shannon families whose members have rate approaching capacity and are,
in a theoretical sense, practical1 .
Hamming weight The Hamming weight (for short, weight) of a vector v is the number of its
nonzero entries and is denoted wH (v). We have wH (x) = dH (x, 0). The mini-
minimum weight mum weight of the code C is the minimum nonzero weight among all codewords
of C,
wmin (C) = min (wH (x)) .
06=xC

( 3.1.2) Lemma. Over a field, Hamming distance is translation invariant. In

particular, for linear codes, the minimum weight equals the minimum distance.

Proof. Clearly dH (x, y) = dH (x z, y z) for all z. In particular

dH (x, y) = dH (x y, y y) = dH (x y, 0) . 2

A consequence of the lemma is that minimum distance for linear codes is

much easier to calculate than for arbitrary codes. One need only survey |C|
codewords for weight rather than roughly |C|2 pairs for distance.
Examples. Of course the minimum weight of the length n repetition
code is n. Also the minimum weight of the parity check code is clearly 2.
The minimum weight of the length 27 real Reed-Solomon code is equal to
its minimum distance which we found to be 21. We listed the codewords
of the [4, 2] ternary Hamming code, and so it visibly has minimum weight
3.
Verifying that the minimum weight of the [7, 4] Hamming code is 3 is
easy to do directly by hand, but we will give a conceptual way of doing
this calculation below. The extended [8, 4] Hamming code adds an overall
parity check bit to the [7, 4] code, so its minimum weight is 4.

The following elementary property of binary weights can be very helpful.

For instance, it proves directly that the parity check code is linear.

( 3.1.3 ) Problem. Prove that, for binary vectors x and y of the same length, we
have
wH (x + y) = wH (x) + wH (y) 2wH (x y)
where x y is defined to have a 1 only in those positions where both x and y have a 1.
3.1. BASICS 33

The matrix G is a spanning matrix for the linear code C provided C = spanning matrix
RS(G), the row space of G. A generator matrix of the [n, k] linear code C over generator matrix
F is a k n matrix G with C = RS(G). Thus a generator matrix is a spanning
matrix whose rows are linearly independent. We may easily construct many
codes using generator matrices. Of course it is not clear from the matrix how
good the code will be.
Examples. (i) The repetition code has generator matrix
h i
G = 1, 1, . . . , 1 .

(ii) A particularly nice generator matrix for the parity check code is

1 0 0 0 0 1
2 3
6 0
6 1 0 0 0 1 7 7
6 0 0 1 0 0 1 7
7 ,
6 7
6 .. .. ..
6
6 . . . 7
7
4 0 0 0 1 0 1 5
0 0 0 0 1 1

composed of all weight 2 codewords with a one in the last column. This
code will have many other generator matrices as well. Here are two for
the [7, 6] parity check code:

2 3 2 3
1 1 0 0 0 0 0 1 1 1 1 1 1 0
6
6 1 0 1 0 0 0 0 7 6
7 6 1 0 1 0 0 0 0 7
7
6
6 1 0 0 1 0 0 0 7 6
7 , 6 1 1 0 1 0 1 1 7
7 .
6
6 1 0 0 0 1 0 0 7 6
7 6 1 1 1 0 1 0 0 7
7
4 1 0 0 0 0 1 0 5 4 0 0 0 0 0 1 1 5
1 0 0 0 0 0 1 1 1 1 1 0 0 0

(iii) Consider the [7, 4] Hamming code of Example 1.3.3. In turn we

set the four message symbols (X3 , X5 , X6 , X7 ) to (1, 0, 0, 0), (0, 1, 0, 0),
(0, 0, 1, 0), and (0, 0, 0, 1). The four resulting codewords form the rows of
a generator matrix. We find
2 3
1 1 1 0 0 0 0
6 1 0 0 1 1 0 0 7
6 7
4 0 1 0 1 0 1 0 5
1 1 0 1 0 0 1

(iv) A generator matrix for the [8, 4] extended Hamming code of Ex-
ample 1.3.4 results from adding a column at the front to that for the [7, 4]
code, each new entry checking parity of that row in the matrix. We have
2 3
1 1 1 1 0 0 0 0
6 1 1 0 0 1 1 0 0 7
6 7
4 1 0 1 0 1 0 1 0 5
0 1 1 0 1 0 0 1
1 Oxymoron!
 34 CHAPTER 3. LINEAR CODES

(v) For a generator matrix of the [4, 2] ternary Hamming code of Ex-
ample 1.3.5, we may set (a, b) equal to (1, 0) and (0, 1) in turn to get the
matrix
1 0 1 2
,
0 1 1 1
although any pair of codewords would do as rows provided one is not a
multiple of the other. For instance

0 1 1 1
1 1 2 0

is also a generator matrix.

( 3.1.4 ) Problem. Prove that, in a linear code over the field Fq , either all of the
codewords begin with 0 or exactly 1/q of the codewords begin with 0. (You might want
first to consider the binary case.)

( 3.1.5 ) Problem. Let C be an [n, k, d] linear code over the field Fq .

(a) Prove that the sum of all the weights of all the codewords of C is at most
n(q 1)q k1 . ( Hint: Use the previous problem.)
n(q 1)q k1
(b) Prove that the minimum distance d of C is at most . ( Hint: The
qk 1
minimum weight is less than or equal to the average nonzero weight.)
(c) Prove the Plotkin bound for linear codes with d/n > (q 1)/q:
d
|C| q1 .
d q
n

( 3.1.6 ) Problem. Prove the Plotkin bound for a general m-ary code C of length n
and minimum distance d with d/n > (m 1)/m:
d
|C| m1 .
d m
n

( Hint: Find an upper bound on the average nonzero distance between codewords by
comparing all distinct pairs of codewords and examining each coordinate position in
turn.)

Let C be any code (not necessarily linear) in F n , for F a field. The dual
dual code code of C, denoted C , is the code

C = {x F n | x c = 0, for all c C} ,

where x c is the usual dot product. The dual of C is linear even if C is not.
(This is often a good way of proving that a given code is linear.) We can in
turn examine the dual of the dual and discover easily that (C ) = C C.
If C is itself a linear code, then in fact C = C. For instance, the dual of
the binary repetition code of length n is the parity check code of length n; and
the dual of the parity check code of length n is the repetition code of length n.
To see that C = C for linear C, we use another description of C . Let G
be a generator matrix for C. Then x is in C if and only if Gx> = 0. Thus
3.1. BASICS 35

the vectors of C are precisely the transposes of the vectors of the null space
NS(G). Therefore by Theorem A.1.7 the dimension of C plus the dimension of
C equals the length n, that is, C has dimension nk. Calculating dimensions
twice, we learn that C has dimension k. As this space contains C and has
the same dimension as C, it is equal to C. In summary:

( 3.1.7) Lemma. If C is an [n, k] linear code over F , then its dual C is an

[n, n k] linear code over F and C = C. 2

The linear code C is self-orthogonal if C C and is self-dual if C = C. self-orthogonal

So, for instance, a binary repetition code of even length is self-orthogonal, as is self-dual
the [7, 3] binary dual Hamming code. Since the dimension of a code plus that of
its dual add up to the length, a self-dual code must be a [2k, k] linear code, for
some k. The [8, 4] extended Hamming code is self-dual, as can be easily checked
using the generator matrix given above. The ternary [4, 2] Hamming code is
also self-dual, as is easily checked.
A generator matrix H for the dual code C of the linear C is sometimes
called a check matrix for C. In general it is not difficult to calculate a check check matrix
matrix for a code, given a generator matrix G. Indeed if we pass to a generator
in RREF, then it is easy to find a basis for the null space and so for C by
following the remarks of Section A.1.3 of the appendix. In particular, if the
generator matrix G (or its RREF) has the special form
h i
Ikk | Aknk

then one check matrix is

h i
H = A>
nkk | Inknk .

( 3.1.8 ) Problem. Consider a binary code of length 16 written as 4 4 square

matrices. The code E is composed of every 4 4 binary matrix M such that:
(i) every row of M contains an even number of 1s; and
(ii) either every column of M contains an even number of 1s or every column of M
contains an odd number of 1s.
(a) Prove that E is a linear code.
(b) What is the dimension of E?
(c) What is the minimum distance of E?
(d) If the matrix
2 3
1 0 0 0
6 0 1 0 0 7
6 7
4 0 0 0 0 5
0 0 0 0
is received, give all possible decodings subject to MDD. That is, find all code matrices
in E that are at minimum distance from this matrix.
36 CHAPTER 3. LINEAR CODES

( 3.1.9 ) Problem. Consider a binary code of length 21 whose words are written as
arrays in the following gem shape:
x1 x2 x3
x4 x5 x6 x7 x8
x9 x10 x11 x12 x13
x14 x15 x16 x17 x18
x19 x20 x21
The code E is composed of every binary array M of this shape and such that:
(i) every row of M contains an even number of 1s; and
(ii) every column of M contains an even number of 1s.
(a) Prove that E is a linear code.
(b) What is the dimension of E?
(c) What is the minimum distance of E?
(d) If the array
0 1 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 1 0
is received, give all possible decodings subject to MDD. That is, find all codewords in
E that are closest to this array.
(e) If the array
1 0 1
1 1 1 1 1
0 1 1 1 0
1 1 1 1 1
1 0 1
is received, give all possible decodings subject to MDD.

( 3.1.10 ) Problem. If C is a binary [n, k] linear code, prove that either all weights
of codewords of C are even or the even weight codewords of C form a linear [n, k 1]
subcode B. In the second case, how can the dual code of B be constructed from the
dual code of C?

( 3.1.11 ) Problem. (a) Let C be a self-orthogonal binary linear code. Prove that all
of its codewords have even weight. If additionally C has a spanning set composed of
codewords with weights a multiple of 4, prove that every codeword has weight a multiple
of 4.
(b) Prove that a linear ternary code is self-orthogonal if and only if all its weights
are a multiple of three.

If C is a binary code and x is a vector of C then cx = 0, for all c C; so x

can be thought of as checking the parity of a subset of the coordinate positions
of C, those positions in which x equals one. Extending this idea to nonbinary
linear codes, we consider any vector of the dual as providing the coefficients
of a parity check equation on the entries of codewords. The rows of a check
matrix provide a basis for the space of parity check equations satisfied by the
code, hence the terminology.
3.1. BASICS 37

Because C = C, we can use a check matrix H for C to give a concise

definition of C:
C = { x | Hx> = 0 }.
Any matrix H for which C = { x | Hx> = 0 } we shall call a control matrix for control matrix
C. (This terminology is not common.) Thus a check matrix is a special kind
of control matrix. A check matrix must have linearly independent rows while a
control matrix need not.
We often define a code in terms of a check matrix (or control matrix). In
Example 1.3.5 we defined the [4, 2] ternary Hamming code to be all 4-tuples
(a, b, c, d) from {0, 1, 2}4 that satisfy a + b = c and b + c + d = 0. That is, we
defined the code via the check matrix
 
1 1 2 0
.
0 1 1 1
Here the first check row requires that, for (a, b, c, d) to be in the code,
(a, b, c, d) (1, 1, 2, 0) = a + b + 2c = 0 ,
that is, a + b = c; and the second forces b + c + d = 0.
Shannons discussion under Examples 1.3.3 of the [7, 4] binary Hamming
code essentially defines the code by its check matrix

0 0 0 1 1 1 1
H= 0 1 1 0 0 1 1 .
1 0 1 0 1 0 1
Here every nonzero binary 3-tuple occurs exactly once as a column of the check
matrix. The columns have been arranged so that column i is the binary repre-
sentation of the integer i.
What is the minimum weight of the [7, 4] Hamming code? If x is a vector
of weight 1, then the product Hx> is a column of H, indeed column i of H if
the single 1 of x is in position i. As all columns of H are nonzero, Hx> is also
nonzero; so x is not a codeword. If instead x has weight 2, then Hx> is the sum
of two columns of H, those columns in which x equals 1. As no two columns are
equal, this sum is never 0; so again x is not a codeword. On the other hand, it is
possible to find three columns of H that sum to 0 (for instance, the first three);
so the code does contain words of weight 3 (for instance, (1, 1, 1, 0, 0, 0, 0)).
Therefore this code has minimum weight 3.
It is not difficult to generalize these arguments. Block matrix multiplication
implies that, for any matrix H and row vector x, the matrix product Hx>
is a linear combination of the columns of H with coefficients provided by x,
namely the sum i hi xi where H has ith column hi and xi is the ith entry
P
of x. In particular the entries of a nonzero codeword x give the coefficients
of a linear dependence among the columns of H, a check matrix (or control
matrix). Of course any column hi that is multiplied by a scalar xi = 0 makes
no contribution to this linear combination. The nonzero entries of the codeword
are the coefficients of a linear dependence among only those columns hi for which
the coefficient xi is not 0. We are led to:
 38 CHAPTER 3. LINEAR CODES

( 3.1.12) Lemma. Let C be a linear code with control matrix H. A set of w

columns of H is linearly dependent if and only if there is a nonzero codeword in
C all of whose nonzero entries occur among coordinate positions corresponding
to members of that column set.
In particular dmin (C) = d if and only if there exists a set of d linearly
dependent columns in H but no set of d 1 linearly dependent columns.
Proof. All but the last sentence was discussed above. By Lemma 3.1.2
dmin (C) = wmin (C). Now wmin (C) d if and only if there are d linearly
dependent columns in H, while wmin (C) d if and only if all collections of
d 1 columns are linearly independent. 2
( 3.1.13 ) Problem. Let
h i
H = h1 , h2 , . . . , hn

be the check matrix of the e-error-correcting, binary [n, k] linear code D, the various
hj being the columns of H. Next let D0 be the binary [n, k] linear code with check
matrix h i
H 0 = h1 , h1 + h2 , h1 + h3 , . . . , h1 + hn .
Prove that D0 is also an e-error-correcting code.

( 3.1.14) Theorem. (Singleton Bound.) If C is an [n, k] linear code over

the field F , then
dmin (C) n k + 1 .
Proof. Every n k n k + 1 submatrix of a check matrix has rank at
most n k, so every set of n k + 1 columns of the check matrix is linearly
dependent. The theorem then follows from Lemma 3.1.12. 2

We have seen in Problem 2.3.10 that this result is true even for nonlinear
codes. Indeed if we move k and d = dmin (C) to opposite sides and raise q = |F |
to the appropriate power, we are left with
|C| = q k q nd+1 .
The present proof of the bound shows that even more is true. Any set of
n k + 1 coordinate positions contains the support (the nonzero entries) of a
nonzero codeword.
( 3.1.15 ) Problem. Use a generator matrix in RREF to give another quick proof
of the Singleton bound for linear codes.

A linear code that meets the Singleton bound with equality is called maxi-
maximum distance separable mum distance separable or, for short, an M DS code. Every subset of n k + 1
M DS code coordinate positions supports a codeword in an M DS code. By convention
the zero code {0} is M DS, even though its minimum distance is somewhat
ill-defined.
The [4, 2] ternary Hamming code has minimum distance 3 and so is M DS
since 3 = 4 2 + 1. We shall meet many M DS codes later when we discuss the
generalized Reed-Solomon codes.
3.2. ENCODING AND INFORMATION 39

( 3.1.16 ) Problem. Prove that the dual of an M DS codes is also an M DS code.

( 3.1.17 ) Problem. Prove that a binary M DS code of length n is one of {0}, the
repetition code, the parity check code, or all Fn
2.

3.2 Encoding and information

If we are transmitting with an [n, k] linear code over the field F , then we think
of our message as being provided as k-tuples from F , members of the space
F k . We can encode using the generator matrix G by mapping the message
k-tuple x to the codeword xG. Here xG is a codeword since, by matrix block
multiplication, it is a linear combination of the rows of G (with coefficients given
by x) and C = RS(G).
The k n generator matrix G is a standard generator matrix if its first k standard generator matrix
columns form a k k identity matrix. The generator matrix G is systematic systematic
if among its columns can be found the columns of a k k identity matrix, in
which case G is said to be systematic on those columns or positions. Notice that
a standard generator matrix is a special type of systematic generator matrix. If
G is a standard generator, then the first k entries of the transmitted codeword
xG contain the message vector x. If G is systematic, then all the entries of
the message vector appear among the entries of the transmitted codeword. A
subset of the coordinate positions of a linear code is called an information set information set
if there is a generator matrix for the code that is systematic on the columns in
those positions. We can think of the positions of an information set as carrying
the information, while the remaining positions are contributing redundancy. A
given code may, however, have many different information sets. A choice of one
set is essentially a choice of the corresponding systematic generator for encoding
purposes.
Examples. Consider the generator matrices given in 3.1. The generator
matrix for the repetition code is (trivially) standard. For the repetition
code, any coordinate position can serve as information set.
The first generator given for the parity check code is standard. Of the
two further generators for the [7, 6] parity check code the first is systematic
but not standard, and the second is neither. Every set of 6 coordinate
positions is an information set.
The generator matrix given for the [7, 4] binary Hamming code is sys-
tematic. Indeed its generator matrix was designed to be systematic on the
positions of the information set {3, 5, 6, 7}. Although it is not clear from
our definition, the set of positions {1, 2, 3, 4} is indeed an information set
for this code, as the following standard generator matrix indicates:
2 3
1 0 0 0 0 1 1
6 0 1 0 0 1 0 1 7
H=6 4 0 0 1 0 1 1 0 5 .
7

0 0 0 1 1 1 1
Not every 4-subset of positions is an information set. The definition via
check equations guarantees that {4, 5, 6, 7} is not an information set, since
 40 CHAPTER 3. LINEAR CODES

each codeword has an even number of 1s in these positions. Each partic-

ular even weight pattern occurs on these positions in two different code-
words, while no odd weight pattern occurs at all.
The generator matrix given for the [8, 4] binary extended Hamming
code is systematic, but this code has no standard generator matrix since
each codeword has an even number of 1s in positions {1, 2, 3, 4}.
The first generator given for the [4, 2] ternary Hamming code is stan-
dard while the second is systematic but not standard. Each pair of posi-
tions is an information set. (This universality characterizes M DS codes;
see Problem 3.2.3.)

It should be noted that, in some references (particularly engineering texts),

generator matrices that we have called standard are called systematic and
the more general class that we call systematic is not given a specific name.
The rows of a generator matrix form a basis of its row space, the code. Every
linear code has a systematic generator matrix, for instance RREF(G) for any
generator G, where the pivot columns are those of an identity matrix. If the
code has a standard generator matrix S, then S = RREF(G). Therefore a
code has a standard generator matrix if and only if its generator matrix G has
a RREF in which the pivot columns are the initial columns.

( 3.2.1 ) Problem. Let C be an [n, k] linear code over F , and let J be a subset of
k coordinate positions. For the generator matrix G we write GJ for the k k matrix
composed of those columns of G indexed by J. Similarly, for the codeword c, we write
cJ for the k-tuple of entries in the positions of J.
The following are equivalent:
(1) J is an information set;
(2) for each m F k , there is a unique c C with cJ = m;
(3) for every generator matrix G, the matrix GJ is invertible.

( 3.2.2 ) Problem. For a nonlinear code C over A, define an information set to be a

minimal subset J of the coordinate positions such that no member of A|J| is repeated
in these positions. Prove that the dimension of C is a lower bound for |J|.

Two related codes may be different but still share many properties. For
instance, if the code D is gotten from C by reversing all codewords (i.e., first
entry last, . . . , last entry first) then C and D will likely be different but will have
many common propertiesthe same length, minimum distance, dimension, etc.
For many purposes we need not distinguish between C and D.
permutation equivalent Two codes C and D of length n over A are permutation equivalent if they
are the same up to a uniform permutation of their coordinate entries. (This is
equivalence often abbreviated to equivalence.) That is, there is a permutation of the set
{1, . . . , n} such that

(x1 , x2 , . . . , xn ) C (x(1) , x(2) , . . . , x(n) ) D.

Since every linear code has a systematic generator matrix, and a systematic
matrix can be changed into a standard matrix by permuting columns, we find
that every linear code is equivalent to a code with a standard generator matrix.
3.2. ENCODING AND INFORMATION 41

Although we do not need the definitions right now, this seems a good time
to give three further notions of equivalence for codes defined over fields. Notice
that linearity is not required for the various forms of equivalence. In practice
regular equivalence is the one of most relevance for codes that are not linear.
Definition. Two codes C and D of length n over the field F are diagonally
equivalent if they are the same up to the multiplication in each codeword of the diagonally equivalent
ith entry by the nonzero constant i , for each i.
Definition. Two codes C and D of length n over the field F are monomially
equivalent if they are the same up to: monomially equivalent
(1) a uniform permutation of their entries (as with regular equivalence);
(2) the multiplication in each codeword of the ith entry by the nonzero constant
i , for each i.
So monomial equivalence is the union of regular equivalence and diagonal equiv-
alence. For a linear code it corresponds to multiplying column i of a generator
matrix by the constant i in addition to permuting the columns of the generator.
Definition. Two codes C and D of length n over the field F are affine
equivalent if they are the same up to: affine equivalent
(1) a uniform permutation of their entries;
(2) the multiplication in each codeword of the ith entry by the nonzero constant
i , for each i;
(3) translation by a fixed vector of F n .
Two codes that are affine equivalent have the same size, length, and minimum
distance. Here if C is a linear code, then D is a coset of a code monomially
equivalent to C.

( 3.2.3 ) Problem. For k 6= 0, prove that the [n, k] linear code C is an M DS code if
and only if every subset of k coordinate positions is an information set.

( 3.2.4 ) Problem. (Threshold decoding of M DS codes.) Let C be an [n, k]

linear M DS code with k 6= 0 and generator matrix G. For a set J of coordinate
positions, the matrix GJ is that submatrix of G composed of the columns of G that are
indexed by the members of J.
By Problem 3.2.3 every k subset J of coordinate positions is an information set
for C, so by Problem 3.2.1 the matrix GJ is always invertible. Indeed if the message
k-tuple m gives rise to the codeword c = mG, then we can recover m from c by
m = cJ G1 J .
For decoding purposes this means that, for any received vector r, each k subset J
of coordinate positions produces a guess or vote m b J = rJ G1
J as to the identity
of the original message m. We choose that k-tuple m b that receives the most votes and
then decode r to the codeword b c = mG.
b
Suppose that c = mG has been transmitted and that r has been received, e symbol
errors having occurred (that is, dH (c, r) = e). For k independent variables x1 , . . . , xk
arranged as a row vector x = (x1 , . . . , xk ), consider the n linear equations, j =
1, . . . , n ,
Eqnj : rj = xGj ,
 42 CHAPTER 3. LINEAR CODES

where rj is the j-th entry of received r and Gj is the j-th column of the matrix G.
(a) Prove that setting x equal to m solves n e of the equations Eqnj . Prove that
m gets ne
`
k
votes.
(b) For any k-tuple l that is not equal to m, prove that setting `x equal to l solves
at most e + k 1 of the equations Eqnj . Prove that l gets at most e+k1k
votes.
(c) Prove that, as long as 2e < n k + 1 (= dmin (C)), the received vector r will be
decoded correctly to c.

( 3.2.5 ) Problem. Consider the M DS code C over the field F7 of integers modulo
7 with generator matrix
1 1 1 1 1 1
.
2 4 6 1 3 5
Use the method of the previous problem to decode the received vector

r = (1, 3, 6, 5, 4, 2) .

3.3 Decoding linear codes

dictionary decoding A form of decoding always available is dictionary decoding. In this we make a
list of all possible received words and next to each word write the codeword (or
codewords) to which it may be decoded under MLD. In decoding, when a word
is received we look it up in our dictionary and decode it to a codeword listed
opposite it. This will almost never be a practical solution.
We now wish to use the structure of linear codes to aid in their decoding. If
we are transmitting with a linear code C of length n over F , then we can think
error vector of the channel as adding in an error vector or error word (or even error pattern
error word in the binary case). If c is transmitted and x is received, then the channel noise
error pattern has had the effect of adding to c the error vector e = x c F n , so that
x = c + e. The decoding problem is then, given x, estimate at least one of
c and e. The weight of e is the number of positions in which c and x differ;
so, when using an mSC(p) (with p < 1/m) and decoding under MLD, we are
looking for an error pattern e of minimum weight.
From the definition of e, we learn that the received vector x and the error
pattern e belong to the same coset x + C = e + C. While we do not know x
ahead of time, the cosets of C can be calculated in advance. We look for vectors
coset leader of minimum weight in each coset. Such a vector is caller a coset leader. Notice
that while the minimum weight of a coset is well-defined, there may be more
than one vector of that weight in the coset, that is, there may be more than
one coset leader. Usually we choose and fix one of the coset leaders. Always 0
is the unique coset leader for the code itself.
We first describe the general technique of decoding with coset leaders and
then give two methods for its implementation. When the word x is received,
we do not know the actual error that was introduced; but we do know that it
belongs to the coset x + C. Thus if b e is the coset leader chosen for this coset,
then b e is one of the most likely error patterns; and we guess that it was the
actual error. (In fact be is the unique most likely error pattern if it is the unique
3.3. DECODING LINEAR CODES 43

leader of its coset.) We decode x to the codeword b c = xb e. With coset leader

decoding, the error patterns that are corrected are exactly those that are the
chosen coset leaders. In particular, the code will be e-error-correcting if and
only if every vector of weight at most e is the unique leader of its coset.
Coset leader decoding is an MDD algorithm for linear codes over fields of
size m. Therefore knowledge of the coset leaders for C makes it easy to calculate
PC on an mSC(p). Indeed, an error pattern will be corrected if and only if it is
a chosen coset leader. Thus, for mSC(p) with q = 1 (m 1)p > p, we have
n
X 
PC = PC (MDD) = 1 ai pi q ni ,
i=0

where ai is the number of cosets of C with coset leader of weight i.

( 3.3.1 ) Problem. If x and y are binary vectors of length n, then we write x  y to

indicate that x has a 0 in every position that y has a 0 (but x may have 0s in places
that y has 1s.) Equivalently, everywhere x has a 1, y also has a 1, but y may have
more 1s. For instance

(0, 0, 0, 1, 1, 0, 1, 0)  (0, 1, 0, 1, 1, 0, 1, 1) .

(a) Let x and y be binary n-tuples, and set f = x + y. Prove that x  y if and only
if wH (y) = wH (x) + wH (f ).
(b) Let C be a binary linear code of length n. Prove that if y is a coset leader for the
coset y + C and x  y, then x is also a coset leader for the coset x + C.

Our first method for coset leader decoding is standard array decoding. Set standard array decoding
K = |C|, the cardinality of C, and R = |F n |/|C|, the number of distinct cosets
of C. Enumerate the codewords:

C = { c1 = 0, c2 , . . . , cK }

and coset leaders:

{ e1 = 0, e2 , . . . , eR },
one coset leader for each coset of C in F n . We form a large array, the standard
array, whose first row contains the codewords, and first column contains the
coset leaders, and in general has cj + ei as its i, j entry. The ith row of the
standard array is the coset ei +C. Thus every n-tuple of F n is contained exactly
once in the array.
To decode using the standard array, when x is received, look it up in the
array. If it is in the i, j position, then we have x = cj + ei . In this case we
assume that the introduced error vector was ei and decode x to b c = cj .
Standard array decoding is not of much practical value as it involves storage
of the large array as well as random access searches through the array. It does
have historical and theoretical value, because it illustrates the important general
fact that code structure can be exploited to design decoding algorithms that are
more efficient than dictionary decoding.
 44 CHAPTER 3. LINEAR CODES

The second method of coset leader decoding is syndrome decoding, where syndrome decoding
the dual code and check matrices are used. Let H be a check matrix for the
[n, k] linear code C. We have already mentioned that the vector x is in the
code C if and only if the matrix product Hx> equals 0. For any received vector
x, the length r = n k column vector Hx> is a measure of whether on not
syndrome the n-tuple x belongs to the code. The column r-tuple Hx> is the syndrome
of the n-tuple x. According to the Pocket Oxford Dictionary, a syndrome
is generally a characteristic combination of opinions. The syndrome voices
information about the error vector. Syndrome decoding is error oriented, using
the opinions voiced by the syndrome vector to identify the appropriate error
vector.
As the syndrome of a codeword is 0, two vectors x and e that differ by a
codeword c will have the same syndrome:

Hx> = H(c + e)> = 0 + He> = He>

That is, syndromes are constant on cosets of C in F n . Equally well, distinct

cosets have different syndromes since the difference of vectors from distinct
cosets is not a codeword and so has nonzero syndrome.
We interpret the above equation as saying that a received vector x and
the corresponding error vector e introduced by the channel will have the same
syndrome, namely that of the coset to which they both belong. Instead of
syndrome dictionary storing the entire standard array, we need only store a syndrome dictionary (or
syndrome table) containing all possible syndromes {s1 = 0, . . . , sR } together
with coset leaders {e1 = 0, . . . , eR } such that He>
i = si . In decoding, when
x is received, first calculate the syndrome s = Hx> . Next look up s in the
syndrome dictionary as s = si . Finally decode x to bc = x ei .

Example. Consider the [4, 2] ternary Hamming code with check matrix

1 1 2 0
H= .
0 1 1 1

The syndromes are therefore column vectors of length 2. For instance,

the received vector x = (1, 2, 1, 1) has syndrome

1+2+2+0 2
Hx> = = .
0+2+1+1 1

To decode using syndromes we first write out our syndrome dictionary,

3.3. DECODING LINEAR CODES 45

the first column containing the transposes of all possible syndromes.

syndrome coset
transpose leader
00 0000
01 0001
02 0002
10 1000
11 0100
12 0020
20 2000
21 0010
22 0200

It is not necessary to list out all cosets of the code to make this dictionary.
Instead notice that two words of F43 are in the same coset if and only if
their difference is a codeword. So, for instance, not only must (0, 0, 0, 1),
(0, 0, 0, 2), and (0, 2, 0, 0) all be of minimum weight in their respective
cosets; but they belong to different cosets. (Subtracting one of them from
another gives a word of weight less than 3, not a codeword since the
minimum weight of the Hamming code is 3.) The transposed syndromes
are then calculated as, respectively, (0, 1), (0, 2), and (2, 2); and the results
are recorded in the dictionary.
To decode our received vector x = (1, 2, 1, 1) we first calculate, as
before, its transposed syndrome (2, 1). We then look up this syndrome
in our dictionary and discover that the corresponding coset leader is b e=
(0, 0, 1, 0). We therefore assume that this is the error that occurred and
decode x to the codeword

c = xb
b e = (1, 2, 1, 1) (0, 0, 1, 0) = (1, 2, 0, 1) .

It may sometimes be more convenient to define syndromes and do syndrome

decoding relative to a control matrix H rather than a check matrix.
Syndrome decoding does not suffer from many of the failings of standard
array decoding. The syndrome dictionary is much smaller than the standard
array for storage purposes; and it can be ordered lexicographically, so that
searches can be done linearly. Still syndrome decoding in this dictionary form is
too general to be of much practical use. Certain practical decoding algorithms
do employ partial syndrome dictionaries that list only the most common syn-
dromes. Syndrome decoding is also the paradigm for many genuine decoding
techniques. To each received vector we associate some kind of syndrome. The
properties of the specific code then are used in the passage from syndrome to
error vector and decoded word. The decoding method for the [7, 4] Hamming
code as given by Shannon in Example 1.3.3 is a type of syndrome decoding,
since he has arranged the columns of the check matrix H (given on page 37) to
contain the binary numbers in order. The calculated syndrome is therefore
associated with the coset whose leader has a 1 in the th position (read in
binary) and 0 elsewhere. We decode assuming an error in this position.
46 CHAPTER 3. LINEAR CODES

( 3.3.2 ) Problem. (a) Give a syndrome dictionary for the [8, 4] extended binary
Hamming code E with the following check matrix (and generator matrixthe code is
self dual): 2 3
0 0 0 0 1 1 1 1
6 0 0 1 1 0 0 1 1 7
XL3 = 6 4 0 1 0 1 0 1 0 1 5 .
7

1 1 1 1 1 1 1 1

(b) Use your table to decode the received word:

(0, 0, 1, 0, 0, 1, 1, 0) .

(c) Use your table to decode the received word:

(0, 1, 1, 1, 1, 1, 0, 1) .

We now consider using syndrome decoding and check matrices to correct

erasures rather than errors. (See Problem 2.2.4.) Remember that erasures
occur as a consequence of soft quantization of received symbols. We allow
transmitted symbols from the alphabet A to be received as members of A or as
?, the erasure symbol. Alternatively we may think of erasures as symbol errors
whose locations are known. Under this second interpretation, we might receive a
word from the alphabet A but with certain positions flagged as being unreliable.
These flagged positions are then the erasure locations. The two views of erasures
are equivalent. Indeed each occurrence of ? may filled arbitrarily by an alphabet
letter (typically 0 for a linear code) and then flagged as unreliable. Conversely
each flagged symbol can be replaced by ?, the erasure symbol. Which point of
view is the best will depend upon the particular situation.
Since C contains codewords of weight d = dmin (C) as well as 0 of weight
0, we could never hope to correct d erasures; but we can decode up to d 1
erasures correctly.

( 3.3.3) Proposition. Let C be an [n, k, d] linear code over F with check

matrix H whose rows are hi , for i = 1, . . . , r = n k. Let x = (x1 , x2 , . . . , xn )
be an n-tuple of indeterminates.
Assume the codeword c = (c1 , c2 , . . . , cn ) is transmitted, and we receive the
vector p = (p1 , p2 , . . . , pn ) F n with the entries pl , for l L, flagged as erasures
but pj = cj , for j 6 L.
If |L| d 1, then the set of equations in the unknowns xi

hi x = hi p for i = 1, . . . , r
xj = 0 for j 6 L ()

has as its unique solution the erasure vector

x = c p = e.

Therefore by solving the equations () we can decode all patterns of up to d 1

erasures in codewords of C.
3.3. DECODING LINEAR CODES 47

Proof. This set of equations has at least one solution, namely the actual
erasure vector e = cp. If e0 is any solution of the equations () then c0 = ee0
has syndrome 0 and equals 0 off L. Therefore c0 is a codeword of weight at most
d 1 and so must be 0. We conclude that e = e0 , and the set of equations ()
has the unique solution x = e. 2

The equations () give n + r |L| linear equations in the n unknowns,

where r d 1 |L| (by the Singleton bound 3.1.14). By the proposition,
the solution is unique; so the system has rank n. The last n |L| syndrome
equations of () are clearly linearly independent; so we may delete some of the
first r equations to reduce () to a system of n equations in n unknowns with a
unique solution. These equations can be solved by Gaussian elimination; so the
number of operations required is at worst on the order of n3 , a respectably small
number. Indeed the set of equations is essentially triangular, so the complexity
is actually on the order of n2 .
The algorithm of the proposition is an effective method for correcting era-
sures in any linear code. This can in turn be helpful when decoding errors as
well as erasures. We may concentrate our efforts upon designing an algorithm
that locates errors. After the errors have been located, they can be thought
of as flagged erasures and their values found with the algorithm of Proposition
3.3.3.