- A significant role of the Data Link layer is to convert the potentially unreliable physical link between two machines into an apparently very reliable link.
- This is done by including redundant information in
each transmitted frame. Depending on the nature
of the link and the data one can either:
- include just enough redundancy to make it possible to detect errors and then arrange for the retransmission of damaged frames, or
- include enough redundancy to enable the receiver to correct any errors produced during transmission.

- One widely used parity bit based error detection scheme is
the cyclic redundancy check or CRC.
- The CRC is based on some fairly impressive looking
mathematics. It is helpful as you deal with its
mathematical description that you recall that
it is ultimately just a way to use parity
bits.
- The presentation of the CRC is based on two simple
but not quite "everyday" bits of mathematics:
- polynomial division
- arithmetic over the field of integers mod 2.

- Arithmetic over the field of integers mod 2 is simply
arithmetic on single bit binary numbers with all
carries (overflows) ignored. So 1 + 1 = 0 and so
does 1 - 1. In fact, addition and subtraction are
equivalent in this form of arithmetic.
- Polynomial division isn't too bad either. There
is an algorithm for performing polynomial division
that looks a lot like the standard algorithm for
integer division. More interestingly from the point
of view of understanding the CRC, the definition of
division (i.e. the definition of the quotient and remainder)
are parallel.
- When one says "dividing a by b produces quotient
q with remainder r" where all the quantities involved
are positive integers one really means that

and that*a = q b + r**0 <=r < b* - When one says "dividing a by b produces quotient q with remainder r" where all the quantities are polynomials, one really means the same thing as when working with integers except that the meaning of "less than" is a bit different. For polynomials, less than means of lesser degree. So, the remainder of a polynomial division must be a polynomial of degree less than the divisor.

- When one says "dividing a by b produces quotient
q with remainder r" where all the quantities involved
are positive integers one really means that
- Now, we can put this all together to explain the idea
behind the CRC.
- Any particular use of the CRC scheme is based
on selecting a generator polynomial G(x)
whose coefficients are all either 0 or 1.
Just to be different from the book, we will use

as our example of a generator polynomial.*x*^{3}+ x^{2}+ 1 - Given a message to be transmitted:

view the bits of the message as the coefficients of a polynomial*b*_{n}b_{n-1}b_{n-2}. . . b_{2}b_{1}b_{0}*B(x) = b*_{n}x^{n}+ b_{n-1}x^{n-1}+ b_{n-2}x^{n-2}+ . . . b_{2}x^{2}+ b_{1}x + b_{0} - Multiply the polynomial corresponding to the message
by
*x*where k is the degree of the generator polynomial and then divide this product by the generator to obtain polynomials Q(x) and R(x) such that:^{k}

Treating all the coefficients not as integers but as integers modulo 2.*x*^{k}B(x) = Q(x) G(x) + R(x) - Finally, treat the coefficients of the remainder
polynomial, R(X) as "parity bits". That is,
append them to the message before actually
transmitting it.
- Since the degree of R(x) is less than k, the
bits of the transmitted message will correspond
to the polynomial:
*x*^{k}B(x) + R(x) - Since addition and subtraction are identical in
the field of integers mod 2, this is the same
as
*x*^{k}B(x) - R(x) - From the equation that defines division, however,
we can conclude that:

In other words, if the transmitted message's bits are viewed as the coeeficients of a polynomial, then that polynomial will be divisible by G(X).*x*^{k}B(x) - R(x) = Q(x) G(x) - This last fact is the basis of error checking using the CRC. When a message is received the corresponding polynomial is divided by G(x). If the remainder is non-zero, an error is detected. Otherwise, the message is assumed to be correct.

- Any particular use of the CRC scheme is based
on selecting a generator polynomial G(x)
whose coefficients are all either 0 or 1.

- The CRC is based on some fairly impressive looking
mathematics. It is helpful as you deal with its
mathematical description that you recall that
it is ultimately just a way to use parity
bits.
- How about an example:
- Suppose we want to send a nice short message like
11010111 using the CRC with the polynomial
*x*as our generator.^{3}+ x^{2}+ 1 - The message corresponds to the polynomial:
*x*^{7}+ x^{6}+ x^{4}+ x^{2}+ x + 1 - Given G(x) is of degree 3, we need to multiply this polynomial
by
*x*and then divide the result by G(x).^{3} - I'll have to think about how to get this formatted better,
but basically we have:
*x*^{7}+*x*^{2}+1

*x*^{3}+*x*^{2}+1 ) *x*^{10}+*x*^{9}+*x*^{7}+*x*^{5}+*x*^{4}+*x*^{3}*x*^{10}+*x*^{9}+*x*^{7}

*x*^{5}+*x*^{4}+*x*^{3}*x*^{5}+*x*^{4}+*x*^{2}

*x*^{3}+*x*^{2}*x*^{3}+*x*^{2}+1

1 - The punchline is that the remainder is just "1". So, the parity bits added in this case would be 001.

- Suppose we want to send a nice short message like
11010111 using the CRC with the polynomial
- I hope this is all strange enough that you feel compelled
to ask "Why bother?". If so, the answer
comes in two parts:
- While the computation of parity bits through
polynomial division may seem rather complicated,
with a little reflection on how the division
algorithm works we will see how to implement a
very simple algorithm for computing CRC bits and/or
verifying the correctness of the CRC associated with
a received message.
- The relationship between the bits and the polynomials will give us some mathematical leverage that will make it possible to prove facts about the sorts of errors the CRC associated with a given generator will detect.

- While the computation of parity bits through
polynomial division may seem rather complicated,
with a little reflection on how the division
algorithm works we will see how to implement a
very simple algorithm for computing CRC bits and/or
verifying the correctness of the CRC associated with
a received message.
- Let's start by seeing how the mathematics underlying the
CRC can be used to investigate its ability to detect errors.
- Suppose that we transmit the message corresponding
to some polynomial B(x) after adding CRC bits.
In this case, the transmitted bits will correspond
to some polynomial, T(x), where

where k is the degree of the generator polynomial and R(x) is the remainder obtained when B(x) is divided by the generator.*T(x) = B(x) x*^{k}- R(x) - Remember, the key property of T(x) is that it is divisible
by G(x) (i.e. G(x) is a factor of T(x)).
- Now, if during transmission some of the bits of the
message are damaged, the actual bits received will
correspond to a different polynomial, T'(x).
If we imagine computing

then the coefficients of E(x) will correspond to a bit string with a one in each position where T(x) differed from T'(x) and zeroes everywhere else. Thus, E(x) corresponds to a bitmap of the positions at which errors occurred.*E(x) = T(x) - T'(x)* - As long as T'(x) is not divisible by G(x), our CRC
bits will enable us to detect errors. SO, the cases
we are really interesting are those where T'(x) is
divisible by G(x).
- Given that we already know that T(x) is divisible by
G(x), T'(x) must be divisible by G(x) if and only if
E(x) is divisible by G(x). So, we can investigate the
forms of errors that will go undetected by investigating
polynomials, E(x), that are divisible by G(x).
Better yet, one might prefer to say we can design good
parity bit schemes by looking for polynomial, G(x),
that do not evenly divide examples of E(x) that correspond
to anticipated error patterns.
- Well, at the very least, it would be nice to make sure
that the CRC did as well as adding a single parity bit.
That is, we would like to avoid using any G(x) that
did not guarantee we could detect all instances of errors
that change an odd number of bits.
- If a received message T'(x) contains an odd number
of inverted bits, then E(x) must contain an odd
number of terms with coefficients equal to 1.
- As a result, E(1) must equal to 1 (since
if x = 1 then
*x*for all i).^{i}= 1 - If G(x) is a factor of E(x), then G(1) would
also have to be 1.
- So, if we make sure that G(1) = 0, we can conclude
that G(x) does not divide any E(x) corresponding
to an odd number of error bits. In this case,
a CRC based on G(x) will detect any odd number of
errors.
- As long as G(x) has some factor of the form
*x*, G(1) will equal 0. So, it isn't hard to find such a polynomial.^{i}+ 1

- If a received message T'(x) contains an odd number
of inverted bits, then E(x) must contain an odd
number of terms with coefficients equal to 1.
- As a sanity check, consider the CRC associated with the
simplest G(x) that contains a factor of the form
*x*, namely^{i}+ 1*x + 1*.- The CRC for any message consisting entirely of
zeroes will be zero.
- Given that the code is guaranteed to detect
any error involving an odd number of bits,
if we start with all zeroes and add 1's
in various posisiton, the parity bit must
flip each time we add a one.
- Accordingly, the value of the parity bit will
be 1 if and only if the number of 1's is odd.
- In other words, when the generator is
*x+1*the CRC is just a single even parity bit!

- The CRC for any message consisting entirely of
zeroes will be zero.
- Having discovered this amusing fact, let's make sure
that the CRC does more than a single parity bit if we
choose an appropriate polynomial of higher degree.
Consider how the CRC behaves is G(x) is
*x*for some k larger than one.^{k}+1- Obviously, this CRC will catch any error that
changes an odd number of bits.
- I argued last time, however, that one generally
worries more about burst errors than isolated
errors. So, consider the case where a burst
error affects some subset of j consecutive bits
for j < k.
- In this case, the error polynomial will look like

where we assume that*E(x) = x*^{n1}+ x^{n2}+ ... x^{nr}*n*for all i and that_{i}> n_{i+1}*n*._{1}- n_{r}<= jFactoring out the lowest degree term in this polynomial gives:

*E(x) = x*^{nr}(x^{n1-nr}+ x^{n2-nr}+ ... + 1 ) - Now,
*G(x) = x*can not divide^{k}+ 1*x*. So, the only way that G(x) can divide E(x) is if if divides^{nr}*x*. However, G(x) can not possible divide a polynomial of degree less than k. So, it can not divide E(x).^{n1-nr}+ x^{n2-nr}+ ... + 1 - Thus, we can conclude that the CRC based on our simple G(x) detects all burst errors of length less than its degree.

- Obviously, this CRC will catch any error that
changes an odd number of bits.
- There are many other examples of ways that properties of G(x) can be used to ensure that the associated CRC will detect certain errors. The text provides a few more examples.

- Suppose that we transmit the message corresponding
to some polynomial B(x) after adding CRC bits.
In this case, the transmitted bits will correspond
to some polynomial, T(x), where

Computer Science 336

Department of Computer Science

Williams College