PSG COLLEGE OF TECHNOLOGY, COIMBATORE - 641 004

DEPT. OF APPLIED MATHEMATICS AND COMPUTATIONAL SCIENCES

2nd Sem. M.Sc - DATA SCIENCE
23XD22 - ABSTRACT ALGEBRA

Lecture notes - (Group Coding)

This lecture note is prepared from Contemporary Abstract Algebra by Joseph

A Gallian (see Chapter 31 - Introduction to Algebraic Coding Theory). Some basic
concepts of groups and modular arithmetic are required to learn this topic.
Coding theory deals with the fast and accurate transmission of messages over an
electronic “channel” (telephone, telegraph, radio, TV, satellite, computer relay, etc.)
that is subject to “noise” (atmospheric conditions, interference from nearby electronic
devices, equipment failures, etc.). The noise may cause errors so that the message
received is not the same as the one that was sent. The aim of coding theory is to enable
the receiver to detect such errors and, if possible, to correct them.
The use of abstract algebra to solve coding problems was initiated by Richard W.
Hamming. In 1950, he developed a large class of error-correcting codes.
Concept of finite fields leads to the development of algebraic coding theory. Algebraic
coding has nothing to do with secret codes. Algebraic codes are now used in compact
disk and DVD players, fax machines, digital televisions, and bar code scanners, and are
essential to computer maintenance.

Problem 1 (Motivation Problem) Suppose that the message to be sent is a single

digit, either 1 or 0. The message might be, for example, a signal to tell a satellite
whether or not to orbit a distant planet. Now let us discuss the error possibilities.
With a single-digit message, the receiver has no way to tell if an error has occurred.
But suppose instead that a four-digit message is sent, that is, 1111 for 1 or 0000 for 0,
then this code can correct single errors. For instance, if 1101 is received, then it seems
likely that a single error has been made and that 1111 is the correct message. In case,
if three errors are made then the satellite will not receive the original message. So this
1
2
scheme is not useful when there are 3 errors. For example, if the intended message is
1111 and suppose that the message received is 1000 then the satellite will consider the
original message as 0000. So there is a possibility that the error may not be detected
when the number of errors are three. But this is much less likely than a single error. The
code can detect double errors, but not correct them. For instance, if 1100 is received,
then two errors probably have been made, but the intended message isn’t clear. (the
intended message may be either 1111 or 0000).
′
Problem 2 Let A be the message set consisting of all possible 4−tuples of 0 s and
′
1 s. Encode each message in A based on Hamming (7, 4) code with the generator matrix
given by  
 1 0 0 0 1 1 0 
 
 0 1 0 0 1 0 1 
G= .
 
 0 0 1 0 1 1 1 
 
 
0 0 0 1 0 1 1

Solution: Hamming (7, 4) code denotes that the input message is of length 4 and it
has to be encoded with length 7 using the matrix G. Each input message consists of
4−tuples (4 components) in which each component will be either 0 or 1. Hence the
entries of each components can be viewed as the elements of Z2 , where Z2 = {0, 1}.
Since the message consists of 4 components and each component is either 0 or 1, there
are 16 possibilities, that is, 24 = 16, where 2 denotes the number of elements of Z2 and 4
denotes the number of components. So, these 16 elements are the elements of the group
Z2 ×Z2 ×Z2 ×Z2 = {0000, 0001, 0010, 0100, 1000, 1100, 1010, 1001, 0110, 0101, 0011, 1110,
1101, 1011, 0111, 1111}. Hence, A = Z2 × Z2 × Z2 × Z2 .
Now, we can encode each of the elements (messages) of A by multiplying each of the
messages with G on the right hand side. Each message in A can be considered as 1 × 4
matrix. All operations to be done modulo 2. The resulting 7−tuples are called code
 3
words. For example the message 0000 is coded as follows:
 
 1 0 0 0 1 1 0 
 
 0 1 0 0 1 0 1 
[0 0 0 0] ×   = [0 0 0 0 0 0 0].
 
 0 0 1 0 1 1 1 
 
 
0 0 0 1 0 1 1

Hence, the message 0000 is encoded as 0000000. Thus 0000000 is the code word for the
message 0000. Similarly, do the above procedure for the remaining messages in A and
hence Table 1 is obtained.
Table 1
Message Encoder Code Word Message Encoder Code Word
0000 → 0000000 0110 → 0110010
0001 → 0001011 0101 → 0101110
0010 → 0010111 0011 → 0011100
0100 → 0100101 1110 → 1110100
1000 → 1000110 1101 → 1101000
1100 → 1100011 1011 → 1011010
1010 → 1010001 0111 → 0111001
1001 → 1001101 1111 → 1111111

Note

✠ The code is called binary if its entries are 0 or 1. Example, the set {0000000, 0010111,
0101011, 1001101, 1100110, 1011010, 0111100, 1110001} is a (7, 3) binary code.
✠ The set {0000, 0121, 0212, 1022, 1110, 1201, 2011, 2102, 2220} is a (4, 2) linear code
over Z3 . A linear code over Z3 is called a ternary code.

Definitions

♢ Hamming Distance between two vectors is the number of components in which

they differ.
♢ Hamming Weight of a vector is the number of nonzero components of the
vector.
♢ Hamming weight of a linear code is the minimum weight of any nonzero
vector in the code.
4
We will use d(u, v) to denote the Hamming distance between the vectors u and v, and
wt(u) for the Hamming weight of the vector u.
Problem 3 Let s = 0010111, t = 0101011, u = 1001101, and v = 1101101. Find the
Hamming distance between the distinct vectors and also find the Hamming weight.
Solution Hamming distance for s = 0010111 and t = 0101011 is calculated as follows:
Find the number of components by which s and t differ, here they differ in the 2nd , 3rd ,
4th and 5th components. Hence the number of components in which s and t differ is 4.
So d(s, t) = 4. Similarly, d(s, u) = 4, d(s, v) = 5, d(u, v) = 1.
To find the Hamming weight of s, find the number of non zero components of s, here
it is 4, so Hamming weight of s, that is, wt(s) = 4. Similarly, wt(t) = 4, wt(u) = 4,
wt(v) = 5.
Properties of Hamming Distance and Hamming Weight: For any vectors u, v,
and w,
d(u, v) ≤ d(u, w) + d(w, v) and d(u, v) = wt(u − v).

Theorem - Correcting Capability of a Linear Code: If the Hamming weight

of a linear code is at least 2t + 1, then the code can correct any t or fewer errors.
Alternatively, the same code can detect any 2t or fewer errors.
′
Problem 4 Let A be the message set consisting of all possible 3−tuples of 0 s and
′
1 s. Encode each message in A based on Hamming (6, 3) code with the generator matrix
given by
 
1 0 0 1 1 0
 
G =  0 1 0 1 0 1 .
 
 
0 0 1 1 1 1
Check whether the resulting codes can correct single error? Is it possible to detect any
double errors?
Solution Hamming (6, 3) code denotes that the input message is of length 3 and it
has to be encoded with length 6 using the matrix G. Each input message consists of
3−tuples (3 components) in which each component will be either 0 or 1. Hence the
 5
entries of each components can be viewed as the elements of Z2 , where Z2 = {0, 1}.
Since the message consists of 3 components and each component is either 0 or 1, there
are 8 possibilities, that is, 23 = 8, where 2 denotes the number of elements of Z2 and 3
denotes the number of components. So, these 8 elements are the elements of the group
Z2 ×Z2 ×Z2 ×Z2 = {000, 001, 010, 100, 110, 101, 011, 111}. Hence, A = Z2 ×Z2 ×Z2 . Use
the similar procedure as in Problem 2 to find the code words and the corresponding
data is given in the Table 2.
Now, since the minimum weight of any nonzero code word is 3, this code will correct

Table 2
Message Encoder Code Word Message Encoder Code Word
000 → 000000 110 → 110011
001 → 001111 101 → 101001
010 → 010101 011 → 011010
100 → 100110 111 → 111100

any single error or detect any double error (by theorem).

Homework Problems:

✠ Problem 5 Let A = {00, 01, 02, 10, 11, 12, 20, 21, 22} be the message set con-
sisting of all possible 2-tuples of 0’s,1’s and 2’s. Construct a (4, 2) linear code
over Z3 with generator matrix given by
 
1 0 2 1
G= .
0 1 2 2

Check whether the resulting codes can correct single error?

Is it possible to detect any double errors?
✠ Define generator matrix. Briefly explain how to construct a generator matrix?

Parity-Check Matrix Decoding

Using standard generator matrix, we can easily encode messages. Similarly to decode
the message, we need a convenient method. Unfortunately, this is not as easy to do;
however, in the case where at most one error per code word has occurred, there is a
6
fairly simple method for decoding. (When more than one error occurs in a code word,
our decoding method fails.)
To describe this method, suppose that V is a systematic linear code over the field F
given by the standard generator matrix G = [Ik×k |Ak×(n−k) ], where Ik×k represents the
k × k identity matrix and Ak×(n−k) is the matrix obtained from G by deleting the first
k columns of G. Then, the n × (n − k) matrix
 
−A
H=
I(n−k)×(n−k)

where −A is the negative of A and I(n−k)×(n−k) is the identity matrix of order (n − k) ×

(n − k), is called the parity-check matrix for V. The decoding procedure is:

(1) For any received word w, compute wH.

(2) If wH is the zero vector, assume that no error was made.
(3) If there is exactly one instance of a nonzero element s ∈ F and a row i of H such
that wH is stimes row i, assume that the sent word was w − (0...s...0), where
s occurs in the ith component. If there is more than one such instance, do not
decode.
(4) When the code is binary, category 3 reduces to the following. If wH is the ith
row of H for exactly one i, assume that an error was made in the ith component
of w. If wH is more than one row of H, do not decode.
(5) If wH does not fit into either category 2 or category 3, we know that at least
two errors occurred in transmission and we do not decode.

Problem 6: Consider the Hamming (7, 4) code with the generator matrix given by
 
 1 0 0 0 1 1 0 
 
 0 1 0 0 1 0 1 
G= .
 
 0 0 1 0 1 1 1 
 
 
0 0 0 1 0 1 1
 7
Find the parity-check matrix for the Hamming (7, 4) code with the generator matrix G.
Also check whether the received vectors 0000110, 1011111 are error free.
h i
−A
Solution: The parity-check matrix H can be find by using the formula H = I(n−k)×(n−k) .
 
 1 1 0 
 
 1 0 1 
Here n = 7, k = 4, n − k = 3 and A =   (obtained by deleting first 4 columns
 
 1 1 1 
 
 
0 1 1
of G). Hence,
   
−1 −1 0 1 1 0
   
   

 −1 0 −1  
  1 0 1 

   

 −1 −1 −1  
  1 1 1 

   
H=
 0 −1 −1 =
  0 1 1 
 (since value of −1 in Z2 is 1, because −1 + 2 = 1).
   
1 0 0 1 0 0
   
   
   
0 1 0 0 1 0
   
   
   
0 0 1 0 0 1

Now, if the received vector is v = 0000110, we find vH = 110. Since this is the first
row of H and no other row of H is 110, we can conclude that an error has been made in
the first position of v. Thus, the transmitted code word is assumed to be 1000110, and
the corresponding message is assumed to be 1000 (first four characters of 1000110.
Similarly, if w = 1011111 is the received word, then wH = 101, and we can conclude
that an error has been made in the second position. So, we assume that 1111111 was
sent and that 1111 was the intended message.

Note

♣ In the above problem, if the encoded message 1001101 is received as z = 1001011

(with errors in the fifth and sixth positions), we find zH = 110. Since this
matches the first row of H, we decode z as 0001011 and incorrectly assume that
the message 0001 was intended.
8
♣ Thus, when only one error was made in transmission, the parity-check decoding
procedure will give us the originally intended message.
♣ Parity-check matrix decoding will correct any single error if and only if the rows
of the parity-check matrix are nonzero and no one row is a scalar multiple of any
other row.

Practice Problems

(1) Determine the (6, 3) binary linear code with generator matrix
 
1 0 0 0 1 1
 
G =  0 1 0 1 0 1 .
 
 
0 0 1 1 1 0

(2) Find all code words of the (7, 4) binary linear code whose generator matrix is
 
 1 0 0 0 1 1 1 
 
 0 1 0 0 1 0 1 
G= .
 
 0 0 1 0 1 1 0 
 
 
0 0 0 1 0 1 1

Find the parity-check matrix of this code. Will this code correct any single error?

⋆ ⋆ ⋆ ⋆ ⋆⋆