Error control coding bch, reed-solomon etc..

ERROR CONTROL CODES BCH CODES, REED-SOLOMON CODES, LFSR, Nested codes, Justesen codes, Alternant codes, Goppa codes

Prerequisite– Galois Fields Basics

Refer to presentation on Basics of Galois Fields by this Author.

Revising Cyclic Codes using field elements (William Wesley Peterson)

Codeword polynomial c(x) of an (n,k) cyclic code is given

as c(x) = f(x) g(x) where

For nonsystematic code, f(x) is information polynomial d(x).

For systematic code, f(x) is quotient q(x) obtained by

dividing d(x)xn-k by g(x). c(x)/g(x) = data.

g(x) is a factor of c(x) .

Any root of g(x) is also a root of c(x).

If β is root of g(x) then,

g(β) = 0 and f(β) g(β) = 0

Example – For (7,4) cyclic code, g(x) = 1+x+x3.

Three roots of 1+x+x3 are α, α2, α4 belonging to GF(23).

Let c(x) = 1+x+x2+x5. (1110010)

Verify that c(α) = c(α2) = c(α4) = 0.

Revising Cyclic Codes using field elements

Example – For (15,11) cyclic code, g(x) = 1+x+x4. Find

roots in GF(24) and show that roots of g(x) are also roots of

c(x).

Solution : Four roots of 1+x+x4 are α, α2, α4 and α8

belonging to GF(24).

Let c(x) = 1+x+x2+x3+x4+x6

Verify from table that c(α) = c(α2) = c(α4) = c(α8) = 0.

Definitions

A block length n of the form n = qm -1 is called a Primitive

Block Length for a code over GF(q).

A cyclic code over GF(q) of primitive block length is called a

Primitive Cyclic Code.

Two elements of GF(qm) that share the same minimal

polynomial over GF(q) are called Conjugates (with respect

to GF(q)).

Generator Polynomial

Polynomials 1+x+x3 and 1+x+x4 serve two functions.

1. They are generator polynomials of cyclic codes.

2. As they are irreducible, they are used to construct finite

fields.

A generator polynomial need not be necessarily irreducible,

in which case it can not be used to construct finite fields

e.g. for (15,7) code,

g(x) = 1+x4 +x6+x7+x8 = (1+x+x4) (1+x +x2+x3+x4)

Generator Polynomial

α, α2, α4 form conjugate set in GF(23) with minimal

polynomial 1+x+x3

1+x+x3 can be specified by α, α2, α4 in GF(23) as

1+x+x3 = (x+ α)(x+ α2)(x+ α4)

α, α2, α4 and α8 form conjugate set in GF(24) with minimal

polynomial 1+x+x4

1+x+x4 can be specified by α, α2, α4 and α8 in GF(24) as

1+x+x4 = (x+ α)(x+ α2)(x+ α4)(x+ α8)

Constructing Generator Polynomial

To construct a generator polynomial g(x) from an arbitrary

set of r field elements β1,β2,β3,…βr.

Find polynomial of least degree having β1,…βr. as its roots.

g(x) = (x+β1) (x+β2) (x+β3)… (x+βr)

May not always be a binary polynomial.

Ex- if β1 = α and β2 = α2 in GF(23) , g(x) = x2 + α4x + α3.

Solution – replace each factor (x+βi) by mi(x), minimum

polynomial of βi .

Constructing g(x) using minimum polynomial

Minimum polynomial of an element is irreducible polynomial

with binary coefficients obtained using element with its

conjugate sets.

g(x) = m1(x) (m2x)… (mrx).

g(x) may contain multiple factors of conjugates min poly if

any element belongs to conjugate sets of other..

LCM of g(x) would eliminate common multiples.

g(x) = LCM[m1(x) (m2x)… (mrx)].

In GF(2m), product of 2 or more minimum polynomials

divides xq-1 +1, where q = 2m .

Hence above g(x) can generate cyclic codes.

Constructing g(x) using minimum polynomial

Example-

Construct a generator polynomial for (7,4) code using roots

α, α2, α4 belonging to GF(23).

Conjugates of α are α, α2, α4 in GF(23). Also for α2, α4 .

m1(x) = 1 + x + x3 .

m2(x) = 1 + x + x3 .

m3(x) = 1 + x + x3 .

g(x) = LCM[m1(x) (m2x) m3(x)] = 1 + x + x3 .

Example-

Construct a generator polynomial for (7,4) code using roots

α, α2, α3 belonging to GF(23).

Theorems

Theorem 1: A cyclic code consists of all multiples of generator polynomial g(x) by polynomials of degree k-1 or less.

Theorem 2: There is a cyclic code of block length n with generator polynomial g(x) if and only if g(x) divides xn -1.

Theorem 3: Let generator polynomial g(x) of a primitive code has zeros β1, ….., βr,in GF(qm). A polynomial c(x) over GF(q) is a codeword polynomial if and only if

◦ c(β1) = c(β2).. .. c(βr)=0

Theorem 4 :If f(x) is the minimal polynomial over GF(q) of β, an element of GF(qm) then f(x) is also a minimal polynomial of βq.

Theorem 5:Let p be the characteristic of the field GF(q). Then for any polynomial s(x) over GF(q) and any integer m

Theorems

Theorem 6: The minimal polynomial of β is

◦ f(x) = (x – β)(x – βq)…(x – βqr-1) where r is smallest

integer such that βqr = β.

Theorem 7: Let GF(q) is a finite field and n and q are

relatively prime, then xn -1 divides xqm-1 -1 for some m and

xn -1 has n distinct zeros in the extension field GF(qm).

Parity-Check polynomial

Let g(x) is a generator polynomial for an (n,k) cyclic code.

Then the polynomial h(x) is Parity-Check polynomial of the

code if it satisfies g(x) h(x) = xn + 1.

h(x) = (xn + 1) / g(x)

Degree of h(x) = n – (n-k) = k

h(x) = hkxk+ hk-1x

k-1+…+ h2x2+ h1x+ h0

hk= h0= 1 and remaining 0 or 1.

(7,4) code with g(x) = x3 + x + 1has parity check polynomial

h(x) = (x7 + 1) /(1 + x + x3) = x4+ x2 + x +1

Analogous to Parity-check matrix H in Hamming codes.

Parity-Check polynomial Vs Parity-Check Matrix

Dual Cyclic Codes The parity check polynomial h(x) of a code is used to

generate (n,n-k) Dual Code of C.

Reciprocal Polynomial h*(x) of h(x) is found as

◦ h*(x)= xr h(1/x)

◦ Where r is degree of h(x).

It has the effect of reversing the order of the coefficients.

Generator polynomial g(x) of dual code is h*(x).

Let : h(x) = h3x3 + h2x

2+ h1x+ h0

h(1/x) = h3/x3 + h2/x2+ h1/x+ h0

h*(x) = h3 + h2x+ h1x

2+ h0x3

h*(x) = h0x3 +h1x

2 +h2x +h3 Coefficients of h*(x) reverse of h(x)

Example : h(x) = x4 + x2+ x+ 1

x4h(1/x) = x4 (1/x4 + 1/x2+ 1/x+ 1)

h*(x) = x4 + x3+ x2+ 1 = g(x)

Generator polynomial of code that is dual to (7,4) code.

Dual Cyclic Codes

Block length n of a code and its dual are same.

Dual of a dual code is original code.

Example : Given (9,6) cyclic code with generator

polynomial g(x) = x3 + 1. Construct its dual code.

Parity-check polynomial of (9,6) code –

h(x) = (x9 + 1) / (x3 + 1) = x6 + x3 + 1

h*(x) = x6 (1/x6 + 1/x3+ 1) = x6 + x3 + 1

Block length = 9

Degree of g(x) = 6

Information length = 3

Hence dual to (9,6) cyclic code is (9,3) code with g(x) = x6 +

x3 + 1.

Idempotents

Idempotence is the property of operations which can be

applied multiple times without altering the result beyond

initial application.

Example: Unary operation like abs(abs(x)) = abs(x).

Example: Binary operation like max(x,x) ≡ x.

Idempotents An element x of a set with a binary operation ∗ is called

an idempotent element (or just an idempotent) if x ∗ x = x.

An idempotent element of a ring is an element a such that a2 = a.

Example: Prime Numbers have only 2 idempotents, 0,1 in mod-n.

Example: In Group of integers mod-n, if n is squarefree(not divisible by perfect square) and has m factors, there will be 2m idempotents. (idempotent for each factor.)

6 has 2 factors, hence will have 22 idempotents.

02 = 0 = 0 (mod 6)

12 = 1 = 1 (mod 6) Next such elements are 10, 15... Test.

22 = 4 = 4 (mod 6)

32 = 9 = 3 (mod 6)

42 = 16 = 4 (mod 6)

52 = 25 = 1(mod 6).

0, 1, 3, and 4 are idempotents of this group, while 2 and 5 are not.

Mattson-Solomon Polynomial

It is like discrete Fourier Transform which converts a time domain

polynomial in x to frequency domain polynomial in z.

Let α be a primitive nth root of unity over GF(q).

(α)n = 1

For each polynomial p(x) ЄRn, there is another polynomial Pms(z)

called the Mattson-Solomon polynomial defined as --

Pms(z) = ∑ i=0

n-1

p(α-i) zi

Pms(z) = ∑ i=0

n-1

p(αn-i) zi

Pms(z) = ∑ i=1

n

p(αi) zn-i


If p(x) = ∑pjxj and Pms(z) is ∑Piz

i , then

∑ i=0

n-1

∑Pizi =

i=0

n-1

∑ pj α-ij

j=0

n-1

( ) zi

∑ i=0

n-1

∑Pizi =

i=0

n-1

∑ pjα(n-i)j

j=0

n-1

( ) zi

Pn-1 1 α α2 … α(n-1) p0

Pn-2 1 α2 α4 … α2(n-1) p1

Pn-3 = . . … . p2

. . . … . .

. 1 α(n-1) α2(n-1) … α(n-1)(n-1) .

P0 1 1 1 … 1 p(n-1)


Given Mattson-Solomon polynomial Pms(z), original

polynomial p(x) can be obtained as -

p(x) = (1/n)∑ i=0

n-1

Pms (αi) xi


Example : Find MS polynomials for following in (7,3,4)

simplex code where α is element of GF(23).

1+x+x2+x4 x(1+x+x2+x4)

P6 1 α α2 α3 α4 α5 α6 p0

P5 1 α2 α4 α6 α α3 α5 p1

P4 = 1 α3 α6 α2 α5 α α4 p2

P3 1 α4 α α5 α2 α6 α3 p3

P2 1 α5 α3 α α6 α4 α2 p4

P1 1 α6 α5 α4 α3 α2 α p5

P0 1 1 1 1 1 1 1 p6




1+x+x2+x4

P6 1 α α2 α3 α4 α5 α6 1

P5 1 α2 α4 α6 α α3 α5 1

P4 = 1 α3 α6 α2 α5 α α4 1

P3 1 α4 α α5 α2 α6 α3 0

P2 1 α5 α3 α α6 α4 α2 1

P1 1 α6 α5 α4 α3 α2 α 0

P0 1 1 1 1 1 1 1 0

1

1

0

= 1

0

0

0

P(z) = z3+z5+z6




x(1+x+x2+x4)

P6 1 α α2 α3 α4 α5 α6 0

P5 1 α2 α4 α6 α α3 α5 1

P4 = 1 α3 α6 α2 α5 α α4 1

P3 1 α4 α α5 α2 α6 α3 1

P2 1 α5 α3 α α6 α4 α2 0

P1 1 α6 α5 α4 α3 α2 α 1

P0 1 1 1 1 1 1 1 0

α

α2

0

= α4

0

0

0

P(z) = α4z3+α2z5+αz6

MDS (Maximum Distance Separable) Codes

Singleton Bound : The minimum distance ( minimum

weight) of any linear (n,k) code satisfies –

◦ d* ≤ 1 + n – k.

Proof: The smallest-weight non-zero code has weight d*.

Smallest systematic codes exists with only one information

symbol and n-k parity symbols.

Such codewords can not have weight larger than 1+(n-k).

Hence minimum weight of the code can not be larger than

1+(n-k).

MDS (Maximum Distance Separable) Codes

Any code whose minimum distance satisfies d* = 1 + n - k

is called maximum distance separable code.

A code which can correct t errors has designed distance of

the code d = 2t + 1.

Actual Minimum distance d* or dmin ≥ d. Hence d* ≥ d = 2t + 1 = n-k+1

As per Singleton Bound, d* ≤ 1 + n – k.

Hence d* = n-k+1 and d* = d

Hence the reason.

MDS Codes - Characteristics

Proposition 1: A q-ary [n,k] linear code is an MDS code if,

and only if, the minimum non-zero weight of any codeword

is n - k + 1.

Claim 1: A code (n,n) for any n and q is an MDS code if

and only if minimum non zero weight is 1.

n-bit data coded to another n-bit code without parity.

Hence a nonzero code should have atleast one “1”. Claim 2: A code (n,1) for any n and q is an MDS code if

and only if minimum weight is n.

1 bit message encodes to n bit code. Cyclic code will give

all zero for “0” and all “1s” for “1”. Hence min weight n.

MDS Codes - Characteristics

Proposition 2: A q-ary [n,k] linear code is an MDS code if,

and only if, every set of (n-k) columns of a parity check

matrix is linearly independent.

BCH Codes

Bose-Chaudhuri-Hocquenghem codes.

BCH Codes are subset of cyclic codes

Powerful multiple error correcting codes with mathematical

properties.

Binary and non-binary BCH codes exist.

Reed-Solomon codes are non-binary BCH codes.

Its generator polynomial can be created using any number

of roots, required for desired error correcting capabilities.

Construction of BCH Codes BCH codes have generator polynomial with roots carefully

specified to give error correcting capability.

A t-error correcting cyclic code with generator polynomial

g(x) is a binary BCH code if and only if g(x) is the least

degree polynomial over GF(2) that has

◦ β, β2, β3,β4, … β2t, as roots where..

β, is an element of GF(2m).

If the field element β is primitive then codes are called Primitive BCH Codes having block length of n = 2m-1.

The g(x) has degree r = (n-k) ≤ mt ◦ where information length k = 2m-1 – r

Capable of correcting any combination of t or fewer errors (t

≤ 2m-1) in block of n.

Construction of BCH Codes Example – Construct a double error correcting BCH code

over GF(24).

Taking β = α, (a primitive element of GF(24) and t = 2, roots required are α, α2, α3, α4.

g(x) = LCM[m1(x) (m2x) m3(x) m4(x)].

m1(x) = m2(x) = m4(x) = 1 + x + x4.

m3(x) = 1 + x + x2+ x3 + x4

g(x) = m1(x) m3(x) = 1 + x4 + x6+ x7 + x8

Block length n = 2m-1 = 15

Degree of g(x) r = 8

Information length k = n-r = 7

Double error correcting (15,7) BCH code with g(x) = 1 + x4 + x6+ x7 + x8 is constructed.

If β = any conjugate of α, e.g. α2, it will give same g(x).

Try with β = α3 also.

Construction of BCH Codes A t-error correcting code has a guaranteed minimum

distance of d = 2t+1.

dmin

of code may be greater than d giving error correcting

capability greater than t.

Minimum distance of d = 2t+1 is called Designed Distance

of code with dmin

≥ d. Generation of BCH codes is same as Linear cyclic codes

and are similarly found from g(x).

However detection process is specific to BCH.

Construction of BCH Codes Example – Construct a single error correcting BCH code

over GF(24).

Taking β = α and t = 1, roots required are α, α2.

g(x) = LCM[m1(x) (m2x)].

m1(x) = 1 + x + x4.

m2(x) = 1 + x + x4.

g(x) = m1(x) = 1 + x + x4.

Block length n = 2m-1 = 15


Information length k = n-r = 11

Hence Double error correcting (15,11) BCH code with

g(x) = 1 + x + x4 is constructed.

Error Syndrome of BCH Codes Also for Cyclic Code

g(x) and c(x) have α, α2, α3,… α2t and their conjugates as

their roots.

If c(x) = c0+c1x+c2x2+…cn-1x

n-1 and αi is the root, 1≤ i ≤ 2t. c(αi) = c0+c1(α

i) +c2(αi)2 +…cn-1(α

i) (n-1) =0 for all i,1≤ i ≤ 2t. [c0,c1,c2,…cn-1 ] [1 αi α2i …α(n-1) i ]T = 0 for all i, 1≤ i ≤ 2t. If αj is the conjugate of αi, then can be eliminated from

above range as it will give same result as αi.

Then for correct code, CHT = 0, where H =

1 α α2 α3 α4 … αn-1

1 (α3) (α3)2 (α3)3 (α3)4 … (α3)n-1

H= 1 (α5) (α5)2 (α5)3 (α5)4 … (α5)n-1

. . . . . … .

1 (α2t-1) (α2t-1)2 (α2t-1)3 (α2t-1)4 … (α2t-1)n-1

Error Syndrome of BCH Codes Example – For double error correcting (15,7) BCH code,

find parity check matrix if α is primitive element in GF(24).

For correct code, CHT = 0, where H =

1 α α2 α3 α4 α5 α6 α7 α8 α9 α10 α11 α12 α13 α14

H=

1 α3 α6 α9 α12 α15 α18 α21 α24 α27 α30 α33 α36 α39 α42

• Using corresponding 4-tuple, binary parity check matrix is 1 0 0 0 1 0 0 1 1 0 1 0 1 1 1

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

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

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

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

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

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

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

Error Syndrome in BCH Codes Roots of g(x) are also roots of c(x).

If α, α2,.. α2t are roots of g(x), and t-error correcting BCH

code c(x),

then c(αi) = 0 for i=1,2,…2t. Received word v(x) = c(x) + e(x) [with error]

v(αi) = c(αi) + e(αi) for i=1,2,…2t. v(αi) = e(αi) as c(αi) = 0

Hence Si = v(αi) = e(αi)

Error Syndrome in BCH Codes –Method 1

Example – (15,7) BCH code over GF(24) with t=2

c(x) = 1+ x+ x4+ x5 + x6 + x9. (110011100100000)

S1 = v(α) = 1+ α + α4+ α5 + α6 + α9 = 0

S2 = v(α2) = 1+ α2+ α8 + α10 + α12 + α3 = 0

S3 = v(α3) = 1+ α3+ α12 + 1+ α3 + α12 = 0

S4 = v(α4) = 1+ α4+ α + α5 + α9 + α6 = 0

Let c(x) is contaminated with e(x) = x7+x4 to give

v(x)= 1+ x+ x5+ x6 + x7 + x9.

S1 = v(α) = 1+ α + α5+ α6 + α7 + α9 = α3

S2 = v(α2) = 1+ α2+ α10 + α12 + α14+ α3 = α6

S3 = v(α3) = 1+ α3+ 1+ α3+ α6 + α12 = α4

S4 = v(α4) = 1+ α4+ α5+ α9 + α13 + α6 = α12

If number of errors do not exceed the error correcting limit of a BCH, then error pattern e(x) can be determined from S1 to S2t .

A particular error pattern will give same S1 to S2t in all code words.

Data set for all error words can be created along with correction words.

Error Syndrome in BCH Codes Another Example from same code set– (15,7) BCH code over

GF(24) with t=2

c(x) = x + x2+ x5+ x6 + x7 + x10. (011001110010000)

No error.

S1 = v(α) = 0

S2 = v(α2) = 0

S3 = v(α3) = 0

S4 = v(α4) = 0

Let c(x) is contaminated with same e(x) = x7+x4 to give

v(x)= x + x2+ x4+ x5 + x6 + x10.

S1 = v(α) = α3

S2 = v(α2) = α6

S3 = v(α3) = α4

S4 = v(α4) = α12

Same error pattern gives same S1 to S2t in both code words.

Error Syndrome in BCH Codes Another Example from same code set– (15,7) BCH code

over GF(24) with t=2

c1(x) = 1+ x+ x4+ x5 + x6 + x9. (110011100100000)

c2(x) = x + x2+ x5+ x6 + x7 + x10. (011001110010000)

Error e(x) = x3+x6

S1 = v(α) = α2

S2 = v(α2) = α4

S3 = v(α3) = α

S4 = v(α4) = α8

Error e(x) = x9

S1 = v(α) = α9

S2 = v(α2) = α3

S3 = v(α3) = α12

S4 = v(α4) = α6

Error Syndrome in BCH Codes–BINARY codes only

Calculating errors in a finite field for binary codes can be

simplified as-

x1

2 + x2

2 …xn

2 = (x1

+ x2 …x

n) 2.

c(x) = 1+ x+ x4+ x5 + x6 + x9.

S2 = 1+ (α2) + (α2)4+ (α2)5 + (α2)6 + (α2)9.

S2 = (1+ α + α4+ α5 + α6 + α9)2 .

S2 = S

12

Similarly S4 = S

22

Hence

S2i = S

i2

Syndromes for odd values of i need to be calculated which

in turn can give syndromes for even values of i.

Error Syndrome in BCH Codes –Method 2

No a priori knowledge of error pattern with Decoder.

Let e(x) = xp1 + xp2 +… xpµ -- µ errors at positions p1 p2 ..pu.

v(x) = c(x) + e(x)

S1 = v(α) = e(α) = αp1 + αp2 +… αpµ

S2 = v(α2) = e(α2) = α2p1 + α2p2 +… α2pµ

…. S2t = v(α2t) = α2tp1 + α2tp2 +… α2tpµ

Let Xi = αpi then syndrome equations are

S1 = X1 + X2 + ….Xµ

S2 = X12 + X2

2 + ….Xµ2

…. S2t= X1

2t + X22t + ….Xµ2t

Single Error Correcting (SEC) BCH Codes

t = µ = 1

S1 = X1

S2 = X12

Error location can be directly given by - X1 = S1

Example – (7,4) SEC has c(x) = 1+ x+ x2+ x5 over GF(23)

It incurs single error e(x) = x5

v(x) = 1+ x+ x2

S1 = v(α) = e(α) = 1 + α + α2 = α5 over GF(23)

Moreover p1 = 5

Hence X1 = S1 = α5

Syndrome table not required.

Double Error Correcting (DEC) BCH Codes

t = µ = 2

S1 = X1 + X2

S2 = X12 + X2

2

S3 = X13 + X2

3

S4 = X14 + X2

4

S2 and S4 are dependent on S1.

Hence S1 and S3 are sufficient.

S1 = X1 + X2

S3 = X13 + X2

3

Nonlinear equations and can not be solved by matrix

inversion.

Double Error Correcting (DEC) BCH Codes

(X1 + X2)3 = (X1 + X2)

2 (X1 + X2)

= (X12 + X2

2) (X1 + X2)

= X13 + X2

3 + X1 X2 (X1 + X2)

S13 = S3 + X1 X2S1

S13 = S3 + S1X1 (S1 + X1 ) S1 = X1 + X2

X12 + S1X1 + (S1

3 + S3) / S1 = 0

OR

X22 + S1X2 + (S1

3 + S3) / S1 = 0

X1 and X2 are two roots.

In general…

x2 + S1x + (S13 + S3) / S1 = 0

Example: Double error correcting (15,7) BCH code

Let codeword is c(x) = x11+ x8+ x7+ x6+ x3+ x2

Let error is e(x) = x10+ x2

Hence v(x) = x11+ x10+ x8+ x7+ x6+ x3

Error Syndrome over GF(24) --

S1 = v(α) = α4

S3 = v(α3) = α13

Hence solving for root equation…

x2 + α4 x + α12 = 0

Finding roots by Chien search for each element of GF(24)..

p(α2) = 0 hence α2 is one root.

Using S1 = X1 + X2 α10 is another root.

X1 =α2 and X2 = α10

Hence e(x) = x10+ x2

Example: (15,7) BCH code having single error

S1 = X1 and X2= 0

S3 = X13 = S1

3

Syndrome equation x + S1 = 0

Let codeword is c(x) = x11+ x8+ x7+ x6+ x3+ x2

Let error is e(x) = x4

Hence v(x) = x11+ x8+ x7+ x6+ x4 + x3+ x2

Error Syndrome over GF(24) --

S1 = v(α) = α4

S3 = v(α3) = α12

Solving for root equation - x2 + S1x + (S13 + S3) / S1 = 0

X = S1 = α4

Hence e(x) = x4

Example: Two code words c1(x) and c2(x) belonging to DEC

(15,7) BCH constructed over GF(24) incur 2 and 1 errors so

giving (a) v1(x) = x11+ x9+ x8+ x6+ x5+ x +1 and

(b) v2(x) = x12+ x11+ x10+ x9+ x7+ x5+ x respectively .

Find c1(x) and c2(x).

Solution: (a) Error syndromes are—

S1 = v(α) = α3

S3 = v(α3) = α13

x2 + α3 x + α7 = 0 X1X2 = α7, X1+X2 = α3,

Roots are X1= α10 X2 = α12,

e(x) = x10+ x12

c1(x) = x12+ x11+ x10+ x9+ x8+ x6+ x5+ x +1

(b) S1 = α4 S3 = α12

X = α4

c2(x) = x12+ x11+ x10+ x9+ x7+ x5+ x4+ x

Example: Code word belonging to DEC (15,7) BCH constructed over GF(24) is c1(x) = x8+ x7+ x6+ x4+ 1 Determine outcome of decoder when it incurs error patters (a) e(x) = x7+ x2 +1

(b)e(x) = x11+ x9 + x6+ x4

Solution : (a) v (x) = x8+ x6 + x4+ x2

S1 = v(α) = α11

S3 = v(α3) = 1

x2 + α11 x + α3 = 0

No element of GF(24) is a solution. Decoding failure.

(b) v (x) = x11+ x9 + x8+ x7 + 1

S1 = v(α) = α7

S3 = v(α3) = 0

x2 + α7 x + α14 = 0

e(x) = x2+ x12

Decoding Error.

Error Location Polynomial

For t-error correcting codes, polynomial of degree ≤ t and has coefficients as function of error syndrome.

For µ ≤ t errors, a polynomial of degree µ can be found whose µ roots are reciprocal of required error-location

number.

Let σ1 = S1 and σ2= (S13 + S3) / S1 ,-- then

x + σ1 = 0 Single error

x2 + σ1x + σ2 = 0 Double error

xµ + σ1xµ-1+ σ2 x

µ-2 +…σµ-1x + σµ = 0 µ errors

µ roots give µ error location numbers.

Replacing x by 1/x to form equation whose roots are

reciprocal of error location numbers—

1/xµ + σ1/xµ-1+ σ2 /x

µ-2 +…σµ-1/x + σµ = 0 OR

σ0+ σ1x+ σ2 x2 +…σµ-1x

µ-1 + σµ xµ= 0 where σ0=0


Error location polynomial is --

σ(x) = σ0+ σ1x+ σ2 x2 +…σµ-1x

µ-1 + σµ xµ= 0

More convenient and conventional to use error location

polynomial whose reciprocal roots are error location

numbers.

For double error correcting codes, error-location

polynomial is –

1 + σ1x + σ2 x2= 0

Example : Given that v (x) = x9+ x8+ x6 + x4+ 1 represents a

codeword c(x) of double error correcting (15,7) code, that

has incurred 2 errors. Determine c(x).

Solution: For GF(24)

S1 = v(α) =1

S3 = v(α3) =α4

σ1 = S1 =1, σ2 = (S13 + S3) / S1 = α

σ(x) = 1 + σ1x + σ2 x2 = 1 + x + α x

2 = 0

Using Chien Search, roots are α6 and α8 .

Hence error location numbers are –

X1 = 1/ α6 = α9

X2 = 1/ α8 = α7

e(x) = x9+ x7

c (x) = x8+ x7+ x6 + x4+ 1


If the roots of error location polynomial are field elements

β1, β2,… βµ, then error location numbers are—

X1 = 1/β1,

X2 = 1/β2, …

Xµ = 1/βµ

Error location polynomial can be expressed as—


Decoding BCH code demands determination of error

location polynomial and its coefficients.

σ0, σ1, σ2, …, σµ, to be determined from error syndromes.

These coefficients are called elementary symmetric

functions of error location numbers.

Comparing following two sets of equations— Shown below

◦ Error location numbers Vs error syndromes

◦ Error location numbers Vs polynomial coefficients

Eliminating error location numbers from these two sets–

S1 = X1 + X2 + ….Xµ

S2 = X12 + X2

2 + ….Xµ2

…. S2t= X1

2t + X22t + ….Xµ2t

Error Location Polynomial – µerrors, 2µ syndromes

Last term iσi is 0 for even values of i and σi for odd i.

Remaining error syndromes are--

Error Location Polynomial – These linear equations are called Newton’s Identity. The two sets can be expressed as--

Error Location Polynomial – Binary Codes S2i = Si

2

e.g. S2= S1

2 and 2σ2 = 0

Hence S2= σ1S1 + 2σ2 reduces to S1= σ1

S2 and hence Si with even i are excluded.

Error Location Polynomial – Example- DEC µ = 2

Error Location Polynomial – Example- TEC µ = 3. Error Location polynomial --

multiplying S2 to S3 and adding to S5 --

Error Location Polynomial – Example- TEC

From middle expression -

σ3 may be simplified by substituting σ1 and σ2 .

Error Location Polynomial – Example

Given a triple error correcting code and its error syndromes

S1 = α3, S3 = α8, S5= 1 over GF(24), determine the error

location polynomial. Find error location numbers.

Example: Given the (15,7) double error correcting binary BCH

code constructed over GF( 24) . The decoder inputs-

v1 = (100011011000101)

v2 = (001010111010001)

Determine resulting error location polynomials. What is the

decision of decoder . Find actual codes transmitted.

Hint: v1 =uncorrectable error patterns

C2 =?

The Peterson-Gorenstein- Zierler decoder

General purpose decoder used for any t-error correcting

BCH code.

Based on error location polynomial.

Without changing the equation, reversing the order of terms

in equations for syndrome, matrix can be given as -


The code is designed to correct t errors.

Let there be µ errors, µ ≤ t. The matrix M is non-singular (has inverse) for i = µ but

singular for µ ≤ i ≤ t. Then


Example: A code is designed to correct 5 errors but only 3 errors actually occur.

t = 5, and µ = 3.Taking i = 5, ..

For i = 5, det(M) = 0 and M is singular.

For i = 4, 4X4 matrix M will also be singular.

If i = µ = 3, the 3X3 matrix M is non-singular, having

inverse.

Hence error polynomial coefficients can be found using --

σ = M-1

S.

Decoding Procedure

1. Calculate error syndrome S1, S2,…S2t from v(x).

2. Assume number of errors, i = t.

3. Construct the matrix M.

4. Find det(M). If det(M) = 0

1. Reduce i by 1. Go back to step 3

2. Otherwise continue to step 5.

5. Determine M-1

and construct S.

6. Find polynomial coefficients using σ = M-1

S. Find σ(x).

7. Find roots of σ(x) and take their reciprocals.

8. Error location numbers are given by reciprocal roots.

Decoding Procedure – Example µ< t

Consider (15,5) triple error correcting BCH code with –

v(x)= x8 + x5 + x2 + x + 1 where v(x) is code c(x) with 2

errors.

Step 1: Error syndromes over GF(24) are –

Decoding Procedure - Example

Step 2 : Assume maximum number of errors, i = 3.

Step 3 : The matrix M is

Step 4 : Determinant of M is


As Matrix M is singular(No inverse), i is reduced by 1. i=2.



As Matrix M is non-singular(Has inverse), find M-1

.

Step 5 : M-1

= adj(M)/det(M)


Step 6 :Using σ = M-1

S

Step 7 :Using Chien rule over GF(24), roots of σ(x) are α5

and α11.

Reciprocal of α5 and α11 are error location numbers α10 and

α4.

Error pattern e(x) = x10 + x4..

c(x) = v(x) + e(x) = x10 + x8 + x5 + x4 + x2 + x + 1

Decoding Procedure – Same Example, µ= t

Consider (15,5) triple error correcting BCH code with –

v(x)= x13 + x10 + x8 + x4 + x + 1 where v(x) is code c(x) with

some errors. Find the number of errors , error pattern and

c(x).

Step 1: Error syndromes over GF(24) are –


Step 2 : Assume maximum number of errors, i = 3.



M non-singular, 3 errors have occurred. Inverse of M is


Step 6 :Using σ = M-1

S

Step 7 :Using Chien rule over GF(24), roots of σ(x) are α2,

α10 and α13.

Reciprocal of α2, α10 and α13 are error location numbers α13

α5 and α2.

Error pattern e(x) = x13 + x5 + x2..

c(x) = v(x) + e(x) = x10 + x8 + x5 + x4 + x2 + x + 1

Peterson-Gorenstein- Zierler decoder - DRAWBACKS

Matrix inversion.

For large error-correction limit , determinants evaluation

can be computationally slow and inefficient.

A second matrix inversion required while dealing with non-

binary codes.

Need to avoid matrix inversion.

Non-Binary BCH Codes

In binary codes, code symbols lie in GF(2).

Non - binary cyclic code has its symbols in GF(q) where q

is a prime number or any power of a prime number.

A non-binary (n, k) cyclic codes can be constructed from a

polynomial g(x) of degree n-k, where g(x) has coefficients

in GF(q) and divides xn-1.

For binary codes xn-1= xn+1

Non - binary cyclic code concerns with detection and

correction of errors in symbols.

Error location and magnitude of error, both need to be

determined in Non - binary cyclic code .

(In binary codes, error magnitudes are 1 and only location

of error is required.)

Non-Binary BCH Codes A t-error correcting non-binary BCH code of block length n

= qm-1 is a (n,k) cyclic code if its g(x) has coefficients in GF(q)and roots β, β2 ,…β2t in GF(qm).

Non-binary BCH codes requires minimal polynomial over GF(q).

Generator polynomial is given as –

g(x) = LCM[m1(x), m2(x),… m2t(x)]

Where mi(x) is minimal polynomial over GF(q).

If q = 2, minimal polynomials are binary, giving Binary BCH.

Most important class of non-binary BCH codes are Reed-Solomon codes.

Both Symbols and generator polynomial roots lie in the field GF(q).

Block length n = q-1.

Here q = 2m and field GF(2m).

Reed-Solomon Codes

A t-error correcting Reed-Solomon code of block length n =

q-1 is a (n,k) cyclic code if its g(x) has coefficients and roots

in GF(q). q = 2m.

Its g(x) is the least degree polynomial that has β, β2, β3,…

β2t as roots where β belongs to GF(2m).

As before, minimal polynomial is not obtained using

conjugates of roots.

The minimal polynomial over GF(2m) of an element β in

GF(2m) is obtained directly from root –-- mβ = x + β

g(x) = (x + β ) (x + β2) (x + β3)…(x + β2t)

No need to take LCM as all factors are distinct.

Reed-Solomon Codes- Generator Polynomial

Example :-Find generator polynomial for double error

correcting Reed-Solomon code over GF(24) if β = α.

g(x) = (x + α ) (x + α2) (x + α3)(x + α4)

g(x) = x4 + α13x3 + α6x2 + α3x + α10

n = 24 – 1 = 15


k = n – r = 11

Hence it is generator polynomial for DEC (15,11) Reed-

Solomon Code.


Example :- Construct a systematic Single error correcting

Reed-Solomon code with block length 7.

Field can be GF(23) as this gives codes with block length n

= 23 – 1= 7

For t = 1, β = α, g(x) = (x + α ) (x + α2) = x2 + α4x + α3

n = 7, r = 2. Therefore k= 5. Hence…

SEC (7,5) Reed Solomon code with g(x) = x2 + α4x + α3

Let data is i = ( 1 0 α α5 α2)

i(x) = x4 + αx2 + α5x + α2

Multiplying by xn-k = x2

x2 i(x) = x6 + αx4 + α5x3 + α2x 2

Dividing by g(x) to get remainder – r(x) = x + α2

c(x) = x2 i(x) + r(x) = x6 + αx4 + α5x3 + α2x 2 + x + α2

C = ( 1 0 α α5 α2 1 α2)


Example :- Construct a (15,13) systematic SEC Reed-

Solomon code for i = (0 0 α 0 0 1 α7 α2 0 0 1 α α2) where α is a primitive element for GF(24)

Solution :- g(x) = (x + α ) (x + α2) = x2 + α5x + α3

n= 15, r= 2, k= 13.

r(x) = α3x + α6

C = (0 0 α 0 0 1 α7 α2 0 0 1 α α2 α3 α6)

Example :- Assume GF(4) = (0, 1, α, α2} with α2 + α + 1 = 0.

Design RS code over GF(4) with n = 3, designed distance 2

and k = 2 with g(x) =x - α2. Find all 42 codewords. Root=α2

Solution: Messages { 00, 01, 0 α ,0 α2, 10,…, α2α2} total 16.

Let D = 01, d(x) = 1.

Rem[x(n-k)d(x)/g(x)] = Rem[x/(x + α2)] = α2.

Code = 01α2. Check C(α2) = 0

Let D = αα2. d(x) = αx+ α2

Rem[x(n-k)d(x)/g(x)] = Rem[x.(αx+ α2)/(x + α2)] = 1.

Code = αα21. = α β 1. (β =α2 )

000 10α α0α2 α201

01α2 111 α10 α2 1α

0α1 1αα2 ααα α2α0

0α2α 1α20 αα21 α2α2α2

Example

R-S code can be extended by adding an overall parity

check without increasing minimum distance.

Theorem 1. Let C be the (n = qm – 1, k, d ) RS code with

g(x) = (x - α) (x - α2).. . (x – αd-1). (d=2t+1)

Then extending each codeword C= (c0,c1,…cN-1) by adding

an overall parity check cN produces an (n+1, k, d+1) code

where cN= -∑ci. i= 0 to N-1

D increases to D+1 provided cN= -∑ci ≠ 0. 000 0 10αα2 α0α21 α201α

01α2α 1111 α10α2 α2 1α0

0α1 α2 1αα20 αααα α2α01

0α2α1 1α20α αα210 α2α2α2α2

Extended Reed-Solomon Codes

Example:c(x) = x6 + α3x4 + α5x3 + α6x 2 + x + α2

= (1)x6 + (1+α)x4 + (1+ α +α2)x3 + (1+α2)x 2 + (1)x + α2

C = ( 1 0 α3 α5 α6 1 α2)

Let α = (α1, α2, .. . , αn ) where the αi are distinct elements of

GF(qm)

let ν = (v1, v2,.. , vn ) where the vi are nonzero elements of

GF(qm).

Then the generalized RS code, GRSK(α, v ),consists of all

vectors--

GRSK(α, v )= (v1f(α1), v2f(α2), v3f(α3), … vnf(αn) )

where , f(x)єF[x]k

where F[x]k ranges over set of polynomials in F[x] of degree

< K with coefficients from GF(qm). i.e. αi can be expressed

as polynomial of α, α2, etc

Generalized Reed-Solomon Codes

Reed-Solomon Codes- Error Correction Capability

Generator polynomial g(x) of t-error-correcting R-S code

has 2t linear factors for roots β, β2, β3,… β2t.

Hence Degree of g(x) = n - k =2t

Hence Parity check symbols = 2t

Code is called 2t error correcting(n, n-2t) R-S code.

R-S codes are MDS codes hence for 2t error correction,

dmin = 2t + 1 = n – k + 1

Such codes are maximum distance codes.

Designed distance d0 and minimum distance dmin are same

for R-S codes.

Reed-Solomon Codes- Number of code-words

A binary (n,k) RS code have 2k code words.

For non-binary RS code, code words are Very large.

A code has n positions, each take any of q = 2m values.

Hence a non-binary (n,n-2t) code has qn-2t code words.

e.g. SEC (7,5) RS Code in GF(23) has 32768 code words.

Reed-Solomon Codes- PGZ Decoding Decoding RS code requires error positions as well as error

magnitude for each position.

Error polynomial with µ error position and magnitude is:

e(x) = yp1xp1 +yp2

xp2 +…ypµxpµ

ypi is error magnitude at position pi

v(x) = c(x) + e(x)

S1 = v(α) = e(α) = yp1αp1 + yp2

αp2 +… ypµαpµ

S2 = v(α2) = e(α2) = yp1α2p1 + yp2

α2p2 +… ypµα2pµ

…. S2t = v(α2t) = yp1

α2tp1 + yp2α2tp2 +… ypµ

α2tpµ

Let Xi = αpi and Yi = ypi then syndrome equations are

S1 = Y1X1 + Y2X2 + …. YµXµ

S2 = Y1X12 + Y2X2

2 + …. YµXµ2

…. S2t= Y1X1

2t + Y2X22t + …. YµXµ2t

Reed-Solomon Codes- Decoding -- SEC

For non-binary RS Code, S2i ≠ S

i2

So 2t error syndromes need to be individually evaluated.

For SEC, t = 1, µ = 1

S1 = Y1X1

S2 = Y1X12

X1= S2 / S1

Y1= S12 / S2

Compare values of position X1 and magnitude of error Y1

with binary RS code where S2 = S

12 .

Reed-Solomon Codes- Decoding -- SEC Example: For (7,5) SEC R-S code, v = (0 1 α5 α2 1 α6α3) where α is an

element of GF(23).Determine magnitude and position of error and

codeword if it is known that codeword underwent single error.

Solution:-

v = (0 1 α5 α2 1 α6α3) Standard right to left--

S1 = v(α) = α

S2 = v(α2) = α3

X1= S2 / S1 = α3/α = α2

Y1= S12 / S2 = α2/α3 =α6

Error located at x2 having magnitude α6.

c(x) = v(x) = α6x2

c(x) = x5 + α5x4+ α2x3 + α2x2 + α6x + α3

c = (0 1 α5 α2 α2 α6 α3 )

Reed-Solomon Codes- t error correction

Code determines number of errors µ and the location

numbers X1, X2, …. Xµ by any technique used for BCH

code.

Then µ error magnitudes can be obtained by solving first µ

equations for Y1, Y2, …. Yµ .

S = XY (S is NOT same as S of PGZ decoder.)

Y = X-1

S X is in form of Vandermonde matrix.

X will always be non-singular as µ non-zero and distinct

errors already known to exist.

Decoding Reed-Solomon Codes- Example

Consider a codeword polynomial c(x) belonging to the

triple-error-correcting Reed-Solomon (15,9) code, that

incurred 3 errors giving v(x) as

v(x) = α3x12 + x8 + α10x7 + α2x5 + α8x4+ α14x3+ α6

Error syndromes are – Assuming errors = 3


Assuming errors = 3

•As det(M) ≠ 0, decoder assumes 3 errors have occurred.


Coefficients of error location polynomial -

• σ1 = 1, σ2 = α11, σ3 =α4 . Error location polynomial -


Searching GF(24) for roots – x = α3, α9, α14, are roots.

Error location numbers – X1 = α12, X2 = α6, X3 = α.

For error magnitudes --


Using Y = X-1

S,

• Y1 = α3, Y2 = α3, Y3 =α9 .

• X1 = α12, X2 = α6, X3 = α correspond to error positions x12,

x6, and x respectively.


A code word belonging to triple-error-correcting (15,9)

Reed-Solomon code incurs errors and gives v(x). Find c(x).

v(x) = x10 + α3x8 + α11x7 + α8x6 + α6x5+ α4x4+ α5x2 + α9x + α6

Error syndromes over GF(24) are – Assuming µ = 3


Roots are α5 α8 α12 .

Error location numbers are X1 = α10 , X2 = α7 , X3 = α3 ,


Y1 = 1, Y2 = α4 , Y3 = α6 ,

Error location numbers X1 = α10 , X2 = α7 , X3 = α3

correspond to error positions x10 , x7 , x3

The Berlekamp decoding algorithm

Fast and efficient algorithm for decoding BCH codes.

Uses error-location polynomial but avoids need for matrix

inversion while determining polynomial coefficients.

Algorithm more complex than Peterson-Gorenstein-Zierler

decoder.

Uses an iterative technique to find error-location polynomial

σ(x) whose coefficients satisfy Newton’s identities.

The Berlekamp algorithm - Method

A suitable set of initial conditions is required. Otherwise the algorithm may fail to carry out the required number of iterations.

The algorithm starts by finding a polynomial σ(1)(x)

◦ whose coefficients satisfy the first of Newton’s identities. ◦ which is a polynomial of least degree that meets the

requirement.

To find polynomial σ(2)(x) –

◦ Check if σ(1)(x) satisfies first 2 equations of Newton’s identity.

◦ If yes, then σ(2)(x) = σ(1)

(x).

◦ Otherwise σ(1)(x) is modified by adding a suitable

correction term to give σ(2)(x) of least degree, whose

coefficients satisfy first 2 equations of Newton’s identity. Process continues…

The Berlekamp algorithm - Method Newton’s identities relate the error syndromes to the

coefficients of the error location polynomial.

At each iteration, polynomial coefficients are used to

estimate the error syndromes of the following iteration.

Let σ(i)(x) be the polynomial of least degree whose

coefficients satisfy first i Newton’s identities. Then -

• To test whether coefficients of σ(i)(x) satisfy (i+1)th identity—

• Predicted (i+1)th syndrome =

• Discrepancy between predicted and actual syndromes are

• di is known as the ith discrepancy.


If di = 0,

◦ Coefficients of σ(i)(x) satisfy the first (i+1) identities.

◦ σ(i+1)(x) = σ(i)

(x)

◦ The degree ri+1 = ri.

If di ≠ 0, ◦ Coefficients of σ(i)

(x) fail to satisfy the first (i+1) identities.

◦ σ(i)(x) needs to be modified by adding a suitable

correction polynomial.

◦ Correcting polynomial depends on one of previous

polynomial σ(k)(x) such that—

The discrepancy dk ≠ 0. nk has the largest value, where nk = k - rk (rk is the

degree of σ(k)(x).

Polynomial required is given by -


It is polynomial of least degree whose coefficients satisfy

(i+1) Newton’s identities. Correction polynomial has degree i+ rk - k = i - nk.

The degree of σ(i+1)(x), ri+1 is ri or i - nk whichever is largest.

ri+1 = max(ri , i – nk)

After finding σ(i+1)(x) and ri+1 , the coefficients of σ(i+1)

(x) are

used to estimate the next error syndrome -

Table is updated.


Process continues iteratively until a polynomial σ(2t)(x) with

coefficients satisfying all the Newton’s identities is obtained. Error location polynomial is then σ(x) = σ(2t)

(x).

Error location numbers are inverse of roots of σ(x).

The Berlekamp algorithm - Example Peterson-Gorenstein-Zierler decoder was used to decode a

(15,5) triple-error-correcting code in which error syndromes

were -- (α is an element of GF(24).

S1 = α12,

S2 = α9,

S3 = α10,

S4 = α3,

S5 = α5,

S6 = α5

Find error location polynomial and error location numbers.

For Berlekamp algorithm, initial conditions are -

The Berlekamp algorithm - Example

First iteration : i=0

d0 = α12 ≠ 0

Need to find a polynomial prior to σ(0)(x) that has dk ≠ 0 and

largest value of nk.

Only available : σ(-1)(x) with k=-1 and d-1 = 1 ≠ 0.

Required polynomial is --

The Berlekamp algorithm - Example First iteration : i=0

Degree of σ(1)(x) is r1 = max(r0 , 0 – n-1) = max(0,1) = 1

To find d1, coefficients of σ(1)(x) are used to estimate next

error syndrome.

The Berlekamp algorithm - Example Second iteration : i=1

d1 = 0

from σ(2)(x)

n2 = 2-r2 = 1

The Berlekamp algorithm - Example Sixth iteration : i = 5

As 2t = 6 for triple error correcting code

Same as obtained before.

The Berlekamp algorithm - Example If number of errors µ < t, then all 2t iterations not required.

If discrepancy di and following mi = t- ri -1 discrepancies are

zero, then σ(i)(x) is required error-location polynomial.

Let t=3 and µ=1

σ(1)(x) = 1 + S1x

r1 = 1

n1 = 0

d1 = 0

m1 = t - r1 -1 = 1 as t = 3

If next discrepancy is zero, no more iterations are required.

σ(1)(x) = σ(x)

The Berlekamp algorithm - Example Consider c(x) = x12 + x11 + x9 + x8 + x7+ x2+ 1 from (15,5)

triple-error-correcting binary BCH code incurs single error

e(x) = x11 and gives x12 + x9 + x8 + x7+ x2+ 1. Show that

Berlekamp algorithm requires fewer than 2t iterations.

Over GF(24) error syndromes and initial conditions are -

• d1 = α11 ≠ 0. Hence k = -1


m1 = t – r1 – 1 = 1.

Hence if next discrepancy is zero, STOP.

As d1 = 0,--

σ(x) is required polynomial.

1/ α11 is root. Hence error location number is α11 .

e(x) = x11 .


All remaining discrepancies must be zero.

Peterson-Gorenstein-Zierler decoder VS Berlekamp algorithm

Number of iterations in Berlekamp algorithm is normally

less than 2t as errors normally less than t.

For binary code, iterations required are t instead of 2t.

Maximum number of iterations increases proportional to t.

Involvement of matrix inversion once for binary and twice

for non-binary code makes Peterson-Gorenstein-Zierler

decoder tedious.

Processing time of Peterson-Gorenstein-Zierler decoder

increases significantly as t increases as evaluation of

inverse of tXt matrix depends on t3.

The Error Evaluator Polynomial – proof omitted

Determines error magnitudes without matrix inversion.

Let number of errors µ and error-location polynomial σ(x)

already found.

Error-evaluator polynomial is defined as --

• Magnitude Yj corresponding to error-location number Xj

is given by --

The Error Evaluator Polynomial – Example

A triple-error-correcting RS code is received with error as

v(x) = α3x12 + x8 + α10x7 + α2x5 + α8x4+ α14x3+ α6

Find Error syndromes, error-location polynomial and error-

location numbers. Find error magnitudes.

HINT: If multiple largest nk option, select one with smallest ri

to make polynomial of least degree. Important


To find error magnitudes

• Same as before.


A code word belonging to triple-error-correcting (15,9)

Reed-Solomon code incurs errors and gives v(x). Find c(x).

v(x) = x10 + α3x8 + α11x7 + α8x6 + α6x5+ α4x4+ α5x2 + α9x + α6


To find error magnitudes

• Same as before.

Berlekamp – Massy Algorithm

Berlekamp-Massy algorithm is used to design Linear

Feedback Shift Register to generate a sequence of binary

bits.

It designs LFSR with minimum number of shift registers to

generate given bit sequence.

Basis for generation is Berlekamp algorithm.

(It is not a decoding algorithm)

What is LFSR?

LFSR- Linear Feedback Shift Register

It consists of series of cells, set by initializing vector (called

secret key).

Each clock shifts bits one by one towards left (/or right).

EX-OR of subset of cell content placed in rightmost

(/leftmost) cell.

Components of LFSR are-

◦ Input sequence ( secret Key).

◦ Feedback.

◦ Output sequence

Feedback ensures linear relationship between input and

output.

The linear complexity of a sequence is the length of the

shortest LFSR, which can produce that sequence.

LFSR- Linear Feedback Shift Register Let input sequence = (S0, S1, …Sn-1).

Number of shift registers = n.

Feedback is given as –

f(S) = ∑i=0

n-1

ciSi

where c0, c1,…cn-1 are constant coefficients.

Output is determined by initial value and linear recursion relationship –

Sk+n = ∑i=0

n-1

ciSk+i , k≥0 or

∑i=0

n

ciSk+i = 0

Lk({si}i0) is the linear complexity of the sequence S0, S1, …, Sk-1, and c(k)(x) to be the characteristic polynomial of Lk stage LFSR that generates Si, 0 i Sk-1.

LFSR- Linear Feedback Shift Register

Sk+n = ∑i=0

n-1

ciSk+i , k≥0

LFSR- Example Let LFSR be of length 4 with initial state 0110.

If c0 = c2 = c3 =1 and c1 = 0, design LFSR.

(S0, S1, S2, S3) = 0110

S4 = c0S0 +c1S1 + c2S2 +c3S3 = 1.0 + 0.1 + 1.1 + 1.0 = 1

S5 = c0S1 +c1S2 + c2S3 +c3S4 = 1.1 + 0.1 + 1.0 + 1.1 = 0

Sk+4 = c0Sk +c1Sk+1 + c2Sk+2 +c3Sk+3 = Sk + Sk+2 + Sk+3 .

Time LFSR State Output

0 0110 1

1 1101 0

2 1010 0

3 0100 0

4 1000 1

5 0001 1

6 0011 0

7 0110 1 Repeats…

Period = 7

LFSR - Properties

Characteristic polynomial of an LFSR is the polynomial,

f(x) = c0 + c1x + … + cn-1xn-1 + xn

where cn = 1 by definition.

In last example, the characteristic polynomial is given as 1 + x2 + x3 + x4.

Period of LFSR can be determined from the characteristic polynomial without knowledge of the input sequence.

Theorem : Every polynomial f(x) with coefficients in GF(2) having f(0) = 1 divides xm + 1 for some m. The smallest m for which this is true is called the period of f(x).

Example - Above example has c0 = 1, i,e f(0) = 1.

f(x) divides x7 + 1 as x7 + 1 = (1 + x2 + x3)(1 + x2 + x3 + x4) in GF(2).

m = 7 is the smallest integer in which f(x) divides xm + 1, thus the period of f(x) is 7.

LFSR - Properties

Theorem : An irreducible polynomial of degree n has a

period which divides 2n – 1.

Theorem : An irreducible polynomial of degree n whose

period is 2n – 1 is a primitive polynomial.

Example :f(x) = x4 + x3 + 1 is a monic irreducible polynomial

over GF(2). Find its period. (Highest or Leading Coefficient is 1)

We need to determine the smallest m such that f(x) divides

xm + 1.

f(x) is irreducible- it has a period which divides 24 – 1 = 15.

Since m > 4, our possible candidates are 5, 15 :

x5 + 1 = (x + 1)(x4 + x3 + 1) + (x3 + x)

x15 + 1 = (x11 + x10 + x9 + x8 + x6 + x4 +x3 + 1)(x4 + x3 + 1)

f(x) has period 15 and is a primitive polynomial.

Confirm by finding outputs.

Berlekamp – Massy Algorithm - Theorems

Berlekamp Massey Algorithm – This algorithm is similar to

Berlekamp decoding algorithm with a difference that –

Berlekamp decoding algorithm is used for decoding BCH

and RS codes,

While Berlekamp-Massey algorithm is used to find LFSR to

generate given binary sequence using same concept.

Berlekamp – Massy Algorithm - Example

Using the Berlekamp Massey Algorithm, find the polynomial of the lowest possible degree that will generate the sequence 1,1,0,1,0,0,1,0. Design LFSR.

S1S2S3S4S5S6S7S8 = 1 1 0 1 0 0 1 0

Set initial conditions.

i=1

d0 = 1 ≠ 0. σ(1)

(x) = σ(0)(x) + (x

0d0/x

-1d-1) σ

(-1)(x) = 1 + x (1+σ1x)

r1 = max(r0, 0 – n-1) = max(0, 1) = 1

n1 = 1 - r1 = 0

d1 =S2+S’2 = S2+σ1S1= 1+1 = 0

i=2

σ(2)(x) = σ(1)

(x) = 1 + x

r2 = r1= 1

n2 = 2 – r2 = 1

d2 =S3+S’3 = S3+σ1S2 +σ2S1 = 0+1 = 1 ≠ 0.


S1S2S3S4S5S6S7S8 = 1 1 0 1 0 0 1 0

i=3

σ(3)(x) = σ(2)

(x) + (x2d2/x

0d0) σ

(0)(x) = 1 + x + x

2. (1+σ1x+σ2x

2)

r3 = max(r2, 2 – n0) = max(1, 2) = 2

n3 = 3 – r3 = 1

d3 =S4+S’4 = S4+σ1S3+σ2S2 +σ3S1 = 0

i=4

σ(4)(x) = σ(3)

(x) = 1 + x + x2.

r4 = r3= 2, n4 = 4 – r4 = 2

d4 =S5+S’5 = S5+σ1S4 +σ2S3 +σ3S2+σ4S1 =1 ≠ 0. σ(5)

(x) = σ(4)(x) + (x

4d4/x

2d2) σ

(2)(x) = 1 + x + x

3.

….. i=8

σ(8)(x) = σ(7)

(x) + (x7d7/x

4d4) σ

(4)(x) = 1 + x + x

4 + x

5.


S1S2S3S4S5S6S7S8 = 1 1 0 1 0 0 1 0

i σ(i)(x) ri ni di

-1 1 0 -1 1

0 1 0 0 1 (S1)

1 1 + x 1 0 0

2 1 + x 1 1 1

3 1 + x + x2 2 1 0

4 1 + x + x2 2 2 1

5 1 + x + x3 3 2 0

6 1 + x + x3 3 3 0

7 1 + x + x3 3 4 1

8 1+x +x4+x5 5 3 0


S1S2S3S4S5S6S7S8 = 1 1 0 1 0 0 1 0

σ(x) = 1 + x + x4 + x

5. (1+σ1x +σ4x

4+σ5x

5)

S9 = σ1S8 +σ2S7 +σ3S6+σ4S5+σ5S4 =1. repeats

S10 = σ1S9 +σ2S8 +σ3S7+σ4S6+σ5S5 =1.

S11 = σ1S10 +σ2S9 +σ3S8+σ4S7+σ5S6 =0.

S12 = σ1S11 +σ2S10 +σ3S9+σ4S8+σ5S7 =1.

S13 = σ1S12 +σ2S11 +σ3S10+σ4S9+σ5S8 =0…..

S8 S4

S7

S6

S5

σ1

σ2

σ3

σ4

σ5

S4 S3 S2 S1

Mapping GF(2m) Codes into binary codes

With q=pm, elements of GF(q) can be represented by m-

tuples of elements from GF(p).

(N,K,D) Reed-Solomon codes over GF(q) becomes code

over GF(p) with (n = mN, k = mK, d ≥ D) If q=2m, binary codes so obtained have high minimum

distance.

Example: Let 1, α are basis for GF(4). (refer vector spaces). Map

the symbols in GF(2).

GF(4) has 4 elements which can be coded using 0 and 1

0 00

1 10

α 01

1 + α = α2 11


Example: Encode following (3,2,2) RS code over GF(4) into

(6,4,2) binary codes.

Alphabets = 4 (0, 1, α, α2 )

000 10α2 α01 α20α

01 α 111 α1α2 α2 10

0αα2 1α0 ααα α2α 1

0α2 1 1α2α αα2 0 α2α2α2

Code into binary.


Let c=(c0, c1, …cN-1) belong to an (N,K,D) RS code over

GF(2m).

If we replace each ci by its binary m-tuple, and add an

overall parity check on each m-tuple, the resulting binary

code has parameter– (2→3, 2→3, 2→3,… )

n = (m+1)(N=2m-1), k = mK, d ≥ 2D = 2(2m-K) (N-K+1)

for any K=1,…. 2m - 2.

If RS code is already an extended code then same

arrangement as above will now give binary code

parameters as

(parity check in two levels) (3→4) →(2→3, 2→3,… )

n = (m+1)(N=2m), k = mK, d ≥ 2D = 2(2m-K+1) for any

K=1,…. 2m - 1. Check

E.g. From the (15, 10, 6) and (16, 10, 7) codes over GF(24)

we obtain (75,40,12) and (80, 40, 14) binary codes.

Nested (Concatenated) Codes

Gives very long block code with very large or even burst

error correcting capability.

Combines a code of small alphabet size and a code of

large alphabet size.

A block of q-ary symbols of length kK is broken into K sub-

blocks of k symbols. (e.g. q=2, k=3)

Each sub-block is viewed as an element from a qk-ary

alphabet. (one of 8 symbol levels)

A sequence of K such sub-blocks are encodes with an

(N,K) code over GF(qk). (e.g RS code)

Each of N qk-ary symbols are re-interpreted as k q-ary

symbols and coded with an (n,k) q-ary code.

Two distinct levels of coding.

New code (nN, kK)


Combination of encoder, channel and decoder is thought of

as super-channel with larger input/output alphabet GF(qk).

(N,K) super-code is constructed over qk –ary alphabet for

this super-channel.


Example: Code for octal channel by nesting a (7,4) RS

code over GF(8) with a (22,18) RS code over GF(84).

Inner Code: (7, 4) RS code over GF(8).

Outer code: (22,18) RS code over GF(84).

72 octal message character in GF(8) are arranged in array

of 4X18.


4 characters in a column over GF(8) are considered as one

character in GF(84).

18 such characters in GF(84) are coded into 22 characters

using (22,18,5) outer RS code.

Each of 22 coded characters in GF(84) are reconsidered as

4 characters in GF(8) to give array 4X22.


4 characters in each column are coded by (7,4,4) inner RS

code over GF(8) to give array of 7X22.

Produces single code of block length 154 over GF(8).

Code (154,72) nested code over GF(8)

Symbols are transmitted row by row.


Received message is received with errors and erasures.

Inner coding was done vertically while characters were

transmitted and reassembled at receiver row-wise.

In spite of large errors or burst errors, errors in each

column are less.


All columns where column errors ≤ t, they are corrected by inner decoder.

Remaining error can now be corrected by outer decoder.


Example: Inner Code: (7, 3) DEC RS code over GF(8).

Outer code: (511, 505) TEC RS code over GF(83).

After nesting they form (3577, 1515) code over GF(8).

It can correct any pattern of 11 errors.

Input is block of 1515 octal characters.

Codeword is a vector of 3577 octal characters shown below in two dimensional array for illustration.

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 codeword has N-K+1 distinct non-

zero columns.

The weight is atleast as great as word constructed by filling

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

weight.

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

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

Hence there is a column of weight I for every I that satisfies

(2).

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

weights of these columns. 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 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 αn-2t+1, αn-2t+2, ….α0.

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 Πi’≠i

(x – αi’ ) = 0 (mod G(x))

Goppa Codes The Goppa code over GF(q) with block length n = qm 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 Πi’≠i

(x – βi’ ) = 0 (mod G(x))

Where βi’ ranges over all elements of GF(qm).

Special case – Binary Goppa codes are codes whose

Goppa polynomial has no repeated zeros in any extension

fiels.

Called seperable Goppa codes.

d* is atleast 2r+1 where r is degree of G(x).

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.

ERROR CONTROL CODING BOOKS:-

• Theory of Error Control Codes by MacWilliams and Slone

• Theory and practice of Error Control Codes by Balahut

• Error Control Coding by Salvatore Gravano

• Error Control Coding by Shu Lin and Daniel Costello

• Information Theory, Coding and Cryptography by Ranjan

Bose

Error control coding bch, reed-solomon etc..

Engineering

Transcript of Error control coding bch, reed-solomon etc..