Download Lecture Notes: Introduction to Multiple-Error Correcting Codes using Galois Fields and more Study notes Electrical and Electronics Engineering in PDF only on Docsity!
ECE 7670
Lecture gfint – Introduction to multiple-error correcting
codes
Objective: To demonstrate important concepts that lead to more general families of codes; to introduce the idea behind Galois fields.
We have seen how the Hamming code can be used to correct single errors, and met syndrome decoding and standard arrays. We have also seen that the storage and/or decoding complexity could be very high. What is needed to deal with this complexity is some sort of structure. While linear algebra provides some structure, more algebraic structure is needed. The material in these lecture notes is drawn from Elwyn Berlkamp, Algebraic Coding Theory (McGraw-Hill, 1968). The book is definitely a classic in coding, and should be explored by all who are truly interested in this material. Of this material, Berlekamp writes: “The student is urged to study the next section with care. In my opinion, it is the most important section of the book.” First, a reminder: For a Hamming code, we can look at the syndrome and determine, from the column corresponding, what the error location is. For example, if we write
H =
[
h 1 h 2 · · · hn
]
the syndrome rHT^ = hi, where i indicates the location of the error (assuming, of course, that there is only one). Let us take the case of a (31, 26) Hamming code, and write the parity check matrix as
H =
That is, for this example we order the columns in binary numerical order. We will consider each column as a 5-tuple, and also write this as
H =
[
γ 1 γ 2 γ 3 · · · γ 30 γ 31
]
where the ith column of H has the binary representation of i in the symbol γi. Now, let us move beyond Hamming codes and attempt to formulate a double error correcting code. We will do this (in this example) by starting with the same parity check matrix, but not adding 5 more rows. We will denote this as
H =
f 1 (1) f 1 (2) f 1 (3) · · · f 1 (30) f 1 (31) f 2 (1) f 2 (2) f 2 (3) · · · f 2 (30) f 2 (31) f 3 (1) f 3 (2) f 3 (3) · · · f 3 (30) f 3 (31) f 4 (1) f 4 (2) f 4 (3) · · · f 4 (30) f 4 (31) f 5 (1) f 5 (2) f 4 (3) · · · f 5 (30) f 5 (31)
The argument tells which column we are dealing with, and the subscript tells which “bit”. Another way to think about this that is notationally important is to have a function
f =
f 1 f 2 f 3 f 4 f 5
which maps binary 5-tuples to binary 5-tuples. In the shorthand notation, we could write
H =
[
γ 1 γ 2 γ 3 · · · γ 30 γ 31 f (γ 1 ) f (γ 2 ) f (γ 3 ) · · · f (γ 30 ) f (γ 31 )
]
We might have, for example, f (γ) = γ, or f (γ) = (1, 1 , 1 , 1 , 1)+γ. To do much more than this simple stuff, however, we need some way of dealing with these 5-tuples as objects in their own right. We need to develop and appropriate arithmetic: add, subract, multiply, divide. Adding is easy — we simply go component by component. But how do we multiply? The key here is to think of each 5-tuple as corresponding to a polynomial of degree ≤ 4. For example:
(0, 0 , 0 , 0 , 0) ↔ 0 (0, 0 , 0 , 0 , 1) ↔ 1 (0, 0 , 0 , 1 , 0) ↔ x (0, 0 , 1 , 0 , 0) ↔ x^2 (1, 0 , 1 , 0 , 1) ↔ x^4 + x^2 + 1
Note that each coefficient of the polynomials is binary; we assume that addition is modulo 2 (i.e., over GF(2)). Clearly, addition of polynomials accomplishes exactly the same thing as addition of the vectors. (They are isomorphic.) How can we multiply? We want our polynomials representing the 5-tuples to have degree ≤ 4, and yet when we multiply, the degree may exceed that. For example,
(x^3 + x + 1)(x^4 + x^3 + x + 1) = x^7 + x^6 + x^5 + 3x^4 + 2x^3 + x^2 + 2x + 1 = x^7 + x^6 + x^5 + x^4 + x^2 + 1.
To reduce the degree, we choose some polynomial M (x) of degree 5, and reduce the product modulo M (x). That is, we divide by M (x) and take the remainder. (Analogous to multiplication modulo and integer.) Let us take M (x) = x^5 + x^2 + 1. Performing the division, we get a quotient of x^2 + x + 1, and remainder of x^3 + x^2 + x. Then we can write
(x^3 + x + 1)(x^4 + x^3 + x + 1) = x^7 + x^6 + x^5 + x^4 + x^2 + 1 ≡ x^3 + x^2 + x mod x^5 + x^2 + 1.
In general, we write
A(x) ≡ a(z) mod M (x)
iff there is a polynomial q(x) such that
A(x) = q(x)M (x) + a(x).
Now, before we proceed, some facts about modulo operations (these go way back to Gauss)
f (γi 1 ) + f (γi 2 ) = s 2
We will write this as
γ 1 + γ 2 = s 1
f (γ 1 ) + f (γ 2 ) = s 2
If we set our function up correctly, we will have two equations in two unknowns, which we could solve for γi which, in turn, will determine i (since γi is, in this case, simply the binary representation of i). Let us consider some possible simple functions. One might be a simple mul- tiplication: f (γ(x)) = a(x)γ(x) mod M (x). But this would lead to a dependent equation: s 2 = as 1 ; the new parity check equations would tell us nothing new. We could try f (γ) = γ + a; This would not help, since we would always have s 2 = s 1. Let us try some powers. Say f (γ) = γ^2. We would then obtain
γ 1 + γ 2 = s 1
γ 12 + γ 22 = s 2.
This looks like independent equations, but we have to remember that we are dealing with operations modulo 2. Notice that
s^21 = (γ 1 + γ 2 )^2 = γ^21 + γ 22 + 2γ 1 γ 2 = γ^21 + γ 22 = s 2.
We have only the redundant s^21 = s 2 : the second equation is the square of the first, and conveys no new information. Try f (γ) = γ^3. Now the decoder equations are
γ 1 + γ 2 = s 1
γ 13 + γ^32 = s 2
These are independent! Now let’s see what we can do to solve this. We can do more or less conventional algebraic manipulation (keeping in the back of our mind how we do multiplication and division). We can write
s 2 = γ 13 + γ^32 = (γ 1 + γ 2 )(γ 12 − γ 1 γ 2 + γ 22 ) = s 1 (γ 12 + γ 1 γ 2 + γ 22 ) = s 1 (γ 1 γ 2 − s^21 )
Hence we have the two equations
γ 1 + γ 2 = s 1
γ 1 γ 2 = s^21 +
s 2 s 1
if s 1 6 = 0. (Note that the first deals with sums of values, and the second with products.) We can combine these into a quadratic:
γ(s 1 + γ) = s^21 + s 2 s 1
or
γ^2 + s 1 γ + (s^21 +
s 2 s 1
or
q(x) = 1 + s 1 γ−^1 + (σ^21 +
s 2 s 1 )γ−^2 = 0.
For reasons hopefully to made clear later, it is more useful to deal with the recip- rocals of the roots. The polynomial q(x) is said to be an error locator polynomial. The roots of the quadratic q(x) can be reciprocated to find γ 1 and γ 2. (How to find the roots?) If there is only one error, then γ 1 = s 1 and γ 13 = s 2 , and we end up with the equation 1 + s 1 γ−^1 = 0. And if there are no errors, then s 1 = s 2 = 0. Let us summarize the steps we have taken. First, we have devised a way of operating on 5-tuples as single algebraic objects, defining addition, subtraction, multiplication, and division. This required finding some irreducible polynomial M (x) which works behind the scenes. Once we have got this, the steps are as follows:
- We compute the syndrome rHT^.
- From the syndrome, we set up the error locator polynomial. If we let
S 1 =
γi = s 1 S 2 =
γ i^3 = s 2
we can write
q(z) = 1 + S 1 z + (S 12 +
S 3
S 1
)z^2
We note that there must be some relationship between the sums of the powers of roots and the coefficients.
- We then find the roots of the polynomial, which determine the error locations.
For binary codes, knowing where the error is is sufficient to knowing now to correct it. For nonbinary codes (which are very commonly used), there is another step: knowing the error location, we must also determine the error value. This involves setting up another polynomial, the error evaluation polynomial, whose roots determine the error values. The above steps establish the outline for the next several weeks. Not only will we develop more fully the arithmetic, but we will be able to generalize to whole families of codes, capable of correcting many errors. However, the concepts are all quite similar to those demonstrated here. It is historically interesting that it took roughly ten years of research to bridge the gap between Hamming and the code presented above. Once this was accom- plished, other generalizations followed quickly.
