BCH code

A BCH (Bose, Ray-Chaudhuri, Hocquenghem) code is a much studied code within the study of coding theory. In technical terms it is multilevel, cyclic, error-correcting, variable-length digital code used to correct errors up to approximately 25% of the total number of digits.

BCH codes are not limited to binary codes, but may be used with multilevel phase-shift keying whenever the number of levels is a prime number or a power of a prime number. A BCH code in 11 levels has been used to represent the 10 decimal digits plus a sign digit.

BCH codes make use of field theory and polynomials over that field. The way the check polynomial is constructed provides the key to indicating that an error has occurred.

If we wish to construct a BCH code to detect and correct 2 errors we use the finite field GF(16) or Z₂[x]/<x⁴+x+1>

Now if we have α a root of x⁴+x+1, m₁(x)=x⁴+x+1. Now m₁ is minimal for α since

m₁(x)=(x-α)(x-α²)(x-α⁴)(x-α⁸)=x⁴+x+1.

If we wish to construct a code to correct 1 error we use m₁(x). Our codewords will be

C(x)≡0 (mod m₁(x))

which has roots α, α², α⁴, α⁸.

This does not allow us to choose many codewords - so we look for the minimal polynomial for the missing power of α from above - α³, and then the minimal polynomial for this is

m₃(x)=x⁴+x³+x²+x+1.

which has roots α³, α⁶, α¹², α²⁴=α⁹.

We take codewords having all of these as roots, so we form the polynomial

m_1,3(x)=m₁(x)m₃(x)=x⁸+x⁷+x⁶+x⁴+1

and take codewords corresponding to polynomials of degree 14 such that

C(x)≡0 (mod m_1,3(x))

So now C(α)=C(α²)=...=C(α⁸)=0. (*)

Now in GF(16) we have 15 nonzero elements, and thus our polynomial will be of degree 14 with 8 check and 7 information bits - we have 8 check bits since we have (*).

Encoding

Construct our information codeword as

(c₁₄, c₁₃, ..., c₈)

so our polynomial will be

c₁₄+c₁₃+...+c₈

Call this C_I.

We then want to find a C_R such that C_R=C_I (mod m_1,3(x))=c₇+c₆+...+c₀

So we have the following codeword to send C(x) = C_I+C_R (mod m_1,3(x)) = 0

For example, if we are to encode (1,1,0,0,1,1,0)

C_I=x¹⁴+x¹³+x¹⁰+x⁹

and using polynomial long division of m_1,3(x) and C_I to get C_R(x), in Z₂ we obtain C_R to be

x³+1

So then the codeword to send is

(1,1,1,0,0,1,1,0, 0,0,0,0,1,0,0,1)

Decoding

BCH decoding is split into the following 4 steps

1. Calculate the 2t syndrome values, for the received vector R
2. Calculate the error locator polynomials
3. Calculate the roots of this polynomial, to get error ___location positions.
4. If non-binary BCH, Calculate the error values at these error locations.

The following steps are illustrated below. Suppose we receive a codeword vector r (the polynomial R(x)).

If there is no error R(α)=R(α³)=0

If there is one error, ie r=c+e_i where e_i represents the ith basis vector for R¹⁴

So then

S₁=R(α)=C(α)+αⁱ=αⁱ

S₃=R(α³)=C(α³)+(α³)ⁱ

=(αⁱ)³=S₁³

so we can recognize one error. A change in the bit position shown by α's power will aid us correct that error.

If there are two errors

r=c+e_i+e_j

then

S₁=R(α)=C(α)+αⁱ+α^j

S₃=R(α³)=C(α³)+(α³)ⁱ+(α³)^j

= (α³)ⁱ+(α³)^j

which is not the same as S₁³ so we can recognize two errors. Further algebra can aid us in correcting these two errors.

Original source (first two paragraphs) from Federal Standard 1037C

Popular decoding algorithms are,

1. Peterson Gorenstein Zierler algorithm

Peterson Gorenstein Zierler Algorithm

Petersons algorithm, is the step 2, of the generalized BCH decoding procedure. We use Peterson's algorithm, to calculate the error locator polynomial coefficients

${\displaystyle \lambda _{1},\lambda _{2}...\lambda _{2t}}$ 

of a polynomial ${\displaystyle \Lambda (x)=1+\lambda _{1}X+\lambda _{2}X^{2}+...+\lambda _{2t}X^{2t}}$ .

Now the procedure of the Peterson Gorenstein Zierler algorithm, for a given ${\displaystyle (n,k,d_{min})}$  BCH code designed to correct

${\displaystyle [t={\frac {d_{min}-1}{2}}]}$  

errors, is

• First generate the Matrix of ${\displaystyle 2t}$  syndromes,
• Next generate the ${\displaystyle S_{txt}}$  matrix with the elements, Syndrome values,

${\displaystyle S_{t\times t}={\begin{bmatrix}s_{1}&s_{2}&s_{3}&...&s_{t}\\s_{2}&s_{3}&s_{4}...&s_{t+1}\\s_{3}&s_{4}&s_{5}&...&s_{t+2}\\...&...&...&...&...\\s_{t+1}&s_{t+2}&s_{t+3}&...&s_{2t-1}\end{bmatrix}}}$ 

• Generate a ${\displaystyle c_{tx1}}$  matrix with, elements,

${\displaystyle C_{t\times 1}={\begin{bmatrix}s_{t+1}\\s_{t+2}\\...\\...\\s_{2t}\end{bmatrix}}}$ 

• Let ${\displaystyle \Lambda }$  denote the unknown polynomial coefficients, which are given,using,

${\displaystyle \Lambda _{t\times 1}={\begin{bmatrix}\lambda _{1}\\\lambda _{2}\\\lambda _{3}\\\lambda _{4}\\...\\\lambda _{t}\end{bmatrix}}}$ 

• Form the matrix equation

${\displaystyle S_{t\times t}\Lambda _{t\times 1}=C_{t\times 1}}$ 

• If the determinant of matrix ${\displaystyle S_{t\times t}}$  exists, then we can actually, find an inverse of this matrix, and solve for the values of unknown ${\displaystyle \Lambda }$  values.

• If ${\displaystyle det(S_{t\times t})=0}$ ,

 then
       if ${\displaystyle t=0}$ 
       then
             declare a empty error locator polynomial
             stop peterson procedure.
       end
       set ${\displaystyle t\rightarrow t-1}$ 
       continue from the beginning of petersons decoding
 end

• After you have values of ${\displaystyle \Lambda }$  you have with you the error locator polynomial.
• Stop peterson procedure.