So, Pima, ja doch, blinkt immer noch.
Sorry, ich dachte, jetzt ist wieder ein neues Gerät,
das sich immer ein bisschen besser verhält, aber das Mikrofon scheint da immer noch reinzustrahlen.
Vorweg nur noch mal kurz als Erinnerung mit nächster Woche,
sprich den Montag, beginnen die ersten Praktikagruppen. Diejenigen,
die sich also in den entsprechenden Gruppen eingeschrieben haben,
ich sah also dann nur noch mal daran erinnert, Wichtig ist eigentlich immer,
dass man sich vorbereitet, weil sonst ist es einfach zeitlich nicht zu schaffen.
Und was man dann auch immer noch machen sollte,
ist, sich dann eben wirklich den Zettel,
was dann logischerweise zur Vorbereitung gehört, von der Praktikums-Webseite,
was dann im Prinzip hier auch über die Den Webbrowser entsprechend erreichbar ist,
dass man sich da dann eben entsprechend die Unterlagen dann vorher runterlädt und ausdruckt,
weil wie gesagt, wenn man dann also vor Ort da ist,
also da noch nicht mal den Zettel dabei hat,
dann ist das immer relativ schlecht.
Beim ersten Versuch haben wir mal eine Ausnahme gemacht,
das heißt, da kann ich nur sagen, diejenigen,
die jetzt also nächste Woche mit dem Praktikum anfangen,
können sich den Aufgabenzettel zu Versuch 1,
den Manfred Grove, der das Praktikum, also dann anbietet,
schon entsprechend oft ausgedruckt hat bei uns im Sekretariat,
also sprich im Informatikum in Haus F im dritten Stock.
Nee, im zweiten Stock, also in 300er Raumnummern dann ebenentsprechend abholen.
Gut, dann zu den Rechnerstrukturen bzw. zu den Übungen.
Ich habe ja am Wochenende, sagen wir mal,
so eine Rundmail losgeschickt, wo ich jetzt gedacht habe,
naja gut, also es ist nun eigentlich ein bisschen blöd,
so was dann also irgendwie hinterher zu machen.
Die Sache war jetzt bloß,
ich habe Also dann auch die Musterlösung erstellt,
die ist ja dann irgendwann also auch nochmal komplett am Block geben wird,
die dann also entsprechend dann verteilt werden,
sodass sie dann eben die auch nochmal nehmen können,
um jetzt zu sehen, wie jetzt entsprechend zu den jeweiligen Aufgaben oder Aufgabentypen man vorgeht.
Dort ist dann also auch wirklich nochmal sehr ausführlich erklärt,
welche Ideen dann teilweise dahinter stehen.
Und jedenfalls also bei der Stellung dieser Musterlösung habe ich dann also festgestellt,
anscheinend ist es die Jahre vorher immer nie aufgefallen,
weil also zumindest diese Art von Aufgaben hatten wir dann schon
Mit drin, habe ich nur festgestellt,
dass dort im Prinzip dann was verlangt wird,
zumindest für den Aufgabenteil 5, 4D,
was man sich zwar sagen wird,
mit ein bisschen gesunden Menschenverstand eigentlich dann auch entsprechend überlegen kann,
was aber also formelmäßig jetzt also nirgendwo auf den Folien auftauchte und einfach nur,
um jetzt also eben fairerweise dann zu sagen, na gut,
es sollen ja dann natürlich auch alle irgendwie dann möglichst in die Lage versetzt sein,
also aufgrund dessen, was vorher bekannt gemacht wurde,
die Aufgaben zu lösen, wobei sie da dann sowieso auch noch bis Freitag Zeit haben,
hatte ich dann also nochmal diese Mail rumgeschickt.
Letztendlich ging es dabei,
ja darum, dass ich im Prinzip eingefühlt hatte,
den Begriff der Entropie, was sich dahinter verbirgt,
dass das eben eine Eigenschaft der entsprechenden stochastischen Verteilung ist.
Das heißt, wie häufig tauchen welche Ereignisse auf,
beziehungsweise mit welcher Wahrscheinlichkeit
Und in den Aufgaben ging es dann ja darum zu sagen,
gut, auf der einen Seite habe ich eben letztendlich die Entropie,
auf der anderen Seite habe ich dann also jetzt für
mein Ereignis oder für meine Symbole irgendeine Art von Kodierung.
Und oft ist es ja so, beziehungsweise dann vielleicht auch gewollt,
das werde ich nun also heute noch vorstellen,
dass die Kodierung Redundanz aufweist. Das heißt,
dass man eben deutlich mehr Bits oder Informationen quasi in die Kodierung parkt,
als ich eigentlich letztendlich für die Symbole benötigen würde.
Und dazu braucht man da quasi jemals Begriff,
den möglichen Informationsgehalt, also dieses H0,
war es im Prinzip jetzt also in der Symbolkodierung quasi eigentlich,
sagen wir mal, so einer gemittelten Kotwortlänge entspricht.
Das heißt, dass ich letztendlich ähm,
formal jetzt berechne über einem äh, Alphabet mit Kuhzeichen,
Logerhythmus, Duales von Kuh hoch. LI,
L ist dann quasi jetzt jeweils die Länge eines Codeworts und
das dann eben mit der entsprechenden Wahrscheinlichkeit für dieses Codewort
oder für dieses Symbol PI multipliziere,
also sprich Wichte und das Ganze dann eben
auch summiere
Gut, wir betrachten jetzt natürlich bei uns immer keine Kuhnähe an Alphabete,
sondern also Alphabete mit genau zwei Zeichen, also Bienehre.
Und dort gilt dann eben einfach, dass es also letztendlich
nichts anderes ist, als die Summe PI mal LI,
also sprich die Länge des Codeworts gewichtet,
mit dessen Wahrscheinlichkeit und das dann über sämtliche Kotworte aufsummiert.
Wie gesagt, das bräuchte man dann eben für kurz,
wo ich jetzt unterschiedliche Wortlängen habe.
Das heißt also, dann eben irgendwie sowas wie Codierung,
die ich jetzt also im Prinzip mit dem Hafen in Baum
oder entsprechend jetzt eben als Farno-Code erzeugt habe.
Bei binären Blockcodes, das ist eigentlich das, was man
in den ganzen ersten Aufgabenteilen dort dann immer benötigen würde.
Die Formel steht dann aber oder stand auch schon immer auf den Folien,
gilt dann natürlich, dass da einfach im Prinzip H0
die Länge der entsprechenden Codierung ist.
Also Hannold Leichen. Gut, Redundanz hatte ich dann ja
letztes Mal dann eben schon entsprechend eingeführt
Jetzt werde ich noch mal auch erst mal aus diesem Bereich
der Informationstheorie noch mal ein bisschen was sagen zur Kanalkodierung.
Da geht es darum, dass ich meine Informationen jetzt
ja auch irgendwo übertragen möchte. Das heißt,
auch dort kann man eben entsprechende formale mathematischen Methoden anwenden,
um jetzt also für die Datenübertragung,
über irgendein Medium oder irgendeinen Übertragungskanal dann eben zu berechnen,
wie sich die Kodierung letztendlich auf die übertragene Information auswirkt.
Entscheidend ist dabei eben die Tatsache, dass also bei dieser Datenübertragung,
also jetzt real quasi die Übertragung irgendwie gestört werden kann.
Und also auch für diese Störung kann man dann eben
ein mathematisches, also ein stochastisches Modell angeben. Als,
sagen wir eigentlich, zentrales Resultat ergibt sich dann eben,
dass Übertragung oder die Übertragungsleistung eines Kanals dann eben auch irgendwo begrenzt ist.
Das heißt, dass ich eben nur eine gewisse Menge an Informationen
jetzt über physikalisches Medium oder was auch immer übertragen kann.
Und dass man dann eben letztendlich sagt,
also pro Binärstelle kann ich dann eben bei einer begrenzten Kanalkapazität
dann eben eigentlich auch nur einen gewissen Informationsgehalt übertragen,
der dann eben davon abhängig ist, wie sich jetzt also hier dieses Fehlerverhalten in diesem Kanal darstellt.
Das heißt, wenn der Kanal keinerlei Fehler aufweist,
kann ich dann eben pro Binärstelle dann auch wirklich ein mit als Information übertragen,
wenn der Kanal dann eben quasi auch eine entsprechende Entropie größer als Null aufweist,
habe ich dann eben Störung und muss quasi auf Empfängerseite damit leben,
dass ich also über geeignete Maßnahmen quasi entweder die Informationen rekonstruieren
kann oder eben überhaupt erst mal feststellen kann,
dass dort Fehler bei der Übertragung aufgetreten sind
Wie gesagt, ganz am Anfang, im vierten Kapitel hatte
ich also schon mal dieses Grundmodell der Informationen zu übertragen,
wo man sagt, also Informationen hat jetzt irgendwo eine Quelle.
Das Ganze wird dann also senderseitig jetzt irgendwie kodiert,
läuft dann also durch irgendein physikalisches Medium als Übertragungskanal.
Dort können dann eben solche Störungen auftauchen und wird dann eben
entsprechend woanders wieder dekodiert und dann entsprechend weiterverarbeitet
So, wenn man sich jetzt Datenübertragungen dann auch wieder jetzt über irgendwelche Mechanismen überlegt,
wo ich jetzt das Allereinfachste Modell ihm erstmal sage,
ich habe jetzt also wirklich nur eine reine Binäre Übertragung,
das heißt eben Folgen von Nullen und Einsen mit bestimmten Wahrscheinlichkeiten der Symbole,
wo ich jetzt erstmal sage,
die Symbole 0 und 1 sind gleich wahrscheinlich.
Und es gibt dann eben eine Wahrscheinlichkeit, P,
die dann eben sagt, das war diese Übertragung an Fehler auftreten kann.
Auch jetzt erstmal vereinfachand angenommen,
nehme ich jetzt eben auch gleich wahrscheinlich die beiden Arten von Fehlern an,
nämlich einmal das aus einer 0-1-1 wird
und das ist eine 1-1-0 wird.
Und was logischerweise natürlich auch noch gilt,
ich betrachte jetzt immer voneinander unabhängige Ereignisse. Das heißt,
für jedes übertragene Bit habe ich dann eben entsprechend dieser Wahrscheinlichkeit
dann die Möglichkeit eines Fehlers und beim nachfolgenden Bit unabhängig davon,
können dann eben wieder entsprechende Fehler auftauchen. So,
wenn man sich jetzt das in diese Formel für diese Entropie eingesetzt vorstellt,
kann ich jetzt eben sagen,
für das Fehlerverhalten gilt quasi als Entroopie,
dass ich eben entsprechend dieser Wahrscheinlichkeit P einen Fehler habe,
nach der Formel für den Informationsgehalt bzw. eingesetzt für die Entropie,
wäre das dann eben P mal Logarithmus,
du alles von 1 durch
Plus, dementsprechende Gegenerereignis, nämlich,
dass ich keinen Fehler habe, also eins, minus P,
mal Logarhythmus, du alles von eins durch eins,
minus P, das beides zusammengefügt,
er gibt dann eben quasi jetzt für diese beiden Ereignisse entweder,
oder für diese, ja, doch auch für Ereignisse,
nämlich entweder ein Fehler tritt auf oder ein Fehler tritt nicht auf,
die entsprechende Entropide des Fehlerverhaltens.
So, die Kanalkapazität, Formel hatte ich ja vorhin schon,
ist dann quasi eins,
minus dieser Entropie
Wie sieht das Ganze grafisch geplottet aus?
Das wären im Prinzip diese Kurve, wo ich also hier unten
die Bittfehlerwahrscheinlichkeit zwischen 0 und 1 habe.
Und hier jetzt quasi als Bits probinärstelle eigentlich die Information,
logischerweise habe ich,
wenn ich jetzt eben eine Bildfehlerwahrscheinlichkeit von null habe,
als Kanalkapazität
Minus. Der Entrubi 0, also das heißt genau eins.
Wenn ich die Bit-Fehler-Wahrscheinlichkeit von 0,5 habe, das heißt mit
der Wahrscheinlichkeit von 50 Prozent wird auch nur eine einzeln umgekehrt.
Kann ich letztendlich sagen, empfange ich eigentlich nur Rauschen,
weil das wirklich nur beliebig verteilt ist.
Nicht die Kurve ist im Prinzip nichts anderes,
also hier zur Kanalkapazität,
also eins minus H von F als quasi der umgerechnete Wert
jetzt hier für die Entropie eines binären Kanals,
wo ich das dann eben nur entsprechend mit 1 minus diesem Wert hier abgezogen habe.
Gut, hier das Ganze jetzt also nur noch mal in
Worten noch mal so ein bisschen weiter beschrieben.
Also wie gesagt, bei Wahrscheinlichkeit 0,5 ist Skandalkapazität null,
hatte ich ihm gesagt.
Der Sender kann also die empfangene Daten nicht
von irgendwelchen zufälligen Sequenzen unterscheiden
Auch nur rein akademisch, wenn also die Wahrscheinlichkeit,
dass Fehler auftreten, wieder größer wird als 0,5,
stark die Kanalkapazität wieder ahnen.
Weil ich dann einfach mit einer größeren Wahrscheinlichkeit dann eben weiß,
dass die Bits immer invertiert werden. Und dann kann ich natürlich sagen,
wenn ich beim Empfänger jetzt also einfach alle Bits invertiere,
dann habe ich zumindest mit einer gewissen Wahrscheinlichkeit dann also irgendwie wieder was Richtiges empfangen.
Letztendlich kann man aber jetzt eben erstmal sagen,
also aufgrund dieser Überlegung zur Entropie, die Kanalkapazität ist,
ist quasi sowas wie eine obere Schranke
Die jetzt eben aufgrund irgendwelcher physikalischen Eigenheiten,
die dann also quasi jetzt diese Fehlerwahrscheinlichkeit, Groß-P beeinflussen,
sagt, wie viele Informationen ich jetzt also wirklich durch meinen Übertragungskanal bringen kann.
Nicht rein praktisch wird man natürlich dann also irgendwie immer unter
dieser oberen Schranke überhaupt erst mal bleiben oder bleiben müssen.
Nicht die Frage ist jetzt immer noch,
nichtsdestotrotz habe ich natürlich also eine gewisse Entropie oder Fehlerwahrscheinlichkeit.
Und die Frage ist jetzt erst mal,
wie kriege ich oder mit welchen Mitteln kriege ich jetzt
eben fehlerfrei Übertragung wirklich dann auch in der Praxis hin
Quintessenz des letzten Satzes, also jetzt aus der Theorie heraus, war sie natürlich erst mal noch nicht, wie ich das hinkriege. Dazu kommen wir jetzt dann gleich im nächsten Kapitel dann zu entsprechenden Codierungen,
aus der Theorie heraus gibt es eigentlich dann nur noch einen relativ berühmten Satz von Claude Channon,
der so auch schon vergleichsweise alt ist, also 1949 veröffentlicht,
das sogenannte Shannon-Theorie, was jetzt eben sagt, vorausgesetzt,
ich habe eben so einen symmetrischen Übertragungskanal mit einer Störwahrscheinlichkeit B eine Kanalkapazität,
C von P, die jetzt eben irgendwo entsprechend der Art des Kanals vorgegeben ist,
dann besagt die Shannon Theorie,
dass wenn die Übertragungsrate kleiner ist, als die Kanalkapazität,
dass man dann eben zu jedem Epstilon größer Null eine Kodierung findet,
die, wenn ich sie jetzt übertrage, gilt,
dass diese Kodierung eben auch immer noch kleiner ist als die Kanalkapazität.
Natürlich zusätzliche Redundanz hinzufügt. Das heißt also,
in der Regel größer wird als er,
dass aber die Fehler dekodierwahrscheinlichkeit, kleiner wird als dieses Y. So,
das ist jetzt natürlich wie immer also schön mathematisch formuliert,
was besagt das Ganze in der Praxis.
In der Praxis heißt das,
dass wenn ich grundsätzlich erst mal die Übertragungsrate kleiner habe als die Kanalkapazität,
dann kann ich im Prinzip kurz bauen, die,
wie jetzt da mal, die Kanalkapazität noch ein bisschen weiter ausnutzen.
Das ist eben genau das, dass also hier
diese Codierung in der Regel größer wird als er.
Ich natürlich immer sagen muss,
da physikalisch hier quasi sowas wie eine Obergrenze ist,
wird das immer kleiner bleiben als die Kanalkapazität.
Dass ich aber mit dieser Codierung erreiche,
dass mein Code letztendlich beliebig gut wird und ich bei
der Dekodierung dann also beliebig wenig Fehler mir einhandeln
Nachteil bei dem Ganzen. Nachher bei dem Ganzen ist es natürlich,
dass diese Theorie erstmal theoretisch nicht sagt,
wie man das jetzt macht, dass das dann also wie bei,
sag mal jetzt, vielen solchen Theorien oder solchen Sätzen,
die jetzt also sagen, zu jedem Epsilon größer Null existiert ein,
dann von irgendwelchen Grenzwertbetrachtungen ausgehen, die sich dann also letztendlich mathematisch ergeben.
Das heißt also, diese Kodierung funktionieren eben in der Regel auch nur,
wenn ich jetzt also als Grenzwert unendlich lange Wörter oder Nachrichten übertrage,
dass ich dann eben entsprechend viel Prüfinformation und Redundanz mit einbauen kann,
um dann eben auch entsprechend viele Fehler ausgleichen zu können,
dass,
wenn diese Voraussetzungen jetzt natürlich nicht gegeben ist und ich jetzt eben nur bestimmte Nachrichten oder bestimmte Längen von Nachrichten habe,
dass das da natürlich so auhast mal nicht geht.
Immerhin, also bei dem,
was man teilweise in der Nachrichtenübertragung macht oder machen kann,
muss man sagen, Also erstaunlicherweise eben wirklich die Informationsübertragung,
also schon relativ nah an dem sind,
was er jetzt physikalisch bei irgendwelchen verrauschten Übertragungen theoretisch machbar ist.
Also Beispiele für solche extremen Sachen, wo sowas jetzt wirklich auftritt,
wo man sich auch wirklich Gedanken machen muss über solche Informationskodierungen. Wer jetzt also zum Beispiel,
gerade also jetzt hier aktuelle Steuerung der Marsson der Curiosity,
nicht wo ich eben sagen kann, okay,
vom Mars bis zur Erde irgendwelche Informationen zu übertragen,
Da wird halt relativ, also zum einen vergeht natürlich also sehr,
sehr viel Zeit, jetzt erstmal in Laufzeit.
Zum anderen ist aber natürlich dann auch so,
dass die Übertragung oder Übertragungskanal also doch sehr stark gestört ist,
also durch irgendwelche atmosphärischen Effekte, durch irgendwelche anderen Effekte oder Teilchen,
die die also jetzt letztendlich bei dieser sehr lang Übertragung ankommen,
wo man dann eben auch sagt, na gut,
die Masson, da hat jetzt nicht einen beliebig starken Sender,
der dann mit einigen tausend Watt,
also irgendwie per Richtanterne
Richtung Erde funken kann
Sondern da steht eben auch noch eine begrenzte Sendeleistung zur Verfügung und das,
was dann also wirklich hier an Informationen auf der Erde aus,
davon da noch aufgefangen werden kann,
ist eben wirklich nur noch ein minimaler Teil.
Und wenn man, also sagen wir mal,
bei solchen Übertragungen nicht mit entsprechend guten Kodierungen arbeitet,
würde man da also wirklich nur noch Rauschen empfangen.
Gut, einige von diesen,
sagen wir jetzt vergleichsweise einfachen Methoden zur Kanalkodierung werde ich also jetzt folgenden noch vorstellen,
wo es darum geht, also letztendlich Fehler zu erkennen,
beziehungsweise dann eben auch Fehler oder sehr einfache Fehler,
dann eben auch schon zu korrigieren.
Dazu wird es einmal, oder können wir uns als erstes erstmal betrachten,
welche Arten von Fehlern können eigentlich auftreten bei der Datenübertragung.
Jetzt kann ich sagen, gut,
also ich möchte in der Information oder irgendwie ein Zeichen übermitteln.
Es kommt ein anderes Zeichen an,
beziehungsweise ich dekodiere das eben als ein anderes Zeichen,
dass wir ja dann eben quasi was wie so
eine Verwechslung von Symbolen
Dann habe ich oft so was wie das Vertauschen benachbarter Zeichen.
Es vertauscht von jetzt irgendwie weiter entfernten Zeichen.
Nicht wie also hier in dieser Sequenz angedeutet,
wo dann eben aus A, W, C, C,
B, A wird oder eben irgendwelche Arten von Gruppen oder Bündelfehlern,
wo dann also Wiederholung von Zeichen durch was anderes ersetzt wird.
Also da kann man sich also beliebige Arten von Fehlerklassen
dann eben auch entsprechend ausdenken. Und je nachdem,
um welche Übertragungsmedien beziehungsweise welche Arten von Codierung es gibt,
gibt es da dann eben sehr unterschiedliche Arten von Fehlern,
die dann eben auch auftreten können.
Also als ein Beispiel, ich weiß ja, sagen wir mal,
auch alle tagtäglich benutzen. Ich lasse es auf CDs,
beziehungsweise jetzt typischerweise natürlich zwischen auch DVDs, habe ich irgendwelche Kratzer, irgendwelche irgendwelchen Dreck drauf.
Das würde sich dann eben wirklich daran äußern,
dass also beim Auslesen der Informationen an also quasi gleichen gesamter,
größerer Blog quasi jetzt einfach falsch gelesen wird und dann also
statt jetzt irgendwo in der Folge oder sequenz von Informationen an eben,
ja, letztendlich, also nur irgendwie lauter Nullen empfangen werden.
Wie gesagt, bei Funkstrecken habe ich dann eben sowas wie irgendwelche Störrimpulse.
Ich also jetzt für ein ganz anderes Medium mal gedacht,
also sowas wie also für Tauschen benachbarter Zeichen,
kann ich jetzt eben sagen,
wenn ich jetzt also irgendwie schnell schreibe,
also die typischen Buchstabendreher wären dann eben im Prinzip dann also
auch so ein Modell dann für solche Fehler
Gut, bevor ich jetzt mit Beispielen zur Codierung für Fehler erkennenden Kurzbeginne,
komme jetzt also auch nochmal einige Begriffe, die ich also nachher,
also gelegentlich vielleicht nochmal verwende, deswegen also ich hier nochmal auch erstmal so als Beschreibung aufgelistet.
Vom Blogcode spricht man dann eben auch,
ähnlich wie jetzt also beim Blogcode in der Zeichen oder Zahlendarstellung,
wo ich also schon Blockcode eingeführt hatte,
dass man dann eben jetzt hier in dem Kontext sagt,
also ein Blockcode ist dann,
wenn ich jetzt eben eine Anzahl von Informations-Bits in einer festen Zahl von übertragenen Bits kodiere,
Faltungscodes, da geht es dann darum,
dass ich einen Bittstrom in einen Codepit-Strom höherer Biterator umrechne,
das wird in der Regel Folgen bei Fehler erkennenden Codes,
war ich da ja dann letztendlich aus meiner ursprünglichen Information noch irgendwo Redundanz hinzufügen muss,
die dann dazu führen, dass also die Worte entsprechend größer wären.
Sowas wie lineare NK-Codes, jetzt hier auch nochmal kurz angesprochen.
Ich würde das jetzt also auch nicht weiter oder genauer ausführen. Da geht es eben auch nur darum,
dass im Prinzip mit diesen Codierungen als Beispiel,
dafür werde ich also nachher den Hemmingcode einführen,
im Prinzip ein Ja, auch jetzt wieder mathematisches Modell,
was im Zweifelsfall eine Diskretmathematik noch nicht drangekommen ist.
Wo ich jetzt aber eben auch nur sagen kann,
gut, wir brauchen das jetzt hier nicht weiter, bloß,
also ich möchte eben nur mal kurz den Begriff erwähnt haben,
also da geht es darum, dass man also einen kadimensionalen Unterraum des GEF 2 hoch N macht.
Das heißt also, dass ich letztendlich Funktionen mit N Ziffern oder Enbinärziffern habe,
was dann also dieser GF2 auch N ist und dass ich da drin dann eben quasi einen Unterraum bilde,
indem ich sage, ich benutze davon also eine bestimmte Anzahl von Bits dann,
also als Nutzbitz und der Rest ist dann quasi sowas wie Prüfinformationen.
Modifizierter Code ist dann eben, wenn ein oder mehrere Sterne
eines linearen Codes systematisch verändert werden. Auch dazu kommt dann nachher,
da also wirklich das praktische Beispiel im Prinzip sowas wie ein CRC,
falls ihr den Begriff schon mal gehört haben,
Cyclicre Dunnance seeshak, wäre im Prinzip nämlich genau ein modifizierter Code,
wo also innerhalb als Codebit Strom es bestimmte Stellen durch XO-Verknüpfung mit sich selber oder Metallen dieses Kurz verrechnet werden.
Auch dazu kommt dann nachher dann also nochmal ein praktisches Beispiel,
wo das dann also wirklich nochmal so ein bisschen anschaulich erklärt wird,
wo ich also jetzt nicht mit langen mathematischen Modellen arbeiten werde,
deswegen,
dass die Ganze dann eben nur entsprechend schnell rüber
Also hier auch nur noch mal kurz als Einschub, jetzt weniger zum kompletten Verstehen,
sondern eigentlich auch nur, also wenn sie da noch mal weiter nachsehen wollen oder so. Also dieses GF2 beziehungsweise GF2 hoch N als Referenz,
also im Prinzip entweder in der deutschsprachigen Wikipedia und der endliche Körper oder in der englischsprachigen unter GF2 beschrieben,
basiert letztendlich darauf, dass ich immer sage,
ich habe als Ziffern oder Zahlen 0 und 1 in der Buhlschen Algebra,
die ich mir also vorgestellt hatte,
wo ich aber auch nur ganz kurz die Aktionen immer kurz definiert hatte,
rechne ich ja mit und oder und Negation,
wo ich dann sage, dass und entspricht quasi eine Art Multiplikation,
das oder entspricht der Addition,
wenn ich das jetzt also mit den natürlichen Zahlen vergleiche,
nicht bloß die Butsche Algabas eben keinen Körper,
weil ich für die oder Operation nicht sowas wie ein inverses Element habe.
Und beim Galoirefield ist im Prinzip genau das Gleiche,
ich habe auch 0 und 1, ist aber ein Körper,
weil hier betrachte ich nämlich als Verknüpfung jetzt und und
das Exklusiv oder das und entspricht also auch jeder Multiplikation,
das Exklusiv-Oder ist aber sowas wie eine Addition,
Modulu 2. Das heißt, also ich erzeuge keine Überträge,
sondern bleibe mit dem Ergebnis quasi in diesem Zahlenraum.
Das führt dann eben dazu, dass dann ein additives Inversus existiert,
wo dann nämlich gilt X exklusiv oder X ist dann eben null.
Und damit habe ich dann also alles zusammen,
womit dann also quasi nach Körperaxium das Ganze dann
mathematisch als Körper gelten
Von einem systematischen Code spricht man, das ist hier,
nochmal weiter zu sehen, begriffen oder zu den Definitionen,
wenn die zu kodierende Information direkt im Codewort enthalten ist.
Ich denke mir alle, alles das,
was ich jetzt hier auch noch vorstelle an Beispielen,
das sind alles systematische Codes,
das heißt,
man hat jetzt also seine zu kodierende Information,
also irgendeine Folge von 0 und 1
und fügt dann eben noch nach unterschiedlichen Verfahren dann
irgendwelche zusätzlichen Bilds hinzu
Die dann quasi für Fehlererkennung oder für Fehlerkorrektur genutzt werden können,
aber ich kann eben auch direkt auf einen Blick meine Informationen auslesen.
Zyklische Codes sind dann eben nochmal Blog-Codes,
denen ich auch jede, oder bei denen gilt,
dass jedes Codewort beliebig nach links oder nach rechts verschoben,
dann eben auch wieder
ein Codewort ist
Solche Codes da mal sind ganz sinnvoll oder haben den Vorteil,
dass jetzt eben bei Bündelfehlern,
wenn jetzt also mehrere bis der Reihe nach,
also betroffen sind, man da dann eben sehr schnell erkennen kann,
dass ich da eben ein ungültiges Codewort empfange,
beziehungsweise dass man das dann dementsprechend korrigieren kann.
Gut, das waren jetzt auch nochmal in grober Übersicht jetzt erstmal nur Begriffe.
Jetzt kommen wir natürlich mal so ein bisschen zu praktischen Beispielen,
wo man also wirklich mal sehen soll, ja,
wie kriege ich denn jetzt überhaupt,
also so eine Fehlererkennung hin
Grundsätzlich kann ich mir jetzt natürlich erst mal zwei Sachen überlegen,
was letztendlich passiert oder passieren soll, wenn ich jetzt,
also mein vorausschender Informationskanal habe,
da wird irgendwas übertragen und es wird dann auch irgendwie festgestellt,
ich habe in meiner Information jetzt eben aufgrund dieses verrauschten Kanals jetzt,
also irgendwas Falsches erhalten, das Allereinfachste Verfahren wäre jetzt eben,
dass also wenn der Empfänger feststellt, er hat was Falsches erhalten,
dass er dann also quasi ein Automatic Repeat Request schickt.
Das heißt also quasi, man braucht eine vidirektionale Verbindung und er fragt,
also Gelände gesagt, einfach warm, Sender nochmal nach.
Ich habe da irgendwie Schrott erhalten und schicke mir das nochmal.
Wie gesagt, das ist vergleichsweise straight. Vorwart hat aber natürlich jetzt den Nachteil nicht,
also ich hatte ja schon dieses Beispiel,
Curious City of Mars,
nicht wenn man dem jetzt also sagt,
ich schicke dir mal einen Farbefehl und du sollst mal also
irgendwie in die Richtung 20 Zentimeter weit fahren
Irgendwann nach einer halben Stunde kommt dann quasi als Rückantwort,
nur ich habe da nichts Richtiges empfangen und schicke mir das nochmal.
Das ist dann natürlich, sagen wir jetzt, also nicht so richtig praktikabel. Das heißt also,
in den Fällen oder eben auch für Sons, Journeys,
also irgendwie sowas wie Echtzeitanforderungen hat, also sprich beispielsweise irgendwelche Sensoren,
Kamera, liefert einen Bilddatenstrom aus,
nicht im Rechner bei der Dekodierung stelle ich fest,
also in dem einen Bild ist irgendwie was kaputt gegangen und ich habe da also irgendwie Noragenempfang,
da kann man jetzt nicht sagen,
also schickt mir das Bild nochmal,
weil das wird im Surface zwar gar nicht zwischengespeichert,
sondern läuft einfach nur in Echtzeit
irgendwo aus dem Sensor heraus
Das heißt, was dann meistens eingesetzt wird,
sind eben wirklich Verfahren zur Fehlerkorrektur,
beziehungsweise technisch gesehen spricht man dann eben von einer Vorratsfehlerkorrektur,
beziehungsweise englischen übersetzt vor What-Error-Correction, deswegen dann auch FPC abgekürzt,
wo dann die zu übertragene Information jetzt eben nicht nur so weit abgesichert wird,
dass der Empfänger erkennt, es gibt einen Fehler,
sondern dass da dann eben noch irgendwelche Informationen oder irgendwas mit eingebaut wird,
dass der Empfänger dann eben Zumindest in einem gewissen Maß,
dann also auch noch die Fehler wieder korrigieren kann.
Nicht und je nachdem, worum es letztendlich jetzt bei der
Information geht, nicht. Also ob ich jetzt sage,
na gut, also wenn das ein Kamerabild ist,
was dann Echtzeit jetzt irgendwo ankommt, und ich habe da was Falsches erhalten.
Nicht unten eine 30. Sekunde später kommt das nächste Bild an.
Jetzt bei 30 Frames pro Sekunde dann, kann ich damit leben,
dass das vielleicht fehlerhaft ist und auf dem Display wird dem Benutzer
dann eben quasi einfach das eine kaputte Bild nicht angezeigt und er sieht dann eben zweimal hintereinander das Leichebild.
Das fällt erstmal nicht größer auf. Aber wenn ich das jetzt brauche,
um beispielsweise jetzt eben wirklich irgendwelche sicherheitsrelevanten Sachen zu steuern oder so,
dann wird man natürlich also mit vergleichsweise viel Aufwand da rangehen,
um eben, je nachdem, was man da zur Möglichkeit hat,
dann eben Fehlerkorrektur einzubauen beziehungsweise die Information nochmal weiter erneut abzufragen.
Anfrage? Wie ist das bei der Vorwärtsfehlerkorrektur
Ewigkeit, die Prozess nicht besteht.
Und sowohl in den USA als auch in den Fünfzimmern,
dadurch, dass das doch hier ganz im Fernsehen steckt.
Also die Frage war, wie ist es bei der Vorwärtsfehlerkorrektur,
wenn jetzt keine Möglichkeit besteht, also nochmal nachzufragen, also kein Automatic Repeat Request.
Und wenn jetzt eben sowohl die Information als auch eben die Prüfziffern kaputt gegangen sind.
Und gut, da muss man jetzt natürlich immer sagen,
nach dem Shannon-Theorie kann ich Solange ich also jetzt insgesamt unterhalte meiner Kanalkapazität bin,
natürlich also den Code so aufbauen,
dass ich da erstmal beliebig viele Fehler korrigieren kann.
Funktioniert aber eben nur für unendlich lange Worte. Das heißt,
in der Praxis sieht das nun immer so aus,
dass ich sagen kann, ich oder ja, dass ich sagen kann,
also meine Nachricht ist jetzt für mich so und so wichtig und so viel Aufwand betreibe ich jetzt eben für Fehlerkorrektur.
Und entsprechend Diesem Aufwand kann man dann eben ein oder zwei
oder dann eben bis so und so viel Fehler korrigieren.
Wenn der Kanal jetzt wirklich so schlecht ist,
dass noch mehr Fehler auftreten,
dann kann ich eben auch nur noch sagen, gut,
aufgrund dieser Maßnahmen kann ich zwar noch erkennen,
dass ich was Ungültiges erhalten habe,
aber ich kann eben die ursprüngliche Information da nicht wiederherstellen und
dann muss man sich dann eben irgendwie was anderes überlegen,
wie man letztendlich damit lebt.
Gut, in dem Zusammenhang ist dann eben interessant
der Begriff des Hemmingabstands
Das ist also jetzt die Anzahl der Stellen,
an denen sich zwei Vigneurcode-Wörter einer bestimmten Länge unterscheiden.
Als Beispiel haben wir jetzt also hier mal zwei Worte,
A und B. Und der Hemmingabstand zwischen den beiden Worten ist drei.
Das heißt, es wird einfach jetzt nur geguckt,
wo unterscheiden diese oder in wie viel Bit unterscheiden die sich?
Das ist einmal hier der Fall. Einmal hier
der Fall. Und hier in dem drittletzten Bit,
und das wäre dann quasi genau dieser Hemmingabstand drei
Als Hemming-Gewicht bezeichnet, meint es also den Hemming-Abstand eines einzelnen Code-Worts vom Null-Wort.
Also in Bezug auf dieses Beispiel hier wäre das dann also bei B gleich 5. Ich hatte ja schon bei diesen ganzen Schiebe und Zähl und sowas Operationen,
also mal eingeführt oder gesagt, also dieses Beispiel mit diesem Bitcount,
wo ich quasi in einem Wort zähle,
wie viele Eins-Bits sind,
gesetzt und um den Hemming-Abstand zwischen zwei Worten zu ermitteln,
würde ich dann also zum Beispiel in Java einfach sagen,
A-X-R-B. Nicht dementsprechend wird jetzt ein Wort gesetzt,
was dann also so und so viele,
also in diesem Fall ist also hier 3-1 gesetzt hat.
Und wenn ich dann eben noch so eine Bitcoin-Routine habe,
habe ich dann eben direkt den Helming Abstand ausgerechnet.
So, jetzt hatte ich ja schon gesagt,
dass zu Fehler Korrektur bzw. Fehler Erkennung überhaupt erstmal
eine Kodierung mit Resonanz
erforderlich ist
Das heißt,
ich baue jetzt eben zusätzlich nochmal mehr Bits ein,
als ich zur eigentlichen Speicherung bräuchte,
weil wenn ich jetzt so was wie eine Minimalkodierung habe,
ist also ganz normal einfach so was wie eine Binärkodierung jetzt zum Beispiel von irgendwelchen Zahlen,
wo ich dann eben wirklich sage,
ich benutze sämtliche Codes in meinem N-Bit langen Wort,
dann ist klar, wenn sich da irgendwo ein einzelnes Bit ändert,
dann ist das ein anderes gültiges Wort und ich kann erstmal nicht entscheiden,
ob ich jetzt dieses andere Wort,
du hast ja dann auch Gültiges gesendet habe oder ob dann eben ein Fehler aufgetreten ist.
Deswegen Kommt es jetzt eben darauf an,
dass ich also quasi jetzt durch zusätzliche Bits dafür sorge,
dass ich zwei Codewörter beziehungsweise zwei beliebige Codewörter, also paarweise mindestens um einen Hemmingabstand D unterscheiden.
Das ist dann eben dieser Minimalabstand. Und wenn ich sage,
ich habe die Codeworte jetzt eben so gewählt,
dass sie sich jetzt eben um einen Minimalabstand meinetwegen jetzt von drei unterscheiden,
dann kann ich jetzt eben sagen,
Damit könnte ich dann eben zum Beispiel schon eine Fehlererkennung machen,
weil dann gilt eben das, wenn ein Bit verfälscht worden ist,
kann ich dann eben bis die minus eins fehlerhafte stellen,
erkennen.
Da war ich dann eben weiß,
ich habe hier ein Codewort meinetwegen 0011,
hier ein anderes Codewort,
jetzt mit entsprechendem Hemmingabstand
1-1, 1-1 und wenn sich dann
eben entsprechend jetzt Bits ändern und dich dann eben,
oder wenn dann eben der Hemming-Abstand eben groß genug ist,
erhalte ich eben ein Wort durch diese Veränderung,
was jetzt also keins dieser beiden gültigen Kotworte ist.
Ich habe dann also erst mal erkannt,
dass ein Fehler aufgetreten mit einer Hemming-Abstand eben groß genug ist.
Kann ich letztendlich dadurch eine Fehlerkorrektur machen von der Idee her,
dass ich eben sage, ich gucke jetzt eben in welche Richtung oder wo
ist der Abstand letztendlich kleiner und in die Richtung oder zu diesem Wort hin wird dann korrigiert.
Denkt mir, das wird dann leicht bei den Beispielen noch ein bisschen anschaulicher,
wie das dann also rein praktisch aussieht,
wobei ich dann ja, wie gesagt,
dann also auch mehrere unterschiedliche Informat-Verfahren dazu vorstellen werde.
Gut, also Idee, man fügt den Daten eben irgendwelche Prüf- und Informationen hinzu.
Zum einen relativ einfach, erstmal nur zur Fehlererkennung.
Da baue ich also da nur einen Hemming-Abstand von zwei.
Das heißt, dass ich zwei Kotworte dann eben um mindestens zwei Bett jeweils paarweise unterscheiden.
Zur Fehlerkorrektur bräuchte ich dann eben größeren Hemming-Abstand.
Mit entsprechend längerer Prüfinformation kriegt man das dann aber eben auch hin. Je nachdem,
wie jetzt die Codes aufgebaut sind,
beziehungsweise wie man diese Prüfinformationen gewinnt, kann man dann eben sagen,
gut, ich kann eben nicht nur einfache Fehler korrigieren,
sondern ich kann an ihm teilweise vielleicht auch schon mehrere Fehler korrigieren,
wenn die, ich sag mal, günstig zueinander liegen.
Ich kann bei schweren Fehlern zumindest schon mal feststellen,
dass ein Fehler aufgetreten ist. Nicht, dass es dann
also letztendlich von der Art und Weise abhängig wie die Prüfformformation generiert wurde.
So, die aller einfachsten Verfahren dazu sind dann sowas wie Prüfziffern oder Parität,
Summenbildung, dann eben solche Cyclic Redunn-Cishek-Verfahren. Da werde ich dann auch noch kurz vorstellen,
nicht jetzt sagen wir jetzt andere, kurz für, oder Beispiele für Prüfsummen,
also sollen jetzt sie also nur mal als Name zum Nachschlagen aufgelistet sein,
also BCH-Codes, 3 Salomon-Codes,
falls sie jetzt also irgendwie in irgendwelchen Datenblättern mal zufällig darüber stolpern,
dass man das also schon mal so ein bisschen einordnen kann, worum es geht.
Die Verfahren selber werde ich dann also nicht weiter im Einzelnen vorstellen von den etwas anspruchsvolleren Sachen,
weil das dann also doch auch wieder sehr weit in die Mathematike reingeht und,
sagen wir mal, das ist ja einfach für die Veranstaltung,
wo man jetzt also sagt, okay,
es gibt einen gewissen Überblick und man kriegt bestimmte Verfahren so erstmal grob mit,
dann, also dann auch, denke ich mir,
deutlich zu weit gehen würde,
weil das ist dann also wirklich ganz speziell Signalverarbeitung,
die man da dann betreiben würde.
Gut, die allereinfachsten Verfahren oder das Allereinfachste ist im Prinzip
so was wie das Anfügen von Paritätsbitz, das heißt,
ich habe ein Binärkotwort aus in Stellen, Z1 bis ZN.
Ich möchte hiermit jetzt auch erstmal nur so was wie Einbettfehler erkennen,
noch gar nicht korrigieren. Und dazu sage ich jetzt einfach,
ich berechne jetzt eine Parität P, als Summe über alle einzelnen Bits,
Module 2, und kann dann eben sagen,
ich baue eben anschließend dann eben entweder eine gerade Parität,
das heißt für Diese Summe und das Paritätswitt muss dann eben gelten,
dass die Parität entsprechend gerade ist.
Im Englischen dann eben Even Parity oder eben als Ungradeparität,
Ort, wo ich quasi dieses Prüfbild so wähle,
dass eben diese Molo 2, soll man dann eben den zufolge,
eins sein muss.
Das heißt also, da passiert nichts anderes,
als dass ich hier die Anzahl der Einsen ziele
Nicht und das Ganze dann eben um einen Paritätsbett so erweitert,
dass ich eben entweder eine gerade oder eine ungerade Anzahl von Einsen erhalte.
In der Praxis benutzt man meistens, auch wenn das Beispiel,
was sie es gleich noch bringen,
wäre natürlich wieder eine Even-Parität hat,
in der Praxis benutzt man meistens ungerade Paritäten,
weil damit ist schon mal gewährleistet,
dass ich in jedem Codewort mindestens auch eine einzige Einsenthalte habe
Damit kann man also zum Beispiel jetzt schon mal ganz einfach sehen,
jetzt für irgendwelche physikalischen Leitungen werden überhaupt Daten übertragen. Nicht,
wenn ich jetzt sage, ich habe sowas wie eine elektrische Verbindung,
ich muss überhaupt erst mal nicht nur null,
sondern auch mal ein Volt oder eine Spannung bekommen,
die quasi ein Volt entspricht, um zu sehen, okay,
da ist überhaupt erst mal was angeschlossen und der Benutzer hat jetzt nicht vergessen,
den Stecker reinzustecken.
Und das habe ich dann mit einer geraden Parität dann
quasi umsonst. Mit einer ungeraden Parität voll,
Gut, für das mathematische Modell dahinter, also wie gesagt,
der Hemming-Abstandsfeier, Codewörter, ist natürlich genau mindestens zwei,
weil ich ja, dadurch,
dass ich innen bei der Erstellung der Parität quasi die Anzahl der Eins-Bits gezielt habe und dann eben entsprechend das Paratät mit hinzugefügt habe,
sich dann eben wirklich bei jedem Ändern eines Nurdspits dann auch logischerweise die Parität entsprechend ändern würde,
nicht womit ich dann auch automatisch immer Zwei Betts für gültige Worte als Unterschied habe,
dem zufolge dann eben Hamming Abstand 2,
womit ich eben ein Bettfehler erkennen kann,
in dem ich dann eben einfach sage,
auch der Empfänger berechnet nach gleichem Verfahren die Parität und wenn er dann eben feststellt,
das ist jetzt genau das andere als erwartet,
habe ich dann eben einen Fehler überhaupt erst mal erkannt.
Ich kann ihn zwar noch nicht korrigieren, aber Natin erkann. So,
wenn ich jetzt mehr Bitfehler habe, das heißt mehrere Fehler gleichzeitig,
dann kann ich jetzt bei diesem Einfahrenverfahren natürlich nur sagen,
wenn ich genau zwei Fehler in meiner Übertragung habe,
war es natürlich aufgrund jetzt irgendeiner des stochrastischen Modells,
also auch vorkommen kann, die erkenne ich nicht,
weil dann, das wäre dann eben wieder genau ein gültiges Kotwort,
nicht aber zumindest ungerade Anzahlen von Mehrwirtfehlern könnten dann eben auch noch erkannt werden.
So ein Anderes Verfahren beziehungsweise darauf dann noch aufbauen,
das erwartet das Verfahren, wenn ich jetzt also schon versuche,
so ein bisschen sowas wie Fehler zu korrigieren,
ist dann im Prinzip so was wie eine zweidimensionale Parität.
Dabei werden eben die zu übertragenen Daten einfach zweidimensional angeordnet,
quasi als Matrix. Ich berechne Zeilen beziehungsweise spaltenweise die entsprechenden Paritäten.
Damit kann ich quasi jetzt in jeder Zeile beziehungsweise spalte Einbittfehler Erkennen.
Und dadurch, dass ich also letztendlich sagen kann,
in welcher Zeilen Fehler aufgetreten ist und dieser Fehler natürlich auch eine Auswirkung auf die entsprechende Spalte hat,
kann ich daraus auf das entsprechende Bit in dieser Matrix zurückschließen.
Grundsätzlich lässt sich dieses Verfahren dann eben auch noch auf weitere Dimensionen übertragen,
dass sich das jetzt eben nicht nur zweidimensional anordne,
sondern also die Bits dann entsprechend mehrdimensional miteinander verrechnen und dann eben noch mehr Parität Paritätsplätze hinzufüge,
nicht und dadurch dann eben auch zu besseren Fehler erkennenden Code komme.
Nicht aber das einfache, zweidimensionale Verfahren,
was man dann also hier überhaupt dessen nochmal grafisch darstellen kann,
wird dann eben so aussehen, also angenommen,
ich hätte jetzt hier als Symbol sowas wie Aski-Zeichen berechne,
hier ist also beispielsweise was für eine gerade Parität und übertrage jetzt hier sieben Aski-Zeichen,
nämlich in diesem Fall,
also hier das Wort Hemming
Wenn ich diese Zeichnung jetzt entsprechend hier so untereinander aufschreibe und dann hier Zahlen beziehungsweise hier spaltenweise die entsprechenden Paritäten hinzufüge,
beziehungsweise dann eben auch noch Paratets bist, also für die,
oder das eine wird dann also hier dann auch noch für diesen Teil der Matrix erstelle,
erhalte ich jetzt also erstmal einen fehlerfreien Fall,
dieses hier,
wenn jetzt irgendwo Fehler auftauchen, also angenommen das,
was also hier jetzt mit den roh dargestellten Zahlen aufschaut oder angedeutet ist,
würde sich oder dann würden sich eben diese Fehler dann eben auch natürlich hier entsprechend auf die Paritätsbiss auswirken.
Was hier auch nur eine Vollständigkeit halber nochmal angesprochen werden sein soll,
ist, was man also bei diesen ganzen Zusätzinformationen mit irgendwelchen
Prüfen bzw. Paritätsbiss natürlich auch immer noch betrachten muss,
die machen natürlich das zu übertragene Wort länger und Die Fehler,
die auftreten, kommen ja eigentlich durch das stochastische Modell des Übertragungskanals.
Die können natürlich genauso auch die Paritätsbit selber betreffen. Das heißt also,
irgendein zufällig auftretender Fehler macht jetzt das ja nun keinen Unterschied,
also ob es sich ja um ein ursprüngliches Datenbett oder um
ein zusätzlich reingebautes Prüfbett handelt.
Also das heißt also, auch das kann,
wie unten angedeutet, letztendlich auftreten.
Gut, also für diesen einfachen Fall zweidimensionale Parität könnte ich
jetzt eben sowas wie Einzelfehler
noch korrigieren
Würde dann hier in dem Beispiel dann so aussehen,
dass ich sage,
in dem Fehlerfall hatte ich also beispielsweise hier diesen einen Einzelfehler,
würde dazu führen, dass wenn jetzt der Empfänger die entsprechenden Paritäten berechnet,
er dann quasi hier in dieser Zeile 3-1 empfängt,
demzufolge er dann als Parität jetzt eine 1 und keine Null berechnet,
die jetzt aber übertragen wurde, dadurch ist quasi jetzt festgestellt worden,
dass also ein Fehler in dieser Zeile auftritt,
hier und für die Spalte dann eben entsprechend ist,
wo ich dann also hier 5-1 lese,
dem zufolge dann eben auch zu einer Parität von 1 und nicht von null komme,
was dann eben auch ein Indiz dafür ist,
dass dann also in dieser Spalte der Fehler aufgetreten ist.
Das heißt, mit diesen beiden Informationen könnte ich dann eben
diesen einen Einzelfehler jetzt genau korrigieren
Gut, und wie man dann also hier natürlich jetzt rein praktisch sieht bei Mehrfachfehlern,
kann ich nachher dann also nur noch sagen,
ich kann sie letztendlich erkennen, beziehungsweise je nachdem, wie,
also dann hier Zahlen oder spartenweise verteilt sind und sich vielleicht auch gegenseitig auslöschen,
kann man jetzt natürlich also beliebige Beispiele konstruieren, wo das ganze Verfahren dann nicht mehr funktioniert.
Also grundsätzlich muss man sich ja immer vergegenwärtigen,
also das war ja auch schon die Frage,
beziehungsweise hatte ja auch schon angedeutet, dass sich,
je nachdem, Welche Arten von Fehlern auftreten in meinem Übertragungskanal,
beziehungsweise je nachdem, wie, sag mal, wichtig mir die Information,
dass ich dann eben entsprechend viel Aufwand betreiben muss,
nicht und sag mal,
sowas hier jetzt als ein sehr,
sehr einfaches Verfahren ist halt eben nur dafür ausgelegt,
also jetzt wirklich so ein Einzelfehler zu korrigieren und gegebenenfalls noch andere Fehler also zu erkennen,
aber das war es dann auch nicht,
aber für entsprechend häufiger auftretende Fehler oder für andere Fehler
ist dann eben nicht geeignet
Ja, nur nochmal kurz zurück zur Art Metik. Nicht als Beispiel,
also im Prinzip kann man solche Ideen mit Paritäten oder sowas,
also auch unabhängig jetzt vom verwendeten Zahlensystem machen.
Also das, was sie jetzt eben vorgestellt hatte,
war ja eigentlich immer alles nur im Binärsystem. Nicht,
ich kann also hier so eine zweidimensionale Parität an,
also beispielsweise auch im Dezima-System machen,
wo ich dann also quasi sage,
ich habe hier sowas wie Zahlen und Spaltensummen
und füge da dann eben so eine Paritätmoduluzene einfach hinzu
Das heißt,
wenn ich jetzt hier diese neuen Ziffern als Daten zu übertragen habe,
nicht, würde ich dann eben entsprechend jetzt hier einfach die Paritäten hier berechnen,
indem ich dann also hier jetzt eben einfach rechne,
3 plus 7 plus 4 ist 14,
14 Module 10 ist 4, nicht hier erhalte ich 17,
hier erhalte ich dann eben 9,
dass man damit dann eben sehr einfach die Paritäten bildet nicht und also auch da würde dann eben gelten im Fehlerfall,
wenn es also hier statt der 8 oder 3 übertragen wurde,
würde ich dann eben hier andere Paritäten erhalten und könnte dann eben sagen,
wenn jetzt also hier diese sieben oder entsprechend diese Paritätsinformationen mit übertragen wurde,
an welcher Stelle der Fehler aufgetreten ist und aus der Differenz zwischen der übertragenen Parität und der berechneten Parität hätte ich dann eben auch genau die Differenz,
nämlich sieben minus zwei.
Entsprechend fünf, die ich dann also
quasi jetzt hier auf diesen falschen Wert hinzuaddieren müsste,
um dann wieder zum richtigen Wert von acht
zu gelangen
Nicht als so ein Beispiel jetzt für Paritäten,
die jetzt zum Beispiel im Dezima-System arbeiten, habe ich hier diese ISBN-Nummern.
Das ist also im Prinzip sämtliche Bücher,
haben ja im Prinzip eine zehnstellige beziehungsweise in Zwischensevester 13-stellige Nummern.
Auch diese Nummern funktionieren, sag mal, ähnlich wie dieser EAN-Code.
Das ist also das, was man also auf sämtlichen Produkten als Barcode hat,
beziehungsweise wo dann immer nochmal klein irgendwelche Ziffern reingeschrieben sind.
Nicht nur dieser Barcode, der dann logischerweise an jeder Supermarktkasse dann auch immer gescannt wird,
um damit dann also gleich in die Datenbank uns zum Preis zu kommen.
Ist eben auch ein Code, war ich also zum Beispiel jetzt bei diesem Scan-Vorgang irgendwelche Probleme haben kann,
wo ich dann eben auch über Paritätsinformationen dafür sorgen kann,
dass ich eben erkenne, dass dort was Falsches eingelesen wurde.
Also ein Beispiel jetzt, nur mal kurz skizziert jetzt hier von diesen ISBN,
also von diesen International Standard Book Numbers, Sieht das so aus,
also in dieser Version mit 13 Zenziffern, gibt es dann erstmal so eine Art Prefix.
Ansonsten bei denen, mit 10 Ziffern geht das dann quasi hier los,
hat man quasi über einen Fahne-Code codiert, den Sprachraum,
das heißt also auf,
wenn sie also irgendwie mal in die Bibliothek gehen oder bei eigenen Büchern mal nachgucken,
wird man dann eben finden, also alles,
was mit Null oder Eins beginnt, sind englischsprachige Bücher,
alles, was mit zwei beginnt, ist Französisch,
alles, was mit drei beginnt es Deutsch.
Das heißt, da habe ich also im Prinzip für die
am häufigsten verwendeten Sprachräume dann acht Möglichkeiten von 0 bis 7.
Nicht für die dann weniger verwendeten Sprachen oder Sprachoptionen habe ich dann eben zweistellige,
dreistellige, vierstellige oder entsprechend fünfstellige Nummern dahinter.
Und wie man hier dann eben auch immer sieht,
sind diese ganzen Nummern so aufgebaut, dass sie letztendlich wie so ein Fano-Code prefixfrei sind.
Nicht und anschließend kommt dann eben noch eine Kodierung des Verlages,
wo ich dann eben Je nachdem,
ob es sich da dann eben auch einen kleinen oder einen großen Verlag handelt,
dann eben auch noch so eine Art Prefix-Kodierung habe von 0 bis 19 für die sehr großen Verlage und für die entsprechend kleineren dann eben auch entsprechend andere Ziffern und dann,
je nachdem, wie viel ich dann,
also letztendlich an Informationen noch frei habe,
noch irgendwelche verlagsinternen Nummern und letztendlich eine einzelne Prüfziffer.
Und bei diesem Verfahren sieht das dann eben so aus,
dass diese Prüfziffern oder diese ESBN-Zahlen dann eben so berechnet werden,
dass ich sage, Ich berechne für die ersten Neunziffern,
also für die normale Information, quasi eine Prüfsumme,
in dem ich rechne, ich mal ZI, also das heißt,
die ziffern einfach immer entsprechend mit der Wertigkeit 1,
2, 3 für 5 bis 9 multipliziere.
Dann diese Summe modulo 11 rechne und das Ganze ist dann
quasi meine Prüfziffer, also die zehnte Ziffer,
die dann eben moduluell logischerweise von 0 bis 10 gehen kann.
Dafür gibt es dann eben noch mal als zusätzliches Symbolen X.
Und wenn ich also jetzt irgendeine ISBN-Zahl habe,
kann ich eben sagen, diese Zahl ist gültig,
wenn diese Summe Modulu 11 gleich null ist.
Das heißt also, die normalen Zahlen und der mit zehn
gewichteten Prüfziffern müsste dann eben null ergeben.
Nicht als Beispiel, Also das wäre jetzt hier der
entsprechende ESBN-Code von dem Buch von Brian und Joe Halleran.
Null, 1,3, 7,1 und so weiter.
Prüft circa 7. Und das Verfahren würde dann eben rechnen,
eins mal 0, 2 mal 1,
3 mal 3, 4 mal 7 und so weiter,
was dann quasi als Summe 161 ergibt
Das Module 11 wäre dann sieben. Das ist dann eben
diese hinten angefügte Prüfzüffer. Und um jetzt eben zu gucken,
ob dieser Code gültig ist, müsste dann eben ein Verfahren,
wo ich sage, das Buch jetzt meinetwegen an der Kasse abscanne,
letztendlich dann auch diese Berechnung machen und zusätzlich dann eben noch mit der Prüfziffer dann eben rechnen,
zehnmal sieben, ist dann eben 231 und das Module 11 ist null,
gut ist gültig und bei allen anderen Fällen wäre es dann eben entsprechend ungültig.
Mit diesem Prüfziffern erreicht man es also jetzt hier bei diesem Verfahren,
dass das ich im Prinzip die Verfälschung einer Ziffer erkennen kann,
die Vertausschung von zwei Ziffern oder eben irgendwie solche Doppelungen von Ziffern.
Nee, als Beispiel jetzt für vertauschte Ziffern würde gelten,
wodurch unterscheidet sich jetzt die richtige von einer falschen Prüfsumme? Ich finde,
zwei Ziffern vertauscht sind, I und J,
habe ich ja also entsprechend diesem Verfahren,
wenn ich richtig rechne oder gerechnet hätte, würde ich ja rechnen,
I mal Z-I plus J mal Z-J,
da war es also jetzt ja hier einfach in diesem fahren in dieser Summe letztendlich drin ist.
Dadurch, dass die Ziffern vertauscht worden sind,
hätte ich jetzt quasi falsch berechnet, joa, malset e und e, malset jord.
Das heißt, wenn ich eben rechne, richtige Berechnung,
minus falsche Berechnung, wie er das genau,
dieser Ausdruck und demzufolge könnte ich da dann eben in der Prüfsumme feststellen,
dass dort was schiefgelaufen ist,
beziehungsweise um welche Ziffern lässig dann dabei handelt
Gut, wieder zurück zu Binärencourdierungen. Jetzt geht es also darum,
nicht nur Fehler zu erkennen oder jetzt eben wie in diesem zweidimensionalen Verfahren zu korrigieren,
sondern also jetzt über ein etwas anderes oder einfacheres Verfahren Korrekturen einzubauen.
Dazu mir jetzt erstmal die unterschiedlichen Varianten oder Ideen dazu jetzt von Hemmingcode einfügen.
Das Allereinfachste ist im Prinzip sowas wie ein Dreifach-Wiederholungscode. Das heißt,
ich übertrage jetzt immer irgendwie Nullen und Einsen und für jedes Zeichen
sage ich, okay, also ich übertrage das Zeichen dreimal.
Statt 1-0 übertrage ich 3-0, statt 1-1 übertrage ich 3-1. So,
was passiert jetzt, wenn irgendwo Informationen kaputt geht,
ein einzelnes Witt kippt,
dann würde ich eben quasi jetzt meinetwegen statt 3-0,
nur noch 2-0 und eine 1 erhalten und könnte dann letztendlich durch einen Majoritätsentscheid,
wo ich eben gucke, was kommt häufiger vor,
sagen,
dass es eben entweder eine Null gewesen oder dass es eine 1 gewesen,
wenn ich also beispielsweise als Folge dann 1-1
-0 empfange
Gut, mathematisch gesehen kann ich sagen, ich habe sowas
wie eine Generator-Matrix. Das ist also das, was jetzt
gerade in diskreter Mathematik dran war. Matrix, Multiplikation,
in diesem Fall ist es also hier noch vergleichsweise trivial,
weil ich das dann also mit einem Vector länger eins multipliziere
und erhalte dann eben hier entsprechend immer den freifachen Wert.
Lässt sich jetzt natürlich auch noch verallgemeiner als Endfachwiederholungscode,
wo ich dann eben entsprechend jetzt diese entfachen Wiederholung dann
eben auch meinen Minimalabstand,
also sprich meine Hemming-Distanz direkt festlege
Wie gesagt, Dekodierung durch Mehrheitsentscheid, das ist also dann auch
vergleichsweise einfach technisch zu realisieren. Nach teilweise solchen Wiederholungskurs ist natürlich,
also dass ich damit also in der Datenrate drastisch runtergehe,
war ich jetzt natürlich also nur noch ein Drittel der Datenrate letztendlich übertrage.
Generell gesehen gilt für Hemming Kurz,
dass ich jetzt eben sage, um Fehler zu korrigieren,
brauche ich überhaupt erstmal mindestens einen Hemming-Abstand von drei.
Nicht damit kann ich dann eben einen Bit-Fehler korrigieren und je nachdem,
wie die Fehler an fatal sind, eben auch viele zwei Bit oder drei Bit-Fehler erkennen.
Das, was man jetzt generell als Hemming-Code bezeichnet,
sieht so aus, dass ich sage,
ich habe ein Datenwort mit N-Bit,
die 1 bis DN,
die ergänzt sich um K
zusätzliche Prüfbits
Hier, also jetzt P1 bis PK und erhalte damit
mein Codewort mit insgesamt, jetzt eben Groß-N-Bits,
was dann eben quasi jetzt aus diesen beiden Teilen besteht.
Das heißt, von der Bezeichnung her,
mit so einem N-N-N-Hemming-Code, sage ich dann eben immer,
so und so viele Bits sind insgesamt wie übertragen und so und so viele davon sind Nurd Spits.
Das war eben genau dieses mit diesem 3-1. Nicht,
dass ich jetzt für jedes Nutz Bit 3 Bit übertrage.
So, um jetzt Eine Fehlerkorrektur wirklich zu gewährleisten, kann ich sagen,
was brauche ich? Oder wie viele Nutzpits brauche ich,
um jetzt zu sagen, es wurde irgendwo ein Fehler,
oder es ist irgendwo ein Fehler aufgetreten.
Und dazu kann man sich also jetzt folgende oder dazu kommen,
also folgende Überlegung anstellen. Es muss als Ungleichung gelten,
2 hochk ist größer, gleich, N plus
1. Warum muss das gelten? Also ich habe anschließend der Prüfpitz NBit
die ich übertrage. Das sind also Endzumarkierende, Bit-Fehler.
Nicht bei jedem dieser Bit kann irgendwo ein Fehler auftreten.
So, und ich habe jetzt Car-Prüfbitz eingefügt.
Und mit diesen Car-Prüfbitz muss ich jetzt quasi beschreiben können,
welches von diesen N-Bit kaputt gegangen ist,
beziehungsweise muss eben beschreiben können, dass ich einen fehlerfreien Fall habe.
Das heißt, ich habe insgesamt mit K-Prüfbitz zwei Hoch-K-Kombinationen
Also Worte, die ich, wo ich also Fehlerstellen markieren kann.
Das sind eben ein Stück und ich habe einen fehlerfreien Fall.
Demzufolge muss jetzt eben gelten für eine Fehlerkorrektur,
zwar auch k-größer, gleich N plus A1. So,
gleichzeitig habe ich jetzt ja gesagt, also das für das Codewort N,
das setzt sich logischerweise natürlich also aus meinen Nutzbits und diesem Prüfbitz zusammen,
kann ich dann also hier in der Gleichung dann eben auch ersetzen.
Und komme dann, wenn ich das dann entsprechend umforme,
Echt, das heißt, also 2OK ist größer, gleich,
N plus K, plus 1. Das möchte ich jetzt,
oder habe ich jetzt hier entsprechend nach N umgeformt,
ist dann eben genau diese Formel oder dieser Tal hier.
So, und der Algorithmus hat das Verfahren zur Hemmingodierung,
besteht jetzt immer aus diesen drei Schritten, die jetzt also quasi hier aufgelistet sind.
Im ersten Schritt bestimme ich jetzt quasi, kleinste K,
das heißt also erstmal die Anzahl der Prüfbits,
die ich hinzufügen muss, wenn ich sage,
ich habe eine bestimmte Zahl von N, Nordspits,
dass ich erstmal gucke, wie viele Prüfbitz brauche ich,
indem ich das also hier entsprechend dieser Formel auflöse.
Anschließend sage ich dann,
ich sortiere mir jetzt Nordspits und Prüfbitz folgendermaßen,
dass ich die,
diese Prüfbits immer an diesen Position 2 auch 0,
2 auch 1
und so weiter in meinem Wort einfüge
Das heißt,
wenn ich diese Position jetzt hier so der Reihe nach durchzähle,
habe ich dann eben an erster Stelle hier im Prüfbett,
dann das nächste prüft mir dann hier mein erstes Datenbett,
dann hier quasi oder zwei hoch zwei,
das nächste Prüfbett, dann folgen drei Datenbett,
ein Prüfbett,
wenn ich dann folge,
würden jetzt hier entsprechend sieben Datenbett folgen und dann wieder
das nächste prüfbett
So, und generell kann ich jetzt eben sagen,
ich berechne die Prüfbiss dann quasi als Modulo 2-Summe,
also sprich über so eine XO-Verknüpfung.
Derjenigen wird es, wo die Positionsnummer eingesetzt ist, E-Bit enthält.
So, was heißt das? Hier ist als Beispiel das
erste Prüfbit, setzt sich zusammen aus dem dritten Bit.
Aus dem fünften Bit,
aus dem siebten Bit
Aus dem neunten Bett und so weiter.
Das zweite Prüfbild setzt sich zusammen aus dem dritten Bett,
5. und 6. 9. und 10. und so weiter.
Rein praktisch, beziehungsweise ein bisschen anschaulicher ist,
dass also hier in dieser farbigen grafischen Darstellung,
wo ich also hier auch für so ein Schema von zwei bis fünf Prüfbits,
also hier mal die entsprechenden Worte oder Auflistung jetzt in dieser Reihenfolge hätte.
Und jetzt kann ich mir,
oder ist mit diesen Farben im Prinzip angedeutet,
also dieses hier, das Rote, das hier vorne wäre,
quasi das erste Prüfbit.
Und das nimmt, wie man hier sieht,
also dann im Prinzip immer jedes zweite Bit.
Dieses zweite Prüfbit würde dann also quasi jetzt hier noch dieses
eine Bit nehmen und dann
immer im Zweierabstand entsprechende Zweiergruppen
Hier habe ich jetzt quasi die nächste Zweierpotenz. Das heißt,
dieses dritte Prüfbit berücksichtigt jetzt, also hier die Dreibit.
Die ist nicht, dann jetzt immer entsprechende Vierergruppen und so weiter und so fort.
Ja, und das ist also die Art und Weise,
wie also im Prinzip dieser Hemming-Code gebildet wird,
beziehungsweise wie der funktioniert oder als Beispiel, also ein 7-4-Hemming-Code.
Das heißt, das wäre im Prinzip jetzt nur dieser Teil bis hier vorne.
Bis hier genau, würde dann eben sich zusammensetzen,
dass das erste Prüfbit Genau, hier diese Datenbits mit dem roten Punkt,
mit dem XO, quasi verbindet.
Das zweite Prüfbild bezieht sich dann eben auf alle Datenbits,
wo jetzt also entsprechend diesem Team mit diesem grünen Punkt markiert sind und
das dritte Prüfbild dann eben auf diese letzten drei Datenbit.
Die nächst höhere oder weitergehende Stufe,
also dann quasi ein 15-11-Hemming-Code,
wo ich jetzt also hier vier Prüfbitz berechne,
würde das dann eben entsprechend jetzt mit diesen vier Farben
hier machen und so weiter und so
Nicht, das ist also jetzt mal so ein bisschen grafischer,
veranschaulicht, letztendlich das, was hier jetzt so formal beschrieben ist.
So, jetzt möchte man,
wenn man das jetzt natürlich über den Computer berechnet,
die Dinger nicht, also irgendwie der Reihe nach irgendwie auflisten und sagen,
da streiche ich das raus, da streiche ich das raus,
sondern macht man das natürlich dann ein bisschen anders.
Und dazu hatte ich also bei dem 3-1-Samming-Code schon angesprochen,
wenn das dann so was wie Matrix-Multiplikationen,
zumindest also jetzt hier beim 7-4-Hamming-Code,
ist es dann eben schon ein bisschen anschaulicher,
weil dann wird das also nicht mehr so ganz trivial
Da sieht das ja eben so aus, dass ich sage, ich habe sieben Codebits für vier, fünf, vier Datenbits. Das Ganze ist ein 7-4-Block-Code. Ich kann dann entsprechend,
um mir zu sagen,
welche Prüfspitze oder welche Stellen von Prüfbitz jetzt aus meinem Datenwort,
Einfluss auf welche,
nein oder welche Prüfbitz jetzt in meinem Datenwort sich aus welchen ursprünglichen Bits berechnen,
dann eben so eine Generatormatrix aufstellen,
wo ich dann eben die Berechnung der Informationen dann eben über so eine Matrix-Multiplikation machen könnte und kann dann im Gegenzug dazu mit einer Prüfmatrix,
die dann quasi orthogonal dazu angeordnet ist,
dann eben sagen,
wenn ich jetzt also ein Hemming kodierte Informationen erhalten habe,
rechne ich dann eben auch über eine Matrix-Multiplikation,
Prüfmatrix mal dieser kodierten Information und das muss dann eben
quasi ein Nullvektor ergeben
Und wenn es nicht an der Null weckte wird,
also sprich ungültige Kotwörter,
erhalte ich dann quasi mit den drei Prüfbitz kodiert, die Information,
an welcher Stelle oder an welchem Datenbit der Fehler aufgetreten ist.
So, die Frage ist,
wie kommt man zu diesen Informationen bzw. wie rechnet man damit?
Also dazu kommt jetzt gleich nochmal das Praktische Beispiel.
Aber hier jetzt nur nochmal, vorab schon mal zusammengefasst.
Grundsätzlich kann ich eben solche Hemming-Kodes Nehmen,
wo ich dann eben auch mit jeweils wachsenden Wortlängen,
auch immer ein besseres Verhältnis von Nutz zu Prüfbitze habe.
Weil ich hatte ja schon gesagt, also im Prinzip 3-1 Hamming-Code,
da habe ich eben ein Datenbit, zwei Prüfbitze,
also sprich drei übertragene Bits.
Das ist also dieses hier vorne, das ist also relativ witzlos.
Nicht beim 7-4-Hamming-Code habe ich vier Datenbitt und drei Prüfbett.
Da habe ich auch immer noch fast ein Verhältnis von eins zu eins.
Wenn ich dann also hier den nächstgrößeren nehme,
hätte ich jetzt elf Nutzbits und vier Prüfbits
und je
Mehr oder je größer meine Datenworte nehmen,
also sprich mit fünf Prüfbits könnte ich dann,
also ich schon 26 Null Spits letztendlich mit so einem Hamming-Code,
zumindest jetzt für einen wird Fehler Fehler erkennen, beziehungsweise korrigieren.
Das heißt also bei größeren Wortlängen kriege ich da immer bessere Verhältnisse von Nutz zu Prüfbits.
Es ist eben vergleichsweise einfaches Prinzip und es ist auch vertleichsweise
einfach dekodierbar, Nachteil Also es gibt also deutlich bessere Codes,
die da eigentlich, wie ich eben schon gesagt habe,
dann also dann auch rein mathematisch oder rein technisch gesehen dann also noch wieder ganz andere Eigenschaften ausnutzen,
dann also sowieso nur auf nochmal deutlich längeren Worten letztendlich funktionieren,
beziehungsweise Sinn machen.
So, jetzt such dich hier eigentlich die Folien,
wo das Ganze dann hier irgendwo nochmal praktisch beschrieben sind.
Muss ich sagen, jetzt habe ich das gerade hier irgendwie nochmal
neu übersetzt. Was habe ich mir da jetzt gerade,
gerade nochmal irgendwie was kaputt gemacht, weil eigentlich meinte ich,
da müsste jetzt eben gleich nochmal das praktische Beispiel kommen,
wo Ich dann also auch wirklich noch mal mit einem Hemming-Wort rechne,
als Beispiel.
Entschuldigung, da muss ich jetzt noch mal kurz hier in
die Quellen gucken, ob ich das,
was da jetzt schief gelaufen ist oder weswegen ich
das jetzt hier empfohlen nicht drin hatte
Musik Gut, beziehungsweise nicht gut, weil ich meinte eigentlich,
da hätte ich noch mal irgendwie jetzt rein praktisches Falsch, wie das Ganze aussieht.
Aber gleich nochmal also nochmal gucken. Also im Zahlshurver
wird das nochmal nachgeliefert. Ansonsten kann ich nur sagen,
oder würde ich das jetzt mal versuchen, also entsprechend hier jetzt herzuleiten.
Also ich habe ja hier diese Generatormatrix,
da geht es ja so im Prinzip jetzt darum zu sagen,
wie setzt die sich zusammen, beziehungsweise wie ist die aufgebaut.
Und das, was man hier im Prinzip jetzt immer Sieht,
ist jetzt für die jeweiligen Bits,
wie die sich jetzt aus entsprechend anderen Bits,
die ich jetzt kodieren möchte, zusammensetzen.
Und da kann ich jetzt eben sagen,
dass erste Bit, was ich letztendlich kodiere,
wäre jetzt ja in der Matrix-Multiplikation
quasi Zeile mal spalte
Das heißt, ich habe in diesem Fall jetzt also vier Nordspits.
Und das erste Bit, was ich quasi jetzt in meinem Hemming-Wort erhalte,
also sprich dieses P1, setzt sich ja zusammen aus Datenbit 1,
X-Or-Datenbit 2, X-Or-Datenbit
4. Und das ist jetzt eben genau in der Matrix-Multiplikation quasi die eins,
mal dem ersten Bit, die eins,
mal dem zweiten Bit,
dann habe ich
hier null
Das heißt, das dritte Bit wird nicht berücksichtigt und die
eins mal dem vierten Bit. Das heißt also,
hier mit diesem Zahlenvektor habe ich dann eben genau die Auswahl der
entsprechenden Nurd Spits, die jetzt in dieses erste Prüfbit eingehen.
Diese Zeile wäre jetzt quasi die Beschreibung für das zweite Prüfbit,
was sich dann eben ergibt als D1, X,
OD 3, X, OD 4,
was dann eben hier erstes Bit ist zweites Bit wird nicht berücksichtigt.
Das dritte Bit wird berücksichtigt und das vierte Bit wird berücksichtigt.
Das heißt, aus der entsprechenden Matrix Multiplikation hätte ich dann eben genau Diesen Ausdruck.
So, anschließend, wenn ich mir jetzt dieses Schema angucke,
kommt das erste Datenbit in meinem Codewort, was jetzt also hier übertragen wird.
Demzufolge habe ich hier in der Generator-Matrix dann eben auch nur
an dieser einen Stelle eine Eins,
mit der wähle ich jetzt eben genau mein Eins,
so eines Datenbit aus und das war's.
Dann kommt jetzt hier das nächste Prüfbett,
berechnet sich dann als die zwei XOD3,
Was also genau hier ist, das erste nicht.
Das zweite, das dritte und das vierte Nutzbit.
Nicht nur anschließend folgen dann eben noch, wie man hier sieht.
Zweites, drittes und viertes Bild meines ursprünglichen Wortes.
Also demzufolge diese Zeile mal dem Wort wählt genau das zweite Bit aus.
Hier wähle ich genau das dritte und hier genau das vierte Bit aus.
Das heißt, über eine entsprechende Matrix-Multiplikation von dieser Matrix und
mal 400 Spits erhalte ich dann eben einen Siebenbettbreitenwektor,
der jetzt genau dem Hemmingcode entspricht
Nicht. Und umgekehrt kann ich dann eben genauso jetzt hier
über diese Prüfmatrix und die Multiplikation damit die entsprechenden Prüfwerte generieren.
Nicht, wo ich dann eben hier quasi mit diesem ersten 1-0,
1-0 und so weiter genau diese Abfolge habe,
dass ich hier letztendlich immer jedes zweite Bit berücksichtigt habe.
Ich hebe dann immer diese Zweiergruppen und hier mit diesem Wort
dann eben entsprechend immer diese Vierergruppen
Die dann also für das nächste Wort benötigt wurden.
Gut, und damit kann man dann eben entsprechend jetzt
seinen Hemmingode über so eine Matrix-Multiplikation erzeugen.
Gut, damit sind wir dann für heute auch erstmal am Ende.
Danke für die Geduld und nächstes Mal
geht's dann weiter