The Fourier Convolution Theorem over Finite Fields: Extensions of Its Application to Error Control Coding

Linear spectral transform techniques such as the discrete Fourier transform and wavelet analysis over real and complex fields have been routinely applied in the literature (Burrus et al. (1998); Strang & Nuygen (1996)). Furthermore, extensions of these techniques over finite fields (Blahut & Burrus (1991); Caire et al. (1993)) have led to applications in the areas of information theory and error control coding (Blahut (2003); Dodd (2003); Sakk (2002); Wicker (1994)). The goal of this chapter is to review the Galois Field Fourier Transform, the associated convolution theorem and its application in the field of error control coding. In doing so, an interesting connection will be established relating the convolution theorem over finite fields to error control codes designed using finite geometries (Blahut (2003); Lin & Costello (1983); Wicker (1994)).


Introduction
Linear spectral transform techniques such as the discrete Fourier transform and wavelet analysis over real and complex fields have been routinely applied in the literature (Burrus et al. (1998); Strang & Nuygen (1996)).Furthermore, extensions of these techniques over finite fields (Blahut & Burrus (1991); Caire et al. (1993)) have led to applications in the areas of information theory and error control coding (Blahut (2003); Dodd (2003); Sakk (2002); Wicker (1994)).The goal of this chapter is to review the Galois Field Fourier Transform, the associated convolution theorem and its application in the field of error control coding.In doing so, an interesting connection will be established relating the convolution theorem over finite fields to error control codes designed using finite geometries (Blahut (2003); Lin & Costello (1983); Wicker (1994)).
While a complete exposition of the field of error control would be out of context for this chapter, we refer the interested reader to the recent characterizations of Low-Density Parity Check (LDPC) codes (Pusane et al. (2011); Smarandache et al. (2009); Xia & Fu (2008)).Such formulations have led to a resurgence of interest in the design (Kou et al. (2001); O. Vontobel et al. (2005); Tang et al. (2005); Vandendriesscher (2010)) and decoding (Kou et al. (2001); Li et al. (2010); Liu & Pados (2005); Ngatched et al. (2009); Tang et al. (2005); Zhang et al. (2010)) of finite geometry codes.The formulation in this chapter is meant to serve as a guiding principle relating finite geometric properties to algebraic ones.The vehicle we have chosen to demonstrate these relationships is an example from the field of error control.In particular, we show how a generalized Fourier-like convolution theorem can be applied as a decoding methodology for finite geometry codes.
We begin in Section 2 by reviewing the Galois Field Fourier Transform (GFFT) followed by an overview of error control coding in Section 3. In addition, in Section 3.1 it is demonstrated how the GFFT can be applied within the context of error control coding.Section 4 then goes on to generalize these results to linear transformations using Pascal's triangle as an example.The combinatorics of such a transformation naturally lead to the design of codes derivable from

The Galois Field Fourier Transform
We are particulary interested in the case of finite fields where p is a prime number and α ∈ GF(p m ) is an element of order n.The Galois Field Fourier Transform (GFFT) and its inverse of a vector v = {v 0 , v 1 , ..., v n−1 } over GF(p) of length n can be related via the equations: For any vector f over GF(p) where the above equations hold true, we define as the GFFT of v and as the inverse GFFT of F.
Using this formulation, given two vectors over GF(p) and their associated transforms the familiar convolution theorem can be demonstrated to hold true for the finite field case.Specifically, computing

Error control coding
Given a message encoded as a vector µ of length k over GF(p), the goal of error control coding (ECC) is to transform the message vector into a code vector C of length n > k in a way that causes C to be robust to errors arising over a communication channel (such as a wireless link, fiber optic cable, etc).Rather than the message vector µ, it is the code vector C that is transmitted over a channel where the receiver is only able to observe a received vector Ĉ.Ideally, in the absence of any noise, it should be the case that Ĉ = C. On the other hand, if noise is present on the channel, the method used to transform (i.e.'encode') the message µ into the code vector C provides a way to recover µ from Ĉ.The basic strategy behind ECC is, given a message, a. Embed a k dimensional message vector µ in a larger vector space of dimension n to create the code vector C.
b.The addition of channel noise converts C into the received vector Ĉ.
c.If the channel noise does not cause Ĉ to be confused with other possible encodings, the original code vector C can be recovered using some predetermined decoding scheme.Conceptually speaking, the Ĉ that lies within a predefined noise 'sphere' with respect to the original C will be decoded as the (ideally) unique C; hence, µ can be recovered as well.
The size of the noise sphere (which is designed as part of the code) determines how many errors can be corrected.
The general idea behind ECC then is to find a C that minimizes ||C − Ĉ|| ; however, numerically determining the minimum distance solution is wrought with dimensionality issues that can lead to computational intractability.Hence, classes of codes have been devised that relate the message encoding method to the decoding algorithm.Such algorithms are often iterative (Blahut (2003); Lin & Costello (1983); Wicker & Kim (2003)) and converge upon the optimal solution by exploiting the mathematical structure designed into the code.
Two important quantities in the field of ECC are the Hamming weight and the Hamming distance.Consider two vectors v and w of length n over GF(p).
Definition 3.1.The Hamming weight w H (v) of a vector v is defined as the number of non-zero components in v.
Definition 3.2.The Hamming distance between v and w is defined as the number of components that differ between v and w.
An important quantity for defining the noise sphere is referred to as d min which is the minimum Hamming distance between all code vectors defined in the code class.To correct up to t errors in any code vector, it turns out that d min = 2t + 1.Furthermore, when the ECC is a linear code, a major simplification arises where d min is simply the minimum Hamming weight computed over all non-zero code vectors in the code class.

Application of the GFFT to Reed-Solomon codes
The GFFT and the convolution theorem have been applied in the field of error control coding for the construction of a class of linear codes known as Reed-Solomon codes (Blahut (2003); Wicker (1994)).The algorithm for encoding a message vector µ over GF(p m ) of length k is

233
The Fourier Convolution Theorem over Finite Fields: Extensions of Its Application to Error Control Coding www.intechopen.comquite straightforward.To be able to correct up to t errors, create a vector of length n by appending µ with 2t consecutive zeros.The code vector C is then derived by computing the inverse GFFT of the appended construction.One approach to proving that this construction is capable of correcting up to t errors involves applying the GFFT convolution theorem.Specifically, given a code vector C,alocator vector Λ must be defined such that C j Λ j = 0 for all j = 0, ••• , n. Letting c and λ denote the GFFT of C and Λ, the convolution theorem implies c * λ = 0. Based upon the convolution approach, the conclusion can be reached that the inverse GFFT construction leads to Reed-Solomon codes capable of correcting up to t errors in the code vector (Blahut (2003); Wicker (1994)).
The key feature of the GFFT approach to constructing Reed-Solomon codes described above is that restrictions are placed on the position and the number of zeros appended to the message vector.To summarize: i. Addition of zeros to the message vector µ of length k is performed at prescribed locations.
ii.The resulting vector is then inverse transformed in order to compute the code vector C.
iii.The error correcting properties of this code can be demonstrated by applying the convolution theorem.
In this work, one our of goals is to demonstrate that, given other linear transformations inducing a convolution theorem, the above steps can be generalized to other classes of codes.As we shall see, the key is to define the transform and the structure of how zeros are introduced into the message vector.

The Pascal matrix over finite fields
Let us now focus our attention on the case of GF(p) where p is prime.Our starting point will be: Definition 4.1.Let p be a prime number, then the ij th entry of a p m × p m m th order Pascal matrix P p m over GF (p) is defined as for i, j = 0, 1, ..., p m − 1 and, by convention, if i > j, then p ij = 0.
In other words, P p m is an upper triangular matrix whose non-zero entries are the elements of Pascal's triangle taken mod p.For the purposes of this work, it is useful to observe that P p m also has a Kronecker product description (Sakk & Wicker (2003)): where P p isa1 st order Pascal matrix.

The inverse of the Pascal matrix
As Section 5 will require understanding Q p m ≡ P −1 p m , we introduce the following.Observation 4.4.Let p be prime and let Q p be the p × p matrix defined by This result easily follows from the integer case (Call & Velleman (1993); Heller (1963)).Furthermore, it has been demonstrated that (Sakk (2002)): Observation 4.5.If p is prime and P p is a 1 st order Pascal matrix over GF(p), then where I p = p × p identity matrix.
Hence, it easily follows that Corollary 4.6.If p is prime and P p is a Pascal matrix over GF(p), then

235
The Fourier Convolution Theorem over Finite Fields: Extensions of Its Application to Error Control Coding www.intechopen.com Example 4.7.A Pascal matrix over GF( 5) and its inverse: Based upon Equation ( 8), it should be clear that Finally, based upon Equation ( 10), it also follows that, for the m th order case, where I p m = p m × p m identity matrix.In a manner similar to the m = 1 case, this characterization provides a path to computing the m th order inverse

Error control codes designed from Pascal matrices
In a manner similar to the GFFT approach to Reed-Solomon codes summarized in Section 3.1, it has been pointed out that P p m can also be used to transform message vectors with the appropriate coordinates set equal to zero (Sakk & Wicker (2003)).More precisely, we have the following: Definition 4.8.Consider an m th order Pascal matrix over GF(p) and let r be an integer such that 0 ≤ r ≤ m(p − 1).Also, consider the p-ary expansion of an index Error control codes derived from the m th order Pascal matrix over GF(2) (i.e.binary data) have been related (Forney (1988); Massey et al. (1973)) to a class of codes known as r th order binary Reed-Muller codes RM(r, m) of length 2 m (MacWilliams & Sloane (1977); Wicker (1994)).In addition, it has been further demonstrated (Sakk (2002)) that P 2 (r, m) codes over GF( 2) are equivalent to RM(r, m) codes with minimum distance d min = 2 m−r .These observations have been extended where it has been demonstrated that P p (r, m) codes over GF(p) are equivalent to generalized Reed-Muller codes (GRM) codes (Sakk (2002)).
To place this class of codes in the same context as that outlined in Section 3.1, we must show how to introduce zeros into the message vector, apply the Pascal matrix as the linear transformation and, based upon this transformation, introduce a convolution theorem.From the definition above, a given code is specified by choosing p, m and a value of 0 ≤ r ≤ m(p − 1).The code vector length then becomes n = p m ; and, for this class of codes, a given value of r defines the length k of the message.The rest of the n − k components of µ must be set to zero in a systematic way that leads to the minimum distance property of the code.
Example 4.9.Consider P 2 3 in Example 4.2 (hence, n = 2 3 = 8) and a message vector µ = (µ 0 , µ 1 , ..., µ 7 ) and let s be the number of consecutive zeros in the vector µ for a given value of r: r = 0 (d min = 8) : s = 7 µ =(µ 0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 Example 4.10.Consider P 3 2 in Example 4.3 (hence, n = 3 2 = 9) and a message vector µ = (µ 0 , µ 1 , ..., µ 8 ) and let s be the number of consecutive zeros in the vector µ for a given value of r: r = 0 (d min = 9) : s = 8 µ =(µ 0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 In the above examples, d min is shown in parentheses for each value of r; furthermore, observe that d min = s + 1. Recalling for a moment the GFFT approach to Reed-Solomon code design, the minimum distance of a code where the message vector has n − k consecutive zeros can be shown to be d min = n − k + 1 (Blahut (2003); Wicker (1994)).It is apparent that, by using a Pascal matrix as the transform, a result similar to that of the GFFT can be ascertained.The major difference is that, for Reed-Solomon codes, the string of zeros must occur at the end of the message vector before applying the GFFT to create C. For P(r, m), in addition to the string of consecutive zeros, based upon the structure of P p m , zeros must also be dispersed in other positions within µ to form code vectors C = µP p m .

237
The Fourier Convolution Theorem over Finite Fields: Extensions of Its Application to Error Control Coding www.intechopen.com

Extensions of the Fourier convolution theorem over finite fields
The convolution operation involves relating the componentwise product of two vectors in one domain to the convolution of their transforms (Blahut & Burrus (1991)).Many linear transforms have well-defined convolution operations.For instance, the Hadamard transform yields the so-called logical or 'dyadic' convolution operation (Ahmed et al. (1973); Dodd (2003); Robinson (1972)).In this chapter, we develop extensions of the convolution theorem that can be used to reveal useful properties of other classes of codes.As an example, we demonstrate how the GFFT approach can be applied to describe generalized Reed-Muller codes (Blahut (2003)).
Notice that if we are dealing with familiar spectral transforms such as the Fourier or the Hadamard transform (where P denotes the forward transform and Q denotes the inverse transform), T i,k takes on a simple form.This is because the product q kj p ji in ∑ n−1 j=0 µ j q kj p ji reduces to a term that enables us to take the transform of µ as C f (i,k) = 1 n (∑ n−1 j=0 µ j p j, f (i,k) ).For the case of the Fourier transform f (i, k)=i − k and T i,k = C (i−k) ; as expected, one ends up with the convolution theorem (Blahut (2003); Wicker (1994)).In the case of a Hadamard transform, f (i, k)=i ⊕ k (where ⊕ denotes bit-by-bit addition of the binary expansions of i and k) and T i,k = C (i⊕k) .Here, the bit-by-bit addition ⊕ of the binary expansions of i and k over GF(2) would result in the dyadic convolution (Ahmed et al. (1973); Robinson (1972)).
For the codes in this presentation, the q kj p ji term in the above summation leads to a convolution theorem that depends on the matrix P p m .Furthermore, this theorem can also be applied to demonstrate how to decode C to recover the message vector µ.In Equation ( 17) 238 Fourier Transform Applications www.intechopen.comq kj =(−1) j−k ( j k ) mod p and p ji = ( i j ) mod p; therefore, the product q kj p ji will not lead to an expression that readily reduces the inner summation to a single term.To see why, let's write out T i,k as follows: where T denotes the matrix transpose.
Observation 5.1.The components of the vector T i =( T i,0 T i,1 ... T i,n−1 ) can be written as a linear combination of the components of C =(C 0 ... C n−1 ).

Proof: Let
where D i is defined in Equation ( 18) and Then, Combining this result with Equation ( 17) we conclude So, instead of T i,k reducing to one single component of the vector C (as one might expect from a typical convolution operation), the Pascal convolution requires a linear combination of the components of C.Although this operation is slightly more complicated than the Fourier approach, the identity in Equation ( 8) does induce a simplification.

239
The Fourier Convolution Theorem over Finite Fields: Extensions of Its Application to Error Control Coding www.intechopen.comusing Equation ( 18) let Di ≡ D i and let Âi ≡ Q p Mi .Then, for any 0 ≤ j ≤ p m − 1 where j = j 0 p 0 + j 1 p 1 + ...
where M j ≡ D j Q T p m .
Finally, we arrive at the desired conclusion

240
Fourier Transform Applications www.intechopen.comObservation 5.2 tells us that, in order to calculate T j = CA j for arbitrary n = p m , one need only calculate Âi for i = 0, ..., p − 1 and then take successive Kronecker products.The initial set of Âi for i = 0, ..., p − 1 can easily be calculated by referring back to Equation (20) where An interesting property concerning the A i is that the sum (where the sum is taken mod p) is a matrix of ones.This follows from two observations.First, from the definition of D i in Equation ( 18), ∑ entry is one and all other entries are zero.Second, it can also be demonstrated that the last column of Q p m must be a column of ones.Therefore, Q p ∑ i=0 A i is a matrix of ones.Example 5.3.For p = 2, the 1st order case n = p gives i = 0, 1; hence, over GF( 2 From Observation 5.2, to obtain the A j for n = p 2 and j = 0, 1, 2, 3, one need only take successive Kronecker products as: As expected, the A i are symmetric matrices.Also, notice, as mentioned above, that ∑ p m −1 i=0 A i is a matrix of ones.For the case where n = p 2 , let us now apply Observation 5.1 to calculate the Pascal convolution of the vectors C =(C 0 , C 1 , C 2 , C 3 ) and Λ =(Λ 0 , Λ 1 , Λ 2 , Λ 3 ).Using Equation ( 22), we have: To close this section, we draw some immediate conclusions from Equation (25): • Because of the Kronecker product, a good deal of self-similar structure can be observed in the resulting vector Γ.For instance, the coefficients of the Λ i can be computed by iteration starting with the initial 'seed' generated by Â0 and Â1 .As an example, the coefficient of Λ 1 in Γ 1 can be computed by adding the coefficient of Λ 0 in Γ 0 to the coefficient of Λ 0 in Γ 1 .The coefficients of Λ 2 and Λ 3 in Γ 2 and Γ 3 can be computed by adding the coefficients of Λ 0 and Λ 1 in Γ 0 and Γ 1 to the coefficients of Λ 0 and Λ 1 in Γ 2 and Γ 3 , and so on.
• Looking at the result columnwise, the set of coefficients associated with a given Λ i appear to be the checksums for an R(r,2) binary Reed-Muller code ((MacWilliams & Sloane, 1977, p.385-388), (Wicker, 1994, p.155-165)).As pointed out in the next section, although this observation is true for the binary case, an orthogonal set of checksums for p > 2willnot come about by this method.It is the dual of the Pascal convolution that will lead to the decoding of GRM codes.

Majority logic decoding using Pascal convolution
GRM codes fall into a larger category of codes known as Euclidean geometry codes (Blahut (2003); Lin & Costello (1983); MacWilliams & Sloane (1977); Wicker (1994)) where it is well-known that a technique known as 'majority logic decoding' (MLD) can be used to recover the message vector.Based upon statements made in Section 4, it should be clear that Pascal codes are also MLD.However, the role played by the Pascal convolution in the decoding strategy is worthy of mention.As pointed out in the conclusions of Example 5.3, the checksums of a majority logic decoding (MLD) scheme for GRM codes can be derived using the dual of the convolution relation derived above.We now demonstrate this observation more clearly.
Because of the similar forms of P p m and Q p m the dual convolution relation is easily derived from the inverse transform.Consider the componentwise product Γ j = C j Λ j of two vectors where C = µP p m and Λ = λP p m : where n = p m .Similar to Equation ( 18), one can also show that which can also be written as where ∆ i is a diagonal matrix with elements (q 0i q 1i ... q (n−1)i ) along its diagonal.Furthermore, if we define then results similar to Observations 5.1 and 5.2 can also be demonstrated.However, in proving the dual of Observation 5.2 there is one difference be aware of.Since q ji =(−1) i−j ( i j ), the Kronecker product in the dual of Equation ( 24) will contain extra factors of (−1) i−j .T o achieve the equality ∆ j = ∆j m−1 ⊗ ... ⊗ ∆j 1 ⊗ ∆j 0 where j = j 0 p 0 + j 1 p 1 + ... + j m−1 p m−1 the following identity will be required: for any 0 ≤ k ≤ p m − 1 where we have applied a p = a for any a ∈ GF(p).Then, following the proof of Observation 5.2, it is straightforward to show that for any 0 ≤ j ≤ p m − 1 where j = j 0 p 0 + j 1 p 1 + ...
where Bj k = P p ∆j k P T p .

243
The Fourier Convolution Theorem over Finite Fields: Extensions of Its Application to Error Control Coding www.intechopen.com where the binary expansion of the γ index has been explicitly written out at the beginning of each row.Next, consider Equations ( 26) and ( 28) to calculate the same convolution: .
Since, for P 2 (1, 2), µ =(µ 0 , µ 1 , µ 2 ,0 ), this set of equations can be simplified as 00 : Equations ( 31) and ( 32) must hold for any vector λ.Therefore, for a specific γ j , we can equate the coefficients of the λ i in Equation ( 31) with those in Equation ( 32).So, for example, we end with the result that For this first order r = 1 code, we can generate a set of checksums using a simple algorithm.
Start at an index i of γ such that w 2 (i)=1 and equate Equations ( 31) and (32) along a diagonal path in order to 'collect' all checksum equations associated associated with µ i .For example, the bold symbols in Equation (32) generate the checksums for µ 1 .It turns out that these diagonal equations actually generate what are known as the 'incidence vectors' of the MLD strategy (Blahut (2003); MacWilliams & Sloane (1977); Wicker (1994)).
We now provide an algorithm for GF(p) to show how the Pascal convolution approach is equivalent to a typical MLD using finite Euclidean geometry ( (Wicker, 1994, p.155-165)).
The interesting aspect of this algorithm is that the Pascal convolution generates the correct checksums for any GF(p).Consider a P p (r, m) code where C = µP p m such that µ j = 0i f w p (j) > r: (0) Let j = r.
(1) Let S j be the set of indices i such that w p (i)=j.
(3) Apply Equation (28) to calculate γ (these equations will simplify based upon which of the µ i are zero).
(4) For each i ∈ S j , start at λ 0 associated with γ i and construct checksum equations by equating the result in Step (2) with that of Step (3) along a diagonal path (i.e.-starting at k=0, choose the coefficient of λ k associated with γ i+k ).
(5) For i ∈ S j , create estimates μi by a majority logic decision on the checksums.
(7) Remove the estimated components as: As with typical MLD schemes, this algorithm starts with the highest order r to obtain estimates of the code vector components and then successively estimates the lower order components.
(2,3,4) Rather than write out the equations for γ i , we summarize by equating the results of step ( 2 After estimating the message components dictated by S 2 (step ( 5)), remove the code estimates from C (step ( 7)) and begin work on S 1 where now (step( 8)) µ i = 0 if w p (i) > 1.For S 1 , we have the checksums: i = 1:

Conclusions
When considering the design of error control codes, it is interesting to look for guiding principles that can account for whole classes of codes.In this presentation, we have shown how the GFFT convolution approach to Reed-Solomon codes can be extended to other classes of codes such as generalized Reed-Muller codes.Instead of applying a Fourier matrix to encode the message, we have applied a Pascal matrix and extended the convolution theorem over finite fields.In doing so, we have observed that this formulation leads to the well-known majority logic decoding algorithm.Additional investigations have also considered codes in the context of the wavelet transform (Sakk & Wicker (2003)).The block codes addressed in this chapter have been shown to lend themselves to graph-based iterative decoding strategies (see Table 1).The results derived above suggest that the generalized convolution approach is useful for understanding the systematic introduction of redundancy for the sake of error control.

246
Fourier Transform Applications www.intechopen.com Theorem over Finite Fields: Extensions of Its Application to Error Control Coding www.intechopen.com

for an r th order Pascal code of length
p m , denoted by P p (r, m), is generated by C = µP p m (15)

Table 1 .
Comparison of Fourier and generalized convolution techniques.