1
00:00:13,769 --> 00:00:19,390
Today we are going to talk about how to decode
and we are going to talk about what is known
2
00:00:19,390 --> 00:00:27,590
as Syndrome decoding So what is a decoding
problem So let us look at scenario where we
3
00:00:27,590 --> 00:00:34,140
are transmitting our codeword which is n-bit
tuple over a communication channel Let us
4
00:00:34,140 --> 00:00:44,550
consider a binary symmetric channel So in
a binary symmetric channel bits 0s and 1s
5
00:00:44,550 --> 00:00:50,000
are transmitted over this communication channel
and with probability 1 minus p they are received
6
00:00:50,000 --> 00:00:56,170
correctly and with crossover probability of
p the bits 0s and 1s can get flipped So the
7
00:00:56,170 --> 00:01:04,070
output channel is also binary Then we have
total 2 k codewords right And if you are looking
8
00:01:04,070 --> 00:01:10,130
at output received sequence we can have total
of 2 to the power n different possibilities
9
00:01:10,130 --> 00:01:18,439
Because we our code bit is codeword is n-bit
and each location can be 0s or 1s
10
00:01:18,439 --> 00:01:33,280
So our decoding problem is we have to partition
these 2 n possibilities into sets of 2 k into
11
00:01:33,280 --> 00:01:44,340
2 k sets So we have to map these 2 n possibilities
into set 2 k sets and corresponding to each
12
00:01:44,340 --> 00:01:50,689
set there should be only one unique codeword
In other words when we map a received sequence
13
00:01:50,689 --> 00:02:00,270
to a particular set we should be able to say
if these set of received sequence are obtained
14
00:02:00,270 --> 00:02:08,729
or we get these received sequence then corresponding
to these sequence there is only one codeword
15
00:02:08,729 --> 00:02:17,709
So the decoding problem is we have to partition
these 2 n different possibilities into total
16
00:02:17,709 --> 00:02:26,350
2 k sets such that in each of the set there
is only one valid codeword So whenever any
17
00:02:26,350 --> 00:02:31,410
of these received sequence you know is mapped
to a particular set then we should be able
18
00:02:31,410 --> 00:02:38,240
to say Ok if you receive any of these code
receive any of these sequences then the transmitted
19
00:02:38,240 --> 00:02:46,350
codeword was this So you can think of we have
total 2 n possibilities and we want to partition
20
00:02:46,350 --> 00:02:53,010
these 2 n possibilities into 2 to the power
k different balls in some sense and each ball
21
00:02:53,010 --> 00:03:00,320
has 1 codeword associated with it That's basically
our decoding problem
22
00:03:00,320 --> 00:03:08,280
So how do we partition these 2 n different
possibilities into 2 k sets is what we are
23
00:03:08,280 --> 00:03:15,560
going to talk about So any decoding scheme
is basically to partition these 2 n possible
24
00:03:15,560 --> 00:03:26,290
codewords received codewords into 2 k disjoint
subsets The word disjoint is important because
25
00:03:26,290 --> 00:03:41,030
we want to we don’t want basically overlapping
decision sets regions Ok And how do we do
26
00:03:41,030 --> 00:03:48,370
this partition is basically based on the structure
of the linear block and that's what we are
27
00:03:48,370 --> 00:03:57,630
going to describe in this lecture So let us
denote the 2 k codewords by v 1 v 2 v 3 v
28
00:03:57,630 --> 00:04:05,350
2 k v 2 raised to power k So let's say these
are my 2 k codewords in a linear block code
29
00:04:05,350 --> 00:04:13,420
in n k linear block code where v 1 is all
zero codeword Now what do we do is we form
30
00:04:13,420 --> 00:04:22,569
an array of vectors from vector space v n
as follows In the top row of this array we
31
00:04:22,569 --> 00:04:34,189
will arrange all of these 2 k codewords with
all zero codeword being the leftmost entry
32
00:04:34,189 --> 00:04:42,440
in the row So we are going in the first row
of this array we are going to put all zero
33
00:04:42,440 --> 00:04:49,979
codeword and then we are going to put other
codewords
34
00:04:49,979 --> 00:04:59,340
So this will be the first row of this array
Now suppose we have formed I am going to tell
35
00:04:59,340 --> 00:05:05,460
you how we are going to form this array Suppose
let’s say we have already formed j minus
36
00:05:05,460 --> 00:05:12,659
1 rows of this array then what do we do We
choose a vector e j from vector space v n
37
00:05:12,659 --> 00:05:23,340
so we pick up a n-bit error vector which has
not been chosen previously in any of the previous
38
00:05:23,340 --> 00:05:35,849
j minus 1 rows We pick that error vector Next
we form the jth row by adding that error vector
39
00:05:35,849 --> 00:05:45,150
to each of the codewords on the top row and
placing the new vector which is e j plus v
40
00:05:45,150 --> 00:05:57,740
i under the codeword v i I will just explain
what I mean by this So as I said in the first
41
00:05:57,740 --> 00:06:10,270
row we have listed all the codewords with
all zero codeword as my leftmost entry Now
42
00:06:10,270 --> 00:06:17,939
let's say I have already formed some rows
and I want to form jth row So how do I find
43
00:06:17,939 --> 00:06:27,629
jth row I will pick up an error vector e j
which is let us say e 3 which has not appeared
44
00:06:27,629 --> 00:06:34,680
before so e 3 should not be any of these elements
which I have already been chosen e 3 should
45
00:06:34,680 --> 00:06:45,729
not have appeared in the previous rows of
this array So I choose such a error vector
46
00:06:45,729 --> 00:06:54,289
and then what do I do is I add this error
vector to each of these elements in the first
47
00:06:54,289 --> 00:07:01,940
row which is nothing but codewords and I place
that element under the same column Now what
48
00:07:01,940 --> 00:07:10,050
do I mean by that Let's say this was v 2 So
I will add e 3 to v 2 and I will add the element
49
00:07:10,050 --> 00:07:21,699
e 3 plus v 2 in the same column as v 2 was
Similarly if I have a codeword v i I will
50
00:07:21,699 --> 00:07:30,460
add e 3 to v i and I will add this element
e 3 plus v i in the same column as v i So
51
00:07:30,460 --> 00:07:37,669
this is how I am going to build up this row
in this array
52
00:07:37,669 --> 00:07:44,069
The next row how do I build up Again I will
pick an error pattern which has not happened
53
00:07:44,069 --> 00:07:51,499
before I will pick up that error pattern and
then I will add that error pattern to v 2
54
00:07:51,499 --> 00:07:58,219
put that element here Add that error pattern
to v i put that pattern here So this is how
55
00:07:58,219 --> 00:08:11,610
I will fill up the entries in this array So
that's what I meant Form the jth row by adding
56
00:08:11,610 --> 00:08:19,129
e j to each of these codewords in the top
row and placing e j plus v i under the same
57
00:08:19,129 --> 00:08:28,539
column as v i and we will continue doing this
until all end bit vectors have been put in
58
00:08:28,539 --> 00:08:38,960
this standard array And this array formed
in this way is known as standard array So
59
00:08:38,960 --> 00:08:46,950
this is how your standard array will look
like Again I will just recap how we are constructing
60
00:08:46,950 --> 00:08:56,870
the standard array The first row of this array
is set of codewords v 1 to v 2 raised to power
61
00:08:56,870 --> 00:09:07,710
k And the leftmost entry here is all zero
codeword Next we pick up an element an error
62
00:09:07,710 --> 00:09:14,830
vector which has not happened in any of the
previous rows and then we add the error vector
63
00:09:14,830 --> 00:09:23,140
to each of the elements of these uh codewords
and put the new element under the same column
64
00:09:23,140 --> 00:09:36,960
as that codeword and we continue doing that
until we have put all the possible vectors
65
00:09:36,960 --> 00:09:44,510
in this array So let us look at 6 3 linear
block code whose generator matrix is given
66
00:09:44,510 --> 00:09:48,910
here
67
00:09:48,910 --> 00:10:01,230
Now how do I find its standard array So as
I said the first step involved is you need
68
00:10:01,230 --> 00:10:09,700
to write down all possible codewords Now you
are already been given the generator matrix
69
00:10:09,700 --> 00:10:16,420
for this code so you can find out what are
the possible codewords You just have to do
70
00:10:16,420 --> 00:10:29,850
v is nothing but u times G So there are total
8 codewords and you can find those 8 codewords
71
00:10:29,850 --> 00:10:35,680
because you know G is given to you and you
know what is your u u basically goes from
72
00:10:35,680 --> 00:10:45,830
0 0 0 to 0 0 1 0 1 0 it goes to 1 1 1 So you
can find out what these codewords are and
73
00:10:45,830 --> 00:10:52,100
I have listed these codewords here So you
have one all zero codeword and then you have
74
00:10:52,100 --> 00:11:05,010
the other codewords are 0 1 1 1 0 0 1 0 1
0 1 0 1 1 0 0 1 0 0 0 1 Since I could not
75
00:11:05,010 --> 00:11:12,700
fit in all the columns in one slide I have
continued it here so this is I had up to v
76
00:11:12,700 --> 00:11:24,040
0 I have v 1 v 2 v 3 v 4 And then I had v
5 v 6 v 7 v 8 So these are 8 codewords for
77
00:11:24,040 --> 00:11:35,550
this 6 3 linear block code Now how do I find
entries in the next column As I said I have
78
00:11:35,550 --> 00:11:42,380
to pick up a vector which has not appeared
in the previous rows So let's look at what
79
00:11:42,380 --> 00:11:48,440
has appeared in the previous rows We had all
zero sequence here we had a sequence which
80
00:11:48,440 --> 00:11:54,990
has three 1's a sequence which has three 1's
sequence has I mean three 1's codeword four
81
00:11:54,990 --> 00:12:04,300
1's so we see we don't have n-tuples which
have just weight 1 Hamming weight 1 they have
82
00:12:04,300 --> 00:12:14,030
not appeared so far So this 1 0 0 0 0 0 has
not appeared so far in first row of this array
83
00:12:14,030 --> 00:12:22,720
So I pick this 1 0 0 0 0 0 as my first element
Now how do I find this element I am going
84
00:12:22,720 --> 00:12:31,670
to add this to this So I am going to add this
to this If I add it what do I get 1 plus 0
85
00:12:31,670 --> 00:12:42,140
is 1 0 plus 1 is 1 0 plus 1 is 1 0 plus 1
is 1 0 plus 0 is 0 0 plus 0 is 0 So this is
86
00:12:42,140 --> 00:12:55,600
what I get How do I get this entry Again I
add this to this So 1 plus 1 is 0 0 plus 0
87
00:12:55,600 --> 00:13:07,710
is 0 0 plus 1 is 10 plus 0 is 0 0 plus 1 is
1 0 plus 0 is 0 So this is how I populate
88
00:13:07,710 --> 00:13:16,170
the entries in this row Next how do I pick
this
89
00:13:16,170 --> 00:13:26,950
I will now have to look at the first two rows
of this array and see pick one n-tuple which
90
00:13:26,950 --> 00:13:35,490
has not happened before and this particular
tuple you can see 0 1 and all zeroes it has
91
00:13:35,490 --> 00:13:45,610
not appeared so far in the first two rows
of the standard array So I can then pick this
92
00:13:45,610 --> 00:13:53,370
as my n-tuple here And then I fill up this
whole entry How I add this vector to this
93
00:13:53,370 --> 00:14:02,480
v 2 put it here Add this vector to this Put
it here Add this vector to this put it here
94
00:14:02,480 --> 00:14:08,220
Add this vector to this Put it here Add this
vector to this You can just verify one such
95
00:14:08,220 --> 00:14:20,380
entry So 0 plus 1 is 1 1 plus 0 is 1 0 plus
1 is 1 0 plus 1 is 1 0 plus 0 is 0 and 0 plus
96
00:14:20,380 --> 00:14:33,650
1 is 1 So this is how you populate this entry
And we will keep on doing it until we have
97
00:14:33,650 --> 00:14:40,970
written all those n-tuples here so we have
already written this way we have written all
98
00:14:40,970 --> 00:14:45,180
the 2 n possibilities We have written it in
this array
99
00:14:45,180 --> 00:14:50,500
Now this array has some interesting properties
and we are going to talk about that which
100
00:14:50,500 --> 00:14:59,960
we will make use of while decoding our linear
block code Every vector in this standard array
101
00:14:59,960 --> 00:15:10,600
appears exactly once This is not very difficult
to prove This follows from the way we are
102
00:15:10,600 --> 00:15:19,040
constructing our standard array Ok and the
proof is by contradiction So I will just it
103
00:15:19,040 --> 00:15:25,320
is a very small proof so I can just give you
that Let's say how does the proof by contradiction
104
00:15:25,320 --> 00:15:32,780
work We will assume something and then we
will show that our assumption is wrong That's
105
00:15:32,780 --> 00:15:40,820
not possible Ok So we have to prove that every
element here is basically unique So let's
106
00:15:40,820 --> 00:15:46,360
say that's not true Let's say 2 elements let
us just call it this element and this element
107
00:15:46,360 --> 00:15:54,550
Let's say these 2 elements are same Ok If
these two elements are same then we can write
108
00:15:54,550 --> 00:16:09,400
this as e 2 raised to power n minus k plus
v 2 to be equal to e 3 plus v i correct Now
109
00:16:09,400 --> 00:16:20,990
we can write this e 2 n minus k as e 3 plus
v i plus v 2 why Because these are all binary
110
00:16:20,990 --> 00:16:25,010
words so basically when we add 1 plus 1 that's
basically 0
111
00:16:25,010 --> 00:16:30,760
So we add v 2 to both the sides so v 2 plus
v 2 will be 0 So we can write this error pattern
112
00:16:30,760 --> 00:16:43,820
as e 3 plus v i plus v 2 And what is v i plus
v 2 v i plus v 2 is another codeword Why because
113
00:16:43,820 --> 00:16:50,810
that's the property of the linear codeword
linear block code So this will be e 3 plus
114
00:16:50,810 --> 00:17:00,900
some other codeword let's call it v i v i
hat So that error pattern e 2 n minus k is
115
00:17:00,900 --> 00:17:18,140
e 3 plus v hat Now e 3 plus v i hat this should
be in the row containing e 3 because these
116
00:17:18,140 --> 00:17:29,330
are how do we find the entries in the row
containing e 3 We add all codewords to e 3
117
00:17:29,330 --> 00:17:38,301
and that's what these entries are So e 3 plus
v i hat should have been some entry here What
118
00:17:38,301 --> 00:17:48,870
does that mean That means we made a mistake
in selecting this error pattern Note what
119
00:17:48,870 --> 00:17:55,770
did we say We are choosing these error patterns
in such a way that in the previous rows this
120
00:17:55,770 --> 00:18:03,420
error pattern has not appeared But here we
have shown if these two elements would have
121
00:18:03,420 --> 00:18:09,780
been same if these two vectors in this standard
array would have been same then this is the
122
00:18:09,780 --> 00:18:17,800
condition Which would mean this error pattern
is already there in the row containing e 3
123
00:18:17,800 --> 00:18:25,880
So that means we cannot choose that as our
error pattern here because we can only choose
124
00:18:25,880 --> 00:18:33,300
an error pattern which has not appeared beforehand
So in other words we are contradicting ourselves
125
00:18:33,300 --> 00:18:38,520
On one hand we are saying we are picking up
these error patterns in such a way that they
126
00:18:38,520 --> 00:18:45,740
have not appeared in the previous rows but
if we are saying these two elements in this
127
00:18:45,740 --> 00:18:50,170
array are same then this is not possible
128
00:18:50,170 --> 00:18:57,430
So hence by contradiction basically we prove
that this is not possible We could not choose
129
00:18:57,430 --> 00:19:05,360
e 2 n minus k as this because this has already
appeared Hence this condition that these 2
130
00:19:05,360 --> 00:19:18,830
elements are same is incorrect Ok So all the
elements of the standard array are distinct
131
00:19:18,830 --> 00:19:29,590
and they appear exactly once No two vectors
in the same row are identical Again this is
132
00:19:29,590 --> 00:19:38,330
very easy to prove because all codewords are
distinct So elements in one row will all be
133
00:19:38,330 --> 00:19:50,790
distinct We call each row of the standard
array as coset and the leftmost entry of each
134
00:19:50,790 --> 00:19:58,830
coset or row is known as coset leader And
we have total 2 raised to power n minus k
135
00:19:58,830 --> 00:20:12,920
such cosets Now question is can we make any
other element as our coset leader So if you
136
00:20:12,920 --> 00:20:23,870
just go back here Let's say look at this row
Coset leader was this right the leftmost entry
137
00:20:23,870 --> 00:20:29,420
in the standard array Now what happens if
we instead of choosing this as a coset leader
138
00:20:29,420 --> 00:20:39,470
if we had chosen say this as coset leader
Would it had changed our elements of this
139
00:20:39,470 --> 00:20:49,910
array No Why Because if you go back and see
the entries of a particular row here the coset
140
00:20:49,910 --> 00:20:57,650
leader of e 3 if instead of e 3 we would have
used e 3 plus v 2 what would have happened
141
00:20:57,650 --> 00:21:03,550
This would have been e 3 plus v 2 this would
have e 3 plus v 2 plus v 2 So this would be
142
00:21:03,550 --> 00:21:12,760
e 3 This would be e 3 plus v 2 plus v i And
v 2 plus v i would be another codeword v i
143
00:21:12,760 --> 00:21:19,260
hat So this would have been some other codeword
So the elements in each row would have remained
144
00:21:19,260 --> 00:21:27,310
the same only they would have just got reordered
Ok So if we pick any other element in the
145
00:21:27,310 --> 00:21:38,650
row as coset leader it does not change the
elements in the coset or in a row
146
00:21:38,650 --> 00:21:47,490
The next property is all the 2 k elements
in a row or in a coset have the same Syndrome
147
00:21:47,490 --> 00:21:56,250
This we can show because each element in the
coset are of the form like this e j plus v
148
00:21:56,250 --> 00:22:04,381
i H transpose and since v i H transpose is
0 they will only depend on the error pattern
149
00:22:04,381 --> 00:22:12,670
And in each row basically it's the same error
pattern that appears in the elements of the
150
00:22:12,670 --> 00:22:20,800
row We can again go back to our diagram for
standard array and we can see this We can
151
00:22:20,800 --> 00:22:28,620
see in each row in this row it's e 3 in this
row all these elements have e 2 So they will
152
00:22:28,620 --> 00:22:39,220
have the same Syndrome and in the previous
lecture we talked about that there are n minus
153
00:22:39,220 --> 00:22:47,770
k Syndrome equations and n unknowns and there
are total 2 k solutions and you can see here
154
00:22:47,770 --> 00:22:57,900
each row has 2 k elements and they have the
same Syndrome So these 2 k elements are exactly
155
00:22:57,900 --> 00:23:08,190
the solution of your Syndrome equations because
they these 2 k elements of a row of a coset
156
00:23:08,190 --> 00:23:16,090
they all have the same Syndrome and they correspond
to the 2 k solutions of the Syndrome equations
157
00:23:16,090 --> 00:23:24,920
So the 2 k elements of a coset are actually
the solutions of your Syndrome equation An
158
00:23:24,920 --> 00:23:31,190
another interesting thing is each of these
cosets or each of these coset leader will
159
00:23:31,190 --> 00:23:40,040
have a different Syndrome Why because each
of these row if you look at each of these
160
00:23:40,040 --> 00:23:47,380
row each of them corresponds to different
error pattern Again let's go back to the diagram
161
00:23:47,380 --> 00:23:58,390
that we had for the standard array This row
split it to e 2 So if we compute Syndrome
162
00:23:58,390 --> 00:24:05,340
for any of these received vectors we will
get Syndrome corresponds to e 2
163
00:24:05,340 --> 00:24:12,900
This row corresponds to e 3 This e 4 e raised
to power n minus k So if you look at Syndrome
164
00:24:12,900 --> 00:24:20,990
for each of these rows they all correspond
to each row corresponding to a different Syndrome
165
00:24:20,990 --> 00:24:31,799
But within a row the Syndrome is same So in
other words you can map one Syndrome to one
166
00:24:31,799 --> 00:24:42,540
row or you can map one Syndrome to one coset
So this is interesting that now we have one
167
00:24:42,540 --> 00:24:53,350
to one mapping between each cosets or each
coset leader to a Syndrome Another thing to
168
00:24:53,350 --> 00:25:00,990
note is if we look at columns of this standard
array each column of the standard array corresponds
169
00:25:00,990 --> 00:25:08,240
to one particular codeword If you recall when
we started the lecture we said we want to
170
00:25:08,240 --> 00:25:19,110
partition our 2 n vectors into 2 k different
sets and each of these 2 k set should correspond
171
00:25:19,110 --> 00:25:28,860
to only one codeword and this is what is happening
here as well You have this whole thing as
172
00:25:28,860 --> 00:25:36,890
total possible 2 n vectors Now we have already
partitioned them into 2 k different partitions
173
00:25:36,890 --> 00:25:45,161
and these are all distinct partitions There
is no element in here which is common with
174
00:25:45,161 --> 00:25:46,161
this element
175
00:25:46,161 --> 00:25:53,210
And another thing to be of interest if you
look at each of these partitions this partition
176
00:25:53,210 --> 00:26:00,510
has all zero vector This partition corresponds
to v 2 This partition corresponds to v i This
177
00:26:00,510 --> 00:26:08,170
partition corresponds to v 2 k So this is
a point basically I am trying to make that
178
00:26:08,170 --> 00:26:14,980
the way we have created the standard array
if you look at the jth column of the standard
179
00:26:14,980 --> 00:26:25,020
array it contains exactly one codeword It
corresponds to only one particular codeword
180
00:26:25,020 --> 00:26:34,490
Now if received codeword belongs to column
d j then r will be decoded as codeword v j
181
00:26:34,490 --> 00:26:47,080
So whenever r belongs to a set this we will
decode this r as correspond to codeword v
182
00:26:47,080 --> 00:26:56,470
j So if v j is our transmitted codeword and
the error pattern is e i and if the received
183
00:26:56,470 --> 00:27:05,880
sequence is in falls in the column v j then
we would decode it as v j which is correct
184
00:27:05,880 --> 00:27:15,290
decoding We would not make any error However
if the error pattern is not a coset leader
185
00:27:15,290 --> 00:27:29,730
then r will not be in column v j and in that
case we will make an error in decoding
186
00:27:29,730 --> 00:27:38,800
So let us look at an error pattern x caused
by a channel and it is in the lth coset So
187
00:27:38,800 --> 00:27:47,850
if it is in the lth coset we are writing this
as let us say error pattern as e l corresponding
188
00:27:47,850 --> 00:27:56,910
to the error pattern e l plus v i So in that
case if we are transmitting codeword v j and
189
00:27:56,910 --> 00:28:06,130
we encounter this error pattern what we would
receive is v j plus 6 this would be nothing
190
00:28:06,130 --> 00:28:15,790
but e l plus v i plus v j Now what is v i
plus v j v i plus v j sum of two codewords
191
00:28:15,790 --> 00:28:24,250
is also a valid codeword Let's call that codeword
as v s So now the received vector is in partition
192
00:28:24,250 --> 00:28:30,740
d s And in this case what are we going to
decode it as We are going to decode it as
193
00:28:30,740 --> 00:28:41,250
v s which is not same as the transmitted codeword
v j So that's what I meant If your error pattern
194
00:28:41,250 --> 00:28:51,559
is not a coset leader then r would not be
in the same column as v j If this would have
195
00:28:51,559 --> 00:28:58,030
been coset leader this would have been just
e l And then received sequence would have
196
00:28:58,030 --> 00:29:04,250
been just e l plus v j So this would have
still remained in the partition d j And we
197
00:29:04,250 --> 00:29:13,870
would not have made a mistake Ok So the error
pattern is not a coset leader then we are
198
00:29:13,870 --> 00:29:24,310
basically going to make an error So from this
we can conclude that our decoding is going
199
00:29:24,310 --> 00:29:34,140
to be correct if and only if our error pattern
is a coset leader And how many such coset
200
00:29:34,140 --> 00:29:44,540
leaders exist We have total 2 n minus k So
this we call as correctable error patterns
201
00:29:44,540 --> 00:29:53,679
Because whenever our error pattern is coset
leader we are not going to make a mistake
202
00:29:53,679 --> 00:29:59,010
in decoding and hence we call these as correctable
error pattern
203
00:29:59,010 --> 00:30:08,570
Now the next question to think about is how
should we choose our coset leader Clearly
204
00:30:08,570 --> 00:30:15,600
our objective is to minimize probability of
error So the error patterns that are more
205
00:30:15,600 --> 00:30:23,750
likely to happen we should choose them as
our error coset leader and what are those
206
00:30:23,750 --> 00:30:32,360
error patterns These are error patterns which
have least Hamming weight So we start with
207
00:30:32,360 --> 00:30:40,400
first start with error pattern of Hamming
weight 1 If we run out of them start with
208
00:30:40,400 --> 00:30:50,700
Hamming weight 2 3 like that Because they
are more likely error pattern and we have
209
00:30:50,700 --> 00:30:55,900
shown that for binary symmetric channel the
error pattern with smaller weights are more
210
00:30:55,900 --> 00:31:06,330
likely than error pattern with larger Hamming
weight So among the coset we should choose
211
00:31:06,330 --> 00:31:17,250
the element which has basically the smallest
error pattern as our coset leader And this
212
00:31:17,250 --> 00:31:24,390
decoding is also maximum likelihood decoding
because we have shown earlier that maximum
213
00:31:24,390 --> 00:31:32,990
likelihood rule for binary symmetrical channel
it basically chooses v in such a way such
214
00:31:32,990 --> 00:31:39,340
that the Hamming difference between r and
v is minimized So in other words we have to
215
00:31:39,340 --> 00:31:44,510
choose an error pattern that has the minimum
Hamming weight So that's also the maximum
216
00:31:44,510 --> 00:31:53,320
likelihood decoding So suppose our received
vector is found in the ith column and lth
217
00:31:53,320 --> 00:32:00,670
coset of the standard array so in that case
because our received vector r is in the ith
218
00:32:00,670 --> 00:32:14,340
column we are going to decode it as v i Now
our received vector is in ith column and lth
219
00:32:14,340 --> 00:32:15,340
coset
220
00:32:15,340 --> 00:32:23,750
So the error pattern is e sub l So our received
sequence is our transmitted codeword plus
221
00:32:23,750 --> 00:32:31,630
our error pattern Now let's try to find out
the Hamming distance between our received
222
00:32:31,630 --> 00:32:38,980
vector and this code vector v i and Hamming
distance between received vector and some
223
00:32:38,980 --> 00:32:44,590
other codeword So when we try Hamming distance
between received codeword r and this code
224
00:32:44,590 --> 00:32:50,440
vector v i we can see Hamming distance is
nothing but number of locations where these
225
00:32:50,440 --> 00:32:58,400
2 bits are differing so if we add r and v
and then count the number of 1s that would
226
00:32:58,400 --> 00:33:03,080
give us the Hamming distance between r and
v So the Hamming distance between r and v
227
00:33:03,080 --> 00:33:12,490
is nothing but Hamming weight of the vector
r plus v i and what is r It is e l plus v
228
00:33:12,490 --> 00:33:24,480
i and plus v i so this was nothing but weight
of error vector Next consider now the Hamming
229
00:33:24,480 --> 00:33:32,780
distance between r and any other codeword
Let's call it v j So we are finding Hamming
230
00:33:32,780 --> 00:33:40,190
distance between r and any other codeword
v j So that would be given by weight of this
231
00:33:40,190 --> 00:33:51,929
vector r plus v j So r is nothing but e l
plus v i plus v j Now v i plus v j sum of
232
00:33:51,929 --> 00:33:57,570
2 codewords is another codeword so this would
be let's call that codeword v s
233
00:33:57,570 --> 00:34:10,039
So this will be weight of e l plus v s So
what have we done so far We found that the
234
00:34:10,039 --> 00:34:16,629
Hamming distance between the received codeword
and this code vector v i is given by this
235
00:34:16,629 --> 00:34:23,859
and Hamming distance between received codeword
and any other codeword which is not v i is
236
00:34:23,859 --> 00:34:32,500
basically given by this Now e l and e l plus
v s are going to be the elements in the same
237
00:34:32,500 --> 00:34:46,770
coset right and if we choose e to be our coset
leader which has minimum number of 1s then
238
00:34:46,770 --> 00:34:53,750
this would be less than this so we our minimum
distance decoding will decide in favor of
239
00:34:53,750 --> 00:35:04,360
v i and not any other codeword v j So as I
said since e l and e l plus v s are in the
240
00:35:04,360 --> 00:35:10,790
same coset and our coset leader has minimum
Hamming weight weight of this is less than
241
00:35:10,790 --> 00:35:18,840
equal to weight of this then this will always
happen In other words v i will be closer to
242
00:35:18,840 --> 00:35:29,540
r than any other codeword v j to r so this
will be our correct decoding So if we choose
243
00:35:29,540 --> 00:35:37,750
our coset leader to be the one which has minimum
weight in that coset the decoding basically
244
00:35:37,750 --> 00:35:43,190
based on maximum likelihood decoding will
be basically maximum likelihood decoding because
245
00:35:43,190 --> 00:35:49,400
maximum likelihood decoder for binary symmetric
channel we have said is the one which minimizes
246
00:35:49,400 --> 00:35:59,050
Hamming distance between received codeword
and the selected code vector v Ok
247
00:35:59,050 --> 00:36:08,410
So now to summarize then how do we do the
decoding We will first compute the Syndrome
248
00:36:08,410 --> 00:36:16,670
then each of these Syndrome corresponds to
one coset leader so we find out the coset
249
00:36:16,670 --> 00:36:21,869
leader corresponding to each Syndrome and
once we find the coset leader we add that
250
00:36:21,869 --> 00:36:27,220
coset leader which is our likely error pattern
to our received sequence and that could be
251
00:36:27,220 --> 00:36:38,330
our estimated codeword And this mapping from
Syndrome to error pattern basically can be
252
00:36:38,330 --> 00:36:45,670
implemented as a table lookup so which Syndrome
corresponds to which coset leader this can
253
00:36:45,670 --> 00:36:54,700
be uh implemented as a table lookup Now we
can use this Syndrome decoding for both error
254
00:36:54,700 --> 00:36:59,280
correction and error detection and we will
give an example to illustrate this
255
00:36:59,280 --> 00:37:05,820
Again basically as we said the coset leader
corresponding to lowest weight error patterns
256
00:37:05,820 --> 00:37:11,750
are essentially used for error corrections
and these are most likely error patterns according
257
00:37:11,750 --> 00:37:19,470
to the maximum likelihood rule Now we could
use this standard array for both a combination
258
00:37:19,470 --> 00:37:24,750
of both error correction and error detection
and we could we are going to illustrate this
259
00:37:24,750 --> 00:37:32,920
point that we could use Syndrome corresponding
to higher weight uh error pattern error detection
260
00:37:32,920 --> 00:37:40,700
rather than correction So let us take example
to illustrate how we can use this standard
261
00:37:40,700 --> 00:37:52,060
array for error correction and error detection
So this is our 6 3 systematic linear binary
262
00:37:52,060 --> 00:38:00,170
code whose generator matrix is given by this
and parity check matrix is given by this These
263
00:38:00,170 --> 00:38:09,630
are encoding equations and this is the mapping
of the Syndrome to the coset leader So the
264
00:38:09,630 --> 00:38:19,500
first step involved in this is creation of
standard array And I believe now you know
265
00:38:19,500 --> 00:38:26,820
how to create a standard array the first step
is first row of the standard array will be
266
00:38:26,820 --> 00:38:32,340
set of codewords You are already given the
generator matrix so you can generate what
267
00:38:32,340 --> 00:38:39,370
are set of codewords The leftmost entry in
the first row which is the row of codewords
268
00:38:39,370 --> 00:38:45,340
should be all zero codewords and then you
can place the other codewords in any order
269
00:38:45,340 --> 00:38:52,940
Now I couldn't fit in all the columns in one
slide so I have v 1 to v 4 in this slide and
270
00:38:52,940 --> 00:39:01,720
next I have v 5 to v 8 in the next slide Ok
271
00:39:01,720 --> 00:39:09,440
Now let me explain what I mean by correctable
error patterns detectable error patterns and
272
00:39:09,440 --> 00:39:20,650
undetected decoding error So out of these
all possible error patterns which are the
273
00:39:20,650 --> 00:39:30,220
error patterns that are correctly decodable
Now if you choose your coset leader to be
274
00:39:30,220 --> 00:39:39,369
the one which has the least Hamming weight
which has the least number of 1s and if you
275
00:39:39,369 --> 00:39:48,770
make that error pattern as your coset leader
then you can correctly decode those error
276
00:39:48,770 --> 00:39:56,160
patterns So let's look at each of these rows
Of course this corresponds to all correct
277
00:39:56,160 --> 00:40:04,750
codewords If the error patterns is this these
are the set of other elements of the coset
278
00:40:04,750 --> 00:40:14,800
and you can see here none of these elements
have weight less than 2 they are all 3 3 5
279
00:40:14,800 --> 00:40:26,619
4 and this has weight 4 2 2 so this is the
minimum weight error pattern and this is Hamming
280
00:40:26,619 --> 00:40:38,820
weight 1 So this error pattern is correctable
And if this error happens this can be corrected
281
00:40:38,820 --> 00:40:42,700
What about this Just look at other elements
282
00:40:42,700 --> 00:40:56,910
This has two 1s four 1s two 1s three 1s five
1s three 1s four 1s So clearly this has only
283
00:40:56,910 --> 00:41:03,200
one 1 rest others all have weight 2 or more
So this is the error pattern and if we make
284
00:41:03,200 --> 00:41:10,340
this as coset leader this is also correctable
Similarly we can see from other rows also
285
00:41:10,340 --> 00:41:16,250
This single error pattern is correctable this
single error pattern is correctable this is
286
00:41:16,250 --> 00:41:22,500
correctable this is correctable These are
all correctable patterns So when I talk about
287
00:41:22,500 --> 00:41:28,339
correctable patterns essentially I mean if
you get this this this this this this of course
288
00:41:28,339 --> 00:41:35,230
this is no error case which also I am counting
in correctable patterns so these 7 patterns
289
00:41:35,230 --> 00:41:41,230
if these are the error patterns then it is
correctable So these are the 7 correctable
290
00:41:41,230 --> 00:41:53,140
patterns Now what happens here This error
pattern has weight 2 This has 3 this has 3
291
00:41:53,140 --> 00:42:06,450
this has 3 oh this has 2 So this has 2 this
also has 2 this also has 2 so in this last
292
00:42:06,450 --> 00:42:13,950
row my coset leader is no longer the error
pattern with lowest Hamming weight There are
293
00:42:13,950 --> 00:42:21,270
2 other error patterns which also have Hamming
weight 2 Ok
294
00:42:21,270 --> 00:42:32,330
So in this situation when my Syndrome is pointing
to this coset I would not be able to do error
295
00:42:32,330 --> 00:42:39,490
correction why Because I know this could be
a likely error pattern or this could be a
296
00:42:39,490 --> 00:42:43,869
likely error pattern or this could be a likely
and they are all equally likely because here
297
00:42:43,869 --> 00:42:49,660
2 bits got flipped Here 2 bits got flipped
Here 2 bits got flipped So any of these 3
298
00:42:49,660 --> 00:42:57,550
patterns are equally likely in my in this
case So whenever Syndrome points to this coset
299
00:42:57,550 --> 00:43:04,980
I cannot do error correction However I can
detect error Why Because whenever it points
300
00:43:04,980 --> 00:43:11,349
to this row I know there is an error because
Syndrome is non-zero But I don't know what
301
00:43:11,349 --> 00:43:17,980
is my error So that's why I call it as detectable
error pattern So what are those detectable
302
00:43:17,980 --> 00:43:23,060
error pattern This is my detectable error
pattern this is my detectable error pattern
303
00:43:23,060 --> 00:43:29,010
this is my detectable error pattern maybe
I can use a different this thing color So
304
00:43:29,010 --> 00:43:38,780
I use red these are my detectable error pattern
These are my detectable error patterns These
305
00:43:38,780 --> 00:43:49,830
are 4 of them then remaining 4 are these
306
00:43:49,830 --> 00:44:01,460
So these are my 8 error patterns detectable
patterns error patterns Now let's use a different
307
00:44:01,460 --> 00:44:08,440
color pen What about these patterns which
have been left out This this this like other
308
00:44:08,440 --> 00:44:13,970
error patterns What happens to them These
error patterns let us say if this error pattern
309
00:44:13,970 --> 00:44:24,150
happens what is going to happen If this happens
I am not able to detect these error patterns
310
00:44:24,150 --> 00:44:31,290
why Whenever this error pattern happens this
is Hamming weight 3 its coset leader was already
311
00:44:31,290 --> 00:44:39,210
Hamming weight 1 So whenever these error patterns
happen whenever these error patterns happen
312
00:44:39,210 --> 00:44:47,750
I am not able to detect any of these error
patterns why Because any of these error patterns
313
00:44:47,750 --> 00:44:52,640
happen any of these error patterns happen
I have already taken decision in favor of
314
00:44:52,640 --> 00:45:00,940
these coset leaders because it is less likely
to get this error pattern than this So these
315
00:45:00,940 --> 00:45:10,850
set of 49 error patterns if any of these error
patterns happen then I am going to make a
316
00:45:10,850 --> 00:45:19,240
mistake This will result in undetected error
because whenever any of these error patterns
317
00:45:19,240 --> 00:45:27,590
happen I would assume that the error pattern
was this So this would result in undetected
318
00:45:27,590 --> 00:45:35,570
error probability So through this example
essentially I have illustrated how we can
319
00:45:35,570 --> 00:45:41,750
use the standard array for error correction
and error detection
320
00:45:41,750 --> 00:45:52,380
So in summary we would like to make our coset
leader as one having minimum Hamming weight
321
00:45:52,380 --> 00:46:00,810
minimum number of 1s And whenever we get an
error our Syndrome will be non-zero Syndrome
322
00:46:00,810 --> 00:46:06,690
will point out to a particular coset or a
row of the standard array and we will if the
323
00:46:06,690 --> 00:46:12,880
coset leader has the minimum number of 1s
then we will pick that coset leader as our
324
00:46:12,880 --> 00:46:21,940
likely error pattern and we are going to decode
it by picking that likely error pattern adding
325
00:46:21,940 --> 00:46:32,599
it to our received codeword and that would
be our estimated codeword So with this I conclude
326
00:46:32,599 --> 00:46:35,670
uh this decoding of linear block codes Thank
you