FLUJO DE INFORMACIÓN PROPUESTO EN TALLERES

A BCH code over GF(q) of blocklength n = q^m− 1 is a subfield-subcode of a Reed–

Solomon code over GF(q^m), and so it has at least as large a minimum distance as the Reed–Solomon code. Unfortunately, even though the original Reed–Solomon code has a great many codewords, the subfield-subcode uses very few of them. BCH codes of large blocklength and large minimum distance have dimensions that are small and quite disappointing. In this section, we shall study a method to form better codes by reduc-ing the Reed–Solomon code to a subfield-subcode in another way. This construction produces a large class of codes known as alternant codes and a subclass of alternant codes known as Goppa codes. The alternant codes are studied in this section, and the Goppa codes are studied in Section2.13.

LetCRSbe an(n, K, D) Reed–Solomon code over GF(q^m). Let g be a fixed vector⁵of length n, called a template, all of whose components are nonzero elements of GF(q^m).

A generalized Reed–Solomon code, CGRS(g), is a code formed by componentwise multiplication of g with each of the Reed–Solomon codewords. That is,

CGRS(g) =%

c| c = gc^, c^∈CRS

&

,

where gc^denotes the vector whose ith component is g_ic^_ifor i= 0, . . . , n−1. The code CGRS(g) is a linear code. This code contains (q^m)^K vectors, as does the codeCRS, and the minimum distance ofCGRS(g) is the same as the minimum distance ofCRS. Both are equal to D. Thus the generalized Reed–Solomon code is also an(n, K, D) code.

A few of the vectors ofCGRS(g) may have all of their components in the smaller field GF(q), and the set of such vectors forms a linear code over GF(q). This subfield-subcode ofCGRS(g) is known as an alternant code. Specifically, the alternant code CA(g) is defined as follows:

CA(g) =CGRS(g) ∩ GF(q)ⁿ

=%

c| ci∈ GF(q); c = gc^, c^∈CRS

&

.

Because all g_i are nonzero, we may also write this statement in terms of an inverse template denoted g⁻¹with components g_i⁻¹. Then

CA(g) = {c | ci ∈ GF(q); g⁻¹c= c^; c^∈CRS}.

5 The use of the notation g and, in Section2.13, h for the template and inverse template is not to be confused with the use of the notation G and H for the generator matrix and check matrix.

93 2.12 Alternant codes

Table 2.5. Extracting binary codes from a(7, 5, 3) Reed–Solomon code

g= (5, 6, 1, 4, 1, 1, 7)

BCH code Reed–Solomon code alternant code

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 1 6 3

0 0 0 0 2 7 6

0 0 0 0 3 1 5

...

0 0 0 1 0 1 1 0 0 0 1 0 1 1

0 0 0 1 1 7 2

0 0 0 1 3 0 4

...

0 0 0 7 0 7 7

0 0 0 7 1 1 4 0 0 0 1 1 1 1

0 0 0 7 2 0 1

0 0 0 7 3 6 2

...

0 0 1 0 0 7 3

0 0 1 0 1 1 0 0 0 1 0 1 1 0 0 0 1 0 1 1 0

0 0 1 0 2 0 5

0 0 1 0 3 6 6

...

An alternant code, in general, is not a cyclic code. It is easy to see that an alternant code is a linear code and that the minimum distance is at least as large as the minimum distance of the underlying Reed–Solomon code, though it may be larger.

The way that this construction extracts a binary code from a Reed–Solomon code over GF(2^m) is illustrated in Table2.5. This small example is based on the(7, 5, 3) Reed–Solomon code over GF(8), which expressed in octal notation with template g= (5, 6, 1, 4, 1, 1, 7). Each component giof g is a nonzero element of GF(8), which is expressed in octal notation. Of course, one cannot hope to find a binary code better than the(7, 4, 3) Hamming code, so the alternant code constructed in Figure2.5cannot contain more than sixteen codewords. This example is too small to give an interesting code. For larger examples, however, it may be that codes better than BCH codes can be found in this way. Indeed, it can be proved that for large values of n and k, by choosing an appropriate template g, one will obtain an (n, k, d) alternant code whose dimension k is large – much larger than that of a BCH code of comparable n and d . Unfortunately, no constructive procedure for choosing the template g is known.

For a more complete example, letCRSbe the extended(8, 6, 3) Reed–Solomon code with defining set{6, 0}. Choosing the template g = (1 1 α⁵α³α⁵α⁶α⁶α³) gives the alternant code with check matrix given by

H =

The first column corresponds to the symbol appended to give the extended code.

Replacing each element of GF(8) by its three-bit representation yields

H =

The six rows of H are linearly independent, and hence this check matrix specifies an(8, 2, 5) alternant code. It is easy to verify that a generator matrix for this code is given by

We shall see in Section2.13that this particular alternant code is actually a Goppa code.

To appreciate why one cannot hope to find the template g by unstructured search methods for large codes, note that over GF(q^m) there are (q^m − 1)ⁿ templates with nonzero coefficients, and each of these templates produces a generalized Reed–

Solomon code with(q^m)^K codewords. To find a binary code of blocklength 255, one would have to search over 255²⁵⁵templates, approximately 10⁶⁰⁰, and each template would produce a generalized Reed–Solomon code over GF(256) with 256^Kcodewords, from which the binary codewords would be extracted to form the binary code. Many of the codes constructed in this way would be worthless, and others would be worthwhile.

We do not know how to find the templates that produce good binary codes – we will show only that they do exist. And, of course, even if a good template were known, it would not be practical, in general, simply to list all the codewords; there would be too many. One would need a practical encoding algorithm that would produce the appropriate codeword when it was needed.

Because of the way in which an alternant code is related to the Reed–Solomon code, it is apparent that the minimum distance is at least as large as the designed distance

95 2.12 Alternant codes

of the Reed–Solomon code. The following theorem says, further, that the dimension satisfies k≥ n − (d − 1)m.

Theorem 2.12.1 Let CGRS be an (n, K, D) generalized Reed–Solomon code over GF(q^m), and letCAbe an(n, k, d) subfield-subcode ofCGRSover GF(q). Then D ≤ d and n− (d − 1)m ≤ k ≤ K.

Proof: The inequality D ≤ d is apparent. This inequality leads immediately to the inequality D+ K ≤ d + K, whereas the inequality d + k ≤ D + K holds because the Reed–Solomon code satisfies the Singleton bound with equality and the subfield-subcode need not. Together these two inequalities lead to the inequality k≤ K.

The only inequality still requiring proof is n−(d −1)m ≤ k. The generalized Reed–

Solomon code is a linear code determined by n− K check equations over GF(q^m).

Each check equation is a linear combination of elements of GF(q) with coefficients in GF(q^m). Each such linear combination can be viewed as m check equations with coefficients in GF(q) that the subfield-subcode must satisfy. These m(n − K) check equations over GF(q) need not be linearly independent. The inequality (n − k) ≤ m(n − K) follows. To complete the proof, set n − K for the Reed–Solomon code equal

to D− 1, so n ≤ k + m(D − 1) ≤ k + m(d − 1).

Because a BCH code is actually a special case of an alternant code in which the template is all ones, the theorem holds for the class of BCH codes. With reference to Theorem2.12.1, one wishes to choose the template of an alternant code such that the inequality bound n− (d − 1)m ≤ k is satisfied as loosely as possible, and, more to the point, that the code is better than the corresponding BCH code. This may occur either because d ≥ D or because k ≥ n − (D − 1)m, or both.

For example, letCRSbe a primitive cyclic Reed–Solomon code over GF(2^m), with defining set{0, 1}. If the template is all ones, then, because C0= 0, all codewords of the binary alternant code have even weight, and, because C₁ = 0, all codewords of that code are binary Hamming codewords. Thus d_min= 4 and k = n − (m + 1). If, instead, the template is g_i = αⁱ for i = 0, . . . , n − 1, then the generalized Reed–Solomon code is actually a Reed–Solomon code with defining set {1, 2}. Hence the alternant code is a Hamming code with d_min = 3 and k = n − m. Both of these examples are actually BCH codes: one has a larger dimension and one has a larger minimum distance.

Alternant codes are attractive because, as we shall see, there are templates that give much better alternant codes than the BCH code. For blocklength n = 2^m− 1, there are nⁿtemplates. Some of these give good codes. In particular, there are sequences of alternant codes of increasing blocklength such that the rate k/n and relative minimum distance d_min/n both remain bounded away from zero as n goes to infinity. This is a consequence of the following theorem.

Theorem 2.12.2 For any prime power q and integer m, let n= q^m− 1, and let d and r be any integers that satisfy

d−1

j=1

n j



(q − 1)^j< (q^m− 1)^r.

Then there exists an alternant code over GF(q) of blocklength n, dimension k ≥ n−mr, and minimum distance d_min≥ d.

Proof: The method of proof is to fix an(n, k) Reed–Solomon code over GF(q^m) and an arbitrary vector v over GF(q) of weight j. Then count the number of templates for which v belongs to the alternant code formed by that template from the fixed Reed–

Solomon code. We conclude that there are not enough v of weight less than d to allow every template to produce at least one such v. Thus at least one of the templates gives an alternant code that has no v of weight less than d . This alternant code must have minimum distance at least as large as d .

Step (1) LetCRSbe a fixed Reed–Solomon code over GF(q^m) of blocklength n and dimension K = n − r. For each template g, letCA(g) be the alternant code over GF(q) generated fromCRSby g. Then

CA(g) = {c ∈ GF(q)ⁿ | g⁻¹c∈CRS},

and g⁻¹c denotes the vector{g_i⁻¹c_i | i = 0, . . . , n − 1}. Because gi = 0 for all i, there are(q^m−1)ⁿsuch templates that can be used with the Reed–Solomon codeCRSto form an alternant code, possibly not all of the alternant codes are different. Each alternant code is a subfield-subcode of the generalized Reed–Solomon code{c ∈ GF(q^m)ⁿ | g⁻¹c∈CRS}. The generalized Reed–Solomon code is linear and has r check equations over GF(q^m) that become at most mr check equations over GF(q). For each such code, it follows from Theorem2.12.1that

k≥ n − mr.

Step (2) Choose any vector v over GF(q) of nonzero weight j < d. This vector v may appear as a codeword in one or more of the alternant codes defined in Step (1).

There are_d−1

j=1

n j

(q − 1)^j such vectors of nonzero weight less than d .

Step (3) A vector v of weight j appears (q^m − 1)^n−r times in the collection of alternant codes defined in Step (1). This is because, as asserted by Theorem2.1.2, any n− r places in a Reed–Solomon codeword specify the codeword. If we fix v, there are exactly n− r places in g that can be independently specified such that g⁻¹v is inCRS.

97 2.12 Alternant codes

Step (4) The number of templates that give rise to an alternant code containing a codeword of weight less than d is not larger than the product of the num-ber of vectors of weight less than d and the numnum-ber of templates for which a given vector could be a codeword in the alternant code produced by that tem-plate. From Steps (2) and (3), this product is given by (q^m − 1)^n−r_d−1

j=1

n j

 (q − 1)^j. From Step (1), the number of templates is(q^m− 1)ⁿ. Suppose

(q^m− 1)ⁿ> (q^m− 1)^n−r

d−1

j=1

n j



(q − 1)^j.

Then some code of dimension at least n− mr does not contain any codeword of weight smaller than d , and so has minimum distance at least as large as d . This is equivalent

to the statement of the theorem.

Corollary 2.12.3 An(n, k) binary alternant code exists that satisfies

d−1

j=1

n j



< 2^n−k.

Proof: With q= 2, the theorem states that if

d−1

j=1

n j



< (2^m− 1)^r,

then there exists a binary alternant code with minimum distance at least as large as d and with k≥ n−mr, so such a code exists with k = n−mr. The corollary then follows

because 2^m− 1 < 2^m.

The class of alternant codes is very large because the number of templates over GF(q) of blocklength q^m−1 is (q^m−1)^qm−1. Theorem 2.12.12 and Corollary 2.12.13 only tell us that some of these templates give good alternant codes, but they do not indicate how to find them. In fact, little is known about how to find the good alternant codes.

The following corollary is a restatement of the previous corollary in a somewhat more convenient form, using the function

H₂(x) = −x log2x− (1 − x) log2(1 − x) 0 ≤ x ≤ 1, which is known as the (binary) entropy.

Corollary 2.12.4 (Varshamov–Gilbert bound) A binary code of rate R and relative minimum distance d/n exists for sufficiently large n, provided that

H₂

d n



< 1 − R.

Proof: The weak form of Stirling’s approximation is given by

n! = 2^{n log2n+o(1)},

where o(1) is a term that goes to zero as n goes to infinity. Using the weak form of Stirling’s approximation, we can form the following bound:

d−1

j=1

n j



>

 n

d− 1



= n!

(d − 1)!(n − d + 1)! = 2^{n[H2( p)+o(1)]},

where p= d/n and o^(1) is a term that goes to zero as n goes to infinity. The difference between p = d/n and (d − 1)/n is absorbed into o^(1). Therefore Corollary2.12.3 can be written 2^{n[H2( p)+o(1)]} < 2^n(1−R), where R= k/n. Under the statement of the corollary, the condition of Corollary2.12.3will be satisfied for sufficiently large n. The

corollary follows.

The Varshamov–Gilbert bound can also be proved for other classes of codes. At present, it is not known whether a class of binary codes exists that is asymptotically better than the Varshamov–Gilbert bound. The alternant codes form a very large class, however, and without some constructive methods for isolating the good codes, the performance statement of Corollary2.12.4is only an unfulfilled promise.

Because an alternant code is closely related to a Reed–Solomon code, any procedure for decoding the Reed–Solomon code can be used to decode the alternant code out to the designed distance. The only change that is needed is a new initial step to modify the senseword, using the inverse of the template to reconstruct a noisy Reed–Solomon codeword. This observation, however, misses the point. The appeal of an alternant code is that its minimum distance can be much larger than its designed distance. A binary alternant code used with a Reed–Solomon decoder has little advantage over a binary BCH code used with that decoder. The only advantage is that, although the Reed–

Solomon decoder can only correct to the designed distance, it can detect error patterns up to the minimum distance. This might be a minor reason to use an alternant code in preference to a BCH code, but it does not fulfil the real purpose of a code.

Finally, we remark that, though we do not have decoders for alternant codes that decode to their minimum distances, this lack remains of little importance because we cannot even find the good codes.

99 2.13 Goppa codes

In document Concesionarios y talleres autorizados Chevrolet® por su colaboración y ayuda para el análisis y conocimiento de la operación y gestión de los talleres de servicio (página 92-97)