advantage of generator matrix: we need to store only the k rows of g instead of 2 k vectors of the...

ADVANTAGE of GENERATOR MATRIX:

we need to store only the k rows of G instead of 2k vectors of

the code.

for the example we have looked at generator array of (36)

replaces the original code vector of dimensions (8 6).

This is a definite reduction in complexity .

Error Control Coding © Erhan A. Ince

Systematic Linear Block Codes Systematic (n,k) linear block codes has such a mapping that

part of the sequence generated coincides with the k message

digits.

Remaining (n-k) digits are parity digits

A systematic linear block code has a generator matrix of the form :


kIPG

100)(,21

010)(,22221

001)(,11211

knkp

kp

kp

knppp

knppp

P is the parity array portion of the generator matrix

pij = (0 or 1)

Ik is the (kk) identity matrix.

With the systematic generator encoding complexity is further

reduced since we do not need to store the identity matrix.

Since U = m G


100)(,21

010)(,22221

001)(,11211

,........,2

,1

,........,2

,1

knkp

kp

kp

knppp

knppp

nmmmnuuu

where

And the parity bits are

given the message k-tuple

m= m1,……..,mk

And the general code vector n-tuple

U = u1,u2,……,uk

Systematic code vector is:

U = p1,p2……..,pk , m1,m2,……,mk


nkniforkni

m

kniforki

pk

mi

pmi

pmiu

),....,1(

)(,.....,1.......2211

)(,........

)(,22)(,11

2........

2221212

1........

2121111

knkp

km

knpm

knpm

knp

kp

kmpmpmp

kp

kmpmpmp

Example:

For a (6,3) code the code vectors are described as

P I3

U = m1+m3, m1+m2, m2+m3, m1, m2, m3

u1 , u2 , u3, u4, u5, u6


100101

010110

001011

3,

2,

1mmmU

Parity Check Matrix (H) We define a parity-check matrix since it will enable us to

decode the received vectors.

For a (kn) generator matrix G

There exists an (k-n) n matrix H

Such that rows of G are orthogonal to the rows of H

i.e G HT = 0

To satisfy the orthogonality requirement H matrix is written as:


Tkn

PIH

Hence

The product UHT of each code vector is a zero vector.

Once the parity check matrix H is formed we can use it to

test whether a received vector is a valid member of the

codeword set. U is a valid code vector if and only if

UHT=0.Error Control Coding © Erhan A. Ince

)(,21

)(,22221

)(,11211

100

010

001

knkkk

kn

kn

kn

T

ppp

ppp

pppP

I

H

0UH

kn

pkn

pppppT ,......,22

,11

Syndrome TestingLet r = r1, r2, ……., rn be a received code vector (one of 2n n-tuples)

Resulting from the transmission of U = u1,u2,…….,un (one of the 2k n-tuples).

r = U + e

where e = e1, e2, ……, en is the error vector or error pattern introduced by the channel In space of 2n n-tuples there are a total of (2n –1) potential nonzero error patterns.

The SYNDROME of r is defined as:

S = r HT

The syndrome is the result of a parity check performed on r to

determine whether r is a valid member of the codeword set.


If r contains detectable errors the syndrome has some non-zero value

syndrome of r is seen as

S = (U+e) HT = UHT + eHT

since UHT = 0 for all code words then :

S = eHT

An important property of linear block codes, fundamental to the

decoding process, is that the mapping between correctable error

patterns and syndromes is one-to-one.


Parity check matrix must satisfy:

1. No column of H can be all zeros, or else an error in the

corresponding code vector position would not affect the

syndrome and would be undetectable

2. All columns of H must be unique. If two columns are identical errors corresponding to these code word locations will be indistinguishable.


Example:Suppose that code vector U = [ 1 0 1 1 1 0 ] is transmitted and the

vector r = [ 0 0 1 1 1 0 ] is received.

Note one bit is in error..

Find the syndrome vector,S, and verify that it is equal to eHT.

(6,3) code has generator matrix G we have seen before:

P I

P is the parity matrix and I is the identity matrix.


100101

010110

001011

G

S = r HT =

= [ 1, 1+1, 1+1 ] = [ 1 0 0]

(syndrome of corrupted code vector)


101

110

011

100

010

001

3,32,31,3

3,22,21,2

3,12,11,1

100

010

001

ppp

ppp

pppTH

101

110

011

100

010

001

]001110[

Now we can verify that syndrome of the corrupted code vector is the same as the syndrome of the error pattern:

S = eHT = [1 0 0 0 0]HT = [ 1 0 0 ]

( =syndrome of error pattern )


Error CorrectionSince there is a one-to-one correspondence between correctable error patterns and syndromes we can correct such error patterns.

Assume the 2n n-tuples that represent possible received vectors are arranged in an array called the standard array.

1. The first row contains all the code vectors starting with all-zeros

vector

2. First column contains all the correctable error patterns

The standard array for a (n,k) code is:


kne

kU

kneU

kne

je

iU

je

ek

Uei

UeUek

Ui

UUU

22222

222222

221

Each row called a coset consists of an error pattern in the first column, also known as the coset leader, followed by the code vectors perturbed by that error pattern.

The array contains 2n n-tuples in the space Vn

each coset consists of 2k n-tuples

there are cosets

If the error pattern caused by the channel is a coset leader, the received vector will be decoded correctly into the transmitted code

vector Ui. If the error pattern is not a coset leader the decoding will produce an error.


knk

n2

2

2

Syndrome of a Coset If ej is the coset leader of the jth coset then ;

Ui + ej is an n-tuple in this coset

Syndrome of this coset is:

S = (Ui + ej)HT = Ui HT + ejHT

= ejHT

All members of a coset have the same syndrome and in fact the syndrome is used to estimate the error pattern.


Error CorrectionDecodingThe procedure for error correction decoding is as follows:

1. Calculate the syndrome of r using S = rHT

2. Locate the coset leader (error pattern) , ej, whose syndrome equals rHT

3. This error pattern is the corruption caused by the channel

4. The corrected received vector is identified as U = r + ej .

We retrieve the valid code vector by subtracting out the identified error

Note: In modulo-2 arithmetic subtraction is identical to that of addition


Example:Locating the error pattern:

For the (6,3) linear block code we have seen before the standard array can be arranged as:

000000 110100 011010 101110 101001 011101 110011 000111

000001 110101 011011 101111 101000 011100 110010 000110

000010 110110 011000 101100 101011 011111 110001 000101

000100 110000 011110 101010 101101 011001 110111 000011

001000 111100 010010 100110 100001 010101 111011 001111

010000 100100 001010 111110 111001 001101 100011 010111

100000 010100 111010 001110 001001 111101 010011 100111

010001 100101 001011 111111 111000 001100 100010 010110


The valid code vectors are the eight vectors in the first row and the correctable error patterns are the eight coset leaders in the first column.

Decoding will be correct if and only if the error pattern caused by the channel is one of the coset leaders

We now compute the syndrome corresponding to each of the correctable error sequences by computing ejHT for each coset leader


101

110

011

100

010

001

jeS

Syndrome lookup table..

error pattern Syndrome

0 0 0 0 0 0 0 0 0

0 0 0 0 0 1 1 0 1

0 0 0 0 1 0 0 1 1

0 0 0 1 0 0 1 1 0

0 0 1 0 0 0 0 0 1

0 1 0 0 0 0 0 1 0

1 0 0 0 0 0 1 0 0

0 1 0 0 0 1 1 1 1


Error CorrectionWe receive the vector r and calculate its syndrome S We then use the syndrome-look-up table to find the corresponding error pattern.This error pattern is an estimate of the error, we denote it as ê

The decoder then adds ê to r to obtain an estimate of the transmitted

code vector û

Û = r + ê = (U + e) + ê = U + (e ê)

If the estimated error pattern is the same as the actual error pattern that

is if ê = e then û = U

If ê e the decoder will estimate a code vector that was not transmitted and hence we have an undetectable decoding error.


ExampleAssume code vector U = [ 1 0 1 1 1 0 ] is transmitted and the vector r=[0 0 1 1 1 0] is received.

The syndrome of r is computed as:

S = [0 0 1 1 1 0 ]HT = [ 1 0 0 ]

From the look-up table 100 has corresponding error pattern:

ê = [1 0 0 0 0 0 ]

The corrected vectors is the Û = r + ê = 0 0 1 1 1 0 + 1 0 0 0 0 0

= 1 0 1 1 1 0 (corrected)

In this example actual error pattern is the estimated error pattern,

Hence û = U


advantage of generator matrix: we need to store only the k rows of g instead of 2 k vectors of the...

Documents