So, ich hatte vorgestern ja im Prinzip aufgehört mit dem Channel-Turim,
was da, sag mal, erstmal überhaupt nur theoretisch zeigt,
dass eben, wenn ich jetzt also im Prinzip einen Kanal-Kodierung mache,
das heißt, wenn ich also meine Kodierung so wähle,
das war die Übertragung quasi Bittfehler, beziehungsweise Bittfehlerhäufigkeiten,
die im Übertragungskanal vorhanden sind, eben berücksichtigt werden sollen,
dass man da eben zu entsprechenden Codes kommt und dass da also auch sehr viele Codes gibt,
die also entsprechend sehr,
sehr gut sind und eben auch nah an dem,
was also im Prinzip theoretisch,
also hinsichtlich der Übertragungsrate möglich ist,
gemacht werden kann.
Andererseits hatte ich ja gesagt,
also bislang habe ich dazu ja noch kein sinnvolles Verfahren vorgestellt.
Das soll jetzt also im Prinzip heute folgen, wo wir
also im Prinzip ganz einfache Verfahren für Fehlererkennung bzw. Fehlerkorrektur kennenlernen werden.
Ja, wenn man sich jetzt erst mal überlegt,
was kann jetzt bei der Datenübertragung in so einem Übertragungskanal passieren?
Zum einen können jetzt also letztendlich Zeichen irgendwie verfälscht werden aus dem A wird ein B. Nicht,
dann kann ich sowas wie irgendwie Vertauschung benachbarter Zeichen haben und was man auch noch relativ häufig Musik Ja,
Entschuldigung, das ist immer das Problem,
dass sie Akkus hier meistens nicht so prickeln vorher sind,
versuchen wir jetzt mit denen.
Und was man eben auch noch relativ häufig haben kann,
ist sogenannte Bündelfehler. Das heißt also ein ganzer Satz,
benachbarter Zeichen wird letztendlich irgendwie verfälscht. Was genau quasi an Fehlerarten auftritt,
wäre dann eigentlich jetzt wieder irgendwie so ein bisschen speziellere Untersuchungen,
weil das dann eben wirklich jetzt wieder davon abhängig ist,
also mit welchem Übertragungsmedium arbeite ich.
Also zum Beispiel bei Funk hat man typischerweise irgendwie sowas wie Störrimpulse,
die dann also sich da überlagern und zu Verfälschungen führen
Wenn ich irgendwie texte, am Rechner schreibe,
beim einen tippen, klassisch nicht,
also irgendwie so der Buchstabendreher oder eben als Beispiel für Bündelfehler,
wenn ich,
also im Prinzip wird es also auf so einem optischen Medium wie einer CD oder DVD,
also letztendlich Grazer habe,
wo dann also im Prinzip ein ganzer Satz von benachbarten Bits letztendlich betroffen ist.
Gut, bevor ich jetzt einige von den Fehlererkennungsbefinden zwar bzw. Fehlerkorrekturmaßnahmen vorstellen werde,
folgen auch jetzt nochmal so ein paar trockene Definitionen,
die wir dort letztendlich benötigen
In der Regel, das, was wir jetzt also hier
auch immer haben, handelt es sich um sogenannte Blockcodes.
Das heißt, ich habe eine bestimmte Anzahl von Informations-Bits,
Karstück, füge dann noch irgendwie eine Anzahl von Prüfbitzen hinzu.
Und er halte dann eben eine Gesamtanzahl von Witz,
nämlich Gab plus Prüfbitz, als N-Bits, die dann übertragen werden.
Das ist also das, was man quasi als Blockcode bezeichnet.
Faltungscodes sind jetzt bestimmte Codes,
also da werden wir nachher auch noch einen ganz kurz,
also zumindest von der Idee her kennenlernen,
wo man sagt,
ich betrachte sowas
wie mit Datenströme
Die quasi von einem Codebit-Strom, der jetzt also irgendwie ein Bit war, so übertragen wird.
Also beispielsweise jetzt durch irgendwelche Funkmedien oder irgendwelche Serielle arbeiten in Leitung,
wo also dieser Datenstrom jetzt on the fly analysiert wird.
Es werden dann eben irgendwelche Prüfeinformationen hinzugefügt und anschließend wird dann eben ein Ausgabedatenstrom erzeugt,
der dann also um diese Prüfeinformationen ergänzt ist,
wenn ich das ganz jetzt also wirklich laufenden Betrieb mache,
muss ich logischerweise daraus ergeben,
dass der Ausgabedatenstrom eine höhere Bittrate hat,
weil ich ja quasi pro Zeiteinheit jetzt eben mehr Bits zu übertragen habe.
Gut, dann kommen wir zu dem Begriff des linearen Codes.
Da geht es im Prinzip um,
jetzt wieder ein mathematisches Konstrukt, wo jetzt zumindest das,
was wir an Codierungen jetzt hier kennenlernen werden, letztendlich mit angesiedelt ist.
Und zwar geht es da um in sogenannten GF2.
Was ist damit gemeint? Kurze Einschub. Wie gesagt,
man kann da zu uns also auch nochmal relativ schnell
irgendwie in der Wikipedia nachgucken oder so.
Also das, was er bislang kennengelernt haben,
ist im Prinzip ja die Bullshal gebracht.
Das war also im vorigen Kapitel dran. Nicht,
wo man sagt, also Aussagenlogik habe ich typischerweise als Verknüpfung,
Wahrheitswerte, True und False, kodiert durch null oder eins.
Und ich habe irgendwie meine Operation und und
oder und eine Negation
Und kann damit also letztendlich die normale Aussagenlogik betreiben. So,
wenn man das jetzt versucht irgendwie in mathematische Konstrukte zu übersetzen,
hatte ich also auch schon die ganzen Gesetze,
die dort gelten,
also mal auf einer Folie mit drauf gehabt,
dann kann man also grob sagen, dass und im Prinzip,
soweit es ähnlich ist, oder ein Äquivalent ist,
so eine Art Multiplikation oder wäre dann also ein Äquivalent zu einer Addition,
das Ganze ist aber mathematisch gesehen jetzt kein Körper,
weil es gibt also kein inverses Element für die Oder-Operation
Das sieht bei sogenannten Galoire-Feldern anders aus. Das ist also im Prinzip,
also GF2 heißt, wir haben Galoire-Feld mit zwei Elementen,
letztendlich auch nichts anderes als True und False, beziehungsweise 1 und 0.
Und wir haben als Verknüpfung darauf jetzt und XR.
Und das ist dann mathematisch gesehen ein Körper, also da gelten die Körperaxiome. Wie gesagt,
und entspricht dort der Multiplikation,
das Exklusiv oder entspricht einer Addition Module 2. Das heißt,
damit habe ich dann also auch die Abgeschlossenheit und ich habe dann eben auch additives Inverse,
nämlich wenn ich x, exklusiv oder x rechne,
habe ich als Ergebnis immer null,
egal ob x gleich 1 oder null ist, damit ist,
wäre x dann also entsprechend das additive Inverse.
Gut, also GF2, das heißt,
wir rechnen immer mit Multiplikation und Addition, technisch ausgeführt dann durch,
sorry, durch und und exklusiv oder.
So, und ein linearer NK-Code heißt dann eben,
ich habe im Prinzip K. Nutzbits, prüfe dort oder füge
dort dann eben auch eine Anzahl von Prüfbits hinzu und habe insgesamt N-Bits.
Das heißt letztendlich genau das, was hier oben auch als
Blogcode definiert ist, gilt da auch.
Und mathematisch gesehen ist also so ein NK-Code dann also ein
Unterraum in GF2 auch. So ein modifizierter Code ist ein Code,
wo ich jetzt im Prinzip einen linearen Code habe und systematisch
jetzt bestimmte Stellen in diesem Code verändert werden.
Rein praktisch, wen wir gleich sehen,
heißt das einfach an bestimmten Stellen
im Code
Füge ich meine Prüfblitze hinzu an anderen Stellen im Code,
habe ich eben meine Notsplits. Das ist eigentlich das,
was dann rein praktisch dahinter steht. Wie gesagt, Beispiele,
dazu folgen dann gleich. Dann noch zwei Begriffe, systematischer Code,
ist also ein Code, wenn die zu kodierende Informationen,
also direkt als substringendem Codewort enthalten ist. Das heißt,
ich muss jetzt nicht, wenn ich irgendein Codewort empfange,
dort über irgendwelche Tabellen oder irgendwelche Operationen quasi jetzt meine Nutzbits wieder herausrechnen,
beziehungsweise herauslesen, sondern ich kann eben sagen,
das Bit und das Bit und das Bit sind meine Notsplits.
Letztendlich, geht das dann also auch so ein bisschen,
also auf diese Information von Blockcodes oder Definition von Blockcodes dann hier zurück.
So ein zyklischer Code wäre dann eben nochmal ein Blockcode,
wo dann eben für jedes Codewort auch noch gilt,
dass also alle Verschiebungen der Codewörter, also im Prinzip,
was man beispielsweise jetzt mit beliebigen Ortationen erreichen kann,
eben auch gültige Codewörter sind.
Das ist zum Beispiel jetzt eben bei Übertragungen ganz gut,
wenn ich jetzt also sowas wie Bündelfehler habe,
weil man dann eben sehen kann, dass,
wenn ich ein gültiges Codewort habe, einen Bündelfehler habe,
dann wird das also bei zyklischen Codes dann eben immer zum ungültigen Wort.
Gut, ja, das ist ja jetzt so ein paar Begriffe.
Jetzt ist ja die Frage, wie kann man überhaupt erst mal Fehler,
die Öhner Übertragung auftauchen, behandeln? Jetzt kann man natürlich sagen,
ja gut, das einfachste Verfahren ist jetzt natürlich sowas,
wenn ich jetzt einen symmetrischen Übertragungskanal habe, beziehungsweise also einen Rückkanal,
dann kann ich als Empfänger quasi wenn ich jetzt erkenne,
es wurde ein ungültiger, ein ungültiges Wort gesandt.
Das heißt also, wenn ich jetzt überhaupt jetzt meine Fehlererkennung nur mache,
kann ich dann eben nachfragen, okay, ich schicke mir das bitte nochmal.
Ist beispielsweise ganz normal im Internetprotokoll bei Im Prinzip Übertragung dort,
also immer der Fall,
wenn ich jetzt also nicht irgendwie UDB-Protokolle habe, dass letztendlich,
wenn der Empfänger jetzt also irgendwann ein Paket empfängt,
dort sind Fehler aufgetreten, ist halt im Protokoll definiert,
dass dann eben über eine Rückantwort, beziehungsweise dann eben nachgefragt wird,
okay, da ist was verlustig gegangen, schicken wir das bitte nochmal.
Wie gesagt, funktioniert natürlich dann nur,
wenn ich also im Prinzip bidienreaktionale Kommunikation habe und es funktioniert eben nicht bei Rechtszeitanforderungen,
weswegen man dann eben solche Protokolle dann eben auch nicht benutzt.
Wenn ich jetzt also wirklich also irgendwelche Daten echtzeitenmäßig übertragen möchte,
weil es da dann eben natürlich sein kann,
dass wenn jetzt Übertragungsfehler auftreten, ich also entsprechend nochmal nachfrage,
okay, ich schicke mir das nochmal,
ich eigentlich nicht zuverlässig Aussagen treffen kann,
wann die Daten eintreffen.
Deswegen funktioniert das da dann also nicht richtig, beziehungsweise dann
also nur mit abgeschwächten Echtzeitanforderungen. Gut, Das reden wir
jetzt aber hier im Prinzip also auch nicht weiter betrachten.
Also das wird dann eben noch behandelt, wenn es dann so zum Beispiel,
also dann später im Laufe des Studiums, also so um Netzwerkprotokolle gibt.
Da werden dann also zum Beispiel dann also bei den üblichen TCPI-B-Sachen dann also nochmal sowas,
beziehungsweise überhaupt jetzt mal diese Protokolle dann also vorgespät gestellt und besprochen.
So das, was wir jetzt hier mit betrachten werden,
sind also sogenannte Verfahren, die sich dann also Vorwärtsfehlerkorrekturen nennen,
beziehungsweise im Englischen Forward Error Correction,
wo man dann eben die zu übertragene Informationen eben durch Prüfziffern bzw. Prüfinformationen eben sichert und dafür sorgt,
dass ein Empfänger erst mal überhaupt erst mal erkennt,
sind bei der Übertragung Fehler aufgetreten.
Das ist natürlich dann auch immer schon Voraussetzung für einen ARQ-Protokoll.
Im Idealfall ich das Ganze dann aber eben noch so weit treibe,
dass ich also Fehler nicht nur erkennen kann,
sondern dass ich Fehler auch korrigieren kann
Das Ganze funktioniert natürlich nur, wenn ich letztendlich Redundanz einbaue. Das heißt,
wenn ich jetzt eben sage, okay,
ich habe meinen Übertragungskanal nicht vollständig ausgelastet und statt acht Bit
könnte ich jetzt meinetwegen 15 Bit übertragen und habe da dann eben noch Prüfeinformationen,
die dann also zum Beispiel genutzt werden können,
um Fehler,
die also bei der Übertragung auftreten,
zu erkennen und beziehungsweise in dem Fall dann also auch
noch irgendwie zu korrigieren
Ganz am Ende werde ich also auch noch mal exemplarisch so
ein paar Verfahren beziehungsweise Beispiele nennen. Also auch da kann man nur sagen,
das ist dann also jetzt hier eigentlich nur als Aufzielen und der Vollständigkeit halber.
Also da muss man jetzt also nicht wissen, dass ein JPEG,
also die und die und die Protokolle und die und die Fehlerkorrekturverfahren drin sind,
sondern einfach nur mal um zu sehen,
was das ist im Prinzip alles beinhaltet.
Weil so relativ viel von dem, was wir eigentlich so an Standarddatenformaten benutzen,
um Daten zu komprimieren um Internetübertragung zu machen,
um irgendwelche Bilder darzustellen und so weiter enthält.
Also in der Regel schon ein ganzes Sammelsurium an, Fehler, Erkennungsfehler,
Korrekturmaßnahmen, Datenkompressionsalgorithmen und die dann also in unterschiedlichsten Kombinationen dann also zusammengefasst.
Das heißt also, da sieht man dann eigentlich,
dass da doch schon relativ viel Aufwand getrieben wird,
um eben wirklich dafür zu sorgen,
dass sich also Fehler da also nicht weiter auswirken
Gut, wie funktionieren jetzt solche Verfahren? Dazu
also erst mal Begriffe. Und zwar der sogenannte Hemmingabstand,
bezeichnet, wenn ich jetzt eine Anzahl von Codewörtern habe,
die Anzahl der Stellen,
in denen sich jetzt also diese Codewörter paarweise jeweils in einzelnen Bits voneinander unterscheiden.
Das Hemming-Gewicht ist also letztendlich der Hemming-Abstand eines Codeworts von Nullwort
oder rein praktisch gesagt einfach die Anzahl der Einsen
Code-Wort. Beispiel, diese beiden Code-Worter haben den Hemmingabstand von drei,
weil die sich also um genau drei Bits unterscheiden,
nämlich einmal an dieser Stelle,
an dieser Stelle und an dieser Stelle Hemminggewicht von B wäre fünf,
weil hier sind 5-1 enthalten,
beziehungsweise dass wir dann der Hemmingabstand von dem Null-Wort.
Da sieht man übrigens, wofür das,
was sich da in dem Kapitel zu den logischen Operationen mal
kurz eingeführt hat, wofür man also dies Bitcount braucht.
Das ist dann eben sowas, um Hemminggewichte zu berechnen,
beziehungsweise den Hemmingabstand kann man dann eben auch sehr einfach dadurch berechnen,
dass ich also quasi Bidvises XOR von den beiden Worten mache und
anschließend dann also das Hemminggewicht berechne und dann habe ich nämlich auch den Hemmingabstand.
Gut, wie kann man jetzt Fehlererkennung und Fehlerkorrektur machen?
Wie gesagt, es muss erstmal Redundanz erforderlich sein.
Das heißt, also ich füge eben jetzt zusätzlich Informationen hinzu
Das heißt, man hat deutlich mehr Bits als das,
was also für die reine Speicherung der Information benötigt werden würde.
Und was man dann eben macht, ist,
dass man aus, oder um jetzt seine Codewörter zu bilden,
aus den möglichen Wörtern eines Codes mit einer bestimmten Länge,
eben die Codewörter so auswählt,
dass sie parweise immer mindestens einen bestimmten Hemmingabstand haben.
Und dieser Minimalabstand, der dann zwar quasi zwischen allen Wörtern
eines Codes gilt, wäre dann eben der Minimalabstand.
Hier dann also auch immer mit D bezeichnet. So,
und was man dann machen kann, ist,
dass man sagen kann, für Die Fehlererkennung,
wenn ich zwischen in einem Code jetzt,
also einen Minimalabstand von D habe,
dann kann ich bis zu D minus 1 fehlerhafte Stellen erkennen und bis zu D minus 1 halben fehlerhafte Stellen korrigieren.
So, jetzt fragt man sich natürlich, ja gut,
da kann er viel behaupten, warum ist das so?
Hier ist das mal so ein bisschen versucht
zu veranschaulichen
Wir haben hier also Codewörter der Länge 3. Drei Bit.
Hier quasi angeordnet an den Ecken eines Würfels.
Das heißt also jedes Bit entspricht irgendwie einer Dimension XYZ.
Und wenn ich jetzt also quasi alle acht möglichen Kombinationen nehme,
das heißt also hier die kompletten Ecken,
dann hätte ich also als Hemming-Abstand letztendlich oder als Minimalabstand eben letztendlich eins.
Das heißt, zwei Codewörter und erscheinen sich quasi immer genau um eins,
wenn sie jetzt also hier von einer Kante zu anderen gehen. So,
hiermit kann ich also weder Fehler erkennen, noch Fehler korrigieren,
weil wenn jetzt also hier beispielsweise das jetzt alles achtgültige Codewörter wären,
ich habe dieses Codewörters hinter das Debit kippt,
dann habe ich hier wieder ein gültiges Codewort und der Empfänger sagt ja wunderbar,
ich habe jetzt statt der sechs eine sieben Empfang zur Ward
So, jetzt wählen wir also Kotwörter,
die jetzt also irgendwie Helming-Abstand größer eins haben.
In diesem Fall nehmen wir jetzt also beispielsweise die hier rot gekennzeichneten Codewörter,
die jetzt jeweils paar weise einen Helming-Abstand von zwei haben.
Also sprich mindestens zwei. Das heißt,
von einem Codewort zu einem anderen gültigen Codewort muss ich hier
also quasi immer über genau zwei Kanten laufen.
Das heißt, wenn sich,
wie in diesem Fall jetzt nur ein einzelnes Bit ändert,
das hier wäre ein gültiges Codewort,
das sind das Debit kippt
Erhalte ich hier ein ungültiges Codewort. Das mittlere Bit kippt,
erhalte ich hier auch ein ungültiges Codewort, wenn das vordere Bit kippt,
würde ich also hiermit dann eben auch ein unnötiges Codewort erhalten.
Das heißt, hiermit kann ich jetzt für einen Einzelwittfehler den zumindest erkennen. Ich kann ihn nicht korrigieren,
aber dadurch, dass also quasi der Hemmingabstand,
also der Paarweiserabstand, In der Anzahl der Bits,
also zwischen zwei Code war dann immer schon mal zwei ist,
lande ich jetzt für ein einzelnes Bit, was sich verändert,
dann immer bei einem ungültigen Codewort und kann sagen,
sorry, da stimmt was nicht.
Ich kann zwar nicht entscheiden, was passiert ist,
also sprich, ob das gültige Codewort, was verfälscht wurde,
dieses ist oder dieses, wenn ich an diesem,
also dieses hier empfangen habe oder also auch das erste Mittel irgendwie von dem Haus falsch gelaufen ist,
aber ich kann zumindest schon mal erkennen,
ein Übertragungsfehler ist aufgetreten.
So, Hemmingabstand 3 wählen wir jetzt also
nur noch
zwei Codewörter
Damit kann ich jetzt schon ein Bit-Fehler-Korrektur machen, einfach in die Formel eingesetzt,
Minimalabstand 3, minus 1 ist 2, durch 2 S1.
Das heißt, ich kann in einer einzigen Stelle,
oder wenn Sie jetzt nur einen Einzelnen ein mit Fehler auftritt, eine Fehlerkorrektur machen.
Also, dies wäre ein gültiges Kotwort, ein Bett ändert sich,
dann lande ich also entweder hier oder hier oder hier. So,
und das, was jetzt letztendlich passiert oder was die Idee dabei ist,
dass man jetzt eben sagt, okay, Wenn ich jetzt weiß,
es hat sich nur ein Bit geändert,
dann muss dieses quasi das Ausgangswort sein, weil alle anderen Worte,
die jetzt also von diesem empfangenen Wort aus quasi mit einer Bit-Änderung von einem Bett erreichbar sind, sind auch ungültige Kotworte.
Das heißt also,
wenn mit diesem Hemming-Abstand 2 habe ich hier erreicht,
dass wenn sich nur ein einzelnes Bit ändert,
also quasi die Entfernung von einem falsch entfangenen Wort zu einem gültigen Wort,
eben hier eins ist und zu dem anderen gültigen Wort MA2 und dem zuvor sagt man dann,
also das,
was näher dran ist,
ist dann das in Anführungszeichen gültige
Voraussetzung für das Ganze ist natürlich nur, dass du nur ein einziger Fehler auftritt.
Wenn es zwei Fehler auftreten, gilt auch ein Formel-mäßig,
also schon nicht mehr, das ist also eine Fehlerkorrektur möglich ist.
Weil dann würde man in dem Falle dann eben auch zur falschen Seite hin korrigieren. So,
hier ist das Ganze jetzt mal für einen Code mit fünf Bits,
zweigültige Codeworte, hier also quasi mal in Rot geschrieben, alles andere, was ich also hier quasi jetzt von diesen 32 Wörtern habe, sei also im Prinzip das hier. Das,
was man also sieht, also ich habe hier von einem gültigen Codewort,
also hier jetzt alles mit Hemmingabstand 1, Hemmingabstand 2,
3, 4 beziehungsweise 5, eine Fehlererkennung ist dann eben für dminus 1,
das heißt also für 4 Bit möglich,
nicht weil ich dann also jeweils irgendwo bei einem dieser Worte hier lande,
Fehlerkorrektur wäre dann für dminus 1 halbe, also für 2 Bit möglich,
letztendlich ist da dann eben auch die Idee, dass man sagt,
wenn ich jetzt also von diesem Wort aus starte,
2 Bits irgendwo beliebig wechseln lasse,
lande ich also entweder bei einem dieser, beziehungsweise dieser Worte,
war zwei Bett und kann dann eben auch wieder sagen,
okay, also ich bin zu diesem gültigen Code Rock quasi näher als zu dem hier und demzufolge wird dann in diese Richtung die Fehlerkorrektur gemacht.
Gut, also das erstmal zu dem Hemming-Abstand oder Auswahl der Code-Worte,
das ist jetzt natürlich, sagen wir mal,
ein Verfahren, was,
wenn man jetzt also irgendwie entsprechend größere Codeworte beziehungsweise Wortmengen hat,
dann will man sowas jetzt natürlich dann nicht eher sich von Hand irgendwie irgendwas ausdenken und sagen,
okay, das markengültiges Codewort sein und das kann man machen,
ist aber eben vergleichsweise aufwendig demzufolge geht es jetzt also darum,
mit welchen Verfahren oder welchen Grundideen,
also hier sollen jetzt eigentlich auch eher die Ideen skizziert werden,
geht es also letztendlich darum,
also diese Prüfinformation zur Fehlerkennung bzw. zur Fehlerkorrektur
zu generieren und wie man das also letztendlich machen kann
Dazu gibt es also relativ viele verschiedene Verfahren,
also die einfachsten Verfahren, sogenannte Prüfziffern oder Paritäten.
Würde ich hier also noch kurz vorstellen,
sowas wie Summenbildung begegnet uns teilweise dann im täglichen Leben,
also bei relativ viel verbreitet oder verbreiteten Codes auch.
Alles, was hier unten ist,
sind also jetzt im Prinzip unterschiedlichste mathematische Verfahren.
Wie gesagt, die Namen stehen der Vollständigkeit halber drauf,
aber die Algorithmen dazu werden jetzt hier auch nicht
weiter oder genauer noch
behandelt werden
Gut, das einfachste Verfahren ist also im Prinzip der sogenannte Paritätscode.
Das heißt, man fügt ein einzelnes Bit hinzu, das sogenannte Paritätsspit.
Damit kann man im Prinzip einen mit Fehler erkennen. Das heißt,
das, was ich erreiche, mit diesem Paritätsbit,
ist also nichts anderes, als dass ich für jedes Code
oder für Kotworte immer einen Hemmingabstand von zwei generiere.
Das ist also nur eine reine Fehlererkennung, auch keine Fehlerkorrektur.
Wie wird diese Parität berechnet? Wenn ich also jetzt hier im Prinzip
eine Zahl habe, Mit N-Bit. Es wird eben dieses
eine Paritätsbit hinzugefügt. Das wird berechnet als Summe Z-E-Modero 2,
beziehungsweise rein technisch gesehen in GF2, XO-Operation der einzelnen Bits miteinander. Gut,
hier in Summen Schreibweise, Modulo 2, das heißt also,
wenn wir jetzt also im Prinzip irgendwelche Bits oder irgendwelche Zahlen haben,
also sowas wie dieses hier, würde ich dann eben letztendlich also zählen,
wie viele Einseln sind da drin,
also sprich nichts anderes als das Hemmingewicht nehmen und dann Entsprechend das.
Modello 2 und dann kann man eben entweder eine gerade Parität bilden,
also auch Even genannt, wo ich dann also quasi genau dieses Parität-Bit hinzunehme.
Letztendlich heißt es dann eben, dass ich eine gerade Anzahl
von Einsen in meinem Codewort habe. Insgesamt oder eben eine ungerade Parität,
Outparity, wo ich dann also quasi Dieses Bit invatiere,
letztendlich dann für mein Gesamtcodewort, das heißt die Bits,
plus das Paritätsbits, würde dann eben Modeloo 2 gleich 1 ergeben,
beziehungsweise in der Summe, dass ich eben eine ungerade Anzahl von einzelnen in meinem Codewort habe.
In der Praxis, also auch wenn ich gleich ein Beispiel habe,
wo ich jetzt wieder mit Even rechne,
in der Praxis werden meistens ungerade Paritäten genommen,
weil dafür gibt es einen ganz trivialen Grund.
Damit ist letztendlich sichergestellt, dass ich in einem Wort,
was ich übertrage,
mindestens eine einzige 1 habe
So, und damit kann man einfach feststellen, besteht überhaupt eine elektrische Verbindung.
Also ich habe einen Empfänger, der empfängt irgendwelche Bits,
dummerweise ist das Kabel gar nicht angeschlossen.
So, und da sagt er ja, da kommen immer
nur Nullen an. Alles gültiges Kotwort. Even Perity,
lauter Nullen, komm an, Qualitätsbitt ist auch null tast.
Bei einer Ort-Perity wäre ein Wort aus lauter Nullen eben gar kein gültiges Kotwort,
sondern es würde dann eben eine einzelne Eins enthalten.
Deswegen würde man das dann dementsprechend
ganz gerne verwenden
Gut, mit dieser Parität erreiche ich aber letztendlich,
dass ich zwei Codewörter immer um genau zwei Bit unterscheiden,
nämlich wenn sich in meinem Ausgangswort ein Bit ändert,
ändert sich auch das Paritätsbild, weil ich also die Anzahl der Einsen quasi mitzähle.
Und wenn ich in meinem ausgehenden Wort eine Null hatte,
da jetzt eine Eins mache, dann würde das Paritätsbitz,
wenn es vorher jetzt also beispielsweise ein eben Null gewesen ist,
auch zu Eins wechseln, beziehungsweise umgekehrt,
wenn ich also aus einer A1 zu 0 machen würde,
würde, also auch in dem Fall dann das Paritätsbeziehwald wechseln.
So, damit hat man dann eben erreicht,
dass sich letztendlich an der Stelle an eben den Hemming-Abstand 2 immer habe.
Gut, damit kann man also einen mit Fehler erkennen. Was man auch noch erkennen kann,
ist, wenn ich eine ungerade Anzahl von Mehrbettfehlern habe,
das heißt also entweder ein Bit kippt oder drei Bit kippen,
also auch dann hätte ich, würde ich beim gültigen Kotwort landen,
wenn sich zwei Bit ändern, ja,
dann habe ich leider wieder Pech gehabt.
Also es sagt eben, Eigentlich generell,
das Dilemma oder das Problem bei dem Einbau von jetzt irgendwelchen Prüfinformationen,
dass man sich also vorher erst mal angucken muss,
wie übertrage ich irgendwas, welche Art von Fehlern tritt auf,
wie häufig sind diese Fehler, wie wahrscheinlich sind diese Fehler.
Und eben das, was ich also am Mittwoch kurz angesprochen hatte,
dass man dann eben auch vorab eben erst mal untersucht,
wie sieht das mit dem Übertragungskanal aus,
was ist da eben letztendlich die Kanalkapazität,
was kann ich da jetzt überhaupt noch an zusätzlichen Informationen mit reinbauen.
Gut, das geht jetzt Wenn man sowas untersuchen wollte in
das Studium der Nachrichtentechnik, Elektrotechnik, das machen wir glücklicherweise nicht. Deswegen,
wie gesagt, hier kommen jetzt eigentlich nur so ein paar einfache Verfahren,
wie man jetzt quasi mathematisch mit 0 und 1 in was macht,
wie man jetzt also im Prinzip bei irgendwelchen Funkspektren, Kanalkapazitäten und so weiter berechnet.
Würde auch ich immer sagen, überlasse ich Leuten,
die sich mit sowas auskennen.
Gut, ja, wie kann man dieses Paritätsverfahren im Prinzip
dann noch erweitern
Herr Gott, das ist ein Schweizer, das ist ein Schweizer.
Da heißt es, genau, genau. Also die Frage war jetzt,
wenn ich diesen Algorithmus für das Paritätsbesitz nehme und quasi jetzt noch ein Zwerg des Paritätsbild mit hinzufüge,
dass man dann einen Hamming-Abstand von drei kriegt und ja,
muss ich sagen, wäre eine schöne Übungsaufgabe.
Leider ist dafür zu spät, Nee, das Problem ist,
man kriegt eben keinen Hamming-Abstand von drei, weil,
also das, was man machen müsste, und das ist das,
was eigentlich dann die, die Fehler korrigierenden Codes auch,
oder anderen Codes dann eben auch entsprechend machen,
Beispiel Vorgleich, ist,
dass ich dann die Parität eben nicht mehr über alle gültigen Nutzbits mache,
sondern über Gruppen von Nutzbits.
Das heißt also, ein Paritätsbit berechnet sich aus den ersten
drei Nutzbits, das zweite Paritätssbits berechnet sich aus Nutzbit
3 und 4 beispielsweise. Und wenn man das also geschickt macht,
dazu wird also auch gleich noch ein Verfahren vorgestellt, dann kann man eben wirklich,
also auch größere Hemming-Abstände erreichen und dann eben auch systematisch,
also auch eine Fehlerkorrektur einbauen.
Wenn ich das aber über alle Paritätsplits mache,
dann habe ich nichts anderes, als dass ich jetzt sage,
ich habe aus einem gültigen Codewort dann einfach nur noch mal
genauso jetzt wieder eine Parität hinzugefügt,
mathematisch wäre das eigentlich noch nichts anderes,
das finde ich auch sehr even eine Ort-Parität machen würde
Ich aber in dem Fall gewinne ich da jetzt keine zusätzliche Information.
Nee, aber was man machen kann, ist also zweidimensionale Parität.
Also da kommt nämlich schon so ein bisschen diese Idee mit rein,
dass also Teile der Paritätsbitz dann eben sich nicht aus allen Teilen des Codes berechnen,
sondern ich damit dann also schon quasi eingrenzen kann,
wie das Ganze geht.
Wie gesagt, also hier gefolgt als Beispiel jetzt immer nur Zweidimensional,
weil das kann man immer noch einigermaßen vernünftig zeichnen.
Im Prinzip lässt sich so ein Verfahren aber also auch noch
mehrdimensional machen. Das, was man macht, ist,
dass man letztendlich die Daten und Informationsbits als Matrix anordnet,
zahlenweise spaltenweise und berechnen Parität dann eben für Zeilen und Spalten jeweils einzeln macht.
Und dadurch kann man dann eben sagen,
an einer bestimmten Stelle
hat sich mitgeändert
Damit kann man dann also letztendlich jeweils einen Wittfehler in den Zahlen und Spalten
erkennen und damit dann eben auch diese Fehler an bestimmten Stellen
korrigieren und teilweise also auch noch mehr Bittfehler entsprechend erkennen.
Also eine mehrdimensionale Anordnung begegnet uns dann ein praktisch beispielsweise im QR-Code, wo man sowas mit drin hat. Gut,
hier mal als einfaches Beispiel, wo man jetzt sagt,
ich ernehme jetzt, also hier das Wort Hamming,
schreibe das jetzt also quasi als, also die entsprechend jetzt,
also hier die sieben Buchstaben mit den Aski-Zeichen,
habe quasi jetzt irgendwie sieben mal sieben Bit,
Zahlen und Spalten und Fügel dann jeweils,
in diesem Fall jetzt mal eine gerade Parität, zahlenweise und spaltenweise hinzu.
Das heißt, das, was man hier jetzt machen würde,
ist, ich habe 49 Benutzdaten,
nämlich sieben mal sieben Bit und übertrage insgesamt acht mal acht Sprich 64-Bit,
also 15 zusätzliche Bit für die Parität.
Wie gesagt, wie berechnet sich die Parität?
Ich also hier auch nur nochmal, wenn ich jetzt hier
zum Beispiel mal hier diese Zahlen jetzt also mal nehme.
Also hier die Anzahl der Einsen wäre in diesem Fall jetzt hier zwei.
Bei einer iven Parität ist das eine gerade Zahl.
Soll dann also auch gerade bleiben.
Also ergibt sich jetzt Parität eine Null.
Hier genauso
Hier habe ich vier Bit. Auch da ergibt sich als Paritäten eine Null. Hier,
wo ich jetzt quasi drei Einsen habe,
wird eben als Prioritätsbit eine Eins hinzugefügt, dass ich heißt,
insgesamt habe ich dann in meiner Zeile auch wieder vier Einsen und erreiche damit,
dass, wenn ich die jetzt alle mitweise, X-Ohr verknüpfe,
beziehungsweise zähle, wie viele Einsbits dort vorhanden sind,
lande ich dann eben auch wieder bei einer geraden Zahl.
So, wie gesagt, das macht man zahlenweise und spaltenweise.
Letztendlich geht das Ganze dann eben auch jeweils für die zusätzlichen Prüfbitz,
dass wir dann eben auch nochmal dieses hier.
So, und was passiert jetzt, wenn hier an bestimmten Stellen irgendwelche Fehler auftreten?
Was hier also auch nur nochmal angedeutet ist,
und das muss man sich natürlich also auch immer klar machen,
also ich füge jetzt ja zusätzliche Bits in meinen Code hinzu,
die werden mit übertragen.
Die können also auch genauso gestört und verfälscht werden,
wie die Nutzbills. Das heißt also, das,
was bei der Fehlerkorrektur dann eben auch immer möglich sein muss,
beziehungsweise passieren muss, ist, dass sich eben quasi auch feststelle,
eins von den Qualitätsbild ist irgendwie kaputt gegangen,
beziehungsweise eins von den Prüfbits.
Also je nachdem, mit welchem Verfahren ich das gemacht habe.
Gut, wie würde sich jetzt so ein Fehlerfall auswirken?
Also nehmen wir jetzt beispielsweise hier mal Designs und gucken, was jetzt passiert.
Wie gesagt, die wurde jetzt verfälscht. Der Empfänger kriegt jetzt
also hier irgendwie seine Informationen. Also sprich, alles,
was hier schwarz ist und an dieser Stelle ja eins.
Der Empfänger würde dann eben letztendlich auch die Parität berechnen
und würde quasi jetzt bei seiner eigenen Berechnung feststellen,
ich habe hier drei Einzeln und eigentlich müsste hier ein Eins
stehen und keine Null
Und genauso würde er dann eben erkennen,
an dieser Stelle hier, 1, 2, 3,
4, 5 Einsen müsste für eine gerade Parität eigentlich
eine Eins stehen und keine Null.
So, und damit sind in diesem Fall dann
eben Zeile und Spalte markiert und der Empfänger weiß,
an dieser einen Stelle muss statt der Eins eine Null gestanden haben,
weil nur dann wäre dann eben auch entsprechend
diese Prüfeinformation richtig geworden
Ja. Genau, auch das, also die Frage war,
also es kann ja auch sein, dass die Prüfeinformationen Fehler hat.
Also das haben wir jetzt zum Beispiel hier in dem Fall.
Auch dann würde im Prinzip dieses Verfahren das Ganze letztendlich erkennen.
Dazu, na gut, oh, das Mamm,
kurz versuchen, irgendwie schnell aufzuschreiben.
Also ich habe jetzt hier als Bits 1-0,
0-
Null. Prüf mit Null
Musik So, das wäre jetzt also hier der fehlerfreie Fall.
Jetzt haben wir also hier an dieser Stelle eine Null-Empfang.
So, und auch dann würde man einfach jetzt wieder
ganz normal berechnen, wie haben sich die Paritäten geändert.
Zahlenweise würde Empfänger sagen, hier null stimmt, das stimmt,
das stimmt das, stimmt das, stimmt das,
stimmt das stimmt.
Diese eins stimmt nicht
Weil hier müsste jetzt eigentlich, wenn ich hier berechne, zwei Einsen quasi eine Null stehen.
Und genauso würde der Empfänger dann eben auch sagen,
dieses hier stimmt, dieses hier stimmt jeweils,
in dieser Spalte, 1, 1, 1,
1, 4 Einsen, 5, 1,
müsste ich an dieser Stelle hier auch eine Eins haben und keine Null.
Und genauso ist, wie das also quasi jetzt für irgendwelche Nutz-Bits gilt,
eben auch hier jeweils die Zeile und die Spalte des kaputten Witzs letztendlich identifizierbar.
Das heißt also auch da,
selbst wenn es also ein Paritätsbit betrifft,
kann man also nach diesem Algorithmus dann eben sagen,
okay, an dieser Stelle müsste eigentlich eine Eins gestanden haben.
Nicht, also das heißt, das Verfahren gilt so
letztendlich dann genauso auch für die Prüfbitz.
Genau, die Frage ist sehr gut, sehr richtig.
Also sprich, gibt es Kombinationen von Fehlern, die sich gegenseitig auslöschen.
Und natürlich ist es auch so, wenn ich jetzt sage,
ich habe hier also irgendwie Kippe von einer Eins zu einer Null und habe hier also an,
in der Seile jetzt also quasi noch einen zweiten Fehler und in der spalte auch noch einen Fehler,
dann würde das zumindest dieser Teil hier maskiert werden.
Man würde also noch irgendwie andere Fehler mitkriegen. Das Problem ist,
Grundsätzlich, also dies ist jetzt nicht ein Verfahren,
womit ich sage, ich übertrage 49 Bit fehlerfrei,
sondern das, was ich hier mitmachen kann, ist,
dass ich sagen kann, okay,
ein einzelner Einbettfehler wird nicht nur erkannt,
der wird auch korrigiert.
Ein paar andere Fehler kann ich noch erkennen. Also wenn jetzt hier
mehrere Fehler auftreten, kann ich die teilweise noch erkennen.
Teilweise können die sich aber auch gegenseitig maskieren und korrigieren kann ich dann auch nichts mehr,
weil dann kann ich eben auch nur noch raten, was passiert. Das heißt,
wenn ich jetzt als wirklich so einen Fall habe wie hier,
wo jetzt also relativ viel, also irgendwo hier an Paritäten falsch wäre,
kann ich eben nur sagen, okay,
da ist also irgendwie was Falsches angekommen,
aber ich kann dann also auch nicht mehr alles wieder korrigieren.
Das heißt, also da muss man dann eben schon so ein bisschen aufpassen,
wo die sich dann also gegenseitig entsprechend dieser Berechnung der Parität
dann eben auch wieder stören können
Ich kann es, sorry, ich kann das versuchen,
also runterzulassen,
wobei das eine von denen war also auch irgendwie kaputt,
aber gehen wir also hier mal auf Charlosien.
Was ist das
Sorry, aber die Jalousien funktionieren nicht. Ja. Hat man
einmal Sonnenschein in Hamburg? Ja, gut. Also wie gesagt,
das nutzt du der Grundidee, zweidimensionale Parität, wie gesagt,
dieses Verfahren lässt sich dann noch mehr dimensional machen,
wo man dann eben noch mehr Fehler erkennen,
einordnen könnte, um jetzt wirklich zu sagen,
ich möchte jetzt also in einem größeren Text also deutlich mehr korrigieren
Da müsste man dann eben entsprechend noch andere Verfahren benutzen.
Grob gesagt, kann man auch mal sagen,
diese Idee ist also jetzt nicht nur für Binärzahn anwendbar,
sondern man kann das also zum Beispiel auch im Dezimalsystem machen.
Das ist also hier mal kurz angedeutet. Einfach in Form
so einer Zahlen- und Spaltensumme, die dann Modulo 10 berechnet wird.
Also ich habe hier diese neuen Zahlen, die als Daten
übertragen werden sollen. Und Parität wird es eben berechnet,
indem ich die jetzt also quasi einfach aufsummiere und Modulo 10 rechne.
Also sprich 3 plus 7 plus 4 ist 14,
also zack,
steht eine
Hey, 5 plus 4 plus 8. 17, 9.
Und das Ganze macht man dann eben auch entsprechend spaltenweise. So,
und auch da gilt jetzt, wenn ich also irgendwo einen
Fehler habe und hier ist also eine falsche Zahl übertrage, was passiert?
Der Empfänger macht also jetzt wieder genau das Gleiche.
Hat also quasi diesen inneren Tag hier empfangen.
An dieser Stelle Ebene 3 und würde jetzt also hier bei
der Berechnung in dieser Zeile machen 5 plus 4 plus 3
, sind zwölf
Er hat ja aber als Paratät eine 7 bekommen,
war es demzufolge in dieser Zeit, da ist irgendwie was schiefgelaufen.
Und in diesem Fall würde sich dann in dieser Spalte dann eben auch ergeben,
das also hier als Parität dann, also eine 2 rauskommt.
Demzufolge dann also dort auch falscher Wert. So,
und die Differenz zwischen 7 und 2 ist nämlich das,
was hier verlustig gegangen ist. Das heißt,
wenn ich die 5 auf die 3 drauf addiere,
erhalte ich die 8. Das ist also im Prinzip,
also in dem Fall jetzt,
also die Art und Weise,
wie man das also beispielsweise im Dezimalsystem rechnen würde
Gut, aber das ist nur als kleiner Exkurs.
Andere Beispiele für solche Codes wären zum Beispiel so was wie der ISBN-Code.
Das ist also quasi immer diese Nummerierung, die man also in Büchern hat.
Ist seit 1970 standardisiert als ISBN-Szene, also sprich mit zehn Ziffern.
Inzwischen benutzt man eigentlich in der Regel ISBN 13,
also mit 13 Ziffern, ist sehr stark an den ERN-Code gekoppelt.
ERN ist also European Artikel Numbers, das ist im Prinzip das,
was Barcode auf irgendwelchen Sachen sind, die ich also typischerweise kaufe.
Also sprich, wenn man in den Supermarkt,
also irgendwas über den Scanner zieht, der Barcode,
das sind eher ein Nummern.
Gut, wie sind diese Codes aufgebaut? Im Prinzip
wird dort also kodiert. Also da gibt es da teilweise
einen Prefix. Dann gibt es quasi eine Art Fahno-Code,
wo jetzt also letztendlich drinsteht,
ist das
ein englischsprachiges Buch
Wird kodiert durch die Zahl 0 und 1, ist das Französisch, ist das Deutsch?
Wäre dann jeweils zwei oder drei Halszahl und für andere Sprachräume,
gibt es dann eben hier entsprechend andere Zahlen oder Zahlen,
Kombinationen, die dann eben quasi auch als,
wie so ein Fahne-Code aufgebaut sind.
Das heißt, wenn ich jetzt also irgendwie eine Vergleichsweise seltene Sprache habe,
dann wird die jetzt natürlich nicht mehr durch eine einstellige Nummer kodiert,
sondern eben durch meinetwegen drei oder vier Stellen, während Englisch
Da genügt eben nicht nur eine einzige oder eine einzige einstellige Nummer mehr aus,
sondern werden dann also sowohl null als noch eins letztendlich zur Kodierung von Englisch benutzt.
So, dann hat man im Prinzip also für den Verlag irgendwie eine Nummer,
das heißt also aus dem nächsten Teil kann man rauslesen,
welcher Verlag das ist.
Auch das wieder so eine Art Fahne-Code von 0 bis 19 ist,
also für die großen Verlage, die sehr viele Titel haben,
für die nächsten kleineren Verlage hat man dann eben die Zahlen von 20 bis 699 und so weiter.
Dann gibt es nur irgendwelche internen Nummern und das,
was uns jetzt hier eigentlich nur interessiert,
als letztes so eine Prüfziffer.
So,
wie sieht das letztendlich aus
Auch das wird dann, also quasi im Dezimalsystem gerechnet.
Das heißt, so eine ISBN-10-Zahl, also diese zehn Ziffern,
sehen so aus, dass quasi neun Zahlen als Nutzinformation dabei sind.
Die zehnte Zahl ist dann eben diese Prüfziffer. Und die
wird eben letztendlich berechnet als Summe von ILAICH 1 bis 9
mal ZE, modulo 11. Das ist dann quasi dann hinterher
diese zehnte Zahl. Und so eine ISBN-Zahl ist eben gültig,
wenn Summe ILAICH 1 bis 10 Model 11, gleich null ist.
Das heißt, wenn ich dann eben quasi nochmal die Model-Summe jetzt
also auch einschließlich dieser Prüfziffer bilde. So, Beispiel dazu,
nehmen wir also hier das Buch von Brian und Helleran,
was also hier unter anderem dann ja also auch der Vorlesungszugrunde liegt,
in dem ISBN 10 Code, ist das also letztendlich so kodiert.
Englischsprachig 2,9,2 steht also in dem Fall dann also irgendwie da
dann jetzt also für den Verlag.
Das andere ist dann die interne Nummer und die 8
ist dann also irgendwie diese Prüfsumme oder der Prüfziffer,
die sich dort ergibt
So berechnet wird das Ganze dann also einfach stumpf,
die ersten neun Zeichen, hier in diese Formel eingesetzt,
dann als einmal eins plus zweimal zwei,
plus 3 mal 9 und so weiter,
landet man bei 162. Model 11 ist 8.
Und das ist dann das, was dann also hier jetzt
als zehnte Ziffer oder als Prüfziffer hinzugefügt wird.
So, und das Dinge ist eben gültig,
wenn die Modellusumme über alle Ziffern,
Model 11
gleich Null ist
Also hier nur mal um es auszuprobieren,
wenn ich jetzt also in diesem Fall jetzt hier also auch
noch mal 162 plus 80 rechne und das Molo 11,
dann erhalte ich dann eben null.
Gut, damit kann man, also mit dieser Art von, sorry.
Genau, die Frage war jetzt, was passiert,
wenn Szenen rauskommt, wenn ich jetzt hier mit Molo 11 rechne,
dafür gibt es dann immer die Symbol X.
Also bei einigen Büchern findet man dann also in diesem Code dann irgendwo hin für den Prüfziffer,
dann also irgendwie so ein X,
das ist dann quasi das,
was dann also in dem Fall jetzt die Kodierung für
die Szenen ist
War aber schon ganz richtig erkannt, dass ich da dann,
war Model 11 auch noch irgendwie was anderes brauche.
Was dann also rauskommen könnte. So,
und was dann damit dann letztendlich machen kann, ist,
dass ich also Verfälschung Einerziffer erkenne,
weil dann also diese Prüfziffer nicht mehr stimmt,
Vertauschung von zwei Ziffern kann man erkennen.
Das ist also das, was ich also quasi hier unten mathematisch mal kurz beschrieben ist.
Also wenn sich zwei Ziffern vertauscht werden, gilt letztendlich,
dass bei der Berechnung der Prüfsumme Der richtige Fall wäre,
eh mal Ciffai plus J Malciffajord.
Im falschen Fall, wenn I und J also vertauscht worden sind,
hätte ich dann also quasi J Malciffai und E-Mail Ciffajord.
Und wenn ich dann also in der Prüfsumme rechne,
was ist die Differenz, also sprich korrekt minus falsch,
würde sich das also durch diesen Ausdruck dann eben hier entsprechend berechnen.
Und man könnte dann eben auch sagen,
was dort also im Zweifelsfall dann schiefgegangen ist.
So, Falschstopplung kann man damit also auch noch erkennen.
Ich aber das jetzt also nur mal als ein,
so ein Verfahren, was dann beispielsweise für solche Prüfziffern
genommen werden kann
Gut, so, jetzt gehen wir mal wieder vom täglichen Leben
und im Dezimalsystem zu dem, was natürlich die Informatiker glücklich macht.
Und wir sind jetzt also wieder irgendwie im Binärsystem. So,
wie kann man dort jetzt neben Even und Outcodes oder vielleicht solchen Matrix-förmigen Anordnungen,
also zweidimensionalen Prüfcodes, wie kann man dort jetzt vielleicht erreichen,
dass ich entsprechend systematisch irgendwie den Hemmingabstand größer mache,
beziehungsweise Fehler erkennen und eben auch gegebenenfalls korrigieren kann.
So die einfachste Möglichkeit in Hemmingabstand größer zu machen,
wäre eben ein Wiederholungscode. Das,
was sie also auch schon am Mittwoch kurz angesprochen habe,
also anstatt ein Bit zu senden, sende ich es dreimal.
Dreifach Wiederholungscode, beziehungsweise der Mathematiker wird natürlich mit so einer
Schreibweise glücklich. Das heißt, ich habe eine Generatormatrix,
mit der multipliziere ich mein zu sendendes Bit,
beziehungsweise mit der transformierten davon.
Hier sehe ich jetzt mal so geschrieben und aus
einer einzigen Null werden 3-0 und aus einer 1
werden drei Einsen
Wie gesagt, rein anschaulich gesprochen, ein Bit wird einfach dreifach wiederholt.
So, das kann ich eben auch als Einfach-Wiederholungsquote natürlich machen,
wenn ich jetzt also noch öfter wiederhole. So,
und je nachdem, wie gut oder wie schlecht der Kanal ist,
kann man damit natürlich dann also entsprechend große Hemming-Abstände erzeugen.
Wie gesagt, abhängig davon, wie oft ich wiederhole,
wäre das dann eben letztendlich mein Minimalabstand. So,
und Dekodierung würde dann eben quasi jetzt bei so einem Dreifach-Wiederholungscode
einfach so aussehen, dass ich sagen kann, okay,
was kann ich mir da Dreifach-Wiederholung erreichen?
Ich habe einen Hemming-Abstand von drei. Kann also einen einzelnen Einbittfehler korrigieren. Das heißt,
wenn ich Staat 000 00, 010 empfangen habe,
als ein falsches Wort, ist also die Grundidee einfach zu sagen,
Mehrheitsentscheid, zweimal 0, einmal eins, die hat verloren.
Das, was gesendet wurde, ist eine Null.
Das ist also letztendlich das, was man dort in dem Fall
dann machen würde. Und nachher bei dem Ganzen ist natürlich,
wenn ich jetzt also irgendwie eine Anzahl von Bit sende,
um jetzt nur ein einzelnes Bit zu korrigieren,
verdreifache ich in diesem Fall schon die Datenmenge.
Wenn ich jetzt also quasi noch besser werden würde,
würde ich sie ja dann für fünffachen oder, oder,
nicht ja sehen, nachdem, was man da macht,
sieht man also,
der Code ist nicht
besonders effizient
So, das, was man typischerweise macht,
sind sogenannte Hemming-Codes, das ist also ein Verfahren,
wo mit dem man also im Prinzip einen mit Fehler erkennen
und eben viele zwei oder eben auch mehr mit Fehler,
nein, nein, mit Fehler korrigieren, sorry,
und eben auch viele zwei oder eben auch Mehrbettfehler erkennen kann.
So, so ein N-Hemming-Code heißt, ich habe ein Nutzbits,
Das wäre jetzt also mein Datenwort D1 bis DN.
Die werden um K-Prüfbitz ergänzt. P1 bis PK.
Und ich hatte eben einen insgesamt Code-Wort der Länge Großen,
was dann logischerweise Endplusgabe et beinhaltet. So,
und ich kann jetzt eben sagen, um eine Fehlerkorrektur zu machen,
brauche ich entsprechend so viele Bits,
dass letztendlich gilt,
zwei hoch K ist größer gleich N plus
So, woher kommt das oder woraus ergibt sich das?
Da kann man sich also folgendermaßen überlegen. Also ich habe
letztendlich N-Not-Spits mit meinen N-Not-Spits habe ich zwei hochkamen gültige Worte.
Nee, Blödsinn, sorry. Also ich habe einen Nutzpits
und Andersrum. Also DSN ist ja N plus K,
plus 1. Ich höre jetzt mal, also in meiner Anzahl von Nutzbits,
sorry, habe ich jetzt falsch angefangen.
Also ich habe jetzt mal eine Nutzbits N und ich möchte
jetzt eine Fehlerkorrektur darauf anwenden und die Frage ist jetzt,
wie viele Prüfbitz brauche ich, um eine Fehlerkorrektur hinzukriegen.
Das heißt, wie groß muss dieses K werden?
Und das ergibt sich dann eben letztendlich hier draus,
weil wenn ich insgesamt Jetzt K-Prüfbitze hinzufüge.
Muss ich mit diesem Prüfbitz ja letztendlich irgendwie darstellen oder kodieren
können. Es ist entweder gar kein Fehler aufgetreten.
Oder ich habe einen Fehler in meinen Bits,
die jetzt insgesamt übertragen worden sind und die muss ich irgendwo darstellen können.
Das heißt, ich muss jetzt also sagen,
also in dem zweiten Bit oder in dem achten Bit oder
in dem Bit
ist ein Fehler aufgetreten
Nicht daraus ergibt sich, dass ich in Bittfehler irgendwie aufzählen
können muss mit meinen Nutzbits oder mit meinen Prüfbits. So,
und ich daraus ergibt sich dann eben letztendlich diese Unleichung,
dass also quasi dieses K so zu wählen ist,
dass 2 hoch K eben größer gleich N plus 1
ist und N ist dann eben letztendlich dann wieder
die Summe aus N plus K. Oder kleinen N plus Kleinkern
Das ist das, was jetzt erst mal gilt,
um zu sagen, wie viele Prüfplätze werden hinzugefügt.
So, und wie macht man das jetzt bei diesem Hemming-Coach?
Also als erstes bestimmt man, also überhaupt erst mal dieses K, was ich brauche. Das heißt,
also es gilt eben,
wenn ich jetzt also hier diesen Ausdruck nehme und dann eben zwei Hochkargrößer gleich N plus K plus 1 habe,
dass ich entsprechend umforme, gilt dann eben N-Planer gleich,
zwei hochkam minus K minus 1. Das heißt,
damit wird jetzt also quasi erst mal festgelegt,
wie viel Prüfbitz, Car brauche ich,
wenn ich jetzt einen kleinen N-Nutzbitz habe.
So, und dann werden die Bits jetzt im Prinzip der
Reihe nach an Positionen von 1 bis N irgendwie verteilt.
Und zwar so, dass man sagt, die Prüfbitz sind jetzt
jeweils an den Positionen, die quasi den Zweierpotenzen entsprechen.
Das heißt, das erste Prüfbit ist also an der ersten Stelle,
das zweite Prüfbit ist an der zweiten Stelle,
also 2 hoch 0, 2 hoch 1.
Das dritte Prüfbit ist an der dritten Stelle,
also ist Blödsinns anderer Position 4,
also sprich 2 hoch
Bit 4 würden anstelle 8, nämlich 2 hoch 3
letztendlich eingebaut werden und so weiter. So,
und anschließend kommen dann die Anzahl der Nutzbits, erstes,
zweites, drittes, viertes, fünftes, hier entsprechend mit rein.
So, und dann kann man jetzt eben sagen,
ein Prüfbit I, also meinetwegen jetzt hier P1,
wird berechnet als Modulo 2-Summe, der Bits,
der im Positionsnummer eingesetzt ist, wird hiervon enthält.
Was heißt das einfach rein praktisch? Also ich habe jetzt hier
mein Prüfbett an der Position 1. Das heißt, das wird gebildet,
indem ich dann quasi alle ungeraden Positionen mit dem X-Or verknüpfe.
Das heißt also, prüfe mit 1, ergibt sich aus
Datenbit 1, X-Or-Datenbit 2, X-Or-Datenbit 4. Das heißt also,
wenn ich jetzt hier quasi diese Position einfach binär hinschreibe,
all die Position, wo hier die Eins gesetzt wird.
Das ist also das, was letztendlich dann hier steht für Prüfbitt 1. Prüfbitt 2,
letztendlich genau das Gleiche, entsprechendste Position 2 hoch 1.
Das heißt, überall bei den Datenwits,
wo ich an dieser Stelle jetzt eben in dem zweiten Bit eine Eins habe,
das wird zur Berechnung von Prüfbitt 2 hinzugezogen.
Also Datenwitt
3 und 4, nicht als nächstes,
wurde dann also im Prinzip hier hinten dann wieder 6 auftauchen,
was jetzt also hier nicht mehr auf der Folie mit drauf ist und so weiter.
So, das ist also die Art und Weise,
wie man jetzt also quasi bei dieser Anordnung von dieser Nummerierung
der Position und dem Vertanen der Prüfpitz dann eben dazu kommt,
wo jetzt welche Datenwits sind und wie sich daraus dann diese Prüfsummen berechnen.
So, hier ist das Ganze jetzt nochmal für den Fall,
also dann bis zu Fünf Prüfbits gezeigt.
Hier unten werden jetzt die Formeln für drei und für vier Prüfbits,
das für den Fall 5 steht jetzt hier,
also nicht mit drauf auf der Folie.
Hier mit diesem farbigen ist eben auch nochmal versucht, so ein bisschen zu veranschaulichen,
welche von den Positionen jetzt hier für welche Berechnung hinzugezogen werden.
Das heißt, wenn ich jetzt ein 7-4-Hamming-Code habe,
heißt das, ich habe vier Not-Spits, Das heißt,
hier in der Folie würde das jetzt letztendlich ab dieser Stelle abgeschnitten werden.
Also das heißt also, nur dieser vordere Teil,
hier gilt für diesen Code. Ich habe vier Nutzbits,
die 1, die 2. 3D 4 und ich habe drei Prüfbits,
mache zusammen sieben Bits, deswegen sieben, vier Hemmingcode.
So, Prüfbit 1 berechnet sich eben aus Datenbit 1,
exklusiv oder Datenbit 2, exklusiv oder Datenbit 4,
prüft Bit 2 aus 1, 6, 3, XR,
D4 und 3 wurde sich dann eben aus, die zwei,
XR, die drei, XRD 4 heraus berechnen. So,
und damit kommen wir jetzt eben zu dieser Frage,
was vorhin her also gekommen ist,
wie kriege ich jetzt eben bei mehreren Daten,
wird es dann eben eine Fehlerkorrektur hin und das ist dann letztendlich über so ein Verfahren gemacht,
weil das, was man damit erreicht, ist,
dass wenn sich hier jetzt in diesem Code ein einzelnes Bit ändert,
kann ich aufgrund dieser drei Prüfbits eben genau sagen,
welches Bit sich geändert hat,
egal ob das in Daten wird oder das Prüfbitsel oder eins von den drei Prüfbits war,
das entsprechend wieder korrigieren.
Wie gesagt, für den 7-4-Hemming-Code ist das also letztendlich dieser vordere Tal.
Ab hier, für den 15-11, Hemming-Code,
das ist dann quasi ab hier und dann eben der linke Tal.
Und hier dann eben entsprechend das, was man dort dann
also berechnen würde. Wie gesagt, also hier sind dann
immer die jeweiligen Anteile entsprechend markiert
Gut, rein praktisch rechnet man sowas dann natürlich immer schickerweise mit Matrizen. Das heißt,
das, was man macht, ist aus diesen Ausdrücken eine Matrix zu bilden,
die letztendlich jetzt folgendes ansagt, also jetzt hier für diesen linearen 7,4 Hemmingcode,
würde sich die Matrix so ergeben,
dass Hier letztendlich jetzt gesagt wird, für ein einzelnes Bit,
von welchen anderen Bits in meinem Wort, das letztendlich dann abhängig ist.
Das heißt, um jetzt also quasi hier herauszulesen,
wie jetzt also hier beispielsweise sich diese Zeile dieser Matrix ergibt,
müsste man jetzt eben quasi gucken, dass erste Datenbit,
was ich hier quasi jetzt habe,
taucht eben auf bei der Berechnung von Prüfbit 1,
taucht auf bei der Berechnung von Prüfbit 2,
taucht nicht auf bei der Berechnung von Prüfbit 3 und das Bit selber muss auch noch übertragen werden.
Das heißt, 1, 1, 0, 1 ist dann,
also letztendlich das, was dann also hier für dieses erste Bit gilt.
So entsprechendes macht man dann eben hier auch für die jeweiligen anderen Positionen.
Und wenn ich dann also diese Matrix aufgestellt habe,
kann man eben sagen, Codewort wird dann also quasi einfach
durch den Matrix-Multiplikationen von dieser Generator Matrix und meinem zu prüfenden Wort erzeugt.
Genauso kann ich dann eben auch eine Prüfmatrix erstellen,
die dann eben letztendlich oder für die dann eben gilt,
dass Prüfmatrix mal dem kodierten Wort gleich null ist,
wenn das ein gültiges Wort ist, wenn das Ergebnis Ungleich,
null ist, dann wird im Prinzip letztendlich hierüber die Stelle,
an der der Fehler aufgetreten ist, kodiert.
Und diese Kodierung, es sagt halt, ist letztendlich,
wenn man sich das ansieht, nichts anderes als die Kombination.
Eins, zwei, drei, vier, fünf, sechs,
sieben, wenn ich das jetzt also quasi jetzt einfach als binär zahle interpretiere und sage,
dies ist die niederwärtigste, dies ist die höchstwertigste Stelle.
Und wie gesagt, der Fehler freie Fall ist dann eben mit der Null kodiert.
So, mit diesem Dieser Prüfmatrix berechne ich ein sogenanntes Fehlersyndrom.
Das heißt, damit bestimmt man eben, an welcher Stelle
der Fehler aufgetreten ist. Gut, solche Hemming-Codes werden,
umso besser, je größer die Wortlängen werden, dass sie,
sah man im Prinzip letztendlich, also auch schon hier drin.
Nicht, weil wenn ich also ein 7-4-Hemming-Code habe,
um das also quasi jetzt zu codieren, brauche ich für vier Nutzbits drei zusätzliche Prüfbits.
Beim 15-11-Hemming-Code habe ich dann eben schon elf Nurds-Bits,
die mit 15-Bits kodiert werden,
die schon in diesem Fall hätte ich dann also hier ein 31-26-Hamming-Code,
wo ich dann eben mit 31-Bit 26 Nurds-Bits kodieren kann.
Gut, also das ist im Prinzip jetzt eine Vergleichsweise einfaches Verfahren,
auch noch weit von dem entfernt, was ist das immer so,
die wirklich guten Fehlerkorrekturverfahren machen, aber wie gesagt,
da müsste man dann auch noch deutlich weiter in die zugrunde liegende Mathematik,
also diese GF2-Felder einsteigen, um das dann zu machen.
Gut, kommen wir jetzt aber hier noch mal zum praktischen Beispiel,
war es jetzt also mit dieser Generator-Matrix und mit dieser Prüfmatrix eigentlich gemeint ist.
Also wir haben als Datenwort, was übertragen werden soll, 0110.
Ich habe jetzt also hier diese Generator-Matrix,
mache dann also hier eine Matrix-Multiplikation und berechne,
also hier quasi jetzt als Prüfwort, dieses hier
100110. Verfahren ist standardmäßig Matrix-Multiplikation, Zeile, mal schmalte,
ist diese Position also ein, mal null, ist null,
ein, mal eins ist eins, ein, mal null,
ist null, und hier wieder ein, mal null.
Snull macht in der Summe eins, das ist genau diese
A1. Wie gesagt, mathematisch Multiplikation und Addition wird letztendlich ersetzt durch
Und als Multiplikation und exklusiv oder als Addition. Gut,
genau das Gleiche macht man dann eben hier, Zeile,
mal Spalte, dann eben jeweils für die entsprechenden Positionen hier.
Und damit erhält man dann letztendlich jetzt hier diese gesamten Vektor,
der dann also in diesem Fall übertragen wird. So,
und was also hier jetzt eben auch der Fall ist,
ich hatte ja gesagt, dass es dann eben ein,
wo waren jetzt hier diese Beschreibungen
Begriffe, das ist ein systematischer Code, das heißt,
die zu kodierende Information ist direkt als Substring in dem Codewort enthalten.
Wo ist das jetzt hier der Fall?
Nicht in diesem Fall wäre das das dritte fünfte,
sechste und siebte Bit. Das heißt, null,
1-1-0 und dieses Bild Dieses Bild und dieses hier,
wenn dann eben die drei Prüfplätze, die dann hinzugefügt worden sind.
Entsprechend die Sahnordnung. Also das ergibt ja dann hier diese Verschränkung.
Gut, das ist mein Wort, was übertragen wird.
Wenn ich das jetzt prüfen würde,
nehme ich jetzt also hier entsprechend meinen Prüfmatrix,
berechne dann eben dieses Maldemo und erhalte dann hier jetzt also
in diesem Fall als Prüffektor Null
Wurde gültig übertragen, was passiert, wenn ich einen Fehlerfall habe.
Es wurde ein einzelnes Bit verändert, in diesem Fall,
also jetzt meinetwegen hier das dritte Bit.
Wenn ich jetzt wieder Prüfmatrix mal dem übertragenen Wort habe,
erhalte, multipliziere, erhalte ich dann eben quasi als Ergebnis die Bits 1-1-0. So,
und Mitte 1-1-0 wird jetzt nämlich quasi,
wenn ich jetzt hier diese Prüfmatrix nehme,
hier mit 1-1-0 kodiert,
Index 3, Also sprich,
genau dieses einzelne Bit wurde verändert und man hat damit also letztendlich hiermit nichts anderes als eine Indizierung der Fehlerstelle gemacht.
Nicht, das ist eigentlich die Grundidee,
die man da hat, beziehungsweise eben die Grundidee von dem,
wo ich ja so anfangs also versucht habe zu erklären,
wie viele Prüfbitz brauche ich.
Das ergibt sich eben dadurch, dass ich letztendlich kodieren muss,
an welcher Stelle in meinem Wort ist ein Fehler gekippt,
beziehungsweise null markiert dann eben,
dass kein Fehler aufgetreten ist
Gut, ja, das zu dem Hemmingcodes.
Dann kommen wir jetzt noch mal zu den Begriffen der Fehlerrate.
Wie gesagt, da geht es jetzt ja darum,
dass man sagt, okay, was passiert jetzt,
wenn ich also über einen Kanal jetzt also meine Informationen übertrage.
Ich habe jetzt eine bestimmte Bittfehlerrate,
das heißt mit einer bestimmten Wahrscheinlichkeit wird jetzt
eben ein Bit von 0 nach 1 bzw. von Arzt
nach 0 kippen
Generell kann man jetzt erst mal sagen, für Hemmingcodes,
das, was ich damit mache, ist,
dass ich letztendlich jetzt einzelne Bitfehler passend korrigieren kann,
was man eben nicht machen kann, ist,
wenn jetzt also entsprechend mehr Fehler auftreten, die dann korrigieren.
So, und jetzt ist ja die Sache,
wenn ich also jetzt einzelnen Witz über den Kanal übertrage,
ich habe eine gewisse Bittfehlerwahrscheinlichkeit,
ich übertrage jetzt ein ganzes Wort an Daten,
wie ist dann also letztendlich die Fehlerwahrscheinlichkeit generell,
wie es in der Übertragung in diesem Kanal,
also sprich jetzt für dieses gesamte Wort.
So, da hatte ich ja schon am Mittwoch eben eingeführt,
nicht was gilt dann, also letztendlich jetzt in den hinsichtlich der Rechenregeln,
die sich da jetzt also für die stocherzischen Modelle geben.
Und das war ja dann also quasi mit diesem Logo Rhythmischen Mars.
Das heißt, da würde man in dem Fall dann eben entsprechend
die Summe der Wahrscheinlichkeiten, als Wort Fehlerwahrscheinlichkeit dann letztendlich zusammennehmen.
So, und das, was hiermit jetzt eigentlich nur ausgedrückt ist,
wie gesagt, die Formen, die sich dahinter ergeben,
will ich jetzt also gar nicht genau ausführen.
Also was hiermit jetzt eigentlich nur ausgedrückt ist, ist,
dass man sieht, also ich habe jetzt hier in meinem Kanal eine Bittfehlerrate,
geht dann eben von 0 bis 0,5.
Ich würde jetzt also hier meine Informationen übertragen in so einem 7-4 Hemmingcode,
wenn ich jetzt nur die vier Nutzpits übertrage und keinerlei Fehlerkorrektur mache,
würde sich also letztendlich dann also hier diese lineare Kurve ergeben,
wo dann also letztendlich mit der Länge oder mit ansteigender Bittfehlerrat
dann eben entsprechend also auch die Wortfehlerrate dann entsprechend stark ansteigt
und zwar in diesem Fall dann linear
Wenn ich jetzt so ein 7-4-Hamming-Code habe,
kann man eben sehen, dass ich,
also hier für einzelne Bit und dann eben für das Gesamtwort hier irgendwo bei einem sehr kleinen Bit-Fehler raten,
also einen Bereich habe,
wo ich dann eben letztendlich in der Fehlerkorrektur für das gesamte Wort was erreiche,
weil das, was hier eben auch passiert, ist,
dass ich aus Vierbit auf einmal Siebenbitt mache,
wenn ich hier jetzt jeweils identische Bittfehler raten habe,
wird natürlich für die Siebenbitt
Die Wahrscheinlichkeit, dass in einem Gesamtwort,
was jetzt nicht mehr aus vier, sondern aus sieben Bit passiert,
die Wahrscheinlichkeit, dass dort ein Fehler auftritt, erst mal größer.
So, und das, was man hier eben sieht,
ist eigentlich so ein Trade-off zwischen Verlängerung des Wortes,
mit dem Verfahren und dem Gewinn,
den ich durch die Fehlerkorrektur habe.
So, und der Gewinn wirkt sich eben wirklich nur bei
sehr klein mit Fehlerraten aus.
So, das ist eigentlich alles das,
was man jetzt also nur so rein plakativ aus dieser Folie
herauslesen kann
Gut, wie gesagt, 7, 4 Hamming-Code, also vergleichsweise einfacher Code.
Jetzt sind hier mal irgendwie so andere Codes, wo eben
auch das Verhältnis von Datenwitz zu Codewortlänge dann eben irgendwie größer wird.
Also dass wir jetzt hier ein Code,
wo ich also quasi zwölf Nutzbits um elf Prüfbits ergänze und
dann eben insgesamt 23 Bit übertrage, nicht?
Und dann sieht man eben schon,
dass ich also hier jetzt also wirklich mal irgendwie so einen Bereich gibt,
wo ich also letztendlich alles an Fehlern erstmal korrigieren kann,
dann aber eben ab irgendeiner steigenden Bittfehlerrate im Kanal eben auch irgendwelche Wortfehlerraten auftreten.
Und wenn also die Kanalbildfehlerrate größer wird, bin ich dann natürlich,
also hier dann auch irgendwann wieder schlechter als das, was ich habe.
Wenn ich jetzt nur die zwölf Bitte übertrage und nicht die 23 spielt.
So extrem wird das dann bei solchen Sachen,
wo ich sage, okay, ich habe acht Nutzbits,
übertrage 2048 Bit, die ich jetzt mit irgendeinem Verfahren generiert habe.
Und da kann man dann eben wirklich sagen, okay,
also bis zu einer bestimmten Bitfehlerrate kann ich damit dann wirklich erstmal alles ausgleichen.
Irgendwann danach versagen alle diese Verfahren. So, das ist eigentlich das,
was man dann auch immer nur rauslesen kann. Gut,
ja, also das zu dem Begriff der Fehlerrate,
dann wird jetzt nochmal ein anderes Verfahren vorstellen,
was auch relativ häufig genommen wird zur Fehlerkorrektur,
wo was im Prinzip dann auf diesen Begriff abzieht,
den ich mal wieder zu den Begriffen zurück
Hier dann nämlich als Faltungscode beschrieben habe,
wo ich also quasi einen Bittstrom habe,
der also in einen anderen Bittstrom einer höheren Bittrate kodiert wird.
Das passiert dann eben beispielsweise bei diesen Verfahren,
die dann also im Prinzip so CAC-ähnlich eigentlich auf Binärpolynomen rechnen.
Was ist damit gemeint? Auch dahinter steckt dann wieder vergleichsweise
viel Mathematikel. Die Idee ist, dass man sagt,
ich habe ein N-Bit-Wort
Und dieses N-Bit-Wort stellt eigentlich eine Kurzschreibweise oder eine Kodierung,
sind es Polynom-Star. Das heißt also hier dieses Wort 1 0011101,
steht quasi jetzt für ein Polynom eigentlich einmal X-Such 6,
0 mal X-U5, 0 mal X-U4,
einmal X-Uch 3, einmal X-Uch 2. Das heißt also,
dieses Wählen ist die Koeffizienten, einfach jetzt so eine polynomialen Ausdrucks.
Also sprich, so war es.
Rein formal gesehen ist es dann also auch noch nicht eindeutig,
also ob ich jetzt mit X und 0 bis X bis 6
gehe oder saube ich jetzt hier die Indizis noch anders wähle,
wie auch immer.
Und mit diesen Polynomen kann jetzt eben auch gerechnet werden,
unter anderem gibt es daran eben auch die Funktionalität so einer Division vom Polynomen untereinander.
Auch das geht also auf die Theorie von diesen Galoir-Feldern dann
wieder zurück. Und das führt dann zu den Codes,
die eigentlich dem zugrunde liegen,
was uns in der Informatik dann immer unter diesem Stichwort CAC-Check,
Suclec Creedon,
Seecek begegnet
Rein formal, mathematisch ist das dann eben im Prinzip so was wie so eine Polynom-Division,
wo ein zyklischer Code, wo also Codewörter durchschieben und Modifikation,
das heißt XO an bestimmten Stellen ineinander überführt werden.
Und das damit errechnet man dann quasi eine Art Prüfsumme. Und je nachdem,
an welchen Stellen in diesem Polynom ich das mache,
beziehungsweise was ich jetzt hier als Coach beziehungsweise in diesem Fall dann als Äquivalent eigentlich als Generatorpolynom wähle,
erhalte ich dann eben etwas, womit man eben solche Fehlerkorrekturen dann auch machen kann.
So, die Dinger werden also relativ häufig auch benutzt,
unter anderem also zum Beispiel im Ethernet-Protokoll,
in Kompressionsverfahren wie Zipp ist das mit drin,
in Bildkodierungen, also PNG als Bilddateien enthalten,
im Prinzip unter anderem dann also auch noch sowas mit Verschiedene von diesen CRC-Kurzs werden dann eben auch in anderen Protokollen,
also im USB-Protokoll ist was in Hardware mit drin, ESDN,
okay, das macht heutzutage keiner mehr in den Funknetzen,
im GSM ist es im Prinzip mit drin oder auch in einigen Verschlüsselungssachen.
So, und das ist also etwas,
was also relativ häufig benutzt wird,
wenn man da jetzt also mal nachguckt,
was es da eigentlich alles gibt,
wo das benutzt wird,
wird man also
vergleichsweise viel in der Literatur bzw. beim Internet
danach sucht
Passend finden. So angesichts der fortgeschrittenen Zeit werde ich jetzt also an dieser Stelle Schluss machen.
Darfst du noch mal grob von einer Idee,
wie man diese Polynome berechnet, warum das also so häufig benutzt wird,
werde ich dann also noch nächsten Mittwoch vorstellen,
allerdings auch nur ganz kurz die Idee skizzieren,
jetzt dass sie nicht weiter sagen,
warum das so gut funktioniert.
Damit allen ein schönes Wochenende und dann bis nächsten Mittwoch