Also da arbeitet man dann also mit linearen,
in K-Codes, wo im Prinzip eine Anzahl von Informationsbits,
in diesem Fall jetzt hier mit dem Index K, insgesamt in Bit codiert werden.
Dann das, was man auch häufig hat, ist dann eben ein sogenannter systematischer Code.
Das heißt, in dem Code oder in dem Codewort ist das originale Datenwort auch wirklich eins zu eins erhalten. Das,
was an Informationen übertragen wird,
wird dann aber eben nur um diese zusätzlichen mit für Fehlererkennung beziehungsweise für Fehlerkorrektur ergänzt,
hat eben wirklich den Vorteil,
dass wenn es also keine Fehler aufgetreten sind,
man eben auch sehr einfach sagen kann, okay,
ich nehme jetzt also dieses und dieses und dieses Bild
und habe damit also auch original mein Codewort und muss da jetzt nicht nur irgendwelche größeren,
arathmetischen oder logischen Operationen auch vorausführen.
So, und das, was man nun auch häufig hat,
sind sogenannte zyklische Codes,
das sind kurz bei denen dann eben auch entsprechend irgendwelche zyklischen Verschiebungen,
die dann also quasi jetzt durch irgendwie solche Protate-Operationen erzeugt worden sind,
dann eben genauso Code-Worte sind.
Das hat eben den Vorteil,
dass man teilweise dann eben bei serieller Übertragung dann auch sagen kann,
wenn solche Bündelfehler auftreten, das heißt ganze Gruppen von Symbolen
beziehungsweise in diesem Fall dann also von Bits quasi sich ändern,
dass man das dann also sehr schnell erkennen kann.
Gut, das sind erstmal nur rein Definitionen,
welche Arten von Codes gibt es jetzt.
Dazu werde ich jetzt also gleich einige einfache Beispiele vorstellen
Und wie gesagt,
es gibt rein praktisch in der Informatik sehr viele sehr unterschiedliche Codierungen,
die dann eben auch teilweise,
was ich also auch vorgestern schon erläutert hatte,
also relativ nah an das rankommen,
was also quasi jetzt hinsichtlich der Informationsverarbeitung oder Übertragung in einem Kanal theoretisch möglich ist.
Die sind dann aber eben doch sehr kompliziert, deswegen,
also hier
nur so einige einfache Ideen dazu
Vorneweg nochmal kurz die Überlegung, was passiert jetzt eigentlich überhaupt bei
der Übertragung in einem gestörten Kanal zwischen Sender und Empfänger.
Generell kann man natürlich sagen, ich habe also erstmal zwei Möglichkeiten,
wie ich also jetzt irgendwie dies gestört, mit diesem gestörten Medium umgehen kann.
Eine Möglichkeit ist, dass ich also überhaupt erst nochmal feststellen muss, wurde Information verfälscht.
Das heißt also, da brauche ich dann eigentlich nur eine Fehlererkennung.
Und wenn der Empfänger jetzt eben festgestellt hat,
es ist ein Fehler aufgetreten, dass man dann quasi jetzt
beim bidirektionalen Kanal über eine entsprechende Nachricht beim Sender eben wieder nachfragt,
okay, ich habe da irgendwie Müllempfang,
schicke mir die Information nochmal rüber.
Nicht, das ist das, was dann also unter
Automatic Repeat Request oder ARQ dann auch gerne abgekürzt wird,
wo man eben im Prinzip eine Fehlererkennung realisieren muss.
Nachteil bei dem Verfahren ist dann natürlich logischerweise, dass es eben sein kann,
dass die Übertragung in dem Übertragungskanal eben erstmal länger dauert.
Es wird festgestellt, okay, die Information ist nicht korrekt.
Okay, schick mir das bitte nochmal.
Diese Nachricht muss erst dann wieder zum Sender zurückgespielt werden.
Der erzeugt dann quasi wieder eine neue Nachricht, die er rausschickt.
Das kann sich eben relativ lange hinziehen. Ist für ein
Prinzip ein sicheres Verfahren. Das ist eben auch das,
wie zum Beispiel relativ viele Protokolle im Internet auch arbeiten,
wo dann eben quasi jetzt für die einzelnen Internetpakete dann eben festgestellt wird,
okay,
Fehler sind aufgetreten oder Pakete fehlen
Es wird dann eben quasi beim Sender nachgefragt, schicken wir das nochmal.
Wo das nicht funktioniert, ist halt eben,
wenn man sowas wie Echtzeitanforderungen hat. Das heißt,
wenn ich sowas in kontinuierlichen Datenstrom habe und sage,
den muss ich eben auch irgendwie unter harten Echtzeitbedingungen wieder zusammensetzen oder dekodieren.
Weil da kann es dann eben wirklich sein,
dass also einfach, wenn diese Übertragungszeit bei größeren Entfernungen bzw.
wenn die Leitung oder die Medien entsprechend belegt sind,
einfach zu groß werden,
dass das nicht funktioniert
Gut, ich hatte jetzt eben schon gesagt, Beispiel Internetprotokolle, wie sieht das da aus?
Gut, da muss man jetzt immer sagen, okay, also da habe ich in dem Sinne jetzt in der Regel erstmal keine Echtzeitanforderungen. Sondern da kann man sagen,
also selbst wenn ich mir jetzt also von irgendeinem Anbieter,
also irgendwo einen Film meinetwegen jetzt streamen lasse,
wo man ja nun vermuten könnte, okay,
Echtzeitanforderungen in dem Sinne sind dort vorhanden, ist das eigentlich also sowas,
was so in der Begrifflichkeit der eingebetteten Systeme dann also unter Soft-Deadline fällt,
also weiche Echtzeitanforderungen, weil das, was passieren kann,
ist halt, wenn jetzt eben irgendwo bei meinem Film,
also irgendwelche Datenpakete, also quasi bei einem Stream jetzt zu bet ankommen,
verlustig gehen, na gut, da kann es dann eben sein,
dass also bei der Wiedergabe mal ein oder zwei Frames ausgesetzt werden,
das Bild ruckelt vielleicht mal im Worst Case,
in der Regel kriegt man das aber gar nicht mit,
beziehungsweise durch irgendwie relativ große Empfangspuffer versucht man das dann eben auch noch so ein bisschen abzufangen und auszugleichen.
Im Gegensatz dazu steht dann sowas wie harte Echtzeitanforderungen,
das ist eben das, was dann eigentlich hier auch mit drin ist,
wo ich eben wirklich sage, ich habe jetzt wirklich eine Verbindung,
wo ich lebensnotwendig quasi eine bestimmte Maximalzeit überhaupt nur zulassen darf.
Das findet sich dann also, gut, also bei Internetprotokollen an,
typischerweise nicht, beziehungsweise da versucht man das zu umgehen.
Also es findet sich dann eher so bei anderen Beispielen gebettelter Systeme nicht,
also stellen wir uns vor,
also irgendwie im Automobil irgendeine Regelung,
meinetwegen jetzt vom Anti-Blockier-System oder sowas und die Meldung quasi jetzt von dem Radsensor an das entsprechende Steuergerät,
das einer abblockiert und deswegen sollte man jetzt also irgendwie den Bremsdruck dann mal wegnehmen,
die sollte halt jetzt sehr schnell und möglichst zeitnah auftreten und nicht irgendwie nach 0,3 Sekunden,
wenn das Auto sich also schon halb gedrehte hat und also auf dem Weg zum nächsten Baum ist.
Also deswegen, das da eigentlich nochmal. Gut,
also wie gesagt, das wäre dann eben dieses Nachfragen,
okay, schick mir nochmal, da brauche ich dann eben entsprechend nur Eine Fehlerkennung.
Das andere ist dann eben die sogenannte Vorwärtsfehlerkorrektur oder im Englischen
dann eben auch Forward-Error-Correction. Da geht es eben darum,
dass man senderseitig quasi die Informationen so umbaut oder so ergänzt, dass der Empfänger eben eine bestimmte Anzahl von Fehlern, die also während der Übertragung aufgetreten sind, dann auch wirklich korrigieren kann. Gut,
und wie gesagt, je nach Einsatzzweck,
wie kritisch oder unkritisch irgendwelche Übertragungen sind, wo es,
wie man das entsprechend einschätzt, sind dann eben wieder sehr einfache,
teilweise, aber eben auch entsprechend kompliziertere Verfahren üblich,
häufig also auch noch irgendwie mehrstufig kombiniert,
dass man eben sagen kann,
zum Beispiel dann auch so bis zu einer bestimmten Anzahl von Fehlern,
kann ich diese Fehler durch so eine Forward-Error-Correction dann quasi wieder zurückrechnen,
wenn es mehr sind, kann ich zumindest eine Fehlererkennung machen,
da ist ein Fehler aufgetreten und dann frage ich vielleicht über so ein Automatic Repeat Request dann,
also nochmal beim Sender nach,
okay,
also da ist jetzt also irgendwie zu viel passiert,
schick mir dieses
eine Datenpaket nochmal
Gut, wie funktioniert jetzt eigentlich diese ganze Fehlerkennung?
Dazu also auch erstmal der Begriff des Hemming-Abstands.
Hemming-Abstand ist die Anzahl der Stellen oder die Anzahl der Bits,
an denen sich Binärwörter jeweils paarweise voneinander unterscheiden. Also als Beispiel,
ich habe hier dieses Wort A, acht Bit breit,
dieses Wort B, acht Bit breit und der Hemming-Abstand von diesen beiden Wörtern ist drei,
weil die sich eben an genau dieser Stelle an dieser Stelle und an dieser Stelle um jeweils einen, wird unterscheiden.
Nicht, das ist also das, was Hemmingabstand ist,
Hemminggewicht, das ist dann quasi der Abstand des Wortes vom Nullwort,
beziehungsweise genau das, was man mit dem,
was wir im Vorletzten Kapitel da mit dran hatte,
mit diesem Bitcount, oder neben dem letzten war das,
also im Prinzip mit diesem Bitcount sich dann letztendlich also ausrechnen kann,
nämlich wie viele Bits in einem Wort gesetzt sind.
Nicht in dem Beispiel kann man jetzt eben sagen,
dass Hemminggewicht, also von diesem Wort B wäre jetzt fünf,
weil ja also quasi fünf Wahnsinn vorkommen
Gut, in Programmiersprachen,
wenn man eben sowas wie so ein Bitcount hat,
nicht also hier jetzt quasi als Driver-Code nicht,
dann könnte ich eben sagen, okay, Bitcount von A exklusiv oder B,
das war ja also hier das Exklusiv-Oder oder Spitvisor exklusiv oder in Java.
Nicht, das berechnet mir da nämlich genau hier,
also diese Unterschiede und davon an den Bitcount würde mir dann
also quasi in Helming Abstand von den beiden berechnen und eben
nur Bitcount von B würde dann eben in diesem Fall dann
diese fünf liefern
Gut, wie funktionieren jetzt eben Fehlererkennung bzw. Fehlerkorrektur?
Dazu muss man eben eine Kodierung wählen, wo Redundanz drin ist.
Das heißt, das Codewort wird größer als das,
was eigentlich, ich sag mal,
an Informationen aufgrund der Entropie in dem Code vorhanden ist.
Das war das, was ich also am Mittwoch vorgestellt hatte.
Entropie ist eben
der mittlere Informationsgehalt
Ein rein stochastisches Modell, was ich also quasi daraus ergibt,
dass ich sage, ein Zeichen ist so und so wahrscheinlich
und ich habe insgesamt so und so viel Zeichen und Entropie war dann halt eben der mittlere Informationsgehalt, wenn ich ein Zeichen empfange.
Im Gegensatz dazu steht dann eben die mittlere Kotwortlänge,
das war also dieses Hanul,
wo man dann also quasi jetzt nicht von dem steuerhastischen Modell,
also sprich von der Wahrscheinlichkeit einzelner Zeichen ausgeht, sondern von der Kodierung,
das heißt, wie lang sind die Zeichen kodiert,
wie viele Bits brauche ich dafür,
dass man darüber dann eben entsprechend ausrechnet,
wie groß dieses Hanu ist.
Und die Differenz zwischen dieser mittleren Kotwortlänge, dem Hanu und der Entropie,
das ist dann eben quasi das, was der Redundanz ist.
Gut, also ich mache meinen Kot künstlich länger als das,
was ich eigentlich an Bits für die eigentliche Godierung bräuchte.
Und man verlängert den dann eben so weit, dass sie,
es gilt, dass eben für alle Kotwörter,
die jeweils paarweise einen bestimmten Hemmingabstand in diesem Fall jetzt
also mal weh genannt haben
Dieser Hemming-Amstand, der dann eben quasi jetzt für alle Codewörter paarweise gelten muss.
Das ist dann eben der Minimalabstand. Und dann ist es eben möglich,
wenn ich jetzt eben so einen Minimalabstand habe,
dass ich eben bis zu deminus eins Fehler stellen,
überhaupt, dass man Fehler erkennen kann.
Und bis zu dem minus eins halbe Fehler stellen,
Fehler korrigieren kann.
Wieso gilt das
Beispiel dazu vorgleich. Bei den Fehlerstellen kann man sich das
einfach schon mal dadurch überlegen oder bei der Fehlererkennung kann man sich das eben dadurch überlegen,
dass man sagt, gut, ich habe zwei Worte,
die unterscheiden sich um Debit voneinander.
Das ist ja dieser Minimalabstand. So, und es treten jetzt
dminus eins Fehler auf, das heißt einzelne Bits kippen.
So, das heißt, von einem gültigen Wort komme ich
mit dminus eins Fehlern immer nur zu einem ungültigen Wort.
Das heißt, es kann mir nicht passieren,
dass ich Durch die Fehler aus einem gültigen Codewort ein anderes gültiges Codewort wird.
Das ist also das, wie letztendlich die Fehlererkennung funktioniert.
So Fehlerkorrektur, kommen jetzt vielleicht zwei Beispiele,
wo das also jetzt für eine relativ kurze Wortlänge überhaupt nochmal so ein bisschen visualisiert werden kann.
In dem Fall, also wir haben jetzt hier ein 3-Bit-Code,
können da mit dem zufolge,
hier jetzt also quasi so als Ecken so eines Würfels dargestellt,
können also demzufolge damit 8 unterschiedliche Kombinationen bilden.
So, und wenn ich jetzt nur Worte nehme,
die jetzt also hier quasi rot gekennzeichnet sind,
dann entspricht das eben ein Hemming-Abstand von zwei.
Das heißt, immer paarweise zueinander gilt für jedes dieser roten
Worte, dass ich zwei Bits ändern muss.
Ändern heißt das jetzt hier über diese Visualisierung dann immer,
also ich bewege mich entlang so einer Kante.
Also wenn ich von dem Wort zu dem Wort will,
muss also quasi aus der einzelnen Null werden und dass der 001,
das heißt, ich gehe dann also irgendwie hier rüber oder hier rüber zu diesem Wort.
So, Hemming-Abstand 2 heißt jetzt in dem Fall,
Ich kann bis dminus 1, also bis eine fehlerhafte Stelle, eine Fehlererkennung machen.
Weil was passiert, wenn sich jetzt immer nur ein,
wenn ich ein gültiges Kotwort habe,
sich immer nur ein einziges Bit ändern kann,
dann lande ich eben immer bei einem ungültigen Kotwort.
Wenn sich zwei Bits ändern, gut,
dann habe ich Pech gehabt,
dann lande ich eben bei einem widergültigen Kotwort und kann jetzt
eben keine Fehlerkorrektur mehr machen oder Fehlerkennung mehr machen
Fehlerkorrektur ist jetzt also hier definiert oder da fahren schaut ich in diesem Beispiel,
wo ich jetzt also einen Hamming-Abstand von drei habe.
Das heißt, von diesen acht möglichen Wörtern bleiben jetzt
nur noch diese beiden Rotmarkieren über.
Die unterscheiden sich logischerweise dann ja eben über drei Bit,
die sich ändern. So und nach der Formel kann ich
also quasi drei minus eins durch zwei,
also sprich Fehlerkorrektur bis zu einer fehlerhaften Stelle machen
Weil was passiert, wenn ich also hier ein gültiges Wort habe,
sich ein Bit irgendwie ändert,
dann lande ich eben entweder hier oder hier oder hier.
Und das, wo ich jetzt also quasi hier bei diesem Ergebnis bin,
was jetzt fehlerhaft übertragen wurde, liegt jetzt eben, sorry,
liegt jetzt eben näher an diesem gültigen Codewort als an diesem gültigen Code vor Ort.
Weil jeder Unterschied quasi ein Bit ist zu diesem gültigen Codewort
wären es zwei Bett, die sich ändern müssten.
Also das heißt, die Fehlerkorrektur funktioniert dann eben dadurch,
dass man sagt, ich liege quasi jetzt mit diesen Fehlern
näher an einem gültigen Wort als an allen anderen gültigen Worten.
Das ist also die Art und Weise, wie das also
jetzt quasi über diesen, die Hemming-Distanz letztendlich funktioniert. Gut,
hier ist das Ganze jetzt mal für einen Code aus 5 Code 5-Bit visualisiert,
wobei ich jetzt, also hier quasi 2,
also auch nur zweigültige Code-Worte habe,
nämlich einmal dieses Arbeit,
dieses Hemming-Abstand zwischen den beiden
ist jetzt
Und was eben möglich ist, einfach nach der Formel,
nicht deminus eins, Bit, kann ich dann also quasi eine Fehlerkorrektur machen.
Das heißt, hier von eins bis vier Bit, Hemmingabstand,
stelle ich dann eben fest, dass es eben aus meinem
gültigen Kotwort eins von den ungültigen Kotworten hier geworden, beziehungsweise umgekehrt.
Das ist also das, wo also eine Fehlererkennung möglich ist und eine Fehlerkorrektur,
wäre dann eben quasi formelmäßig fünf, minus eins,
durch zwei, also quasi zwei Bit, kann ich Fehlerkorrektur machen.
Das heißt, wenn ich also hier bei diesem gültigen Kotwort bin,
zwei bis ändern sich, dann halte ich eben entweder eins hiervon oder eins von diesen Worten.
Und das Ergebnis liegt quasi jetzt immer noch näher,
an dem hier vom Hamming-Abstand, als an diesem zweiten Kotwort.
Das ist also die Art und Weise, wie das Ganze letztendlich jetzt funktioniert.
Gut, Das ist jetzt natürlich irgendwie so erstmal willkürlich ausgewählt.
Eine Veranschaulichung jetzt eigentlich von dem Begriff des Hemmingabstands.
Jetzt geht es aber eigentlich darum, dass wir also Folgendes machen möchten.
Wir möchten eigentlich irgendwelche Informationen übertragen und uns nicht also irgendeinen komischen Kot ausdenken,
wo ich jetzt also quasi hier genau zwei Symbole in fünf Bits kodieren kann.
Das heißt, jetzt geht es darum,
also wie kommt man letztendlich zu irgendwelchen systematischen Verfahren,
wo man im Prinzip jetzt Prüfinformationen zu seinem Wort hin zurechnen kann,
entweder zu Fehlererkennung oder zu Fehlerkorrektur.
Gut, dazu gibt es jetzt einen ganzen Satz,
unterschiedliche Verfahren und zumindest hier für die ersten drei Folgen dann also auch noch kurze Beispiele. Nicht,
es ist allereinfach, sie sind dann also im Prinzip sowas wie Prüfziffern,
dann kann man Summen bilden,
dann diese ganzen sogenannten CRC-Verfahren sind auch welche,
die also relativ häufig in der Datenübertragung eingesetzt werden und dieses hier gut sind jetzt,
also Kurz oder Kurdierung sollen, ist ja sehr Vollständigkeit halber vom Namen her mal erwähnt worden sein.
Ansonsten, wenn sie sich dann also irgendwann später in einer Informatik,
also noch mit Datenübertragung beschäftigen, wird ihnen das sicherlich wieder begegnen.
Aber werde ich jetzt also hier nicht weiter vorstellen, weil wie gesagt,
gerade so mit dieser ganzen Codierung kann man auch noch relativ viel Informationen beibringen.
Gut, das Einfachste oder einfachste Methode sind halt eben sogenannte Paritätscodes,
beziehungsweise dass man eben sagt, man fügt einfach an ein Binärcode-Wort ein,
sogenanntes Paritätsbitt hinzu.
Das berechnet sich dann eben quasi jetzt als die Summe über die einzelnen Bits,
Module 2, Summenbildung in GF2, war die XO-Operation.
Das heißt also, man kann das eben beispielsweise einfach dadurch machen,
dass sie eben wirklich witweise in XO mache.
Und dann hat man dann letztendlich die Parität. Das ist also das,
was dann also mathematisch gesehen jetzt hinter diesem komischen Körper
GF2 hoch einsteckt
In dem Fall würde man eben sagen, okay,
also entweder oder das, was man häufig macht,
ist, also entweder sogenannte Geradeparität. Das heißt,
ich habe hier meine Bits und ergänze die dann eben so um ein Paritätsbit,
das eben diese Modulsumme über die einzelnen mit gleich Null
ist oder ungerade Parität,
sodass eben die Modulsumme über die einzelnen Bits
gleich eins ist
Gut, in der Praxis, bei der Übertragung,
auch wenn jetzt also gleich noch ein Beispiel mit Evan Perrity folgt,
nimmt man häufig die Ungeradeparität,
hat jemand vielleicht eine Idee,
weswegen das sein könnte,
weswegen eine Ungeradeparität besser geeignet ist als eine gerade Parität,
wenn ich jetzt also irgendwelche Daten von A
nach B übertrage
Da einmal. Naja, also das Paritäts,
also die Antwort war, war das Paritätsbit 1 ist,
nee, also es muss ja gelten, dass diese Modulo-Summe dann gleich 1 ist.
Also Idee ist schon nicht verkehrt,
also es kommt dann noch was mit hinzu,
was würde im Prinzip Nee, also ich rechne immer Modulo 2. Das heißt,
es kommt immer nur als Paritätsbesetzer 0 oder 1 raus.
Nee, eigentlich auch nicht. Also die Idee ist folgende.
Also wenn man jetzt sagt, also ich nehme jetzt beispielsweise als Wort,
was ich übertragen möchte, ein Wort aus lauter Nullen.
Dann ist die Ungerade Parität, null, exklusiv oder null.
Ist null, exklusiv oder null und so weiter und so fort.
Das heißt, da habe ich eine Null raus.
Und jetzt soll aber dazu, dass Paritätsbett gleich eins sein,
dann wird also in dem Fall, dass Paritätsbett eine eins.
Bei der geraden Parität wäre es eine Null.
Und hört sich jetzt immer irgendwie doof an,
aber der Grund, weswegen man sowas macht,
da ist es daran in einfach,
wie unterscheide ich
Wenn ich jetzt irgendwelche Werte empfange,
ein Wort aus lauter Nullen von einer kaputten Leitung.
Nicht, weil das ist eigentlich die Sache, die dann letztendlich elektrotechnisch dahintersteht.
Also ich empfange jetzt irgendwie meine Bits. So, und
jetzt hat jemand den Stecker gezogen. Der Empfänger ist jetzt also
irgendwie doof und das ist jetzt also nicht wie beim Internet,
wo man jetzt also letztendlich dann ja noch elektrisch, also entsprechend Verbindungen hat,
sondern eigentlich wirklich nur sowas wie so eine serielle Leitung.
So nicht. Und da wird einfach jetzt immer irgendwie abgetastet
und man empfängt immer
nur Nullen
So, und dann kann man jetzt nicht sagen,
okay, da ist irgendwie elektrisch was kaputt gegangen,
sondern es sind alles gültige Worte mit einem gültigen Paritätsbild.
Und deswegen baut man relativ gerne eben auch so komische Strings oder Stringkombinationen sich immer zurecht, wo immer auch mal Nullen und Eisen sich abwechseln. Das ist also auch eine der Sachen,
weswegen bei vielen von diesen anderen Codierungen,
die also vorher da so auch gekommen sind,
wo man dann zum Beispiel war der Codierung von Zahlen,
in einschrittigen Codes, wenn man das also entsprechend oben rechnet,
wo man ja auch immer sagt,
also ich habe jetzt Folgen von Nullen,
die wir jetzt nicht Codi oder Form von Gleicherziffern,
die wir dann immer nicht codierten, wenn sich da was ändert,
wird das immer entsprechend codiert und dass man da dann aber auch Mechanismen einbaut,
das eben in gültigen Worten, sowohl Nullen als auch 1 drin sind.
Gut, also das ist eben in dem Fall jetzt also mal so ein Vorteil,
also für so eine ungerade Parität,
ansonsten nimmt sich das aber alles nicht, sondern das sind immer Sachen,
wo man eigentlich immer nur zwischen Sender und Empfänger sagen muss,
was genommen wird.
Gut, wie gesagt, also hier ist das Ganze dann eben
auch nochmal in der Praxis meistens ein Satz zur Umgradenparität,
weil ich dann nämlich in jedem Kotwort mindestens eine Null und eine Eins drin habe.
Also gleiches gilt eben genauso wenigstens dringend aus lauter Einsen habe,
dass man dann eben dort dann also auch immer nochmal
mindestens eine Null mit reinbaut in die Parität.
Gut, was gilt jetzt eben für diese Paritätscodes?
Die haben automatischen Haming-Abstand von zwei
Weil ich habe zwei Worte, die unterscheiden sich um genau ein einziges Bild.
Wenn die sich um genau ein einziges Bild voneinander unterscheiden und ich füge die,
oder ich berechne die Parität, egal ob jetzt gerade oder ungerade,
wird sich auch das Paritätsbit dieser beiden Worte voneinander unterscheiden.
Das heißt, damit habe ich genau Hemming-Abstand 2 erreicht. So,
wenn die sich um mehr als nur einen wird voneinander unterscheiden,
dann können die zwar wieder die gleiche Parität haben,
aber dann haben die auch automatisch einen Hemming-Abstand von 2. Das heißt,
mit Diesen Mechanismus der Parität erreicht man eben automatisch Distanz zwischen den Kotorteln des 2. So,
das heißt,
damit kann ich dann eben auch entsprechend dieser Formel dann gleich sagen,
okay, ich kann letztendlich damit dann alle ein mit Fehler erkennen.
Und zumindest, wenn es jetzt eine ungerade Anzahl von Mehrbettfehlern ist,
weil die dann ja auch eine falsche Parität liefern,
kann man die auch noch miterkennen.
Wenn ich eine gerade Anzahl von Mehrbettfehlern habe, okay,
dann hat man Pech gehabt,
dann ist die Kodierung aber auch ungeeignet
Ja. Ja, beziehungsweise habe ich da jetzt gerade irgendwie,
also nicht, dass ich jetzt gerade Unsinn erzählt habe,
also wir haben ein Wort aus lauter Einsen und bei der
ungeraden Quarität würde sich immer ergeben, eins XO1 ist null.
XO1 wäre dann in diesem Fall dann wieder eins.
Das heißt, es ändert sich dann immer jeweils. So,
jetzt muss man also erstmal Fallunterscheidungen machen, ob man entsprechend
jetzt eine gerade oder eine ungerade Anzahl von einsen drin hat.
Also bleiben wir jetzt also erstmal bei dem Fall einer geraden Anzahl von einsen,
also sprechen sehr kurzes Wort, also jetzt nur aus genau 2-1,
nüchtern würde quasi diese X-Off-Verknüpfung eine Null liefern.
Und dann wird das Paritätsbit bei uns gerade Parität muss dann eben gelten,
Modul 2 ist gleich eins, dann müsste das eine null werden.
Ich war, ich, also hier,
dies wäre jetzt, also hier das Paritätsbit, beziehungsweise,
also ich würde das jetzt immer quasi mit dem Even nehmen und
das dann invertieren und hätte da dann eben immer hier eine Null,
nee,
dann müsste ich ja eigentlich auch eine Eins bekommen.
Gut erwischt
Gut, also in dem Fall,
zumindest dann bei einer geraden Anzahl von allen, stimmt,
also da kriegt man also auch wie ganz dringend dann also aus Einzelnen hin,
bei einer ungeraden Anzahl,
also wenn ich hier jetzt noch eine dritte Eins hätte,
dann wäre das Paratiesbild wirklich null,
aber in dem Fall... Gut,
habe ich mich jetzt also selber reingelegt,
stimmt das also nicht,
das heißt,
pro Kotwort mindestens die eine 0 und 1 würde dann
also für die Scodewort aus entsprechender geraden Anzahl von Einsen
nicht gelten
Ja, weil eigentlich müsste es symmetrisch sein, irgendwie kann das ja nicht hinhauen, ja.
Gut, den Satz muss ich dann also noch mal korrigieren.
Nichtsdestotrotz hat man natürlich immer noch diesen elektrischen Effekt,
wenn ich jetzt sage, okay,
null wird irgendwie als Nullvolt übertragen, eins,
also irgendwie eine bestimmte Spannung, dass ich immer noch diesen Vorteil habe,
habe ich eine elektrische Verbindung, ja oder nein.
Aber gut, also in Bezug auf die Paritätsworte
ist es dann also schon so, dass es eben,
also da dann also auch ein Vektor aus lauter Einsen
geben kann
Gut, das heißt also, wie gesagt, diese Aussage stimmt nicht zwingend.
Gut, muss mir da nochmal eine passende Formulierung ausdenken.
Und ich denke mir dann also irgendwann morgen im Laufe des Tages
gibt es die Folie dann immer überarbeitet in den entsprechenden Sachen mit drin.
Gut, das, was man häufig dann macht,
ist, also gerade wenn man jetzt also nicht nur jetzt
mit einer Parität erkennen möchte,
ist ein Fehler aufgetreten
Also in dem Fall konnte ich also wirklich nur einen einzelnen Einbettfehler erkennen,
dass man also vielleicht also auch schon Fehler korrigieren möchte.
Dazu sind dann eigentlich Verfahren typischerweise so aufgebaut,
dass man also im Prinzip mehrdimensional Paritäten bildet.
Relativ einfach visualisieren kann man das zumindest noch für zwei Dimensionen,
indem ich jetzt also quasi beispielsweise jetzt für meine übertragenen Informationen
die Bits dann eben matrixweise anordne und sowohl Zahlen als auch spaltenweise dann eben,
sei es jetzt Ort oder Even Paritäten,
die dementsprechend verrechnen
So, damit kann man dann eben, weil das ist quasi zweidimensional mache,
dann eben auch in den Zahlen oder in den Spalten einbett Fehler entdecken.
Und dadurch, dass ich dann eben weiß,
in welcher Zeile und in welcher Spalte dieser Fehler aufgetreten ist,
dann eben auch einen einzelnen Einbettfehler korrigieren.
So, und je nachdem,
wie sich die Fehler dann verteilen,
kann man eben sagen,
also im Best Case kann man damit also auch
noch mehr Fehler korrigieren im Worst Case ist es dann eben
mal wirklich nur eine einzige
So, dieses Verfahren, was ich jetzt also hier gleich nochmal vorstelle,
lässt sich im Prinzip dann also auch noch mehr dimensional weiter ausbauen.
Wie gesagt, also um das ein bisschen zu veranschaulichen,
geht das jetzt natürlich nur irgendwie so zweidimensional.
Also nehmen wir hier einfach mal Aski-Kodierung, Großbuchstaben,
das Wort Hemming. Nicht, wenn ich das jetzt so
untereinander schreibe und dann in diesem Fall jetzt also eine Even,
also sprich eine gerade Parität ausrechne.
Das heißt also hier eins,
XO1 ist null
90 XO1 ist 0 1, XO1, XO1, XO1, das ist auch null.
Nicht hier habe ich dann quasi jetzt meine 1 mittleren,
hat man dann eben hier für die Zahlen,
hier für die Spalten, die entsprechenden Paritätsbits zusätzlich wird,
dann eben auch für die Paritätsbits selber nochmal die Parität gebildet,
dass es eben in diese einzelne Einzelne in der Ecke.
Und was dann letztendlich passieren kann, ist ja,
dass dann also irgendwie einer oder mehrere Fehler auftreten.
Also hier einfach mal irgendwie so rot gekennzeichnet. Letztendlich,
man muss sie bei diesen ganzen Codierungen auch immer noch gegenwärtigen,
dass natürlich also auch Fehler in den zusätzlichen Prüfbilds auftreten können.
Das heißt, ich muss jetzt,
also wenn ich Fehler betrachte, nicht nur sagen,
okay, ich gucke nur meine Ausgangsinformation an,
sondern eben auch in dem langen Wort mit den zusätzlichen Prüfbilds
können ja auch Fehler auftreten.
Also deswegen hier nur so als Beispiel
Gut, in dem Fall,
den wollen wir jetzt nicht weiter genauer betrachten, weil das sind jetzt,
also in diesem Fall jetzt also wirklich vier Fehler,
wobei in dem Fall könnte man sie also zumindest auch noch irgendwie erkennen.
Aber hier sieht man also im Prinzip das Prinzip,
was passiert, wenn jetzt ein Einzelfehler auftritt.
Also in diesem Fall wurde also hier dieses,
hat sich dieses eine Bit geändert.
Alles, was also quasi jetzt hier an Paritätsbits
mit übertragen wurde
Wird dann halt von Empfänger entsprechend quasi durchgerechnet und geguckt und was man dann eben feststellt,
ist,
dass ich also hier an dieser Zeile mit eins exklusiv oder eins exklusiv oder eins eigentlich als Parität eine eins stehen müsste,
aber eine Null empfangen wurde,
also weil sich diese Zeile ist fehlerhaft und wenn ich also hierüber jetzt in der Spalte die Parität bilde,
eins exklusiv oder eins, exklusiv oder eins,
oder eben auch eine Parität 1 liefern.
Eine Null wurde gesendet. Nicht das muss dann eben logischerweise
auch erstmal für alles machen und kann dann aber eben dadurch
die fehlerhafte Spalte lokalisieren und weiß dann eben dieses eine Bit ist falsch übertragen worden.
Das wird dann eben von 1 nach Null korrigiert und man hat dann eben seine richtige Information hinterher. Gut,
und hier sieht man jetzt eben im Prinzip auch schon,
also wenn mehrfache Fehler auftreten,
solange die in den Zahlen und in den Spalten quasi jetzt immer des Jungen zueinander sind,
kann man die immer noch entsprechend zuordnen,
wenn ich jetzt aber eben hier in einer Spalte an mehrere Fehler habe,
dann kann das, könnte das dann eben beispielsweise nicht mehr korrigierbar sein,
aber es gibt eben auch Fälle, wo man mehrere Fehler,
bei so einer zweidimensionalen Parität dann eben auch noch teilweise korrigieren kann und zumindest auch erkennen kann.
Gut, das Ganze ist vom Prinzip her,
also jetzt nicht nur irgendwie zwingend auf das Dualsystem beschränkt,
ich kann mir also so eine zweidimensionale Parität zum Beispiel auch im Dezima-System ausdenken,
also indem ich jetzt einfach sage, okay, Rechner als Parität,
sowas wie die Zahlen, beziehungsweise Spaltensumme, Modulo 10.
Also was anderes macht die Parität im Dualsystem ja auch nicht.
Das ist also quasi die berechnungde Summe, Modulo, Basis. So,
wenn ich jetzt also als Daten hier irgendwie diese neuen Ziffern habe,
so zwar dimensional dann, also als 3774, 548,
135 irgendwie anordne, kann ich eben hier einfach die Parität zahlenweise und spaltenweise ausrechnen,
also sprich 3 plus 7 plus 4 ist 14,
Modulo 10 ist Parität 4 und so weiter und so fort.
Und eben auch hier kann man dann auch nochmal über die Paritäten sowas entsprechend bilden.
So, was passiert dann im Fehlerfall? An dieser Stelle
wurde jetzt statt der 8 eine Trage übertragen. Also wie gesagt,
ein Einzelner Fehler, also in diesem Fall jetzt nicht ein Bittfehler,
sondern Fehler an einer Stelle,
aber ein einzelner Fehler eben in dieser übertragenen Ziffer.
Führt dazu, dass wenn ich hier hier die Paritäten berechne,
ich dann eben rechne 5 plus 4 plus 3 ist 12 Ich habe aber eine Sieben-Empfang.
Gleiches mache ich eben für die Spalte, kann damit dann eben auch sagen,
in welcher Zeile, in welcher Spalte der Fehler aufgetreten ist.
Und die Differenz zwischen dem,
was ich jetzt als Parität ausgerechnet habe und dem,
was also quasi gesendet wurde, ist dann nämlich das,
was ich als Korrektur einfach hinzurechnen bzw. drauf addieren bzw. abziehen muss.
Wenn ich in diesem Fall eine Sieben wurde gesendet,
zwei habe ich ausgerechnet, Differenz ist 5,
also muss ich drei plus 5 rächen und lande dann eben auch bei dem richtigen Wert 8.
Das ist die Art und Weise, wie man Im Prinzip
so eine zweidimensionale Parität dann eben auch auf dem Dezimalsystem übertragen könnt.
Gut, andere Beispiele auch, sagen wir mal so,
Daily Life sind dann so was wie diese ISBN-Nummern,
sind im Prinzip diese International Standard Book Numbers.
Also wenn sie in irgendwelche Lehrbücher oder irgendwie sonstige Bücher immer mal reingucken,
die haben dann immer irgendwie so eine Szene beziehungsweise inzwischen sind
das eigentlich irgendwelche 13-stelligen Nummern
Sind von der Idee her auch immer sehr stark an diesen ERN,
also European Article Number, also das ist auch so ein 13-stelliger Code gekoppelt.
Und die sind im Prinzip dann auch so ein mathematisch,
über so ein mathematisches Prüferfahren letztendlich zu berechnen,
wo man dann sagt, okay,
also so eine Nummer in diesem Fall jetzt,
also irgendwie ESBN-10 oder Reizen, wie auch immer,
besteht also irgendwo aus dem Prefix, also bei den drei ESBN-13
Nummern sind das drei Stellen vorne weg. Nicht,
dann gibt es also quasi eine Nummer, aus der heraus ersichtlich ist,
in welcher Sprache das Buch geschrieben wurde, beziehungsweise aus welchem Sprachraum es kam.
Das ist dann also auch schon mal so was wie so
eine Art Fahne-Kodierung. Nicht, wo man sagt, okay,
es gibt von 0 bis 7 8 verschiedene Nummern für das,
was also an Sprachen am weitesten verbreitet ist.
Und dann gibt es von 80 bis 94 dann eben für die nicht so weit verbreiten und für was ich jetzt,
also irgendwelche Dialekte auf Südseeinseln, wird dann also schätzensweise irgendeine von diesen fünfstelligen Nummern hier,
also von diesen 105-stelligen Nummern hier hinten dann, also irgendwie genutzt werden können.
Also typischerweise das, was wir dann zum Beispiel immer haben,
also wenn man sie jetzt bei irgendwelchen Büchern mal nachgucken wäre,
dann eben, dass dann da dann eine Drei steht,
weil das steht dann eben für deutsche Sprache,
nicht 0 und 1, das sind für Englisch,
zweifel Französisch und wie gesagt,
so anschließend gibt es dann ein Code auch wieder so eine Art Fahne-Code,
wo dann also quasi der Verlag codiert ist.
Das heißt, da kann man jetzt eben aus dem Code herauslesen,
welcher Verlag das gewesen ist. Die großen Verlage kriegen dann
eben auch kurze Ziffern, nicht von 0 bis 19.
Und die kleineren Verlage dann eben entsprechend hier kleinere oder längere Nomaden. Eine Idee ist halt eben,
je weniger Ziffern ich jetzt von diesen 10 oder 13 Ziffern hierfür und hierfür verbrauche,
umso mehr bleiben hinterher noch über,
um dann quasi so eine verlagsinterne Nummer wo die Verlage dann quasi ihre Bücher natürlich nummerieren zu machen.
Gut, und am Ende gibt es eine Prüfziffer.
Wie wird die bei diesem ISBN-Code gebildet? Das ist dann eben auch so eine Modulo-Summe,
wo man dann im Prinzip jetzt für die neuen Ziffern,
die jetzt also quasi den eigentlichen Code ausmachen,
die quasi jetzt mit einer Wertigkeit,
also eben von 1 bis 9 multipliziert, das ganze Modulo 11 rechnet.
Und das ist dann eben die letzte Ziffer. Wenn ich als Ziffer,
was ja so bei dieser Modul-11-Operation rauskommen kann, eine Zehen habe,
wird das mit einem exkludiert. So, und die Prüfung,
ob jetzt eben so ein ESBN-Code überhaupt gültig ist,
kann man dann eben machen, indem man dann also sagt,
also ich bilde diese Summe von 1 bis 10 E-Mail,
ZE modul-11 und die muss eben genau Null ergeben.
So, und dadurch kann man eben sehr einfach feststellen,
ob jetzt also irgendwie so ein ESBN-Code irgendwie gültig ist.
Ja, und sagen wir mal, solche Arten von Codierungen,
gut, da gibt es eben sehr viele sehr unterschiedliche Verfahren,
werden also relativ häufig, also auch irgendwie so täglichen Leben eingesetzt.
Also wie gesagt, also ISBN ist eines der einfachen Beispiele dazu.
Dieser European Artikel Number Code ist im Prinzip auch sowas. Das,
was man bei Bankgeschäften hat, also im Prinzip diese IBAN-Nummer,
beinhaltet eben auch Prüfziffern, wo man dann eben sehr einfach oder sehr schnell feststellen kann,
ob sich jemand jetzt bei der Eingabe irgendwo vertippt hat,
weil dann eben letztendlich also irgendeine ungültige Nummer rausgekommen ist.
Gut, also dort ist das Prüfverfahren also ein bisschen was anderes als hier,
aber auch da sind dann im Prinzip also irgendwelche Umrechnung,
Multiplikation und in der Regel dann auch irgendwelche Module-Operationen da mit drin,
die dann da so genommen werden. Gut,
aber wie gesagt, nochmal kurz zurück hier zu dem Buchziffern,
also hier so ein Beispiel,
also das wäre jetzt also hier das Buch von Hannessin und Patterson in der deutschen Ausgabe,
das ist dann glaube ich auch irgendwie eine deutliche,
nee,
in der deutschen nicht,
also es ist null vorneweg,
heißt Englischsprachig und 13 müsste dann also im Prinzip in
dem Fall dann MacGrow Hill sein
Also das wäre jetzt also hier quasi das von dem Buch
, wie wird das berechnet? Entsprechend einfach dieser Formel,
rechne ich ein, mal null, plus zwei mal eins,
plus drei mal drei, plus vier mal sieben,
plus 5 mal eins und so weiter.
Er gibt 161, modulu 11, ist sieben.
Das ist dann also quasi diese zusätzliche Prüfzeffer, die daraus dann rausgerechnet wurde.
Um eben zu gucken, ob dieser ESBN-Code gültig ist,
rechne ich dann eben quasi diesen Ausdruck aus, modulu 11,
das heißt also im Dienstfall also die 161 plus 70,
bin ich bei 231, modulu 11 ist null,
ist also in diesem Fall dann also eine gültige Zahl.
So und was man damit dann erreicht ist,
dass man also sehr einfach einen Fehler in einer Ziffer feststellen kann,
dass man also eben sagen kann, okay,
es ist überhaupt eine gültige ISBN-Nummer,
dass man eben für Tauschung von zwei Ziffern,
also sehr einfach hat oder eben irgendwelche Doppelungen,
wenn also eine Ziffer jetzt also quasi zweimal hintereinander angegeben wurde.
Hier nur kurz skizziert, wie man also sieht,
was passiert, wenn ich also jetzt zwei Ziffern vertausche.
Nicht dadurch, dass jede Ziffer ja also quasi einen Gewichtungsfaktor hat.
Nämlich dieses I wird dann also letztendlich passieren,
die korrekte Prüfsumme hat in der Berechnung eben I mal Set-I plus J Marset J.,
die falsche Prüfsumme, wenn ich also quasi die Ziffern ZI und ZJ vertauscht habe,
wird quasi beinhalten, J mal ZI und E-Mail ZJ Nöch.
Und wenn ich das also hier von dem Korrekten abziehe,
erhalte ich dann also irgendwo hier so einen Ausdruck von e-jord mal,
Z-I-Jord on, der führt dann eben dazu,
dass ich dort dann eben in dieser Modelooperation falschen Werte halte.
Gut, aber kommen wir jetzt wieder zu den Übertragungsmöglichkeiten bzw. Kodierungsmöglichkeiten
Den wir in der Informatik begegnen, also sprechen wir jetzt
mit irgendwelchen Binärzahlen. Gut, ganz einfache Möglichkeit,
also jetzt irgendwas, Fehler korrigierend zu machen gegen einen,
wird Fehler, ist sowas wie so ein Dreifach-Wiederholungscode.
Sprich, wenn ich ein Bit sende, eine Null oder eine Eins,
kann ich das eben, mache ich das dadurch,
dass ich das also quasi so salopp gesagt einfach dreimal wiederhole.
Aus einer Null mache ich 3-0 und aus einer 1 mache ich 3-1.
So, wenn sich jetzt ein einzelnes Bit geändert hat,
kann ich quasi dann per Mehrheitsentscheid einfach sagen,
das ist entweder eine Null oder eine Eins gewesen.
Wie gesagt, wir sind jetzt hier bei Hemmingabstand 3,
führt eben dazu, dass ich einen einzelnen Einbettfehler korrigieren kann.
Gut, mathematisch gesehen kann man sowas dann eigentlich immer dadurch machen,
dass man sagt, okay, das ist das,
was dann also auch bei den anderen Verfahren immer angewandt wird.
Man rechnet im Prinzip aus seinem Eingangswort, das zu sendende Wort quasi über eine Matrix-Multiplikation aus. In dem Fall ist es,
dass es jetzt eben vergleichsweise trivial, dass ich sage,
okay, die Generator Matrix ist eben den Vector 1,
1, 1. Und der wird eben multipliziert mit seinem Wort,
beziehungsweise in diesem Fall dann also hier jetzt,
wenn ich das jetzt so schreibe, dann die transponierte,
nicht das heißt, aus einer 0 werden 3, 0, das eine 1 werden 3, 1 sind.
Gut, wie gesagt, damit kann man über diesen
Mehrheitsentscheidendeheim mit Fehlerkorrekturen machen
Warum hat sich dieses hervorragende Verfahren nicht durchgesetzt? Weil man
damit natürlich eine Vergleichsweise geringe Datenrate hat. Also sprich,
aus einem Notesbit mache ich drei Bits, die ich übertragen muss.
Das heißt also, die Datenmenge verdreifacht sich mal eben.
Und damit kann ich dann also einen Einbettfehler korrigieren,
ist dann eben natürlich nur bedingt praktikabel.
Das, was man meistens macht oder häufig macht,
ist dann eben den sogenannten Hemming-Code zu benutzen.
Das ist eben auch ein Verfahren, wo man also letztendlich
dann auch Bei einem Hamming-Abstand von drei landet.
Das heißt, man kann damit eben einen Bit-Fehler korrigieren und
man kann eben auch viele zwei Bit- oder Breibet-Fehler erkennen.
Je nachdem, wie wir dann fatal sind. So,
wie wird dieser Hamming-Code gebildet? Dazu sagt man,
ich habe eben ein Datenwort. Das sind also jetzt hier
die Bits D1 bis DN. Die ergänzt sich um K-Prüfbits.
Das heißt, das Codewort hat dann in diesem Fall Groß Anne,
also N plus K-Bit. Das heißt, Im Sinne dieser
linearen Codes wäre das dann eben da dann ein... falsch.
Ansaudair, Gesamtbits, Anzahl der Nutzbits, also Großen,
in dem Fall Klein, N, Hemming Code.
So, wann Kann dieser Code überhaupt nur funktionieren? Das heißt,
hier unten steht jetzt also um die Fehlerkorrektur zu gewährleisten,
brauche ich mindestens oder muss eben gelten,
dass zwei hochkarg, größer gleich N plus 1 ist.
So, warum ist das so oder weswegen ergibt sich das?
Also ich habe meine K-Prüfbitz und ich habe jetzt als Gesamtlänge von dem Codewort Groß-N-Bits,
also oder sprich N plus Carbit, die ich übertrage.
So eine Fehlerkorrektur muss ja letztendlich aussagen,
dass ich eben entweder sage, ich habe keinen Fehler,
oder in meinen Bits, die ich übertrage,
habe ich an genau dieser Stelle einen Fehler.
Das heißt, mit Carb Prüfbitz Kann ich zwei Hoch-K-Kombinationen bilden,
die ich quasi jetzt für diese Prüfplätze vergeben kann.
Und mit diesen zwei Hoch-K-Kombinationen möchte ich sowohl den Fehlerfreien Fall,
als auch eben quasi irgendeinen Hinweis darauf geben,
wo der Fehler aufgetreten ist.
Demzufolge muss ich GroßN plus 1 unterschiedliche Kombinationen bilden können.
Deswegen gilt hier letztendlich dann immer diese und Leichen,
die dann also quasi gelten muss.
Im Idealfall ist dann eben zwei Hochkahrgleichend plus eins,
häufig ist dann aber eben entsprechend größer noch.
Gut, wie wird jetzt so ein Hemmingcode gebildet?
Als erstes muss man jetzt erst mal feststellen für ein gegebenes Anne,
also sprich für die Anzahl der Bits,
die in meinem Ausgangscodewort sind,
wie viele Prüfbits brauche ich
Demzufolge oder kann man sagen, okay, ich bestimme das
kleinste K mit Endkleinert Live 2 hochkam, minus k, minus 1.
So, warum gilt jetzt diese Formel? Ich hoffe,
ich habe das einigermaßen deutlich erklärt oder veranschaut,
weswegen also im Prinzip dieses 2 hochk Größergleich NPlus 1 gelten muss,
nicht wahrlich ja im Prinzip,
also hiermit also die Anzahl der Kombinationen habe und damit also
den Fehlerfreien Fall und eben alle fehlerhaften Bits
irgendwo ausdrücken muss
Gut, wenn ich für eingegebenes N, oder nein,
eben jetzt bestimmen möchte, wie viele BitCarb brauche ich, um das auszudrücken?
Kann ich dann eben sagen, okay, also ich nehme jetzt,
also ich habe quasi zwei hochk größer gleich,
so N war ja in plus plus 1,
wenn ich das Ganze jetzt nach N-Auflöse lande ich letztendlich,
also genau bei diesem Ausdruck hier nicht, das heißt,
es ist also nichts anderes als eine Umformung von dem,
was da so vorher drauf stand.
Nicht nur okay, also letztendlich müsste man das jetzt noch mathematisch an,
also entsprechend umformen oder beziehungsweise man kann dann eben entsprechend ausrechnen,
wenn ich ein gegebenes N habe, für welche Cast das dann gilt.
Gut, dadurch weiß sie dann erst mal, wie viele Prüfwitze ich brauche.
So, und dann ist es jetzt eben so,
dass in dem Hemmingcode die Prüfbitz an den Bit-Positionen quasi jetzt untergebracht werden,
die also den Zweierpotenzen entsprechen.
Und die Original-Bits kommen dann an die üblichen Positionen. Also erst mal ganz stumpf gesagt,
also ich habe hier Positionen 1, 2, 3,
4, 5, 2 hoch 0 ist 1,
das heißt also hier an dieser ersten Position kommt das erste Prüfbit hin.
2 hoch 1 ist 2, hier kommt das
zweite Prüfbit hin
Hier an Position 4, das dritte Prüfbett an Position 8
, das vierte Prüfbett. Und die Datenwitz werden jetzt
quasi immer entsprechend danach Datenwitz 1, Datenwitz 2,
da hatten wir drei Daten mit vier Daten mit 5,
dann im entsprechend weiter hier in diese Lücken verteilt.
Am Anfang noch sehr wenige. Am Ende dann immer entsprechend mehr. So,
und das, was also an der Hamming-Code einfach macht,
ist, dass man sagt, also ich berechne,
das prüft mit I,
als die Module 2-Summe der Bits,
also sprich also
auch wieder so
eine X-Ra-Verknüpfung
Wo in der Positionsnummer, das heißt also hier 1,
2, 3, 4, 5, eingesetztes BitE, vorkommt.
Sprich, prüft Bit 1, wird berechnet,
indem ich letztendlich alle Positionen nehme,
wo quasi in der Binärkodierung das niederwärtigste Bild oder das Bit
mit der Stellenwertigkeit 1 gesetzt ist.
Das heißt also
alle Ungradenwitz
Das heißt also, in diesem Fall berechnet sich das Prüfbild 1,
als das, was an dieser Position steht und das,
was an dieser Position steht und das,
was an dieser Position steht, also D1, XO,
D2, XO, D4, XO, D5 und so weiter.
Für, Prüfbild 2, wird jetzt quasi alles genommen,
wo hier an den Positionen das Wartebild gesetzt ist.
Also sprich, hier an 4,
Beziehungsweise andersrum an 3 habe ich schon das zweite Bitt gesetzt,
an 4 habe ich das zweite Bitt gesetzt.
Nee, an 5 habe ich das Smart-Wett gesetzt,
an 6 habe ich das zweite Bit gesetzt. Nicht,
also das heißt, da habe ich dann eben die 1,
die 3, 4, gut, habe ich wieder falsch erklärt.
Jedenfalls, also das sind dann immer die jeweiligen Bits,
wo dann also quasi das zweite Bit gesetzt wird.
Und so weiter und so fort. Gut,
hier ist das Ganze jetzt nochmal Ein bisschen anders visualisiert,
da sieht man das dann noch ein bisschen direkter.
Also das ist jetzt also hier für,
in diesem Fall jetzt mal, also irgendwie 31 Stellen gemacht.
Blau sind jeweils die jeweiligen Prüfbits und das sind dann eben
der Reihe Nacht dann, also hier die Datenbits.
Und je nachdem, wie viele Daten witzig, also quasi benötige,
hat man dann eben, oder braucht man dann eben unterschiedlich viele Prüfbits,
wo man dann eben sagen kann, damit kann ich meinen Code aufbauen.
So, wenn ich jetzt nur ein einziges Datenbett habe,
dann brauche ich Prüfbitt 1,
Prüfbitt 2 und Datenbitt 1 und dann ist das quasi dieser Hemming-Code,
nichts anderes als der Dreifach-Wiederholungscode beziehungsweise formal gesehen würde,
dann hast du 3,1 Hemming-Code auch gelten.
So, 7,4 heißt, 7 Datenbitts insgesamt, 4 Nurtspits,
Ich habe hier die drei Prüfbits, PA, SP2 und P3,
die sich dann also quasi hier entsprechend dadurch berechnen,
dass ich eben hier dieses Prüfbett berechne, als das exklusiv oder das exklusiv oder das.
Das zweite Prüfbett berechnet sich dann eben hier aus der Stelle 3 der Stelle 6,
in der Stelle 7, das dritte Prüfbett wäre dann eben Herstelle 5,
also Datenbett 2, Stelle sechs und Stelle sieben, also exklusiv oder Datenbett 3, exklusiv oder Datenbett 4.
Das wäre dann also quasi dieser 7-4-Hemming-Code,
nicht wenn ich jetzt mehr Bits bräuchte, würde das heißen,
ich bräuchte eben das vierte Prüfbett und könnte dann also hier entsprechend mehr Datenbett benötigen,
eben bis maximal 15, 11, Hemmingo,
das wäre dann also quasi das,
was man also hier rauslesen könnte und was dann also jetzt hier in dieser Grafik noch drin ist,
aber im Text, dann fehlt, ist dann eben,
dass sich sowas wie ein 31 26,
Hamming Code mache.
Das heißt also mit fünf zusätzlichen Prüfbets, insgesamt 31 Bit im Codewort,
kann ich dann eben 26 gültige oder 26 Bits meines Datenworts irgendwie mit übertragen.
Gut, wenn man sowas jetzt natürlich hier irgendwie in solchen Tabellen macht,
also da jetzt irgendwie rausliest, wie gesagt, das ist das eine,
wie kann man das jetzt also rein praktisch dann berechnen?
Dazu hatte ja schon angedeutet, macht man das eigentlich typischerweise so, dass man letztendlich Matrix-Multiplikationen einsetzt. Das heißt,
in dem Fall für diesen 7-4-Hemming-Code, jetzt mal als Beispiel,
ich habe eben ja meine 7-Bits in dem Code,
4 Datenwitz, 3 Prüfbits, formal gesehen ist,
dass eben ein linearer 7-4-Blockcode und die Generatormatrix,
um jetzt also diesen Code auszurechnen, im Prinzip diese Matrix und das Quotwort berechnet sich dann eben aus Matrix, mal Datenwort.
So wie kommt man jetzt zu dieser Generator Matrix,
also auch hier nun mal, kurz angedeutet,
die kann ich jetzt eben hier dadurch ablesen,
dass ich dann immer jeweils für die einzelnen Zeilen letztendlich gucke,
über welche... Indie-C ist das dann, also hier gerechnet wird,
was dann also mal jetzt eben hier bei den Prüfbitz,
also bei dem ersten,
war der zweiten und dann eben hier bei der vierten Zeile letztendlich auftritt,
so und die anderen Zeilen, das heißt also,
die dritte, fünfte, sechste und siebte,
da soll also letztendlich ja nur das Datenwort selber rauskommen,
das Datenwort selber erhalte ich,
indem ich das dann also quasi dann einfach hier mit 1,
0, 0, 0 bzw. 0, 1,
0,
0 und so weiter jetzt entsprechend hiermit multipliziere.
Das heißt, damit erhalte ich dann immer einfach nur die jeweiligen Bits aus dem Datenwort.
Und hiermit ist dann quasi jetzt für die Prüfbits letztendlich dann mit rein kodiert, welche Bits des Datenwortes dort dann eben berücksichtigt werden. Also beispielsweise dann jetzt,
also hier bei dem ersten Prüfbit, nicht, dass man sagt, okay,
das ist dann eben von dem Datenwort entsprechend das Bild von dem von dem,
also habe ich da dann eben eins, eins,
0, 1, das ist dann eben genau diese Zeile,
ich führe den, das zweite Prüfbild hätte ich dann eben hier,
wenn ich das jetzt auf die Datenworte beziehe, eins,
das zweite Datenwort geht nicht ein, also 0,
1,
das ist dann genau diese Zeile und für dieses Prüfbild werden hier eben alle drei Daten benötigt,
das ist dann eben genau diese Zeile 0,1,
So könnte man dann eben quasi aus dem Ganzen,
also sowas wie diese Generator Matrix, ablesen,
entsprechend an dem Beispiel Folk dann gleich noch,
entsprechend für die Rückrechnung gibt es dann eben eine Prüfmatrix,
wo ich dann eben letztendlich berechne, Prüfmatrix,
mal übertragenem Wort, muss eben ein Nullvektor ergeben,
prüft Matrix für diesen 7-4 Hemming-Code,
wäre dann im Prinzip dieses hier Also auch hier sieht man eigentlich,
ist letztendlich nichts anderes als drin kodiert das,
was ich dann eben hier mit drin habe.
Das nimmt beispielsweise dann eben für das erste Prüfbüttern immer jetzt
quasi immer jeweils dieses zweite Bit,
hier dann die Bits der Wertigkeit 2 oder das erste Feld an einem entsprechend weg.
Also wir diese Bits dran sind, hier dann eben immer diese Vierer-Folgen von Bits.
Und genau das spiegelt sich dann eben auch hier entsprechend in dieser Prüfmatrix wieder.
So, und wenn ich jetzt eben ein ungültiges Kotwort habe,
würde ihm gelten, dass Matrix mal Codewort miteinander multipliziert,
dann eben ein Vactor on Live Null ergibt.
So, und aufgrund dessen, was dann dort rauskommt,
kann ich dann aber eben auch sagen, an welcher Stelle der Fehler aufgetreten ist, in der Codierungstheorie nennt sich das Ganze dann Fehlersyndrom. Gut,
was erreiche ich generell jetzt erst mal mit diesen Hemming Codes,
also verglichen mit so irgendwie so dreifach Wiederholungscode,
kann man sagen, also zumindest bei größeren Wortlängen,
habe ich natürlich ein deutlich besseres Verhältnis von Nutzbits zu Prüfbitz,
weil wie gesagt, also wie man hier in dem Beispiel ja schon Sieg kriegt,
man also im Prinzip dann mit fünf Prüfbits,
26 nur Spitz quasi kodiert, beziehungsweise andersrum,
also hier dann eben mit vier Prüfbits, elf Nordspits und gut,
je kleiner ich werde,
umso effizienter wird das.
Ist ein vergleichsweise einfaches Prinzip,
man kann das Ganze dann eben wirklich sehr schnell mit Matrix,
Multiplikation generieren bzw. mit Matrix,
Multiplikation dann eben
quasi wieder zurückrechnen
Nachteil bei dem Ganzen. Also wenn ich das jetzt
eben wirklich noch vergleiche mit dem,
was also nach der channelischen Theorie eigentlich möglich ist,
also hiermit kann man eben wirklich genau einen einzigen Einbittfehler korrigieren,
wenn jetzt in der Übertragung im Fehlerkanal mehr auftauchen,
ist dieser Code dann eben auch ungeeignet nicht.
Also da muss man dann eben entsprechend andere bessere Codes nehmen. Gut,
aber kommen wir jetzt also einfach nochmal zu so einem Beispiel,
wo man jetzt sieht, wie das Ganze letztendlich funktioniert.
Also ich habe hier
ein Datenwort,
Würde jetzt also quasi meinen,
zu übertragenes, wo er dann eben dadurch berechnen,
dass sich das also quasi jetzt mit dieser Generator Matrix multipliziere.
Also eins, 1, 0, 1,
mal diesem Board ist, gibt an der ersten Stelle null,
1, exklusiv oder 1,
jetzt mal multipliziert ist an Dana
Da dann wieder eine Eins, da eine Null und das
Ergebnis wäre dann eben hier eine Eins für die zweite Stelle,
hätte ich dann eben einmal Null, plus Nullmal.
Eins, plus einmal eins, plus einmal Null,
ist dann eben eine einzige Eins, nämlich hier und so weiter und so fort.
Und was man dann eben auch schon sieht, dieses Originalwort,
ich hatte gesagt, also das ist eben einer von diesen kurz,
wo dann eben das Originalwort ja auch direkt in dem Code selber mit drin ist.
Nicht in diesem Fall, dann kodiert quasi an der dritten,
vierten, fünften und sechsten Stelle. Das heißt,
dieses Wort 0, 1, 1, 0 ist hier diese 0,
diese 1, diese 1 und diese 0. Gut,
das ist jetzt mein kodiertes Wort, was übertragen wird.
Das soll jetzt geprüft werden. Also nehme ich jetzt,
also ich entsprechend dieses, die Prüfmatrix mache dann eben auch
wieder ein Matrix-Multiplikation,
also einmal 1 plus 0 mal
Plus 1 mal 0, plus 0 mal 0, plus 1 mal 1.
Eine 1 hatte ich hier oben, hier eine zweite 1,
exklusiv oder das Ergebnis ist also schon wieder null.
Plus 0 mal 1, plus 1 mal 0,
ergibt hier eine null. Das Ganze macht man dann eben
entsprechend weiter und erhält da dann eben diese null Vektor.
Gut, was passiert jetzt, wenn ein Fehler auftritt?
Also in diesem Fall habe ich jetzt hier eigentlich
mein gültiges Wort gehabt. Es wurde jetzt aber eine,
dieses Wort
Hier übertragen, wenn ich das Ganze entsprechend ausmullipliziere,
wie führt das dazu,
dass man hier als Ergebnis dann eben einen Vector erhält,
1, 1, 0. Also, wie kommt er zustande?
Ist das klar mit dieser Matrix-Multiplikation,
wie hier die einzelnen Ergebnisse sind oder soll ich das also
hier nochmal für dieses Beispiel nochmal kurz,
ist klar,
Also das heißt, also jedenfalls,
also hier komme ich dann eben über diese Multiplikation,
also hier entsprechend zu diesem Ergebnisvektor. So,
und dieser Ergebniswerk, du hast ja eben letztendlich so zu interpretieren,
dass ich sage, okay, 1-1-0,
der Fehlerfall war lauter Nullen.
Dieser Fall 1,1-0, wenn ich jetzt nachsehe in meinem,
in meiner Prüfmatrix, wo steht dort dieser Vector?
Hier dann
quasi als dritte Spalte
Das ist dann nämlich genau der Hinweis. Damit wird nämlich kodiert,
dass quasi die dritte Stelle meines Worts kaputt gegangen ist.
Das heißt, das ist dann eben entsprechend der Hinweis auf die Fehlerstelle.
Ich kann das Ganze dann eben korrigieren aus der Eins,
hier eben wieder eine Null machen und habe dann eben hier
mein richtiges Codewort damit wieder zurückgerechnet.
Gut, das ist also die Art und Weise,
wie jetzt
diese Hemming-Codes funktionieren
Generell jetzt noch mal zur Datenübertragung. Wenn ich jetzt sage,
ich habe eben so ein Endplus-K-Kodes oder Endplus-K-Code,
wo ich dann eben mit einer Anzahl von Informationsbits eine Anzahl von Bits kodiere,
wie er gesagt hatte, also ich kann maximal Bitfehler,
also sprich die minus eins halbe, korrigieren.
Was passiert jetzt eigentlich in allen übrigen Fällen?
Und das führt dann eben zu dem Begriff der Fehlerrate,
wo man dann eben im Prinzip jetzt untersucht,
Wenn ich jetzt mehr Bittfehler habe als das,
was ich in dem Code korrigieren kann.
Und ich schicke aber das Ganze jetzt über meinen letztendlich irgendwie gestörten Kanal.
Wie gut oder wie schlecht bin ich da dann eigentlich mit
meinem Ergebnis? Und das führt dann eben,
wie gesagt, dass man sagt, okay,
im Kanal habe ich eine gewisse Bittfehlerwahrscheinlichkeit,
eine bestimmte Anzahl von Bittfehlern kann ich mit meinem Code korrigieren.
Es gibt aber natürlich immer noch Bittfehler,
die ich nicht korrigieren kann
Das führt dann eben zu dem Begriff der Wortfehlerwahrscheinlichkeit,
sprich der Summe der Wahrscheinlichkeit nicht korrigierbarer mit Fehler.
Nicht, weil ich habe jetzt mit meinem Akkur dafür gesorgt,
dass ich ein paar Fehler korrigieren kann.
In dem Kanal habe ich aber natürlich immer noch die Wahrscheinlichkeit,
dass also mehr Fehler auftreten. Und für mein gesamtes Datenwort,
was ich übertrage, eben dieser Fall eintritt,
dass ich jetzt also quasi hier in diesem Bereich bin,
wo entsprechend jetzt das Ergebnis dann also nicht mehr korrigierbar ist.
So, und das Ganze kann man dann eben auch
irgendwie so mathematisch sich überlegen und aufplotten.
Also hier sollen eigentlich auch nur diese Kurven letztendlich veranschaulichen,
was also auch noch grob gemeint ist, eben mit dem,
was sich also am Mittwoch mit dem Shannon-Theorie gesagt habe.
Also hier habe ich jetzt also quasi ein 7-4 Hemming-Code,
also das, was sie gerade eben vorgestellt habe.
Und ich habe im Kanal
eine bestimmte Bildfehlerrate
So, das heißt, also in einem Kanal habe ich
eine bestimmte Wahrscheinlichkeit, dass ein einzelnes Bit kaputt geht.
Der Code liefert mir, dass ich jetzt also quasi für ein
7-Bit Datenwort von vier möglichen Nutzbits ein einzelnen Einbettfehler korrigieren kann.
So, wenn ich jetzt hier aber eine bestimmte Bittfehler rate,
also meinetwegen jetzt 0,1 habe, das heißt,
mit einer Wahrscheinlichkeit von 0,1 geht eben ein Bitt kaputt, ich übertrage ein ganzes Wort aus
In diesem Fall bei diesem Code jetzt also sieben Bit.
Dann zeigt diese Kurve dann eben letztendlich an,
hier in dem Blauen dann als Kanalbittfehlerrate, wie groß die Wahrscheinlichkeit ist,
dass ich jetzt eben irgendwas erhalten habe, was nicht mehr korrigierbar ist.
Und was hiermit jetzt eigentlich immer nur angedeutet ist,
ist, dass man sagt, okay,
wenn ich jetzt eben andere Codes nehme, Gut,
die Namen tun jetzt nichts zur Sache,
aber was man dann hier eigentlich sieht, ist,
dass eben dieses Verhältnis von Nutzbit zu übertragenen Bit sich also irgendwie entsprechend stark verändert.
Also wie gesagt, hier habe ich vier Nutzbit, übertrage sieben Bit.
Hier habe ich zwölf Nutzbits, übertrage 23 Bit. Das heißt,
da hat man dann also schon entsprechend deutlich mehr Redundanz in den Code reingebracht,
kann demzufolge also auch schon mehr Mehrbefehler korrigieren,
als jetzt eben beim Hemming-Code,
wo ich ja also im Prinzip nur einen Bitfehler korrigieren kann
Oder das ist dann eben ein Code,
wo ich dann, also letztendlich, also auf achten,
aus acht nutze bis 2048 Bills mache, nicht in das,
was man da dann eben sieht, dass,
solange die Kanalbitfehlerrate dann nicht doch irgendwie zu groß wird,
erhalte ich eben immer erstmal ein Ergebnis, was ich korrigieren kann,
nicht bloß ab einer gewissen Größe der Kanalbitfehlerrate,
habe ich dann eben letztendlich dann zu viele Fehler mit drin,
als dass ich sie dann eben noch korrigieren kann und dann ist eben die Wahrscheinlichkeit,
dass sich eben ein Wortfehler habe,
geht dann eben auch relativ schnell gegen eins,
weil ich dann eben irgendwas dann nicht mehr korrigieren kann.
Also letztendlich hiermit ist aber im Prinzip immer nur veranschaulicht,
wie jetzt abhängig von über dieses Verhältnis von gesamt bis zu Nurdspits,
also sprich das, was er dann also in der Gudierungstheorie dann ja über die Redundanz drin ist,
wie man das dann eben entsprechend an den Kanal anpassen kann.
Gut, abschließend werde ich dann nochmal hier ein bisschen was sagen zu den CRC-Codes,
beziehungsweise vorher noch mal kurz diesen Begriff der Binärpolynome einführen.
Damit ist gemeint, dass man sagt, also wenn ich
jetzt also ein Nbit-Wort habe, wie näher Wort aus in, mit.
Dass das eigentlich auch eine Kodierung sein kann für ein Polynom in dem Körper der Binären Zahlen,
Das heißt also, im Prinzip kann ich das immer irgendwie verstehen oder interpretieren,
als eine Kurzschreibweise, wo ich sage,
wenn ich jetzt also hier so ein Wort habe, 1,
0, 0, 1, 1, 0, 1,
dass das eigentlich nichts anderes ist als ein Polynom, also sprich,
entsprechende NR-Kombination von einmal X hoch 6 plus Nummer XO5 plus Nummer XO4. Nicht,
wo ich dann eben einfach sage,
ich habe jetzt hier irgendwelche Eingangswerte mit Stellenwahrscheinlichkeiten und das sind dann eben die entsprechenden Multiplikationsfaktoren.
Das heißt also,
dieses ist dann eine Kurzschreibweise für dieses Polynom
Das Ganze ist,
also auch da muss man sich dann im Prinzip immer auf so eine Innovation einigen,
wie man das interpretieren möchte,
aber das Ganze ist dann eben auch nicht eindeutig,
also ich könnte das also im Prinzip dann also
auch von den Bit-Reihenfolgen her vertauschen und sagen,
ich fange hier mit dem niederwärtigsten Faktor an und sage,
das ist dann eben einmal X hoch 0 plus 0 mal
X hoch 1 plus 0 mal X hoch 2 plus 1
mal X hoch 3 und dann erhalte ich eben entsprechend dann
dieses Polynom nicht oder ich kann das dann eben auch beliebig anders mal verschieben
So, das erstmal nur als so eine Kurzschreibweise für einen Polynom.
Und jetzt ist es aber so,
dass man mathematisch gesehen mit diesen Polynomen eben auch rechnen kann.
Also ich kann die addieren, ich kann mit denen multiplizieren
dividieren und erhalte dann also quasi immer aus diesen entsprechenden Funktionen wieder andere Funktionen.
Beziehungsweise, ich schreibe ja nicht so auf,
sondern einfach jetzt in Form dieser Bit-Werktouren. So,
und mit diesem Binärpolynom, das ist dann eben letztendlich die Basis von dem,
was dann diese zyklischen Codes sind,
beziehungsweise findet man dann an einer Literatur dann immer als CAC abgekürzt,
Cycling Redonency Check, wo man im Prinzip jetzt über so
eine Polynom-Division auf Basis eines bestimmten Polynoms dann eben Prüfbilds zu einem Eingabewort generieren kann.
Und zyklisch deshalb war dann eben letztendlich diese Codewörter durch
jeweils Schieben der einzelnen Bits und Modifikation beziehungsweise Modulo 2-Summe,
also sprich XO-Operation, miteinander berechnet fehlen.
So, und damit kann man dann eben auch relativ viele,
auch vergleichsweise prominente Codes generieren, die man also für Fehlererkennung benutzt,
beispielsweise im Ethernet-Protokoll in der ZIP-Kompression, in der PNG-Kompression.
Da wird also im Prinzip die CRC 32,
das ist dann also quasi dieser Bit Vector,
beziehungsweise das Zugehörige Polynum verwendet, in anderen Protokollen,
Wörter werden dann dementsprechend andere CRC-Codes verwendet, mit denen man da dann eben rechnet.
Gut, auf die genaueren mathematischen Eigenschaften werde ich jetzt also hier nicht weiter eingehen.
Ich werde dann also nochmal ganz kurz nur so ein Beispiel vorstellen,
wie man das Ganze dann rein praktisch macht, weil,
also wie gesagt, mit diesen Polinum zu rechnen,
ist technisch gesehen dann nämlich eigentlich vergleichsweise trivial und einfach zu realisieren.
Nicht aber warum das Ganze jetzt, also so gilt,
hast ja entsprechend dann weg.
Angesichts der fortgeschrittenen Zeit werde ich das dann aber nächste Woche
weiter fortsetzen und sie dann also in ein,
wenn auch nicht sonniges,
sondern regnasses Wochenende entlassen und das soll es dann für heute
gewesen sein