Chapter 10.

Error
Detection and Correction

Stephen Kim ([email protected])

10.1

Notes
Data

can be corrupted during transmission.

Some applications (acutally most of
applications) require that errors be detected
and corrected.

10.2

INTRODUCTION

Let us first discuss some issues related, directly

or indirectly, to error detection and correction.

10.3

Type of Errors
Single-bit

error

Only 1 bit in the data unit (packet, frame, cell) has

changed.
Either 1 to 0, or 1 to 0.

Burst

error

2 or more bits in the data unit have changed.

More likely to occur than the single-bit error because
the duration of noise is normally longer than the
duration of 1 bit.

10.4

Redundancy
To

detect or correct errors, we need to send

extra (redundant) bits with data.
The receiver will be able to detect or correct
the error using the extra information.
Detection
Looking at the existence of any error, as YES or NO.
Retransmission if yes. (ARQ)
Correction

Looking at both the number of errors and the location

of the errors in a message.
Forward error correction. (FEC)

10.5

Coding
Encoder

vs. decoder
Both encoder and decoder have agreed on a
detection/correct method in priori.

10.6

Modulo Arithmetic
In

modulo-N arithmetic, we use only the

integers in the range 0 to N1, inclusive.
Calculation
If a number is greater than N1, it is divided by N and
the remainder is the result.
If it is negative, as many Ns as needed are added to
make it positive.
Example

in Modulo-12

1512 = 312
-312 = 912

10.7

Modulo-2 Arithmetic
Possible

numbers are {0, 1}

Arithmetic
Addition
0+0=0, 0+1=1,

1+0= 1,

1+1=2=0

Subtraction
0-0=0,

0-1=-1=1,

1-0=1, 1-1=0

Surprisingly, the addition and subtraction give the

same result.
XOR (exclusively OR) can replace both addition and
subtraction.

10.8

BLOCKCODING

In block coding, we divide our message into

blocks, each of k bits, called datawords. We add
r redundant bits to each block to make the
length n = k + r. The resulting n-bit blocks are
called codewords.

10.9

Datawords and codewords in

block coding

10.10

Example 10.1
The

4B/5B block coding discussed in Chapter 4

is a good example of this type of coding.
In this coding scheme, k = 4 and n = 5. As we
saw, we have 2k = 16 datawords and 2n = 32
codewords.
We saw that 16 out of 32 codewords are used
for message transfer and the rest are either
used for other purposes or unused.

10.11

Error Detection
A

receiver can detect a change if the original

codeword if
The receiver has a list of valid codewords, and
The original codeword has changed to an invalid one.

10.12

Example 10.2
Let

us assume that k = 2 and n = 3, and assume the

following table.

Assume

the sender encodes the dataword 01 as 011

and sends it to the receiver. Consider the following
cases:
The receiver receives 011. It is a valid codeword. The
receiver extracts the dataword 01 from it.
The codeword is corrupted during transmission, and 111 is
received. This is not a valid codeword and is discarded.
The codeword is corrupted during transmission, and 000 is
received. This is a valid codeword. The receiver incorrectly
extracts the dataword 00. Two corrupted bits have made
the error undetectable.
10.13

Note
An

error-detecting code can detect only the

types of errors for which it is designed; other
types of errors may remain undetected.
The previous example
Is designed for detecting 1-bit error,
Cannot detect 2-bit error, and
Cannot find the location of the 1-bit error.

10.14

Error Correction
The

receiver needs to find (or guess) the

original codeword sent.
Need more redundancy than for error
detection.

10.15

Example 10.3

Add 3 redundant bits to the 2-bit dataword to make 5-bit

codewords as follows:

Example
Assume the dataword is 01.
The sender creates the codeword 01011.
The codeword is corrupted during transmission, and 01001 is
received. The receiver
Finds that the received codeword is not in the table.
Assuming that there is only 1 bit corrupted, uses the following
strategy to guess the correct dataword.
Comparing the received codeword with the first codeword in the table
(01001 versus 00000), the receiver decides that the first codeword is not
the one that was sent because there are two different bits.
By the same reasoning, the original codeword cannot be the third or
fourth one in the table.
The original codeword must be the second one in the table because this
is the only one that differs from the received codeword by 1 bit. The
receiver replaces 01001 with 01011 and consults the table to find the
dataword 01.
10.16

Hamming Distance
The

Hamming distance between two words is

the number of differences between
corresponding bits.
The Hamming distance d(000, 011) is 2 because
000 011 = 011 (two 1s)
The Hamming distance d(10101, 11110) is 3 because
10101 11110 = 01011 (three 1s)

The

minimum Hamming distance is the

smallest Hamming distance between all
possible pairs in a set of words.
10.17

Example 10.5
Find

the minimum Hamming distance of the

coding scheme in Table 10.1.
Solution
We first find all Hamming distances.
d(000,011)=2, d(000,101)=2,
d(000,110)=2
d(011,101)=2, d(011,110)=2,
d(101,110)=2
The dmin in this case is 2.

10.18

Example 10.6
Find

the minimum Hamming distance of the

coding scheme in Table 10.2.
Solution
We first find all the Hamming distances.
d(0000,01011)=3,
d(00000,10101)=3,
d(00000,11110)=4,
d(01011,10101)=4,
d(01011,11110)=3,
d(10101,11110)=3
The dmin in this case is 3.

10.19

Hamming Distance and

Detection
To

guarantee the detection of up to s-bit errors

in all cases, the minimum Hamming distance in
a block code must be
dmin = s + 1.

10.20

Example 10.7
The minimum Hamming distance for our first code
scheme (Table 10.1) is 2. This code guarantees
detection of only a single error. For example, if the
third codeword (101) is sent and one error occurs,
the received codeword does not match any valid
codeword. If two errors occur, however, the
received codeword may match a valid codeword and
the errors are not detected.

10.21

Example 10.8
Our second block code scheme (Table 10.2) has dmin
= 3. This code can detect up to two errors. Again,
we see that when any of the valid codewords is sent,
two errors create a codeword which is not in the
table of valid codewords. The receiver cannot be
fooled.
However, some combinations of three errors
change a valid codeword to another valid
codeword. The receiver accepts the received
codeword and the errors are undetected.
10.22

Minimum Distance and

Correction
To

guarantee correction of up to t errors in all

cases, the minimum Hamming distance in a
block code
must be dmin = 2t + 1.

10.23

Example 10.9
A code scheme has a Hamming distance dmin = 4.
What is the error detection and correction
capability of this scheme?
Solution
Thiscodeguaranteesthedetectionofuptothree
errors(s=3),butitcancorrectuptooneerror.In
otherwords,ifthiscodeisusedforerrorcorrection,
partofitscapabilityiswasted.Errorcorrection
codesneedtohaveanoddminimumdistance(3,5,
7,...).
10.24

LINEAR BLOCK
CODES
Almost all block codes used today belong to a
subset called linear block codes. A linear block
code is a code in which the exclusive OR
(addition modulo-2) of two valid codewords
creates another valid codeword.

10.25

Note
In

a linear block code, the exclusive OR (XOR)

of any two valid codewords creates another
valid codeword.

10.26

Example 10.10
Let us see if the two codes we defined in Table 10.1
and Table 10.2 belong to the class of linear block
codes.
1.The scheme in Table 10.1 is a linear block code
because the result of XORing any codeword with
any other codeword is a valid codeword. For
example, the XORing of the second and third
codewords creates the fourth one.
2.The scheme in Table 10.2 is also a linear block
code. We can create all four codewords by XORing
two other codewords.
10.27

Example 10.11
In our first code (Table 10.1), the numbers of 1s in
the nonzero codewords are 2, 2, and 2. So the
minimum Hamming distance is dmin = 2. In our
second code (Table 10.2), the numbers of 1s in the
nonzero codewords are 3, 3, and 4. So in this code
we have dmin = 3.

10.28

Simple Parity-Check Code

A

simple parity-check code is a single-bit errordetecting code in which n = k + 1 with dmin =

2.
A simple parity-check code can detect an odd
number of errors.

10.29

Encoder and decoder for simple

parity-check code
In

modulo,

r0 = a3+a2+a1+a0
s0 = b3+b2+b1+b0+q0
Note

that the receiver addds all 5 bits. The

result is called the syndrome.

10.30

Example 10.12
Let us look at some transmission scenarios. Assume the
sender sends the dataword 1011. The codeword created
from this dataword is 10111, which is sent to the receiver.
We examine five cases:
1.No error occurs; the received codeword is 10111. The
syndrome is 0. The dataword 1011 is created.
2.One single-bit error changes a1 . The received
codeword is 10011. The syndrome is 1. No dataword is
created.
3.One single-bit error changes r0 . The received codeword is
10110. The syndrome is 1. No dataword is created.

10.31

Example 10.12 (continued)

4. An error changes r0 and a second error changes
a3 . The received codeword is 00110. The
syndrome is 0. The dataword 0011 is created at
the receiver. Note that here the dataword is
wrongly created due to the syndrome value.
5. Three bitsa3, a2, and a1are changed by
errors. The received codeword is 01011. The
syndrome is 1. The dataword is not created. This
shows that the simple parity check, guaranteed
to detect one single error, can also find any odd
number of errors.
10.32

Hamming Code
Error

correcting codes.
The relationship between m and n in these
codes is n = 2m 1.

10.33

Figure 10.11 Two-dimensional parity-check code

10.34

Figure 10.11 Two-dimensional parity-check code

10.35

Figure 10.11 Two-dimensional parity-check code

10.36

Table 10.4 Hamming code C(7, 4)

10.37

Figure 10.12 The structure of the encoder and decoder for a Hamming code

10.38

Table 10.5 Logical decision made by the correction logic analyzer

10.39

Example 10.13
Let us trace the path of three datawords from the
sender to the destination:
1. The dataword 0100 becomes the codeword
0100011. The codeword 0100011 is received. The
syndrome is 000, the final dataword is 0100.
2. The dataword 0111 becomes the codeword
0111001. The syndrome is 011. After flipping b2
(changing the 1 to 0), the final dataword is 0111.
3. The dataword 1101 becomes the codeword
1101000. The syndrome is 101. After flipping b0, we
get 0000, the wrong dataword. This shows that our
code cannot correct two errors.
10.40

Example 10.14
We need a dataword of at least 7 bits. Calculate
values of k and n that satisfy this requirement.
Solution
Weneedtomakek=nmgreaterthanorequalto
7,or2m1m7.
1.Ifwesetm=3,theresultisn=231andk=7
3,or4,whichisnotacceptable.
2.Ifwesetm=4,thenn=241=15andk=15
4=11,whichsatisfiesthecondition.Sothecode
isC(15,11)

10.41

Figure 10.13 Burst error correction using Hamming code

10.42

CYCLIC CODES

Cyclic codes are special linear block codes with

one extra property. In a cyclic code, if a
codeword is cyclically shifted (rotated), the
result is another codeword.

10.43

Cyclic Redundancy Code

Widely

used in data communication

Example of CRC C(7,4)

10.44

Architecture of CRC

10.45

Figure 10.15 Division in CRC encoder

10.46

CRC Decoder
The

decoder does the same division as the

encoder.
The remainder of the division is the syndrome.
If there is no error during communication, the
syndrome is zero. The dataword is sperated from the
received codeword and accepted.
If the syndrom is non-zero, then errors occurs during
communication.
Question

What if there is errors during communication, but the

syndrome is zero.

10.47

Figure 10.16 Division in the CRC decoder for two cases

10.48

Figure 10.17 Hardwired design of the divisor in CRC

10.49

Figure 10.18 Simulation of division in CRC encoder

10.50

Figure 10.19 The CRC encoder design using shift registers

10.51

Figure 10.20 General design of encoder and decoder of a CRC code

10.52

Polynomials
The

binary vector can be represented by a

polynomial.
Coefficients are either 0 or 1.
Power of each term represents the position of the bit.

10.53

Polynomial Notation of CRC

S

and R agree upon a generator function g(x)

of degree n in priori.
Use binary and modulo-2 arithmetic
no carry for addition, no borrow for subtraction
addition = subtraction = exclusive OR.
n is the degree of g(x).
f(x)
S
g(x)

Is xnf(x)-r(x)+e(x) divisible by
g(x) ?
xnf(x)+
r(x)
g(x)*s(x)

x f(x)=g(x)*s(x)
+r(x)
n

e(x)

xnf(x)-r(x)
+e(x)
g(x)*s(x)

R
g(x)

+e(x)

3-54

CRC Division Using

Polynomials

10.55

Equivalence of Polynomial and

Binary Polynomial
Binary Vector
Generator,
g(x)

x3+x+1

1011

Data, f(x)

x3+x2

1100

xnf(x)

x6+x5

1100000

Division
xnf(x)g(x)

x3+x
+1

x3+x2+x
x6+x5
x6+x4+x3
x5+x4+x3
x5+x3+x2
x4+x2
x4+x2+x
x

Codeword,
xnf(x)-r(x)

x6+x5+x

1011

1110
1100000
1011
111000
1011
10100
1011
10

1100010

3-56

Note
The

divisor in a cyclic code is normally called

the generator polynomial or simply the
generator.
In a cyclic code, the remainder of
(xnf(x)-r(x)+e(x)) % g(x)
If s(x) 0, one or more bits is corrupted.
If s(x) = 0, either
No bit is corrupted, or
Some bits are corrupted, but the decoder failed to detect
them.

In

a cyclic code, those e(x) errors that are

divisible by g(x) are not caught.

10.57

Capability of CRC
If

the generator has more than one term and the

coefficient of x0 is 1, all single errors can be caught.
If a generator cannot divide xt+1 (t between 0 and
n 1), then all isolated double errors can be
detected.
A generator that contains a factor of x+1 can
detect all odd-numbered errors.
For the length of error (L) and the degree of the
generator (r)
All burst errors with L r will be detected.
All burst errors with L = r + 1 will be detected with
probability 1 (1/2)r1.
All burst errors with L > r + 1 will be detected with
probability 1 (1/2)r.
10.58

Example 10.15
Which of the following g(x) values guarantees that
a single-bit error is caught? For each case, what is
the error that cannot be caught?
a. x + 1
b. x3
c. 1
Solution
a.Noxicanbedivisiblebyx+1.Anysinglebit
errorcanbecaught.
b.Ifiisequaltoorgreaterthan3,xiisdivisibleby
g(x).allsinglebiterrorsinpositions1to3are
caught.
c.Allvaluesofimakexidivisiblebyg(x).No
singlebiterrorcanbecaught.Thisg(x)isuseless.
10.59

Figure 10.23 Representation of two isolated single-bit errors using polynomials

10.60

Example 10.16
Find the status of the following generators related to two
isolated, single-bit errors.
a. x + 1
b. x4 + 1
c. x7 + x6 + 1
d. x15 + x14 + 1
Solution
a.Thisisaverypoorchoiceforagenerator.Anytwoerrors
nexttoeachothercannotbedetected.
b.Thisgeneratorcannotdetecttwoerrorsthatarefour
positionsapart.
c.Thisisagoodchoiceforthispurpose.
d.Thispolynomialcannotdividext+1iftislessthan
32,768.Acodewordwithtwoisolatederrorsupto32,768
bitsapartcanbedetectedbythisgenerator.
10.61

Example 10.17
Find the suitability of the following generators in
relation to burst errors of different lengths.
a. x6 + 1
b. x18 + x7 + x + 1
c. x32 + x23 + x7
+1
Solution
a.Thisgeneratorcandetectallbursterrorswitha
lengthlessthanorequalto6bits;3outof100
bursterrorswithlength7willslipby;16outof
1000bursterrorsoflength8ormorewillslipby.

10.62

Example 10.17 (continued)

b.Thisgeneratorcandetectallbursterrorswitha
lengthlessthanorequalto18bits;8outof1
millionburstErrorswithlength19willslipby;4
outof1millionbursterrorsoflength20ormore
willslipby.
c.Thisgeneratorcandetectallbursterrorswitha
lengthlessthanorequalto32bits;5outof10
billionbursterrorswithlength33willslipby;3out
of10billionbursterrorsoflength34ormorewill
slipby.

10.63

Good CRC Generator

A

good polynomial generator needs to have

the following characteristics:

It should have at least two terms.

The coefficient of the term x0 should be 1.
It should not divide xt + 1, for t between 2 and n 1.
It should have the factor x + 1.

10.64

Standard Polynomials

10.65

CHECKSUM

The last error detection method we discuss here

is called the checksum. The checksum is used in
the Internet by several protocols although not at
the data link layer. However, we briefly discuss
it here to complete our discussion on error
checking

10.66

Example 10.18
Suppose our data is a list of five 4-bit numbers that
we want to send to a destination. In addition to
sending these numbers, we send the sum of the
numbers. For example, if the set of numbers is (7,
11, 12, 0, 6), we send (7, 11, 12, 0, 6, 36), where 36
is the sum of the original numbers. The receiver
adds the five numbers and compares the result with
the sum. If the two are the same, the receiver
assumes no error, accepts the five numbers, and
discards the sum. Otherwise, there is an error
somewhere and the data are not accepted.
10.67

Example 10.19
We can make the job of the receiver easier if we
send the negative (complement) of the sum, called
the checksum. In this case, we send (7, 11, 12, 0, 6,
36). The receiver can add all the numbers
received (including the checksum). If the result is
0, it assumes no error; otherwise, there is an error.

10.68

Example 10.20
How can we represent the number 21 in ones
complement arithmetic using only four bits?

Solution
The number 21 in binary is 10101 (it needs five
bits). We can wrap the leftmost bit and add it to
thefourrightmostbits.Wehave(0101+1)=0110
or6.

10.69

Example 10.21
How can we represent the number 6 in ones
complement arithmetic using only four bits?
Solution
In ones complement arithmetic, the negative or
complement of a number is found by inverting all
bits. Positive 6 is 0110; negative 6 is 1001. If we
consideronlyunsignednumbers,thisis9.Inother
words, the complement of 6 is 9. Another way to
find the complement of a number in ones
complement arithmetic is to subtract the number
from2n1(161inthiscase).
10.70

Example 10.22
Let us redo Exercise 10.19 using ones complement
arithmetic. Figure 10.24 shows the process at the sender
and at the receiver. The sender initializes the checksum to
0 and adds all data items and the checksum (the checksum
is considered as one data item and is shown in color). The
result is 36. However, 36 cannot be expressed in 4 bits.
The extra two bits are wrapped and added with the sum to
create the wrapped sum value 6. In the figure, we have
shown the details in binary. The sum is then
complemented, resulting in the checksum value 9 (15 6
= 9). The sender now sends six data items to the receiver
including the checksum 9.

10.71

Example 10.22 (continued)

The receiver follows the same procedure as the sender. It
adds all data items (including the checksum); the result is
45. The sum is wrapped and becomes 15. The wrapped
sum is complemented and becomes 0. Since the value of
the checksum is 0, this means that the data is not
corrupted. The receiver drops the checksum and keeps the
other data items. If the checksum is not zero, the entire
packet is dropped.

10.72

Figure 10.24 Example 10.22

10.73

Internet Checksum
16-bit

checksum
Sender site:
1. The message is divided into 16-bit words.
2. The value of the checksum word is set to 0.
3. All words including the checksum are added using ones
complement addition.
4. The sum is complemented and becomes the checksum.
5. The checksum is sent with the data.
Receiver

site:

1. The message (including checksum) is divided into 16-bit

words.
2. All words are added using ones complement addition.
3. The sum is complemented and becomes the new checksum.
4. If the value of checksum is 0, the message is accepted;
otherwise, it is rejected.
10.74

Example 10.23
Let us calculate the checksum for a text of 8 characters
(Forouzan). The text needs to be divided into 2-byte (16bit) words. We use ASCII (see Appendix A) to change each
byte to a 2-digit hexadecimal number. For example, F is
represented as 0x46 and o is represented as 0x6F. Figure
10.25 shows how the checksum is calculated at the sender
and receiver sites. In part a of the figure, the value of
partial sum for the first column is 0x36. We keep the
rightmost digit (6) and insert the leftmost digit (3) as the
carry in the second column. The process is repeated for
each column. Note that if there is any corruption, the
checksum recalculated by the receiver is not all 0s. We
leave this an exercise.

10.75

Figure 10.25 Example 10.23

10.76