VARIOUS LINEAR BLOCK

CODES –PART 1
Information Theory and Coding
Prof. Deron Ray Rodrigues
Unit 3
Channel coding Asst. Prof.
ETC Dept., DBCE
CONTENTS:

SINGLE PARITY CHECK BIT CODE

REPEATED CODE
HADAMARD CODE
HAMMING CODE
REED MULLER CODE

Prof. Deron Rodrigues

SINGLE PARITY CHECK BIT CODES:
 This code is a single error-detecting block code and  Example: (4,3) even parity check code
will not correct errors.  k = 3, r = 1, n = 4 , rate RC = ¾
 The codes use a single parity check bit to generate Message bits  parity bit
codewords.
p = m1 ⊕ m2 ⊕ m3
 The parity bit can be even parity or odd parity m1 m2 m3 p

 For even parity, p = 0 if the number of 1’s in the data Message bits Parity bit Codeword bits Weight
word (message) are even, else p=1 m1 m 2 m3 p c1 c2 c3 c4 w
 For odd parity, p=0, if the number of 1’s in the data 000 0 0000 0
word are odd, else p = 1 001 1 0011 2
 The single even parity check bit has the equation, 010 1 0101 2

 p=m1⊕ m2 ⊕ m3 ⊕ ….. ⊕ mk 011 0 0110 2

100 1 1001 2
 For any (n, k) SPC code, there are k message bits and
one redundant (parity) bit (r =1). 101 0 1010 2
110 0 1101 2
 n = k+r = k+1
111 1 1111 4
 Rate of the code, RC = k/k+1
𝑑𝑚𝑖𝑛 − 2
Prof. Deron Rodrigues dmin = 2, l = dmin – 1 = 1 , t = =0
 MATRICES FOR SINGLE PARITY CHECK BIT CODES:
 Generator Matrix, G = [Ik | P] (5,4) even parity check code
 Ik is identity matrix of order (k x k)  k = 4, n = 5
 P is having order (k x r) = (k x 1)  single column matrix as  Generator Matrix, G = [Ik | P]
r =1 𝟏 𝟎 𝟎 𝟎 ⋮ 𝟏
 Example: (4,3) even parity LBC  if k = 3 , n = 4 𝟎 𝟏 𝟎 𝟎 ⋮ 𝟏
 G=
𝟎 𝟎 𝟏 𝟎 ⋮ 𝟏
𝟏 𝟎 𝟎 ⋮ 𝟏
𝟎 𝟎 𝟎 𝟏 ⋮ 𝟏
 G= 𝟎 𝟏 𝟎 ⋮ 𝟏
𝟎 𝟎 𝟏 ⋮ 𝟏
 Parity Check Matrix, H = [PT | Ir]
 Parity Check Matrix, H = [PT | Ir ]  H= 𝟏 𝟏 𝟏 𝟏 ⋮ 𝟏
 PT is having order (r x k) = (1 x k)  single row matrix.
 Ir is identity matrix of order (r x r )  r =1, I1 = [ 1 ]
 Example: for k=3, n = 4  (4,3) even parity LBC
 H= 𝟏 𝟏 𝟏 ⋮ 𝟏
Prof. Deron Rodrigues
  In order to correct ‘t’ errors, r =2t parity bits
REPEATED CODES: are needed, therefore n= r +1 = 2t+1
𝟏
 In a repeated code, a binary 0 is encoded as ‘n’  Repeated codes are called as Rate ‘ ′code
𝟐𝒕+𝟏
number of zeros and binary 1 as ‘n’ number of 1’s.
 Hence to correct t =1 error, we need n = 3 
 Information bits, k = 1, total bits in a codeword = n Rate 1/3 Repeated code.
 redundant bits, r = n -1  Also, to correct t =2 errors, we need n = 5 
 Rate of the code, RC = k/n = 1/n Rate 1/5 Repeated code.
 Repeated codes are called as Rate 1/n code
 In repeated codes, all redundant bits are same
Code Encoding n r dmin as message bit:
Rate ½ 0 is represented by ‘00’ ; 2 1 2  p1 = p2 = p3 ….. = pr = m
code: 1 is represented by ‘11’
 There will be r parity check equations:
Rate 1/3 0 is represented by ‘000’ ; 3 2 3
code: 1 is represented by ‘111’  p1 ⊕ m = 0 or (p1 = m )
Rate 1/4 0 is represented by ‘0000’ ; 4 3 4  p2 ⊕ m = 0 or (p2 = m )
code: 1 is represented by ‘1111’  ……..
 pr ⊕ m = 0 or (pr = m )
Prof. Deron Rodrigues
 MATRICES FOR REPEATED CODES:
Generator Matrix, G = [Ik | P] Rate ½ code: k=1, r = 1 , n=2
k=1  I1 = [ 1 ]  matrix of 1 row & 1 column  G= 𝟏 | 𝟏  (k x n)  (1 x 2)
 P is having order (k x r) = (1 x r)  single row  H= 𝟏 | 𝟏  (r x n)  (1 x 2)
matrix with r- elements
 G= 𝟏 ⋮ 𝟏 𝟏 … 𝟏
Rate 1/3 code: k=1, r = 2 , n=3
 G= 𝟏 | 𝟏 𝟏  (k x n)  (1 x 3)
Parity Check Matrix, H = [PT | Ir]
𝟏 | 𝟏 𝟎
 H=  (r x n)  (2 x 3)
 PT is having order (r x k) = (r x 1)  single 𝟏 | 𝟎 𝟏
column matrix
𝟏 | 𝟏 𝟎 ⋯ 𝟎
𝟏 | 𝟎 𝟏 ⋯ 𝟎  Disadvantage of Repeated codes:
 H=
⋮ | ⋮ ⋮ ⋱ ⋮  Requires the use of significant bandwidth as it is a
𝟏 | 𝟎 𝟎 ⋯ 𝟏 1
rate ‘ ′code, therefore such codes are
2𝑡+1
inefficient.
Prof. Deron Rodrigues
 HADAMARD CODE:
 It is an orthogonal code, derived from a n x n Data k Hadamard Matrix Codewords n
square matrix, called Hadamard Matrix. set
 The rows of the Hadamard Matrix represent the 0 1 0 0 00 2
M1 =
1 0 1 01
code vectors, representing n code vectors of n-
bits each. M1 M1
M2 =
00 M1 M1∗ 0000
 Hadamard matrix is represented as Mk & n=2k
01 2 0101 4
0 0 | 0 0
 For 1-bit data set (k=1), Hadamard Matrix, M1 10 0011
0 1 | 0 1
is used to transform data bits into orthogonal 11 0110
= − − | − −
codewords of 2 digits each (n=21) 0 0 | 1 1
 For 2-bit data set (k=2), codeword set is 0 1 | 1 0
generated by a higher order Hadamard Matrix
M2 which is made up of 4 sub-matrices of M1  In general, Hadamard matrix is (n x n) = (2k x 2k ) matrix
(lower order Hadamard matrix) extending both 𝑀𝑘−1 | 𝑀𝑘−1
horizontally and vertically.  𝑀𝑘 = − | −
 Lower right quadrant of M2 is complement of 𝑀𝑘−1 | 𝑀∗ 𝑘−1
M1 ( M1* )
Prof. Deron Rodrigues
 • Each codeword differs from every other codeword
HADAMARD CODE: in ‘n/2’ places. Therefore the codewords are
orthogonal to one another. [ Ci . Cj = 0 ,Ɐ i≠ j]
 For 3-bit data set (k=3), codeword set is generated
• In any two codewords, no. of similarities = no. of
by a higher order Hadamard Matrix M3 which is
dissimilarities.
made up of 4 sub-matrices of M2.
• 01010101  -1, 1, -1, 1, -1,1, -1, 1  C1
 One codeword contains all zero and remaining
• 00110011  -1, -1, 1, 1, -1,-1, 1, 1  C2
codewords will have n/2 zeros and n/2 ones.
• C1 .C2 = 0
Data set k Hadamard Matrix Codewords n
• C1 .C1 = 8
M2 M2
M3 =
M M2∗
000 00000000 Parameters:
0 0 0 0 | 0 0 0 0
001 3
0 1 0 1 | 0 1 0 1
01010101 8 • n = 2k
010 00110011
011 0 0 1 1 | 0 0 1 1 01100110
• r = n-k = 2k – k
100 0 1 1 0 | 0 1 1 0 00001111 • dmin = n/2 = 2k /2 = 2k-1
101 = − − − − | − − − − 01011010
0 0 0 0 | 1 1 1 1 • Rate = k/n = k/ 2k = k 2-k
110 00111100
111 0 1 0 1 | 1 0 1 0 01101001
0 0 1 1 | 1 1 0 0
0 1 1 0 | 1 0 0 1 Prof. Deron Rodrigues
 HADAMARD CODE:
Parameters:  DISADVANTAGE:
• Information bits = k  As k increases the number of parity bits increase very much in
• Codeword bits, n = 2k comparison to the information bits:
• r = n-k = 2k – k  k =1 , n= 21 =2, r = n-k= 2-1= 1  RC = 1/2
 k =2 , n= 22 =4, r = 4-2= 2  RC = 1/2
• dmin = n/2 = 2k /2 = 2k-1
 k =3 , n= 23 =8, r = 8-3= 5  RC = 3/8
• (same as Hamming distance)
 k =4 , n= 24 =16, r = 16-4= 12  RC = 1/4
• Rate = k/n = k/ 2k = k 2-k
𝑑𝑚𝑖𝑛 −2 2k−1  Correspondingly the rate of the code becomes quiet small.
• t= = − 1 = 2k-2 −1
2 2  If k is large, in order to transmit codewords at the same rate as
the data word, much large bit rate will be required. Hence, large
• For significant error correction, k>2 bandwidth will be required.
• For large k, t increases as 2k, hence  Hence, Hadamard codes are used only when there is no
significant error correction is bandwidth restrictions, such as in deep space probes.
possible

Prof. Deron Rodrigues

 HAMMING CODE • Parity check matrix has (r = n - k) rows and n
columns.
 Hamming code is a single error correcting code in • For (n, k) Hamming code there are n = 2r -1
which dmin=3. columns very interesting.
 Since, dmin=3  2t+1 =3  t=1 • Columns of H, thus consist of all possible r-
bit binary vectors except the all zero vector.
 It can correct single error.
 It can detect 2 errors, as l =dmin-1 =2 • If r = 3, n = 7, k=4
 Number of bits in codeword, n = 2r -1 • Parity check matrix will have 3 rows and 7
columns.
 Number of information bits, k = n – r = 2r -1 - r
• Parity check matrix for systematic (7,4)
 Example: if r = 3 Hamming code
 n =23 -1 =7 & k = 7 – 3 = 4 1 1 1 0 | 1 0 0
 (7,4) Hamming Code which is a linear block code • H= 1 1 0 1 | 0 1 0 = [PT | Ir ]
1 0 1 1 | 0 0 1
 Example: if r=4
7 6 5 3 4 2 1
 n=24 -1 = 15 & k=15 – 4 =11
  (15, 11) Hamming Code which is a linear block
code Prof. Deron Rodrigues
 SYSTEMATIC V/S NON-SYSTEMATIC HAMMING CODE
• Parity check matrix for systematic (7,4)  In case of systematic (7,4) Hamming code, the
Hamming code coefficient sub-matrix and identity sub-matrix can
be separated, hence is systematic code.
1 1 1 0 | 1 0 0
• H= 1 1 0 1 | 0 1 0 = [PT | Ir ]  Although each of the columns represent a decimal
1 0 1 1 | 0 0 1 number 1 to 7, but they are not arranged in a
particular order.
 7 6 5 3 4 2 1

• Parity check matrix for non-systematic (7,4)  In case of non-systematic (7,4) Hamming code, the
Hamming code columns are re-arranged so that the decimal
numbers are in descending order.
0 0 0 1 1 1 1
 H= 0 1 1 0 0 1 1  But the coefficient sub-matrix and identity matrix
1 0 1 0 1 0 1 are not separate. Hence it is non-systematic code.
 1 2 3 4 5 6 7

Prof. Deron Rodrigues

 m1 m2 m3 m4 p1 p2 p3
SYSTEMATIC (7,4) HAMMING CODE c1 c2 c3 c4 c5 c6 c7
1 1 1 0 | 1 0 0 0 0 0 0 0 0 0
 Parity check matrix, H = [PT | Ir ] = 1 1 0 1 | 0 1 0 0 0 0 1 0 1 1
1 0 1 1 | 0 0 1 0 0 1 0
0 0 1 1
 7 6 5 3 4 2 1
0 1 0 0
1 0 0 0 | 1 1 1 0 1 0 1
0 1 0 0 | 1 1 0 0 1 1 0
 Generator matrix, G = [Ik | P] =
0 0 1 0 | 1 0 1 0 1 1 1
0 0 0 1 | 0 1 1 1 0 0 0
 Equations of parity bits: Parity check equations: 1 0 0 1
1 0 1 0
 p1 = m1⊕ m2 ⊕ m3 = c5 c1⊕ c2 ⊕ c3 ⊕ c5 = 0
1 0 1 1
 p2 = m1⊕ m2 ⊕ m4 = c6 c1⊕ c2 ⊕ c4 ⊕ c6 = 0
1 1 0 0
c1⊕ c3 ⊕ c4 ⊕ c7 = 0
 p3 = m1⊕ m3 ⊕ m4 = c7 1 1 0 1
m1 m2 m3 m4 p1 p2 p3 1 1 1 0
c1 c2 c3 c4 c5 c6 c7 Prof. Deron Rodrigues 1 1 1 1
 SYNDROME FOR SYSTEMATIC (7,4) HAMMING CODE
𝟏 𝟏 𝟏 Syndrome equations:
𝟏 𝟏 𝟎 s1 = r1 ⊕ r2 ⊕ r3 ⊕ r5
𝟏 𝟎 𝟏
 s = r. HT  [s1 s2 s3] = [r1 r2 r3 r4 r5 r6 r7 ] 𝟎 𝟏 𝟏 s2 = r1 ⊕ r2 ⊕ r4 ⊕ r6
𝟏 𝟎 𝟎
𝟎 𝟏 𝟎 s3 = r1 ⊕ r3 ⊕ r4 ⊕ r7
𝟎 𝟎 𝟏
 s= syndrome e1 e2 e3 e4 e5 e6 e7 Bit in error Syndrome Decimal no.
[s1 s2 s3]
 r = received codeword
0 0 0 0 0 0 0 No error 000 0
 Also 1 0 0 0 0 0 0 1st 111 7
 e = error pattern 0 1 0 0 0 0 0 2nd 110 6
0 0 1 0 0 0 0 3rd 101 5
 s= e.HT
0 0 0 1 0 0 0 4th 011 3
0 0 0 0 1 0 0 5th 100 4
0 0 0 0 0 1 0 6th 010 2
Prof. Deron Rodrigues 0 0 0 0 0 0 1 7th 001 1
 NON-SYSTEMATIC (7,4) HAMMING CODE
 Parity check matrix
0 0 0 1 1 1 1
 H= 0 1 1 0 0 1 1
1 0 1 0 1 0 1
 1 2 3 4 5 6 7
 Parity check equations:
c4⊕ c5 ⊕ c6 ⊕ c7 = 0 c4= c5 ⊕ c6 ⊕ c7 p3= m2 ⊕ m3 ⊕ m4
c2 =c3 ⊕ c6 ⊕ c7 p2 =m1 ⊕ m3 ⊕ m4
c2⊕ c3 ⊕ c6 ⊕ c7 = 0
c1 = c3 ⊕ c5 ⊕ c7 p1 = m1 ⊕ m2 ⊕ m4
c1⊕ c3 ⊕ c5 ⊕ c7 = 0
p1 p2 m1 p3 m2 m3 m4
c1 c2 c3 c4 c5 c6 c7
1 1 1 0 0 0 0
p1 p2 m1 p3 m2 m3 m4
1 0 0 1 1 0 0
Generator matrix, G =
0 1 0 1 0 1 0
Prof. Deron Rodrigues
1 1 0 1 0 0 1
 SYNDROME FOR NON- SYSTEMATIC (7,4) HAMMING CODE
0 0 1
0 1 0
0 1 1 s1 = r4 ⊕ r5 ⊕ r6 ⊕ r7
 s = r. HT  [s1 s2 s3] = [r1 r2 r3 r4 r5 r6 r7 ] 1 0 0
1 0 1 s2 = r2 ⊕ r3 ⊕ r4 ⊕ r7
1 1 0
1 1 1 s3 = r1 ⊕ r3 ⊕ r5 ⊕ r7

e1 e2 e3 e4 e5 e6 e7 Bit in Syndrome Decimal

error [s1 s2 s3] no.
1 0 0 0 0 0 0 1st 001 1
0 1 0 0 0 0 0 2nd 010 2
0 0 1 0 0 0 0 3rd 011 3
0 0 0 1 0 0 0 4th 100 4
0 0 0 0 1 0 0 5th 101 5
0 0 0 0 0 1 0 6th 110 6
0 0 0 0 0 0 1 7th 111 7
Prof. Deron Rodrigues
HAMMING CODES  PERFECT CODES
 Hamming Bound:
 For a binary (n,k) linear code with dmin ≥2t+1, the number
of parity bits
 n-k ≥ log 2 (1 +nC1+ nC2+….+ nCt)

 Perfect Codes:
 A code which achieves the Hamming bound with equality.
 It is also defined as a code, where it is possible to form a
standard array with all patterns of t-or less errors and no
others, as the coset leaders.
 [i.e. 2n-k = nC1+ nC2+….+ nCt ]

 Hamming code satisfies the Hamming Bound  Perfect

code
 Since, dmin=3  2t+1 =3  t=1
 Number of bits in codeword, n = 2r -1
 Number of information bits, k = n – r = 2r -1 - r
Prof. Deron Rodrigues
MODIFYING THE CODES
 When it is not possible to find a code with a suitable block-length, information length and minimum distance:
 Select a code that is closest to required and modify it to meet the requirements.
 Various modifications can be done such as shortening the codes or extending the codes.

SHORTENED CODES:
 An (n, k) linear code can be shortened to an (n-i, k-i) shortened linear code
by setting the first (left-hand side) ‘i' information bits to zero.
 Generator matrix of shortened code is obtained by omitting first ‘i’ rows
and ‘i’ columns of G.
 And parity-check matrix is obtained by omitting first ‘i’ columns of H.
 Codewords bits are then ‘n-i’
 But parity bits, r = (n – i ) – ( k – i) = n – k  same as the original code.
 Note: Shortening the code doesn’t reduce its error control capability.

Prof. Deron Rodrigues

SHORTENED CODES:
• Example (12,8) shortened code is obtained from (15,11) hamming code by removing 3 information bits.
• Consider (15,11) Hamming code  n = 15, k = 11, r = n-k = 4

1 0 0 0 0 0 0 0 0 0 0 | 1 0 0 1 For shortened code, i = 3  ns= n – i = 15 – 3 =12

0 1 0 0 0 0 0 0 0 0 0 | 1 1 0 1 & ks= k – i = 11 – 3 = 8  (12,8) shortened code.
0 0 1 0 0 0 0 0 0 0 0 | 1 1 1 1
0 0 0 1 0 0 0 0 0 0 0 | 1 1 1 0 1 0 0 0 0 0 0 0 | 1 1 1 0
0 0 0 0 1 0 0 0 0 0 0 | 0 1 1 1 0 1 0 0 0 0 0 0 | 0 1 1 1
• 𝐺= 0 0 0 0 0 1 0 0 0 0 0 | 1 0 1 0 0 0 1 0 0 0 0 0 | 1 0 1 0
0 0 0 0 0 0 1 0 0 0 0 | 0 1 0 1 0 0 0 1 0 0 0 0 | 0 1 0 1
• 𝐺=
0 0 0 0 1 0 0 0 | 1 0 1 1
0 0 0 0 0 0 0 1 0 0 0 | 1 0 1 1
0 0 0 0 0 1 0 0 | 1 1 0 0
0 0 0 0 0 0 0 0 1 0 0 | 1 1 0 0
0 0 0 0 0 0 1 0 | 0 1 1 0
0 0 0 0 0 0 0 0 0 1 0 | 0 1 1 0
0 0 0 0 0 0 0 1 | 0 0 1 1
0 0 0 0 0 0 0 0 0 0 1 | 0 0 1 1
1 0 1 0 1 1 0 0 | 1 0 0 0
1 1 1 1 0 1 0 1 1 0 0 | 1 0 0 0 1 1 0 1 0 1 1 0 | 0 1 0 0
0 1 1 1 1 0 1 0 1 1 0 | 0 1 0 0 • 𝐻=
• 𝐻= 1 1 1 0 1 0 1 1 | 0 0 1 0
0 0 1 1 1 1 0 1 0 1 1 | 0 0 1 0 0 1 0 1 1 0 0 1 | 0 0 0 1
1 1 1 0 1 0 1 1 0 0 1 | 0 0 0 1
Prof. Deron Rodrigues
EXPURGATED CODES:
 (n, k) linear code can be modified by add an all ones row to the parity-check matrix to produce an expurgated
(n, k-1) code.
 The parity-check bit added gives even parity codewords.
 No of columns = n
 No of rows = n-k+1
 Information bits = n – (n-k+1) = k-1
 The parity check matrix of an expurgated (n, k-1) linear code is given as
𝐻
 𝐻𝑒𝑥 = where H is the parity-check matrix of the (n,k) code
1 1 … 1

Prof. Deron Rodrigues

EXTENDED CODES:
 (n, k) linear code can be modified by adding an overall  The parity check matrix of an extended (n+1, k) linear code is
parity-check bit to produce an extended (n+1, k) code.
0
 No of columns = n+1 0
𝐻
 No of rows = n-k+1 given as 𝐻𝑒 = ⋮
 Information bits = (n +1)– (n-k+1) = k 0
1 1 … 1 1
 The parity-check bit added gives even parity codewords where H is the parity-check matrix of the (n,k) code
and will also preserve linearity of the code.

EXTENDED HAMMING CODES:

 Hamming code also can be extended by extending its parity check matrix by adding a row consisting of all 1’s
and a column on the right hand side of all zeros except bottom-most element which remains a 1.
 ne = n +1 = 2r -1 +1 = 2r re = r +1, ke = ne - re = (2r ) – (r+1) = 2r – 1- r
 The inclusion of an overall parity check bit gives (2r , 2r -1-r ) extended Hamming code with minimum distance 4
with single error correcting and double detecting capabilities. Prof. Deron Rodrigues
EXTENDED HAMMING CODES: m1 m2 m3 m4 p1 p2 p3 p
c1 c2 c3 c4 c5 c6 c7 c8
 Consider Parity check matrix for (8,4) Extended
Hamming Code
Generator Matrix, G= [Ik | P]
1 1 1 0 | 1 0 0 0
 p1 = m1 ⊕ m2 ⊕ m3
1 1 0 1 | 0 1 0 0
 H=  p2 = m1 ⊕ m3 ⊕ m4
1 0 1 1 | 0 0 1 0
1 1 1 1 | 1 1 1 1  p3 = m1 ⊕ m2 ⊕ m4
• The codewords of (7,4) Hamming code are taken  p = m2 ⊕ m3 ⊕ m4
and an overall parity-check bit is added. 1 0 0 0 | 1 1 1
• p = m1 ⊕ m2 ⊕ m3 ⊕ m4 ⊕ p1 ⊕ p2 ⊕ p3 0 1 0 0 | 1 0 1
 G = [Ik | P] =
0 0 1 0 | 1 1 0
= m1 ⊕ m2 ⊕ m3 ⊕ m4 ⊕ (m1 ⊕ m2 ⊕ m3 )
0 0 0 1 | 0 1 1
⊕ (m1 ⊕ m3 ⊕ m4 ) ⊕ (m1 ⊕ m2 ⊕ m4 )
= m2 ⊕ m3 ⊕ m4

Prof. Deron Rodrigues

 Dual Codes
 Consider an (n,k) linear block code ‘C’ with generator matrix G
and parity check matrix H.
 Generator matrix G is k x n  It has k rows  vector space
generated by ‘G’ has a dimension k and contains 2k vectors.
 Parity check matrix H is (n-k) x n  It has n-k rows  vector space
generated by H has a dimension (n-k) and contains 2n-k vectors
 Rows of generator matrix G and rows of parity check matrix H are
linearly independent and hence generate a vector space.
 Parity check matrix of a linear code ‘C’ can be used as a generator
matrix to generate another linear code.
• If ‘C’ is an (n,k) linear code, then C is (n,
d
 Vector spaces generated by G and H are dual spaces such that
n-k) linear code.
any vector in one of the spaces is orthogonal to all the vectors
• Although block length ‘n’ remains same,
in the other space.
C contains 2k codewords and Cd contains
 Hence, the linear code generated by H is the dual code of C
2n-k codewords.
and is denoted by Cd .
Prof. Deron Rodrigues
Dual Codes: Example Message
Message Codewords
Codewords
0000
0000 0000
 Consider (7,4) LBC with generator matrix
0001
0001 0001  To construct dual code, Obtain H
1 0 0 0 | 1 0 1 0010
0010 0010
0 1 0 0 | 1 1 1 1 1 1 0 | 1 0 0
0011
0011 0011
 G=  H= 0 1 1 1 | 0 1 0 = Gd
0 0 1 0 | 1 1 0 0100
0100 0100
0 0 0 1 | 0 1 1 1 1 0 1 | 0 0 1
0101
0101 0101
 No of rows, k = 4  No of rows, n-k = 3 & No of columns, n= 7
0110
0110 0110
 No of columns, n= 7  (7,3) LBC
0111
0111 0111
Message Codewords
 n-k = 3  (7,4) LBC 1000
1000 1000
000 0000
000000
1001
1001 1001
001 1101
001001
1010
1010 1010
 Its dual will be (n, n-k) = (7,3) code 010 0111
010010
1011
1011 1011
011 1010
011011
1100
1100 1100
100 1110
100100
1101
1101 1101
101 0011
101101
1110
1110 1110
110 1001
110110
Prof. Deron Rodrigues 1111
1111 1111
111 0100
111111
 REED-MULLER CODES:
 Form a class of multiple error correcting codes.
 Simple in construction and rich structural properties.
 A class of linear block codes with flexible parameters that are particularly interesting due to the
existence of simple decoding algorithm for them.
 RM (r, m) code with block length, n= 2m and order r < m is an (n,k) linear block code with
 Code length, n= 2m
 Dimension, k(r,m) = 𝑟𝑖=0 𝑚𝐶 𝑖
 Minimum distance, dmin = 2m-r
 Example: RM (2,5) m = 5, r = 2
 n = 32
 k = 5C0 + 5C1 + 5C2 = 1+5+10 = 16
 dmin = 2m-r = 25-2 = 23 = 8
 There exists a (32,16) RM (2,5) code with dmin = 8 Prof. Deron Rodrigues