Fehlererkennung und -korrektur
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
RS-232: Parity-Bit

  Nachricht:          11010110

  gerade Paritt:     zustzliches Bit, Quersumme wird gerade gemacht: 1
  kodierte Nachricht: 110101101

  ungerade Paritt:   zustzliches Bit, Quersumme wird ungerade gemacht: 0
  kodierte Nachricht: 110101100

RAID: Ausfallsicherheit durch Parity-Bit

  mehrere Festplatten

    1      2         3                        Daten: A = A1 + A2
    A1     A2    A3 = A1 xor A2


  xor-Verknpfung:

         0101 A1
    xor  0011 A2
        -----
         0110 A3

  Platte 2 ist defekt. Rekonstruktion:

         0101 A1
    xor  0110 A3
        -----
         0011 A2

Funktioniert mit beliebig vielen Festplatten
 bitweise: RAID 3 (ungebruchlich)
 blockweise: RAID 4 (ungebruchlich)
 Parittsblcke ber Platten verteilen: RAID 5

    1         2         3
    A1        A2    A1 xor A2
 B2 xor B3    B2        B3
    C1     C1 xor C3    C3
    D1        D2    D1 xor D2
             ...

Nachteil von RAID 3 und 4: Parittsplatte wird jedesmal beschrieben.
--> hoher Verschlei

Auch mglich: mehrere Reserve-Platten


Hamming-Abstand zweier Nachrichten := Anzahl der verschiedenen Bits

  Nachricht:          11010110
  defekte Nachricht:  11000110   Hamming-Abstand 1

Fehlerkorrektur ist mglich,
wenn man "zu viele" Symbole verwendet,
wobei solche mit Hamming-Abstand 1 fr dieselbe Nachricht stehen
--> 1 Fehler korrigierbar

(3,1)-Hamming-Code

   Kodierung:    1     111
                 0     000

  Nachricht:          1  1  0  1  0  1  1  0
  kodierte Nachricht: 111111000111000111111000
  defekte Nachricht:  111111010111000110111010
  Rekonstruktion:     111111000111000111111000   "Mehrheitsbeschlu"
                      1  1  0  1  0  1  1  0

Nur dann nicht rekonstruierbar, wenn 2 Bits in demselben Symbol fehlerhaft

(5,1)-Hamming-Code

   Kodierung:    1     11111
                 0     00000

(7,4)-Hamming-Code

   Wir wollen 4 Bits bertragen und kodieren sie in 7 Bits.

   Ich zhle mit 3 Bits bis 7 + 1 = 8

   0 1 0 1 0 1 0 1
   0 0 1 1 0 0 1 1
   0 0 0 0 1 1 1 1

   Ich codiere in 3 Bits die Paritt fr alle Bits.

     p p d p d d d   Konvention: 2er-Potenzen als Parittsbits verwenden
   0 1 0 1 0 1 0 1   <-- auf diesen Bits gerade Paritt kodieren
   0 0 1 1 0 0 1 1   <-- auf diesen Bits gerade Paritt kodieren
   0 0 0 0 1 1 1 1   <-- auf diesen Bits gerade Paritt kodieren

Nachricht: 1011
Kodierung:

     p p d p d d d
     0 1 1 0 0 1 1
     ^   ^   ^   ^   gerade Paritt ber 0 1 0 1 0 1 0 1
       ^ ^     ^ ^   gerade Paritt ber 0 0 1 1 0 0 1 1
           ^ ^ ^ ^   gerade Paritt ber 0 0 0 0 1 1 1 1

kodierte Nachricht: 0110011
defekte Nachricht:  0111011   (mit 1 Fehler)

Fehler erkennen: Paritten bilden

     p p d p d d d
     0 1 1 1 0 1 1
     ^   ^   ^   ^   gerade Paritt ber 0 1 0 1 0 1 0 1: OK
       ^ ^     ^ ^   gerade Paritt ber 0 0 1 1 0 0 1 1: OK
           ^ ^ ^ ^   gerade Paritt ber 0 0 0 0 1 1 1 1: nicht OK

Parittsbits: OK, OK, nicht OK
==> Rckschlu auf das defekte Bit
==> Korrektur durch Umklappen des defekten Bits

defekte Nachricht:  0111111   (mit 2 Fehlern)

Fehler erkennen: Paritten bilden

     p p d p d d d
     0 1 1 1 1 1 1
     ^   ^   ^   ^   gerade Paritt ber 0 1 0 1 0 1 0 1: nicht OK
       ^ ^     ^ ^   gerade Paritt ber 0 0 1 1 0 0 1 1: OK
           ^ ^ ^ ^   gerade Paritt ber 0 0 0 0 1 1 1 1: OK

Parittsbits: nicht OK, OK, OK
==> Rckschlu auf das defekte Bit: erstes Parittsbit
==> fehlerhafte Korrektur

"Korrigierte" Nachricht:

     p p d p d d d
     1 1 1 1 1 1 1
     ^   ^   ^   ^   gerade Paritt ber 0 1 0 1 0 1 0 1: OK
       ^ ^     ^ ^   gerade Paritt ber 0 0 1 1 0 0 1 1: OK
           ^ ^ ^ ^   gerade Paritt ber 0 0 0 0 1 1 1 1: OK

--> Kann (7,4)-Hamming zwei defekte Bits zumindest erkennen?
    Experiment und Wikipedia: erkennen ja, aber es wird falsch korrigiert

bungsaufgabe: Hamming-Code mit 4 Parittsbits aufstellen und testen
               Um welchen (?,?)-Hamming-Code handelt es sich?

Lsung:

   4 Parittsbits auf Zweierpotenzen anordnen

   p p d p d d d p d d d d d d d   15 Bits bertragen, davon 11 Datenbits





Lsung:

    p p d p d d d p d d d d d d d   Parittsbits an Stelle 1, 2, 4, 8 (2er-Potenzen)
    ^   ^   ^   ^   ^   ^   ^   ^   \
      ^ ^     ^ ^     ^ ^     ^ ^    binr zhlen
          ^ ^ ^ ^         ^ ^ ^ ^    |
                  ^ ^ ^ ^ ^ ^ ^ ^   /

    15 Bits, davon 4 Parittsbits --> (15,11)-Hamming-Code

Test:

  Nachricht:            1 0 1 1 0 1 0 0 1 1 1

  kodierte Nachricht:   0 0 1 1 0 1 1 0 0 1 0 0 1 1 1
                        x x 1 x 0 1 1 x 0 1 0 0 1 1 1
                        ^   ^   ^   ^   ^   ^   ^   ^  0
                          ^ ^     ^ ^     ^ ^     ^ ^  0
                              ^ ^ ^ ^         ^ ^ ^ ^  1
                                      ^ ^ ^ ^ ^ ^ ^ ^  0

  defekte Nachricht:    0 0 1 1 0 1 1 0 0 1 0 0 0 1 1
                        ^   ^   ^   ^   ^   ^   ^   ^  0  nicht OK
                          ^ ^     ^ ^     ^ ^     ^ ^  0  OK
                              ^ ^ ^ ^         ^ ^ ^ ^  1  nicht OK
                                      ^ ^ ^ ^ ^ ^ ^ ^  0  nicht OK
                                                !         betroffenes Bit


Fehler erkennen: CRC
"Checksumme"

  RS-232: Parity-Bit

    Nachricht:          11010110

    gerade Paritt:     zustzliches Bit, Quersumme wird gerade gemacht: 1
    kodierte Nachricht: 110101101

    ungerade Paritt:   zustzliches Bit, Quersumme wird ungerade gemacht: 0
    kodierte Nachricht: 110101100

  Prinzip: Gltige Nachrichten mssen [drfen nicht] durch 2 teilbar sein.
           Gltige Nachrichten mssen bei Division durch 2 einen bestimmten
           Rest haben.                                   ^
                                                  verallgemeinern

  CRC: Gltige Nachrichten mssen bei Division durch ein Polynom
       einen bestimmten Rest haben.

  Warum Polynomdivision? --> xor statt Subtraktion

  Beispiel:      x^3 + x^2      + 1
  Koeffizienten: 1     1     0    1
                                               _____ 3 Extra-Nullen
  Nachricht:            1 0 1 1 0 1 0 0 1 1 1  0 0 0   (Polynom-Grad = 1 weniger
  Polynom:              1 1 0 1                        als Polynom-Koeffizienten)
                        -------  keine Subtraktion, sondern xor
                          1 1 0
                          1 1 0 1
                          -------
                          0 0 0 1 1 0 0
                                1 1 0 1
                                -------
                                      1 1 1 1
                                      1 1 0 1
                                      -------
                                          1 0  0 0
                                          1 1  0 1
                                          --------
                                            1  0 1 0
                                            1  1 0 1
                                            --------
                                               1 1 1   Rest

  kodierte Nachricht:   1 0 1 1 0 1 0 0 1 1 1  1 1 1
  Polynom:              1 1 0 1
                        -------  keine Subtraktion, sondern xor
                          1 1 0
                          1 1 0 1
                          -------
                          0 0 0 1 1 0 0
                                1 1 0 1
                                -------
                                      1 1 1 1
                                      1 1 0 1
                                      -------
                                          1 0  1 1
                                          1 1  0 1
                                          --------
                                            1  1 0 1
                                            1  1 0 1
                                            --------
                                                   0   Rest


Polynome: standardisiert
(z.B. CRC-32: x^32 + x^26 + x^23 + x^22 + x^16 + x^12 + x^11 + x^10 + x^8 + x^7 + x^5 + x^4 + x^2 + x^1 + x^0, CRC-64: x^64 + x^4 + x^3 + x^1 + x^0)
so gewhlt, da "typische" Fehler zuverlssig erkannt werden


Reed-Salomon-Code:
Ausfall- und Fehlerkorrektur

  Ziel: n Zahlen bertragen
  Problem: Zahlen gehen verloren
  Lsung: m > n Zahlen bertragen, so da jedes n-Tupel
          die vollstndige Information enthlt

Beispiel: n = 3
  3 Werte bertragen: a0, a1, a2
  als Koeffizienten eines Polynoms verwenden
  Polynom durch m > n Sttzstellen bertragen
  m x-Werte werden vorab festgelegt
  m y-Werte (Funktionswerte) werden bertragen
  --> Wenn m - n Punkte verlorengehen,
      bleibt das Polynom und damit die Nachricht rekonstruierbar.
  --> Ausfall korrigierbar

Fehler korrigieren: komplizierter
  Wenn m Sttzstellen angekommen sind,
  aber ein Teil davon (hchstens m - n) ist falsch,
  beschreiben diese trotzdem ein Polynom.
  Dieses hat aber mit hoher Wahrscheinlichkeit einen hheren Grad.
  Man kann dann zurckrechnen, welches Polynom n. Grades das richtige war.

Bemerkung: Man rechnet nicht mit reellen Zahlen, sondern mit endlichen Krpern
  (vgl. RSA)
