EE 387, Notes 15, Handout #26

Cyclic codes: review

◮ A cyclic code is a LBC such that every cyclic shift of a codeword is a
codeword.
◮ A cyclic code has generator polynomial g(x) that is a divisor of every
codeword.
◮ The generator polynomial is a divisor of xn − 1, where n is blocklength.
xn − 1
◮ The parity-check polynomial is h(x) = .
g(x)
◮ Codewords can be generated by:
nonsystematic: m(x) → m(x)g(x)
systematic: m(x) → xn−k m(x) − Rg(x) xn−k m(x)

◮ Codewords can be characterized by (and errors detected by):

c(x) mod g(x) = 0
c(x)h(x) = 0 mod (xn − 1)
EE 387, October 28, 2015 Notes 15, Page 1
Examples of binary cyclic codes
Example: Over GF(2) the cyclic polynomial of degree 6 can be factored as
x6 − 1 = (x3 ± 1)2 = (x + 1)2 (x2 + x + 1)2 .
The binary cyclic codes of blocklength 6 have generator polynomials
(x + 1)i (x2 + x + 1)j , 0 ≤ i ≤ 2, 0 ≤ j ≤ 2
None of these 9 cyclic codes is interesting — poor minimum distance.
Example: Over GF(2), x7 − 1 = (x + 1)(x3 + x + 1)(x3 + x2 + 1).
There are 23 = 8 divisors x7 − 1 and thus 8 cyclic codes of blocklength 7.
Primitive polynomial yields cyclic Hamming code; e.g., g(x) = x3 + x + 1 .
 
1 1 0 1 0 0 0 
1 0 0 1 0 1 1

 0 1 1 0 1 0 0 
G=   =⇒ H = 0 1
 0 1 1 1 0 
1 1 1 0 0 1 0 
1 0 1 0 0 0 1 0 0 1 0 1 1 1

The “dual” code has generator matrix H, the (7, 3) maximum-length code.
All nonzero codewords have the same weight, 2m−1 = 4.
EE 387, October 28, 2015 Notes 15, Page 2
Cyclic codes of blocklength 15
Over GF(2) the cyclic polynomial x15 − 1 has five distinct prime factors:
x15 − 1 = (x + 1)(x2 + x + 1) ·
(x4 + x + 1)(x4 + x3 + 1)(x4 + x3 + x2 + x + 1)
There are 25 cyclic codes. Some of the more useful generator polynomials:

(x4 + x + 1) (15,11) binary cyclic Hamming

4 4 3 2
(x + x + 1)(x + x + x + x + 1) (15,7) 2-error-correcting BCH
4 4 3 2 2
(x + x + 1)(x + x + x + x + 1)(x + x + 1) (15,5) 3EC BCH
4 4 3 2 2
(x + x + 1)(x + x + x + x + 1)(x + x + 1)(x + 1) (15,4) maximum-length

These codes, with d∗ = 3, 5, 7, 8 , are obtained by expurgation.

Weight 1 0 0 35 105 168 280 435 435 280 168 105 35 0 0 1
distributions of 1 0 0 0 0 18 30 15 15 30 18 0 0 0 0 1
blocklength 15 1 0 0 0 0 0 0 15 15 0 0 0 0 0 0 1
cyclic codes 1 0 0 0 0 0 0 0 15 0 0 0 0 0 0 0

EE 387, October 28, 2015 Notes 15, Page 3

Equivalent codes
The cyclic (7, 4) Hamming code is different from earlier (7, 4) Hamming
code; check bits are in positions 1, 2, 3 instead of 1, 2, 4.
   
1 0 1 0 1 0 1 1 0 0 1 0 1 1
Hold =  0 1 1 0 0 1 1  6= Hcyclic =  0 1 0 1 1 1 0
0 0 0 1 1 1 1 0 0 1 0 1 1 1

Definition: Two block codes that are the same except for a permutation of
the symbol positions are called equivalent.
◮ Equivalent codes have same weight distribution and minimum weight.
◮ Not every linear block code is systematic. Consider this generator matrix:
 
1 1 0 0
G=
0 0 1 1
◮ Every linear block code is equivalent to a linear block code that has a
systematic generator matrix G = [ P | I ] (or G = [ I | P ]).

EE 387, October 28, 2015 Notes 15, Page 4

Parity-check polynomial
The parity-check polynomial of cyclic code with generator polynomial g(x)
is
xn − 1
h(x) = .
g(x)
The degree of the parity-check polynomial is n − (n − k) = k.
Parity-check polynomial defines a relation satisfied by all codewords:
c(x)h(x) = m(x)g(x)h(x) = m(x)(xn − 1)
= xn m(x) − m(x) = 0 mod (xn − 1)
= (0, . . . , 0, m0 , . . . , mk−1 ) − (m0 , . . . , mk−1 , 0, . . . , 0)
Therefore coefficients of xi in c(x)h(x) are 0 for i = k, . . . , n − 1.
This corresponds to n − k check equations:
xk =⇒ 0 = c0 hk + c1 hk−1 + · · · + ck−1 h1 + ck h0
xk+1 =⇒ 0 = c1 hk + c2 hk−1 + · · · + ck h1 + ck+1 h0
.. ..
. .
xn−1 =⇒ 0 = cn−k−1 hk + cn−k hk−1 + · · · + cn−2 h1 + cn−1 h0
EE 387, October 28, 2015 Notes 15, Page 5
Parity-check matrix: nonsystematic
The n − k check equations obtained from c(x)h(x) = 0 mod (xn −1)
correspond to a nonsystematic parity-check matrix:
c0 c1 · · · ck−1 ck ck+1 ck+2 · · · cn−1
hR (x)
   
hk hk−1 · · · h1 h0 0 0 ··· 0
0 hk hk−1 · · · h1 h0 0 ··· 0   xhR (x) 
   
. ..  ..
.. .. .. .. .. ..
 
.
H1 =  . . . . . . . .= .
  

   
 0 ··· 0 hk hk−1 · · · h1 h0 0  x
  n−k−2 R
h (x)
 
0 ··· 0 0 hk hk−1 · · · h1 h0 x n−k−1 R
h (x)

This matrix has the same form as the nonsystematic generator matrix.
The rows of H1 are shifts of the reverse of h(x).
hR (x) = hk + hk−1 x + · · · + h1 xk−1 + h0 xk .
Since h(x) is also a divisor of xn − 1, it generates an (n, n − k) cyclic code.
EE 387, October 28, 2015 Notes 15, Page 6
Parity-check matrix: nonsystematic (cont.)
Since hR (x) = xk h(x−1 ), zeroes of hR (x) are reciprocals of zeroes of h(x).
Thus hR (x) is also called the reciprocal polynomial.
The equation
gR (x)hR (x) = (g(x)h(x))R

= (xn − 1)R = 1 − xn = −(xn − 1)

shows that hR (x) is a divisor of xn − 1.
Parity-check matrix H1 has the form of a nonsystematic generator matrix.
Rows of H1 are shifts of the reversal polynomial hR (x). Thus h−1 R
0 h (x)
generates a cyclic code.
The cyclic code generated by h(x) consists of the reversals of the dual of
the cyclic code generated by g(x).

EE 387, October 28, 2015 Notes 15, Page 7

Syndrome circuit #1
Syndrome computation circuit corresponding to H1 multiplies by the fixed
polynomial h(x).
r(x)h(x)

h4 h3 h2 h1 h0

r(x)

This circuit convolves input sequence r0 , r1 , . . . , rn−1 with parity-check

polynomial coefficient sequence h0 , h1 , . . . , hk .
Since deg r(x) ≤ n − 1, the product r(x)h(x) has degree ≤ n − 1 + k.
Only n − k of the n + k coefficients of r(x)h(x) are used as the syndrome.
The syndrome consists of the coefficients of xk , . . . , xn−1 in r(x)h(x).
These are generated after rn−1 , . . . , rn−k have been shifted into the register.
EE 387, October 28, 2015 Notes 15, Page 8
Syndrome polynomial
We can obtain the systematic parity-check matrix from the systematic
generator matrix using the general approach:
G = [ P | I ] =⇒ H = [ I | −P T ]
Direct construction: define syndrome polynomial to be the remainder of
division by generator polynomial:
s(x) = r(x) mod g(x) = s0 + s1 x + · · · + sn−k−1 xn−k−1
Every codeword is a multiple of g(x), so codewords have syndrome 0. Thus
s(x) = r(x) mod g(x) = (c(x) + e(x)) mod g(x)
= c(x) mod g(x) + e(x) mod g(x) = e(x) mod g(x)
The remainder function is linear in the dividend r(x).
Therefore remainders of all n-tuples are linear combinations of
xi mod g(x) (i = 0, 1, . . . , n − 1)

EE 387, October 28, 2015 Notes 15, Page 9

Parity-check matrix: systematic
Polynomial syndrome s(x) corresponds to systematic parity-check matrix:
T
1

 
[n−k] [n−2] [n−1]
 x  1 0 ··· 0 s0 · · · s0 s0
 ..  
[n−k] [n−2] [n−1]

.
   
   0 1 ··· 0 s1 ··· s1 s1 

x n−k−1   
H2 = 
 = 
 xn−k mod g(x)   ... ... . . . .. .. .. .. ..
  
   . . . . . 

 ..   
 . 
0 0 ···
[n−k] [n−2]
1 sn−k−1 · · · sn−k−1 sn−k−1
[n−1]
xn−1 mod g(x)

Column i of H2 is syndrome of xi , consists of coefficients of xi mod g(x).

Special case: column n − k consists of coefficients of −g(x) except xn−k .
Column i is obtained from column i − 1 by a linear feedback shift.

EE 387, October 28, 2015 Notes 15, Page 10

Syndrome circuit #2
Syndromes corresponding to H2 can be calculated very efficiently using
linear feedback shift register circuits that implement polynomial division.

g0 g1 g2 g3 −1

r(x) r(x) div g(x)

r(x) mod g(x)

Encoding circuits can also be used for syndrome computation:

syndrome = actual check symbols − expected check symbols
where expected check symbols are computed from received message
symbols using the above encoder.

EE 387, October 28, 2015 Notes 15, Page 11

Partial syndromes
The zeroes of the generator polynomial determine codewords:

c(x) is codeword ⇐⇒ c(β) = 0 for every zero β of g(x).

(The “if” holds when g(x) has no repeated zeroes, i.e., repeated factors.)
The zeroes of g(x) belong to extension field GF(q m ) of GF(q).
Let {β1 , . . . , βt } include at least one zero of each prime factor of g(x) .
The partial syndromes S1 , . . . , St of r(x) are defined to be
Si = r(βi ) = r0 + r1 βi + · · · + rn−1 βin−1 (i = 1, . . . , t)
The partial syndromes belong to the same extension field as β1 , . . . , βt .
Syndrome component Si corresponds to m linear equations over GF(q).
The equations are linearly dependent if βi is in a proper subfield of GF(q m ).

EE 387, October 28, 2015 Notes 15, Page 12

Example: cyclic Hamming code
Let p(x) be a primitive polynomial over GF(2) of degree m.
The smallest value of n such that p(x) | (xn − 1) is n = 2m − 1.
Cyclic code generated by p(x) has blocklength n = 2m − 1.
The parity-check matrix H whose columns are xi mod p(x) has distinct
nonzero columns, so the code can correct all single errors.
The columns of H are powers of α = x in GF(2m ):
H = 1 α α2 · · · αn−2 αn−1
 

Assume a single error in location i, i.e., e(x) = xi . Partial syndrome for α:

S1 = r(α) = r0 + r1 α + · · · + rn−1 αn−1
= c(α) + e(α) = e(α) = αi .
Decoder must find error location i from syndrome S1 = αi , i.e., decoder
must compute a discrete logarithm base α.
EE 387, October 28, 2015 Notes 15, Page 13
Nonbinary Hamming codes
Every 1EC code has d∗ ≥ 3, hence any two columns of check matrix are LI,
hence no column of H is a multiple of another column.
There are q m − 1 m-tuples over GF(q). The largest number of pairwise LI
columns is
qm − 1
= q m−1 + q m−2 + · · · + q + 1 .
q−1
since we can use only one of the q − 1 nonzero multiples of any m-tuple.
We normalize columns by requiring first nonzero entry to be 1. Example:
 
1 1 1 1 1 1 1 1 1 0 0 0 0
H= 0 0 0 1 1
 1 2 2 2 1 1 1 0 .
0 1 2 0 1 2 0 1 2 0 1 2 1
Decoding procedure for this (13, 10) code:
1. Compute syndrome s = rH T .
2. Normalize syndrome by dividing by first nonzero entry si .
3. Equal column of H is error location, and si is error magnitude.
EE 387, October 28, 2015 Notes 15, Page 14
Cyclic nonbinary Hamming codes
A cyclic nonbinary Hamming code is defined by an element β of GF(q m ) of
order n = (q m − 1)/(q − 1). The check matrix is
H = 1 β β 2 · · · β n−1 ,
 

and g(x) is the minimal polynomial over GF(q) of β. (Fact: deg g(x) = m)
Columns of H are LI over GF(q) if and only if β j /β i = β l is not in GF(q).
Fact: There exists a cyclic Hamming code of blocklength n if and only if n
and q − 1 are coprime, which is true if and only if m and q − 1 are coprime.
Example: If q = 3 then q − 1 = 2, so odd values of m are required.
Let GF(33 ) be defined by primitive polynomial x3 + 2x + 1, and β = α2 .
 
1 0 0 1 2 0 2 0 1 1 1 2 1
H = 1 α2 . . . α22 α24 =  0 0 2 1 0 1 0 2 2 2 1 2 2  .
 

0 1 1 1 2 1 1 0 0 1 2 0 2
The generator polynomial x3 + x2 + x + 2 can be found by several
methods, then used to construct a systematic parity-check matrix.
EE 387, October 28, 2015 Notes 15, Page 15
Cyclic binary Golay code
Multiplicative orders of elements of GF(211 ) divide 211 − 1 = 23 · 89.
There are φ(23) = 22 elements of order 23. Conjugates of any such β are
β, β 2 , β 4 , β 8 , β 16 , β 9 , β 18 , β 13 , β 3 , β 6 , β 12
The minimal polynomial has degree 11. Prime polynomials of degree 11 are
g(x) = x11 + x10 + x6 + x5 + x4 + x2 + 1
g̃(x) = x11 + x9 + x7 + x6 + x5 + x + 1
These polynomials are mirror images; their zeroes are reciprocals.
Consecutive powers β, β 2 , β 3 , β 4 among the conjugates guarantee d∗ ≥ 5.
Lemma: Golay codewords of even weight have weight a multiple of 4.
Theorem: The cyclic Golay codes has d∗ = 7 and in fact are perfect codes.

Weight enumerator: 1 + 253x7 + 506x8 + 1288x11 + 1288x12 + 506x15 + 253x16 + x23

EE 387, October 28, 2015 Notes 15, Page 16
Examples of cyclic codes: CRC-16
Cyclic codes are often used for error detection because the encoding and
syndrome calculation circuits are very simple.

The most common generator polynomial is CRC-16:

CRC-16 = x16 + x15 + x2 + 1 = (x + 1)(x15 + x + 1)
CRC-16 is simplest polynomial of degree 16 with degree 15 primitive factor.
The factor x15 + x + 1 is primitive of degree 15 hence has order 215 − 1 .
Therefore the design blocklength of CRC-16 is 215 − 1 = 32767 bits.
A significantly shortened code is almost always used.
EE 387, October 28, 2015 Notes 15, Page 17
Examples of cyclic codes: CRC-CCITT
Another popular generator polynomial is
< CRC-CCITT = x16 + x12 + x5 + 1 = (x + 1)p2 (x) ,
where p2 (x) is a primitive polynomial of degree 15:
p2 (x) = x15 + x14 + x13 + x12 + x4 + x3 + x2 + x + 1
CRC-16 and CRC-CCITTT polynomials have only 4 nonzero coefficients, so
the shift register coding circuits need only 3 exclusive-or gates.

Minimum distance for CRC-16, CRC-CCITT is 4. Both codes correct single

errors while detecting double errors, or detect up to 3 errors.
Any cyclic code with n − k = 16 detects burst errors of length 16 bits, which is optimal.
EE 387, October 28, 2015 Notes 15, Page 18