Error Detection and Correction by xiangpeng

VIEWS: 4 PAGES: 38

									01010000001001

 by Colin Kriwox




                   1
Contents
Introduction
        credit card error checking
        what is a code
        purpose of error-correction codes
Encoding
       naïve approach
       hamming codes
Minimum Weight Theorem
       definitions
       proof of single error-correction
Decoding
       list all possible messages
       using vectors
       syndrome
Conclusion
       perfect codes
                                            2
Detect Error On Credit Card




                              3
Formula for detecting error
 Let d2, d4, d6, d8, d10, d12, d14, d16 be all the even
 values in the credit card number.
 Let d1, d3, d5, d7, d9, d11, d13, d15 be all the odd
 values in the credit card number.
 Let n be the number of all the odd digits which have a
 value that exceeds four
 Credit card has an error if the following is true:
 (d1 + d3 + d5 + d7 + d9 + d11 + d13 + d15) x 2 + n +
 (d2 + d4 + d6 + d8 + d10 + d12 + d14 + d16)
   0 mod(10)                                             4
Detect Error On Credit Card


 n=3




   d1

        d2   d3   …   d15   d16


                                  5
Now the test
(4 + 4 + 8 + 1 + 3 + 5 + 7 + 9) = 41
(5 + 2 + 1 + 0 + 3 + 4 + 6 + 8) x 2 + 3 = 61
41 + 61 = 102 mod (10) = 2




                                 3             6
Credit Card Summary
The test performed on the credit card number is called a
parity check equation. The last digit is a function of the
other digits in the credit card. This is how credit card
numbers are generated by Visa and Mastercard. They
start with an account number that is 15 digits long and
use the parity check equation to find the value of the
16th digit.


“This method allows computers to detect 100% of
single-position errors and about 98% of other common
errors” (For All Practical Purposes p. 354).
                                                             7
What is a code?

A code is defined as an n-tuple of q elements. Where q is
any alphabet.


Ex. 1001                   n=4, q={1,0}
Ex. 2389047298738904       n=16, q={0,1,2,3,4,5,6,7,8,9}
Ex. (a,b,c,d,e)            n=5, q={a,b,c,d,e,…,y,z}


The most common code is when q={1,0}. This is known as
a binary code.                                         8
The purpose
    A message can become distorted through
    a wide range of unpredictable errors.

•   Humans
•   Equipment failure
•   Lighting interference
•   Scratches in a magnetic tape

                                             9
Why error-correcting code?

 To add redundancy to a message so
 the original message can be recovered
 if it has been garbled.

 e.g. message = 10
      code = 1010101010


                                         10
Send a message


Message   Encoder   Channel   Decoder   Message

 10       101010     noise    001010      10




                                                  11
Encoding

Naïve approach
Hamming codes




                 12
Take Naïve approach

Append the same message multiple times.
Then take the value with the highest
average.

 Message:= 1001
 Encode:=   1001100110011001
 Channel:= 1001100100011001
 Decode: = a1 = Average(1,1,0,1) = 1
            a2 = Average(0,0,0,0) = 0 ... (a1,a2,a3,a4)
 Message:= 1001
                                                          13
Hamming [7,4] Code
The seven is the number of digits that make the code.
E.g. 0100101
The four is the number of information digits in the code.
E.g. 0100101




                                                            14
Hamming [7,4] Encoding
Encoded with a generator matrix. All codes can be formed
from row operations on matrix. The code generator matrix
for this presentation is the following:

   1    0 0 0 0 1 1
   0    1 0 0 1 0 1
 G                
   0    0 1 0 1 1 0
                   
   0    0 0 1 1 1 1



                                                           15
Hamming [7,4] Codes
1000011
0100101
0010110
0001111
1100110
          2  16
           4
                      Codes
1010101


          2  128
1001100
0110011    7          Possible codes
0101010
0011001
1101001
1001010
1111111
0111100
0011001
0000000
                                       16
Minimum Weight Theorem
Definitions
Proof of Theorem




                         17
Definitions
The weight of a code is the number of nonzero
components it contains.
e.g. wt(0010110) = 3


The minimum weight of Hamming codes is the weight of
the smallest nonzero vector in the code.
         1   0 0 0 0 1 1
         0   1 0 0 1 0 1
e.g.   G                  d(G)= 3
         0   0 1 0 1 1 0
                        
         0   0 0 1 1 1 1
                                                       18
Definitions
The distance between two codes u and v is the number of
positions which differ
e.g.   u=(1,0,0,0,0,1,1)
       v=(0,1,0,0,1,0,1)
       dist(u,v) = 4


Another definition of distance is wt(u – v) = dist(u,v).



                                                           19
Definitions
 For any u, v, and w in a space V, the following three
 conditions hold:

       dist(u, u )  0
       dist(u, v)  dist(v, u )
       dist(u, w)  dist(u, v)  dist(v, w)




                                                         20
Definitions
The sphere of radius r about a vector u is defined as:
   Sr (u)  {v V | dist(u, v)  r}

  e.g. u=(1,0,0,0,0,1,1)           (0,0,0,0,0,1,1)

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

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

                                       (1,0,0,0,0,0,1)
                                                                   21
Minimum Weight Theorem
If d is the minimum weight of a code C, then C can
correct t = [(d – 1)/2] or fewer errors, and conversely.




                                                           22
Proof
Want to prove that spheres of radius t = [(d – 1)/2] about
codes are disjoint. Suppose for contradiction that they
are not. Let u and w be distinct vectors in C, and
assume that v  St (u )  St ( w)




                u     v   w


                                                             23
Proof
By triangle inequality
dist(u, w)  dist(u, v)  dist(v, w)  2t




                         v
                 u           w




                                            24
 Proof

Since spheres of radius t = [(d – 1)/2] so 2t  d  1 and this
gives dist(u,w)  dist(u,v) dist(u,w)  2t  d  1


But since dist(u, w)  wt (u  w)  d


We have a contradiction. Showing the sphere of radius t
about codes are disjoint.


                                                                 25
Result of Theorem
   1    0 0 0 0 1 1
   0    1 0 0 1 0 1
 G                
   0    0 1 0 1 1 0
                   
   0    0 0 1 1 1 1

Since d(G) = 3 then for t = [(3 – 1)/2] = 1 or fewer
errors, the received code is in a disjoint sphere about a
unique code word.




                                                            26
Decoding
list all possible messages
using vectors
syndrome




                             27
List all messages

This is done by generating a list of all the possible
messages. For something small like the Hamming [7,4]
codes the task is feasible, but for codes of greater
length it is not. An example of a list is as follows:

 Code words   1000011      0100101      0010110 …
              0000011      0000101      0000110
 Other        1000001      0100111      0010100
 Received     0010011      0001101      1010110
 Words        1100011      1100101      0110110
              …            …            …


                                                        28
List all messages

For example, if the received code was 0001101 then it
would be decoded to 0100101 from the list.




 Code words   1000011      0100101      0010110 …
              0000011      0000101      0000110
 Other        1000001      0100111      0010100
 Received     0010011      0001101      1010110
 Words        1100011      1100101      0110110
              …            …            …


                                                        29
Vector Decoding
  1          0 0 0 0 1 1
  0          1 0 0 1 0 1
G                      
  0          0 1 0 1 1 0
                        
  0          0 0 1 1 1 1


Let a:=(0,0,0,1,1,1,1), b:=(0,1,1,0,0,1,1), and
c:=(1,0,1,0,1,0,1).
                                                                         7

 If x : ( x1 ,..., x7 )   y : ( y1 ,..., y 7 ) then inner product =   x y
                                                                        i 1
                                                                               i   i   mod(2)




                                                                                                30
Vector Decoding
Correct errors by taking inner product of received
vector u by a, b, c. We get u  a, u  b, u  c


e.g. recall: a:=(0,0,0,1,1,1,1), b:=(0,1,1,0,0,1,1), and
c:=(1,0,1,0,1,0,1).

Message     Encoder      Channel       Decoder     Message

  1001       1001100      noise        1000100        ?

a u  1
              Error at 100 = digit 4. Decode to
b u  0      1001100 and message equals 1001
c u  0                                                     31
syndrome
Decodes without having to derive decoding vectors.
In addition to decoding Hamming [7,4] it can decode other
codes
More feasible than a list of messages




                                                        32
syndrome
The cosets of C are determined by {a  c | c  C}


 Some facts about cosets:
 (i) Every coset of C has the same number of elements
     as C does
 (ii) Any two cosets are either disjoint or identical
 (iii) V is the union of all cosets of C
 (iv) C has q nk   cosets

                                                        33
syndrome
A Coset leader is the vector with the minimum weight in
the coset.
The parity check matrix is found by solving the generator
matrix for GH T  0




                                                            34
syndrome
The first step is to create a list of syndromes
corresponding the coset leaders. The syndrome of each
vector y is found by syn( y)  Hy T


 When a code is received, the syndrome is computed
 and compared to the list of syndromes. Let the coset
 leader to the syndrome by e. Finally the code is
 decoded to x = y – e.




                                                        35
Syndrome example
   1   0 0 0 0 1 1             0 1 1 1 1 0 0 
   0   1 0 0 1 0 1
 G                        H  1 0 1 1 0 1 0
                                               
   0   0 1 0 1 1 0
                               1 1 0 1 0 0 1
                                               
   0   0 0 1 1 1 1


 Note that G=(I | A) and H = ( AT | I).




                                                    36
Syndrome example
Let x:= 1001100 be the original message

Message    Encoder     Channel       Decoder   Message

  1001      1001100      noise       1000100     ?

Compute the syndrome of the received code syn( y)  Hy T
    0 1 1 1 1 0 0  1       1
                      
H  1 0 1 1 0 1 0 0
                            1
                               
    1 1 0 1 0 0 1 0
                           1
                               
                      0 
                      1 
                       
                      0 
                      1                                37
                       
Conclusion
A code of minimum weight d is called perfect if all the
vectors in V are contained in the sphere of radius t =
[(d – 1)/2] about the code-word.


The Hamming [7,4] code has eight vectors of sphere
of radius one about each code-word, times sixteen
unique codes. Therefore, the Hamming [7,4] code
with minimum weight 3 is perfect since all the vectors
(128) are contained in the sphere of radius 1.


                                                          38

								
To top