Justesen codes alternant codes goppa codes

Justessan Codes Alternant Codes Goppa codes

Justesen Codes

Mapping codes converts (N,K) linear code over GF(qm) into

(mN,mK) linear code over GF(q) by ‘tilting’ each qm-ary

symbol into m q-ary symbols.

d* nonzero symbols of min wt. codeword tilts to md*

symbols, not all symbols zero.

Code rate remains unchanged but minimum distance is

much smaller fraction of block length.

Justesen modified the construction to give a good code for

long block lengths.

Advantage: Creates a simple form of multiple burst-error

correcting codes.

Gives infinite family of good binary codes.

Justesen Codes - Construction

Construction starts with all the codewords of a single fixed

(N,K) Reed-Solomon code that has the same number of

codewords as desired Justesen code.

Let α be the primitive element of GF(qm).

Starting with codeword C = (c0, c1, … cN-1) from Reed-

Solomon code, first form the 2 by N array of GF(qm)-ary

symbols. (ci Є GF(qm) )

c0 c1 c2 … cN-1

α0c0 α1c1 α2c2 … αN-1cN-1

C’ = (c0,α0c0 ; c1,α1c1 ; c2,α2c2 ; … cN-1,αN-1cN-1)

Replace each element by binary m-tuple symbols we obtain

binary vector of length 2mN.

This gives one code word of the Jestesen Code.

Code rate R = K/2N, half of RS code.

Justesen Codes

Justesen code is the concatenation code of an RS code and

linear binary codes.

A natural decoding algorithm for Justesen code would be

one that reverses the process of concatenation.

Algorithm:

Decode each set of m bits to yi over GF(qm).

Ties are broken arbitrarily to give two set.

Decode y = (y0, . . . , yn−1) using any decoding algorithms for

RS code.

The decoding algorithm can be used to correct all errors up

to less than dD/4 in number.

Justesen Codes

Theorem: The minimum distance of the (2mN, mK)

Justesen code constructed from an (N,K) RS code is

bounded by --

Justesen Codes

Proof:

The minimum weight RS codeword has N-K+1 distinct non-

zero symbols.

These will make N-K+1 nonzero pairs (ci,αici ) which appear

as distinct 2m-tuples.

The weight is atleast as large as word constructed by filling

N-K+1 2m-tuples by N-K+1 distinct 2m-tuples of smallest

weight.

In an m-tuple, there are (2im) ways of picking i non-zero

places and (q-1) different non-zero values at each place.

Hence there is a weight I for every I that satisfies (2).

The minimum distance is at-least as large as the sum of the

weights of these pairs. Hence (1).

Justesen Codes

Disadvantage: Not very attractive for random error

correction.

Good only for long block-lengths.

Hence did not get popular.

Hence they do not have well developed collection of

decoding algorithms.

Alternant Codes- Limitations of BCH codes:

A BCH code over GF(q) of block length n = qm-1 is a subfield-subcode of a Reed-Solomon code over GF(qm).

subfield-subcode has same length as original but fewer codes.

BCH code consists of all those Reed-Solomon codes that are GF(q)-valued.

BCH codes with large block length and large minimum distance contain fewer codes.

But in BCH code, with increasing block length and fixed rate R’ (k/n≥R’),normalized minimum distance d*/n approaches zero.

Hence, the BCH code uses very few of many code words of RS code or else has poor distance structure.

Alternant codes, a variation of BCH code, increases minimum distance by reducing RS code to a subfield by new way.

Alternant Codes

Alternant codes are linear codes that are a variation of BCH

codes defined such that in spite of fixed rate, large minimum

distance can be obtained.

Let n = qm-1,

A fixed n-vector h of nonzero components over GF(qm)

called (time-domain) template, is chosen.

Reed-Solomon code over GF(qm) with designed distance

2t+1 is chosen.

If Alternant code is GF(q)-valued vectors C and C’ is codeword in RS code then-

c’i = ci hi for i= 0,1,…n-1 . (component-wise in Time domain)

hi is always nonzero.

So, let gi = hi-1.

ci = gic’I for i= 0,1,…n-1 .

Alternant Codes

Minimum distance very large if template chosen properly.

Can be defined in frequency domain also.

Let h ≠ 0 and H is its frequency domain template. Cyclic convolution H*C gives Reed-Solomon spectrum.

∑n-1

k=0 H((j-k)) Ck = 0 j = j0, … j0+ 2t-1.

If G is transform of vector gi ( =hi-1), H*G is a delta function.

(If j=0, (H*G)j =1; otherwise (H*G)j =0.)

As polynomial this convolution becomes

H(x)G(x) = 1 (mod xn-1).

H(x) is a polynomial over GF(q), it has no roots in GF(qm).

Hence H(x) is prime to xn-1.

H(x)G(x) + (xn-1) F(x) =1

Hence H(x)G(x) = 1 (mod xn-1).

Alternant Codes

The alternant code C(α, h ) consists of all codewords of

GRSk0which have components from GF(q).

C(α,h) consists of all vectors C over GF(q) such that CHT=0,

where H is given by H = Vr(α1 …αn) .diag(h1 …hn)

1 … 1 h1 0 . 0

α1 … α

n 0 h

2 . 0

H= α1

2 . αn

2 . 0 . 0

. . . . . . .

(α1)r-1 … (α

n)r-1 0 0 . h

n

h1 … h

n

h1α

1 … h

nα

n

H= . . .

. . .

h1(α

1)r-1 … h

n(α

n)r-1

Alternant Codes - example

Decoding by any method used for BCH or RS codes.

GF(8)

BCH Code Reed-Solomon Code (7, 5, 3) Alternant code

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

0000000 0000000 0000000

0000163

0000276

0000315

0001011 0001011

0001172

0001304

0007077 0001011

0007114 0001111

0007217

0010073

0010110 0010110 0010110

Goppa Codes

Goppa code is the generalization of the class of BCH code.

BCH code can also be described alternately as –

Let a(x) and G(x) be two polynomials over same field with

no common factors.

By Euclid”s algorithm, a polynomial u(x) exists such that –

a(x) u(x) Ξ 1 mod G(x)

One option u(x) can be a-1(x) -- can be found under

modG(x).

THEOREM:- The q-ary narrow sense BCH code of length n

with designed distance d is equivalent to code

{ c єVn(q) ׀∑i=0

n-1

ci / (x – αi’ ) Ξ 0 (mod xd -1)}

-where α є GF(qm).

PROOF--

Goppa Codes

PROOF—

C will be a code of BCH if S1+ S2+ S3… S2t= 0

∑j=1

d-1 Sj= 0 (2t = d-1)

Hence S(x) =0 where S(x) = ∑j=1

d-1 Sjx

j-1 with Sj= c(αj )

S(x) Ξ ∑j=1

d-1 ∑i=0

n-1 ci αij x

j-1 αi +α2i +α3i +…α(d-1)i

Ξ ∑i=0

n-1 ci ∑j=1

d-1 αij x

j-1 Take αi out and expand the rest.

Ξ ∑i=0

n-1 ci αi[1+αi x+α2i x

2+… +α(d-1)i xd-1] GP

Ξ ∑i=0

n-1 ci αi[1- α(d-1)i x

d-1]/ [1-αi x] mod(x

d-1)

Goppa Codes

Ξ ∑i=0

n-1 ci αi [1- α(d-1)i x

d-1]/ [1-αi x] mod(x

d-1)

Ξ ∑i=0

n-1 ci αi [1]/ [1-αi x] mod(x

d-1) 2nd term remainder is 0.

Ξ ∑i=0

n-1 ci / [α-i - x] mod(x

d-1)

Ξ - ∑i=0

n-1 ci / [x-α-i] mod(x

d-1)

Replacing α by 1/α will not alter the summation.

Hence proved for BCH code.

Goppa Codes

Goppa code of designed distance d is an alternant code of

designed distance d, with additional property that—

The inverse frequency template G has width d.

Inverse frequency template, called Goppa polynomial can

be described as G(x) with degree d-1.

A narrow sense Goppa code is a Goppa code with 2t parity

frequencies at locations α0, …..αn-2t+2, αn-2t+1

THEOREM:- Let L = {α0 , α1 , …, αn-1} be a subset of GF(qm)

of size n,and let G(x) be a polynomial of degree s over

GF(qm) but has no root from L then—Goppa code is given

by

Ғ(L,G) = { c єVn(q) ׀∑i=0

n-1 ci / (x – αi ) Ξ 0 (mod G(x))}

Taking G(x) = xd-1

–

Goppa codes contain BCH code as subclass.

Goppa Codes

THEOREM:- The narrow sense Goppa code over GF(q)

with block length n = qm -1 and with Goppa polynomial G(x)

is given by the set of all vectors c = (c0, …cn-1) over GF(q)

satisfying

∑i=0

n-1 ci’ Π (x – α-i) = 0 (mod G(x)) excluding self i≠i’

Goppa Codes -Example

Smallest example is (8, 2, 5) binary Goppa code.

G(x) = x2 + x + 1.

Roots(zeros) of G(x) are in GF(4) or in any extension of

GF(4).

Hence none are in GF(8).

Hence G(x) can be used to obtain a Goppa code with

blocklength 8, minimum distance of 5 and 2 information

symbols.

Goppa Codes -Example

Example: Let α be the primitive element in GF(24) satisfying

α4 + α3 + 1=0. Consider the binary Goppa code Ғ(L,G) of

length 12 with G(x)=(x+ α)(x+ α14) and L={αi 2 ׀ ≤ i ≤ 13}.

Find parity check matrix H.

G(x)=(x+ α)(x+ α14)= x2 + α8x + 1

α and α14 are used to generate G(x), while rest of 12

elements are member of L.

∑i=0

n-1 ci / (x – αi ) Ξ 0 (mod G(x))} for ci to be code.

Product of C and H should be zero for correct code ,

otherwise would give syndrome.

Hence H becomes inverse of (x – αi ). {αi 2 ׀ ≤ i ≤ 13}.

e.g. Lets find inverse of (x – α2 ) modulo G(x).

Let inverse of (x – α2 ) modulo G(x) is ax+b.

(x – α2 )(ax+b) Ξ 1 (mod G(x))

Goppa Codes -Example

(x – α2 )(ax+b) = ax2 + (b + aα2)x + bα2

G(x)=x2 + α8x + 1=0

x2 = α8x + 1

= a (α8x + 1) + (b + aα2)x + bα2

= (aα10 + b)x + a + bα2 Ξ 1 (mod G(x))

Hence ---- (aα10 + b) =0 and a + bα2 = 1

Solving above a= α14 and b= α9

Inverse ax+b = α14 x+ α9

Similarly 11 other inverses can be found.

H= α9 α α8 α13 α7 α5 0 α9 α α6 α5 α6

α14 α3 α α4 α7 α1 α14 α4 α14 α9 α9 α3

Goppa Codes -Example

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

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

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

H= 0 0 1 0 0 1 0 0 0 1 1 1

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

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

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

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

H= α9 α α8 α13 α7 α5 0 α9 α α6 α5 α6

α14 α3 α α4 α7 α1 α14 α4 α14 α9 α9 α3

H has rank 8 and Goppa code of { , , ≥ )

Goppa Codes-- Decoding

THEOREM:- Let σ(x) and ω(x) be the error locator and error

evaluator polynomials of an error pattern of weight at most

[s/2] where s is degree of polynomial G(x) of Goppa code. (

s= n-k =d+1. i.e. s/2=t)

Then σ(x) = λ vi(x) and ω(x) = λ si(x)

where si(x) and vi(x) are obtained from Euclid’s Algorithm applied to G(x) and S(x) (to find hcf or gcd λ) until

deg(si(x))<[s/2] for the first time and where λ is chosen such

that λ vi(x) is monic.

(Proof omitted. Ref:

hyperelliptic.org/tanja/teaching/CCI11/CODING.pdf.)

Roots of σ(x) and ω(x) together will give error location and

magnitude.