3.7 Elements of Algebraic Decoding

3.7 Elements of Algebraic Decoding
The channel is viewed as a q-ary input, q-ary output, discrete
memoryless channel.
When an error is made in transmission of a code symbol with
probability P, the error is equally likely to be any of the q-1
possibilities. A possible extension is to let the demodulator
produce one of q symbols or an erasure when the demodulator
has a low confidence in its ability to decide which symbol
occurred.
Consider now the log-likelihood function for such a channel.
The conditional probability that
r = c
i
i
is received, given that
ci
was sent, satisfies
⎧1 - P ,
⎪
P ( ri
| ci
) = ⎨ P
,
⎪⎩ q - 1
r
r
i
i
= c
≠ c
i
i
where
ri
is the i-th component of the received word
r
= ( r ,r , L,
1)
0 1
rn-
Thus,
⎧log(
1 - P)
,
⎪
log P( ri
| ci
) = ⎨ P
log(
),
⎪⎩ q - 1
r
r
i
i
= c
≠ c
i
i

The ML decoding for this channel is equivalent to minimum
Hamming distance decoding.
In general, Hamming distance is the basis for two important
possible types of decoders:
(1) Complete error-correcting decoder:
A decoder which, given a received word
r , selects the
codeword c that minimizes ( r, c )
d H
as the transmitted
codeword.
The complete decoder is thus, for most channels, the ML
decoder.
If there are more than one codeword c
that minimizes
d H
( r, c )
, the complete decoder chooses randomly from
among the closest codewords.
(2) Bounded-distance decoder

3.8 Syndrome and Error Detection
Suppose a codeword c = c ,c , L,
) in a block code C is
(
0 1
cn-1
transmitted and the received word is given by r = r ,r , L,
) .
(
0 1
rn-
1
The difference between r and c gives the error pattern of
errors.
e
= r + c
= ( r0 + c0
,r1
+ c1
, L ,rn-1
+ cn-1)
= ( e0
,e1
, L,
en-1
)
There are a total
n
2 possible error patterns.
Among these error patterns, only
n-k
2 of them are correctable
by an (n, k) linear block code.
To minimize the probability of a decoding error, it is desired
to design a code, which corrects the
n-k
2 most probable
error patterns.
The (n-k)-vectors
s
r
H
c
e
T
≡ ⋅ = ( + )
⋅ H
T
= e ⋅ H
T
s = ( s ,s , L,
) 1
0 1
sn-k-

Note that H is a (n-k)× n matrix.
Then r is a codeword in code C if and only if s = 0 .
Hence, if s ≠ 0 , r is not a codeword, and contains
transmission errors. In this case, we say that the presence of
errors is being detected.
If s = 0 , r is a codeword. In this case, r is assumed to be
error-free and accepted by the receiver.
A decoding error is committed if r
is a codeword which is
different from the actually transmitted codeword.
s
= ( s L )
T
0
,s1
, ,sn-k-1
= e ⋅ H
The equation gives a relationship between the unknown error
pattern and the syndrome.
The elements of s are linear combinations only of the errors,
e
i , and, therefore, is called the syndrome of the error patterns.

Example:
If the parity-check matrix of the (6, 3)codeisgivenby
H
⎡1
=
⎢
0
⎢
⎢⎣
0
0
1
0
0
0
1
0
1
1
1
0
1
1⎤
1
⎥
⎥
0⎥⎦
Suppose that the received word is r = ( 10 10 0 1)
.
We first find that the syndrome s ≡ r ⋅ H
T = ( 0 1 1)
.
Hence r is not a codeword.
Syndrome circuit:
Considerthecaseof(6, 3) code given above with
H T
⎡1
⎢
0
⎢
⎢0
= ⎢
⎢
0
⎢1
⎢
⎣1
0
1
0
1
0
1
0⎤
0
⎥
⎥
1⎥
⎥
1
⎥
1⎥
⎥
0⎦
T
s = ( s , s1
, s2
) = r ⋅ H = ( r0
, r1
, r2
, r3
, r4
, r5
0
)
⎡1
⎢
0
⎢
⎢0
⎢
⎢
0
⎢1
⎢
⎣1
0
1
0
1
0
1
0⎤
0
1
1
1
⎥ ⎥⎥⎥⎥⎥⎥ 0⎦

∴
s
s
s
s
0
1
2
= r
0
= r + r
1
= r
2
+ r
3
4
+ r
3
+ r
+ r
5
5
+ r
4
can be implemented as a combinational circuit.
Example:
(7, 4) linear block code.
Let
H
⎡1
=
⎢
0
⎢
⎢⎣
0
0
1
0
0
0
1
1
1
0
0
1
1
1
1
1
1⎤
0
⎥
⎥
1⎥⎦
Suppose c = ( 10 0 10 1 1)
and r = ( 10 0 10 0 1)
is transmitted
is received.
T
Thenthesyndromeof r is s = ( s s s ) = r ⋅ H ( 1 1 1)
.
0 1 2
=
Let e = (e ,e ,e ,e ,e ,e , ) be the error pattern
0 1 2 3 4 5
e6
Since
s
= r ⋅ H
T
We have
1
= e0
+ e3
+ e5
+ e6
1 = e
1 = e
1
2
+ e
+ e
3
4
+ e
4
+ e
5
+ e
5
+ e
6

There are 16 possible solutions for e .
0 0 0 0 0 10
1 10 10 10
0 1 10 1 10
10 1 1 1 10
1 1 10 0 0 0
0 0 1 10 0 0
10 0 0 10 0
0 10 1 10 0
10 10 0 1 1
0 1 1 10 1 1
1 10 0 1 1 1
0 0 0 1 1 1 1
0 10 0 0 0 1
10 0 10 0 1
0 0 10 10 1
1 1 1 1 10 1
While the true error pattern is
e = r + c = ( 10 0 10 0 1)
+ ( 10 0 10 1 1)
= ( 0 0 0 0 0 10)

3.9 Standard Array
The standard array is a way of tabulating all of the
n
q
n-tuples
over GF(q).
This
n-k k
q × q rectangular array is used as a decoding table by
simply locating the minimum-weight n-tuple word in the table.
The n-tuple in the i-th column equals the sum of the codeword
heading the i-th column and the minimum-weight error pattern
which appears in the same of the first column.
Formation of standard array:
For an (n, k) linear binary code
Let
c
= 0, c , L,
k be the
1 1
c2
k
2 codewords in C.
(1) First we arrange the
the array with c 1
= 0
k
2 codewords from C as the top row of
as the first element.
(2) Suppose we have formed the (j-1)-th row of the array.
(3) Choose a vector e
j from V n which is not in the previous j-1
rows.

Form the j-th row by adding
e
j to each codeword ci
in the
top row and placing
e
j
+ ci
under i
c .
(4) The array is completed when no vector can be chosen from
V
n .
(5) This array, called standard array, is shown below.
c 1
= 0 c
2
• • •
c
i
• • •
k c 2
e2
e
2
+ c2
• • •
e
2
+ c i
• • •
e
2
+ c 2
k
M
e e c
2 -k
2
n-k
2
n + • • •
e
n + • • •
c
2 -k
i
e
n-k
+ c
2 2
k
Note:
(a) Each row is called a coset.
(b) There are exactly
n-k
2 cosets.
(c) The first element of each coset is called the coset leader.
(d) Every vector in
array.
Vn
appears one and only once in the
(e) All the vectors in a given row must have the same
syndrome. The syndrome of the vectors in different rows
cannot be equal.

Example: (page 95) (6, 3) linear block code.
⎡0
G =
⎢
1
⎢
⎢⎣
1
1
0
1
1
1
0
1
0
0
0
1
0
0⎤
0
⎥
⎥
1⎥⎦
Standard array:
000000 000001 000010 000100 001000 010000 100000 001001
110001
101010
011011
011100
101101
110110
000111
110000
101011
011010
011101
101100
110111
000110
110011
101000
011001
011110
101111
110100
000101
110101
101110
011111
011000
101001
110010
000011
111001
100010
010011
010100
100101
111110
001111
100001
111010
001011
001100
111101
100110
010111
010001
001010
111011
111100
001101
010110
100111
111000
100011
010010
010101
100100
111111
001110
Table 3.4 Standard Array for the (6, 3) single-error-correcting code.

3.10 Syndrome Decoding Using Standard Array
Syndrome decoding can be done by using a table (standard array)
which consists of
n-k
2 correctable error patterns (coset leaders)
and their corresponding syndrome.
s
s
s 1
= 0
e 1
= 0
T
2
= e2
⋅ H
2
T
3
= e3
⋅ H
3
e
e
M
M
s
T
-k e k ⋅ H
2 n 2
n-
e 2
= n-k
Example:
Consider the (6, 3) linear block code generated by
⎡0
G =
⎢
1
⎢
⎢⎣
1
1
0
1
1
1
0
1
0
0
0
1
0
0⎤
0
⎥
⎥
1⎥⎦
The parity-check matrix is
H T
⎡1
=
⎢
0
⎢
⎢⎣
0
0
1
0
0
0
1
0
1
1
1
0
1
1⎤
1
⎥
⎥
0⎥⎦

Syndrome decoding table for this code is constructed by using H
and is shown below
s
e
000 000000
110 000001
101 000010
011 000100
001 001000
010 010000
100 100000
111 001001
Suppose the received word is r = ( 10 10 0 1)
Then s = r ⋅ H
T = ( 0 1 1)
The corresponding error pattern is e = ( 0 0 0 10 0 )

Implementation of Syndrome Decoding (Fig. 3.9)
The decoding circuit can be implemented by combinational
circuit from the syndrome-error pattern look-up table, such as
the table shown in the Example.
e
e
0
1
= s
= s&
M
0
0
I s&
I s
1
1
I s&
I s&
2
2
e
5
= s
0
I s
1
I s&
2
+ s
1
I s
2
I s
3
Here s&
1 is the complement of s
1 .