Coding Theory: Coset Decoding

Alex Andonian and Milan Brankovic

Math 309
April 8, 2016

Introduction and Motivation

Coding theory originated in the 1940s as a way to develop error-correcting for
the reliable transmission of information across noisy channels. Coding theory has
many practical applications such as how to best encode and decode messages sent
over communication channels. In this project, we investigate how coded messages
can be decoded using cosets. Specifically we examine what it means to decode a
received binary word of length n and how this can be accomplished using cosets.
Furthermore, our discussion of coset decoding leads us to topics such as the coset
leader and syndrome of a word x. We are particularly interested in this topic
because it is about learning efficient ways of sending and understanding received
information, which is ubiquitous in today’s modern world.

Elementary Definitions and Theorems

Definition A binary word a = a1 a2 · · · an is a string of 0s and 1s, such as 0010111,
1010011, etc., and is considered to be the most basic way of transmitting informa-
tion. The number of 0s and 1s in any binary word is called its length.
Definition If a word a = a1 a2 · · · an is sent, but a word b = b1 b2 · · · bn is received
(where ai and the bj are 0s or 1s), then the error pattern is the word e = e1 e2 · · · en
where
(
0 if ai = bi
ei =
1 if ai 6= bi
With this in mind, we can define an operation of adding words in the following
way: If a and b are both words of binary words of length n, we add them by adding
corresponding digits according to the following rules

0+0=0 1+1=0 0+1=1 1 + 0 = 1.

Thus, the addition of a and b is

(a1 , a2 , . . . , an ) + (b1 , b2 , . . . , bn ) = (a1 + b1 , a2 + b2 , . . . , an + bn ).

The symbol Bn designates the set of all the binary words of length n, and it can
be shown that Bn forms a group.
Definition A code is just a subset of Bn . Notice that there are 2n possible words
of length n, but only a subset of these words called codewords need to be selected
to make up a code, and only codewords are transmitted.
Definition The weight of a binary word is just the number of 1s in the word.
Definition The distance between two binary words is the number of positions in
which the two words differ. With this, we can define the minimum distance in a
code to be the smallest distance among all the distances between pairs of codewords.
2

Definition In practice, every codeword contained in a code is constructed with

a certain number of information positions, with the remaining positions, typically
labeled as redundancy positions, satisfying parity-check equations.
Definition A m × n matrix G is a generator matrix for the code C if C is the
group generated by the rows of G.
Definition Encoding a message is the process of adding the parity-check digits to
the end of the message. If x is a message, then E(x) denotes the encoded word.
Furthermore, if G is the generator matrix of a code and x is a message, then E(x)
is equal to the product xG.
Definition The parity-check matrix of a code C is a matrix that describes the
linear relations that the components of a codeword must satisfy It can be used
to decide whether a particular vector is a codeword and is also used in decoding
algorithms. Specifically, the rows of a parity check matrix are the coefficients of
the parity check equations. That is, they show how linear combinations of certain
digits of each codeword equal zero.
Definition To decode a received word x means to find the codeword a closest to
x, that is, the codeword a such that the distance d(a, x) is a minimum.
Definition A coset leader is a word of minimum weight in any particular coset,
that is, a word with the lowest amount of non-zero entries. Sometimes there are
several words of equal minimum weight in a coset, and in that case, any one of
those words may be chosen to be the coset leader.
Definition Let C be a code and let H be the parity-check matrix of C. If x is any
word, Hx is called the syndrome of x and is denoted syn(x).
Theorem 0.1. Let H be the parity-check matrix of a code C in Bn . A word x in
Bn is a codeword if and only if Hx = 0.

K. Coding Theory: Coset Decoding

1 Let C1 be the code consisting of the following binary words of length 5:

00000
00111
01001
01110
10011
10100
11010
11101
(a) List the elements in each of the cosets of C1 .

In general, when creating cosets, it is helpful to leave the information positions

unchanged: only change the numbers in parity-check positions. So one can create
every coset by adding every word that has nonzero elements only in parity-check
positions to the code C. The number of unique cosets that are created is equal to
the number of words that have nonzero elements only in parity-check positions.
 3

Using this method, we found four cosets:

C1 = C1 + (00000)
C2 = C1 + (00001)
C3 = C1 + (00010)
C4 = C1 + (00011)

(b) Find the coset leader in each coset.(There may be more than one word of
minimum weight in a coset; choose one of them as the coset leader.)

As a general strategy for finding the coset leader, for the nth coset Cn = C1 +an ,
we find en by adding an to each element of Cn and then take the coset leader to
be the result with the fewest non-zero elements.

Now, for this particular set, we see that elements of each coset are shown below:

C1 C2 C3 C4
00000 00001 00010 00011
00111 00110 00101 00100
01001 01000 01011 01010
01110 01111 01100 01101
10011 10010 10001 10000
10100 10101 10110 10111
11010 11011 11000 11001
11101 11100 11111 11110

It is not challenging to verify that the boxed word in each column above serve
as the coset leader of coset represented in that column.

(c) Use the procedure described above to decode the following words x: 11100,
01101, 11011, 00011.
To summarize the procedure used to decode a word x, we first examine the coset
C + x to find the coset leader e, and then add e to x to produce the decoded word
e + x.
11100:
4



 11100

11011





10101





10010
C + 11100 =


 01111
01000





00110





00001 = e (one coset leader)


Therefore, the decoded word is e + x = 11101.

01101:


01101


01010




 00100 = e

 (one coset leader)


00011
C + 01101 =


 11110
11001





10111




10000


Therefore, the decoded word is e + x = 11101.

00011:



 01101

01010





00100 = e (one coset leader)





00011
C + 00011 =


 11110
11001




10111





10000


Therefore, the decoded word is e + x = 00111.

2 Let C1 be the following Hamming code in B7 : the first four positions are
information positions, and the parity-check equations are a5 = a2 + a3 + a4 ,
a6 = a1 + a3 + a4 , and a7 = a1 + a2 + a4 . List the elements in each of the
cosets of C1 and find a coset leader in each coset. Then use coset decoding to
decode the following words: x : 1100001, 0111011, 1001011.

(a) Given the parity-check equations, let us first find the generator matrix G1 ,
which will allow us to generate all the words in the code.
 5

 
1 0 0 0 0 1 1
 0 1 0 0 1 0 1 
G1 = 
 0

0 1 0 1 1 0 
0 0 0 1 1 1 1
Since G1 is the generator matrix of the code C1 , we can generate the code words
of C1 by taking all the linear combinations of the rows of G1 . That is , C1 = xG1
for all x ∈ B4 . By this method, we have that C1 contains the following 16 words:

0000000 1000011
0001111 1001100
0010110 1010101
0011001 1011010
0100101 1100110
0101010 1101001
0110011 1110000
0111100 1111111
Next, to find the nth coset of C1 (there are 8 in total), we simply take Cn =
C1 + (0, 0, 0, 0|an ) for all an ∈ B3 . In other words, we just add every word with
nonzero elements only in the parity-check positions to the code C1 . Thus we obtain
the following cosets:

C1 C2 C3 C4 C5 C6 C7 C8
0000000 0000001 0000010 0000011 0000100 0000101 0000110 0000111
0001111 0001110 0001101 0001100 0001011 0001010 0001001 0001000
0010110 0010111 0010100 0010101 0010010 0010011 0010000 0010001
0011001 0011000 0011011 0011010 0011101 0011100 0011111 0011110
0100101 0100100 0100111 0100110 0100001 0100000 0100011 0100010
0101010 0101011 0101000 0101001 0101110 0101111 0101100 0101101
0110011 0110010 0110001 0110000 0110111 0110110 0110101 0110100
0111100 0111101 0111110 0111111 0111000 0111001 0111010 0111011
1000011 1000010 1000001 1000000 1000111 1000110 1000101 1000100
1001100 1001101 1001110 1001111 1001000 1001001 1001010 1001011
1010101 1010100 1010111 1010110 1010001 1010000 1010011 1010010
1011010 1011011 1011000 1011001 1011110 1011111 1011100 1011101
1100110 1100111 1100100 1100101 1100010 1100011 1100000 1100001
1101001 1101000 1101011 1101010 1101101 1101100 1101111 1101110
1110000 1110001 1110010 1110011 1110100 1110101 1110110 1110111
1111111 1111110 1111101 1111100 1111011 1111010 1111001 1111000
6

The word 1100001 + 0000000 = 1100001 is an element of C8 . Therefore, C1 +

1100001 = C8 . The leader of C8 is 0001000 so the word 1100001 will be decoded
to 0001000 + 1100001 = 1101001.

The word 0111011 + 0000000 = 0111011 is an element of C8 . Therefore, C1 +

0111011 = C8 . The leader of C8 is 0001000 so the word 0111011 will be decoded
to 0001000 + 0111011 = 0110011.

The word 1001011 + 0000000 = 1001011 is an element of C8 . Therefore, C1 +

1001011 = C8 . The leader of C8 is 0001000 so the word 1001011 will be decoded
to 0001000 + 1001011 = 1000011.

3 Let C be a code and let H be the parity-check matrix of C. Prove that x and
y are in the same coset of C if and only if Hx = Hy.

Proof. (⇒) To prove the forward direction, let x and y be elements of the same
coset with the leader e. The closest word to x is a = x + e and closest to y is
b = y + e. Since a and b are codewords of C, we can then express x = a + e and
y = b + e. Therefore, we have that

Hx = H(a + e) = Ha + He = 0 + He and Hy = H(b + e) = Hb + He = 0 + He.

So Hx = Hy = He when x and y are in the same coset.

(⇐) Now, to prove the reverse direction, suppose that Hx = Hy. This implies
that H(x + y) = 0 which implies that x + y is a codeword of C. So let a be the
codeword of C that is equal to x + y. Then we can write x as x = a + y and y
as y = 0 + y where 0 is the identity element of the code C. So x and y are both
elements of the same coset C + y. So if Hy = Hx, then x and y are in the same
coset. 

4 Let code C have q cosets, and let the coset leaders be e1 , e2 , . . . , eq . Ex-
plain why the following is true: To decode a received word x, compare syn(x) with
syn(e1 ),. . . , syn(eq ) and find the coset leader ei such that syn(x) = syn(ei ). Then
x is to be decoded to x + ei .

If syn(x) = syn(ei ), then by what we have proven in problem three, x must be

in the same coset as ei . Thus, we can find the codeword closest to x by finding
x + ei . It is explained in exercise K why we can do this.

5 Find the syndromes of the coset leaders in part 2. Then use the method of
part 4 to decode the words, x = 1100001 and x = 1001011.

The coset leaders for part two are:

 7

e1 = 0000000
e2 = 0000001
e3 = 0000010
e4 = 1000000
e5 = 0000100
e6 = 0100000
e7 = 0010000
e8 = 0001000

The parity-check matrix for part 2 is equal to:

 
0 1 1 1 1 0 0
H= 1 0 1 1 0 1 0 
1 1 0 1 0 0 1
We can find the syndrome of a coset leader by multiplying the parity-check ma-
trix by the coset leader:

syn(e1 ) = 000
syn(e2 ) = 001
syn(e3 ) = 010
syn(e4 ) = 011
syn(e5 ) = 100
syn(e6 ) = 101
syn(e7 ) = 110
syn(e8 ) = 111

The syndrome of the word x = 1100001 is Hx = 111 which implies that

x = 1100001 is an element of a coset with the leader e8 = 0001000. Thus, the
word 1100001 should be decoded to e8 + x = 1101001.

The syndrome of the word x = 1001011 is Hx = 111 which implies that x =

1001011 is an element of a coset with the leader e8 = 0001000. Thus, the word
1001011 should be decoded to e8 + x = 1000011.