Ja, also am Mittwoch hat er ja aufgehört mit der Idee bzw. Vorstellung,
also zu beschreiben, wie man wirklich jetzt Informationen in Informationsgehalt messen kann. Das heißt,
wenn ich jetzt also sage, ich habe jetzt irgendwelche Ereignisse,
die mit einer bestimmten stocherstischen Wahrscheinlichkeit ankommen und ich empfange eben eine bestimmte Nachricht mit einem,
die eine Wahrscheinlichkeit aha hat, dass man dann eben sagt,
Entsprechend je kleiner ihre Wahrscheinlichkeit ist,
umso größer ist eigentlich die Information, die ich,
also aus dem Empfang dieser Nachricht,
beziehungsweise eben aus diesem Ereignis ziehen kann.
Nicht demzufolge könnte man jetzt erstmal sagen, der Kehrwert der Wahrscheinlichkeit
kann dann im Prinzip als Maß für den Informationsgewinn angesetzt werden.
Nachteil bei dem ganzen Verfahren ist jetzt,
wenn ich jetzt eben mehrere voneinander unabhängige Ereignisse habe,
also sprich Wenn wir jetzt wieder irgendwie auf dem Computer übergehen,
normale Datenübertragung. Ich empfange jetzt also irgendwelche einzelnen Zeichen,
die jetzt nach ODF 8 oder was auch immer irgendwie kodiert sind,
sind sie im Prinzip erstmal unabhängig voneinander. Und die Wahrscheinlichkeit,
dass sich jetzt eben eine bestimmte Zeichenkombination empfange,
wäre danach dann entsprechende Wahrscheinlichkeitsrechnung, dann eben einfach das Produkt der jeweiligen Einzelwahrscheinlichkeiten,
was sich dann eben entsprechend dann in dieser Rechnung,
wenn ich jetzt eben eins durch PS Mars für einen Informationsgewinn nehme, berücksichtigen müsste.
So, und da wäre es jetzt natürlich also einfach schöner zu sagen,
ich habe jetzt also als Maßanheit, also nicht irgendwas,
was ich ja so multiplizieren kann, sondern wenn ich sage,
ich empfange ein, Zeichen, zwei Zeichen, drei Zeichen,
dass ich das also quasi jetzt entsprechend irgendwie addieren kann.
Deswegen als Größe, eine additive Größe,
nämlich indem ich also den Logarithmus von eins durch P bilde,
auf dieser Folie nochmal kurz die Wiederholung, Schulmathematik,
was ist Luca Rhythmus, ist im Prinzip also die Umkehrungs-Exponentialfunktion.
Das heißt, wenn ich eben ein A habe,
eine Basis B, dann ist also quasi der Logarhythmus, zur Basis
B von A, die Zahl X,
für die dann eben gilt, A ist gleich B hoch X. Beispiel,
ganz klar Logarhythmus, duales,
zwei von acht wäre drei,
weil zwei hoch drei ist acht
Ich das also erst mal, Erklärung der Logarithmusfunktion. So,
an Rechenregeln gilt dann dementsprechend,
also wenn ich Logarithmus von x Mal Y berechne,
dass ich dann eben Logarithmus x plus Lungarhythmus y rechnen kann.
Nicht ganz einfach, dadurch da das, was ja hier
als Logarithmus rauskommt, ist ja quasi hier der Exponent.
Und wenn ich also quasi zu rechne,
nicht bleiben wir also erst mal im Vinärsystem,
zwei hoch drei, mal zwei hoch fünf,
dann ist das eben zwei hoch drei plus fünf,
also sprich zwei
hoch acht
Gut, dann gilt, Herr Logarhythmus B, Hochlugarhythmus,
B, von Access Leiche X, beziehungsweise Logarhythmus B,
von B hoch X ist auch gleich X.
Hier mit dieser Formel ist jetzt angedeutet, beziehungsweise das Verfahren beschrieben,
was man also gelegentlich nun auch mal braucht,
zum Beispiel vielleicht in den Übungsaufgaben oder so,
wie ich Logarhythmen jetzt zu anderen Basen auch noch bilden kann,
das heißt also, wenn ich Logarhythmus von X einer Basis
B rechne oder bestimmen möchte, kann ich eben auch sagen,
okay, ich kann jetzt also Lugath Moss X an der Basis A nehmen, geteilt durch Lugath Moss
B zur Basis A. Also wo man das häufig anwendet,
ist, wenn ich als Basis die Ohrlasche Zahl nehme,
das ist dann immer als LN abgekürzt, Lugathmus naturales,
wo ich dann eben sage,
also Logarhythmus zu Basis 2 von X wäre dann eben denen zufolge,
LNX durch LN2, das ist eben eine Konstante,
die dann also irgendwie so 0,69 und so weiter ist
Gut, in Bezug auf Binärzahlen, dann auch nochmal den Begriff des Binärenlugarhythmus.
Wenn ich also eine Zahl X zwischen 1 und 2 habe,
dann ist nämlich im Prinzip der Lugarhythmus der Basis 2,
das, was ich quasi jetzt in der Dualdarstellung von dem Ganzen,
also als 0,
BIS,
B2 oder 3 und so weiter habe,
spricht die Nachkommastellen der jeweiligen Dualdarstellung
Entsprechend. Hier ist das Ganze nochmal so als Pseudo-Code beschrieben,
wie man quasi jetzt mit dem Algorithmus das Ganze jeweils ausrechnen könnte.
Das entspricht im Prinzip, also auch dem Verfahren,
was ich also oft mal grob vorgestellt habe,
als es darum ging,
dann also quasi mit den Zahlen Basen hin und her zu rechnen.
Also da steckt dann hier im Prinzip dann auch noch mit drin.
Gut. Jetzt also Definition von den Informationsgehalt
Wenn ich ein Ereignis habe mit einer bestimmten Wahrscheinlichkeit und man
macht das jetzt eben quasi mit dieser additiven Größe des Logerhythmus,
dann ist eben der definierte Informationsgehalt eines Ereignisses als Logerhythmus,
Duales von eins durch PI, das heißt also quasi,
wie vorher schon angedeutet, Kehrwert von der Wahrscheinlichkeit,
davon aber jetzt eben der Logerhythmus gebildet.
Gut, mathematisch kann ich das dann auch umrechnen,
statt eins durch PI kann ich sagen
Die hoch minus eins, kann das dann rausziehen und hätte
dann also minus Lugarithmus-Duales VP. Das ist die Definition für
den Informationsgehalt. Als I quasi jetzt hier immer bezeichnet,
beziehungsweise in anderer Literatur, findet man dann auch oft Entscheidungsgehalt.
Damit kann man dann eben entsprechend rechnen,
wenn ich jetzt also zwei Nachrichten A und B habe,
dann ist eben der Informationsgehalt von A plus B,
demzufolge, dann Lugarithmus-Duales von 1 durch PA,
mal PP und aufgrund Der Rechenregeln des Lugarithmus kann ich das dann dementsprechend hier in dieser Addition direkt umsetzen.
Gut, dieser Wert von ihm ist dann jetzt wirklich eine reelle Größe.
Wird gemessen in der Einheit ein Bit. Bit,
hier jetzt also nicht zu verwechseln mit der Anzahl von Binärstellen
oder mit dem Bürgerriff Binary Digit
Hier als Maßeinheit wird das typischerweise eigentlich auch immer groß geschrieben.
Ich habe jetzt nur festgestellt, ich habe das,
glaube ich, teilweise vorher im Skript immer nicht ganz konsistent.
Das heißt, wenn ich also irgendwie sowas habe wie eine 16-Bit-Leitung,
kann es sein, dass da auch einfach mal ein großes Beam mit drin steht.
Nicht eigentlich sollte man das so ein konsequenter, da dann immer
irgendwie klein schreiben und wirklich nur für die Maßeinheit groß.
Aber gut, also das verwechselt man dann eigentlich immer gerne mal,
aber in der Regel geht das eigentlich aus dem Kontext,
der vor war es jetzt gemeint
Gut, wenn ich jetzt nur als Nachrichten erhalte,
Symbol Null oder Symbol 1, mit der gleichen Wahrscheinlichkeit von jeweils einem halb,
bin ich dann aus der Informationsgehalt des Empfangs einer Null oder einer Eins.
Dann einfach eins durch eineinhalb, Glugoth musst du alles davon
genau, ein Bit. Nicht, das heißt,
da deckt sich dann die Anzahl der empfangenen Bits dann auch
wirklich genau mit dem Informationsgehalt eins zu eins,
wobei das eben Deswegen auch nur giltweilig,
also letztendlich hier beide Symbole gleich wahrscheinlich habe.
Gut, hier nochmal, jetzt zwar zwei, drei andere Begriffe.
Wenn ich jetzt also hier von eigentlich zusammennehme,
also Informationen, Informationsgehalt, das Gegenteil davon quasi eins,
minus der Wahrscheinlichkeit wäre dann eigentlich
die Ungewissheit
Das heißt also, vor dem Nachrichtanempfang war einer oder vor dem Empfang einer Nachricht,
weiß ich jetzt eben nicht, was letztendlich übertragen wird.
Nicht beim Empfang gewinne ich dann eben Informationen und das
ist dann eben letztendlich dann dieser Informationsgehalt.
Je nachdem, in welchem Kontext das gemeint ist,
wird das dann also alles in mitgemessen.
Gut, das Ganze sind eigentlich Begriffe,
die man dann, also typischerweise einer Nachrichtentechnik mitverwendet.
Nicht demzufolge ist dort die Information dann eben auch jetzt erstmal
so nachrichtentechnisch genommen und jetzt ist weniger Umgangssprachlich
Weil da kommen dann ja noch so andere Effekte mit rein.
Also diese Mehrdeutigkeiten, was ich dann also beispielsweise in einem vierten Kapitel
auch schon mal kurz angesprochen hatte. Beispiele. Also wenn ich sage,
die Wahrscheinlichkeit, dass man an einem bestimmten Tag jetzt,
also von einem Meteor getroffen wird, sei 10 Uhr,
minus 16, dann wäre quasi die Ungewissheit,
sprich das Gegenteil davon, also 1,
minus 10 Uhr minus 16 und der Informationsgehalt davon dann entsprechend 3,2 mal 10 und minus 16 sehr klein.
Nicht demzufolge ist dann also auch der Informationsgewinn, wenn ich eben sage,
ich wurde jetzt nicht vom Meteor erschlagen, auch vergleichsweise gering,
weil das also natürlich der extrem wahrscheinliche Fall ist.
Umgekehrt wenn dieses Ereignis jetzt doch eintreten sollte,
hätte man dann zu rechnen, dann eben eins durch,
zehn hohe minus 16, Lugarith musst du alles davon.
Und der Informationsgehalt wäre dann 53,15-Bit. Gut, wo ist das
eigentlich jetzt eher begegnet? Ist jetzt bei so den üblichen,
stohassischen Beispielen, also sprich Würfeln mit einem Würfel, wo man jetzt eben sagt,
also beispielsweise Ich möchte hier irgendwo eher eine Sechs würfeln.
Die Wahrscheinlichkeit dazu ist, dann eben ein Sechste. Und der Informationsgehalt,
der dann also quasi da drin steht, wenn das Ereignis dann eben auftritt,
wäre dann also 2,5-8-5-Bit.
Das heißt, dann nehme ich dann eben wirklich einfach genau die Wahrscheinlichkeit,
setze es also hier in die Formel ein und rechne das stumpf aus.
Anderes Beispiel, wenn ich jetzt also hier ein Buch nehme,
zum einen mal eins, Jetzt als typisches Beispiel eigentlich irgendwie so ein normaler,
umgangssprachiger deutscher Text.
Zum anderen also eins, wo ich jetzt einfach über einen Zufallsgenerator jetzt,
also von 80 möglichen Zeichen, irgendwie ein beliebiges Zeichen drinstehen habe.
Wie groß ist der Informationsgehalt in beiden Fällen?
Da ist eben das, wo man dann eigentlich auch schon sieht,
wie also Kontextentscheidungen sich dann eben entsprechend auch auswirken. Nicht mal,
wenn ich beispielsweise in dem deutschen Text jetzt als Informationen dann schon gelesen habe,
der Begriff, dann wird höchstwahrscheinlich,
also das zweite noch fehlende F für den Begriff,
das nächste Zeichen sein.
Nicht während im Gegensatz dazu beim Zufallszahlentext,
die ja wirklich alle Zeichen gleich wahrscheinlich sind und jedes Symbol
dann als zusätzliche Informationen dann eben ein 80. und davon eins durch ein 80. Rhythmus du alles dann entsprechend nimmt.
Und auch da habe ich da dann eben genau diesen Fall,
dass alle Zeichen gleich wahrscheinlich sind
Das, was sie daraus dann eben auch ergibt, ist,
dass dann also der Zufallsex dann eben auch die größtmögliche Information beinhaltet,
auch wenn er in dem Sinne als Text jetzt natürlich also erstmal Unsinn ist.
Anderes Beispiel, die Wahrscheinlichkeit,
dass in einem Text an einer gegebenen Stelle das Zeichen A anzutreffen ist,
das war ein 0,01, Informationsgehalt, demzufolge dann,
wenn ich das hier einfach ausrechne,
dann auch 6,6439 Bit
Wenn dieser Text jetzt als ISO 88, 59 Text kodiert ist,
mit 8, Bit jetzt klein geschrieben,
also 8 wie näher stellen zur Repräsentation, dann sieht man,
dass also der Informationsgehalt, der da also jetzt bei dieser Wahrscheinlichkeit drin ist,
eben kleiner ist als das, was jetzt hier für die Kodierung genommen wird.
Also das eigentlich auch nur nochmal zur Veranschaulichung,
wo jetzt also der Unterschied ist zwischen dem Begriff Informationsgehalt,
wie er jetzt also aus der Informationstheorie stammt,
wo es sich eigentlich die Einheit Bit großgeschrieben,
dann eben wirklich nur aus den Wahrscheinlichkeiten bzw. der Wahrscheinlichkeitsverteilung heraus ergibt und dem,
wo uns jetzt also der Begriff Bit immer begegnet ist,
bei irgendwelchen Kodierungen,
wo ich also quasi jetzt sage,
ich benutze dafür so und so viel die Näherstellen
Dass sich das dann eben noch unterscheiden kann,
welche Auswirkungen das hat,
wird dann also gleich im Vorgänge noch kurz skizziert,
beziehungsweise dann kommt nämlich eigentlich auch der Teil, wo man sieht,
also weswegen ist er dann vielleicht nur noch Unterschiede gibt oder geben sollte,
weil wenn ich im Prinzip es bei der Nachrichtenübertragung irgendwie Codierung verwende,
die Fehler erkennen oder Fehler korrigieren sollen,
muss ich nämlich genau sowas im Prinzip dann einbauen.
Das heißt, in dem Fall dann Redundanz einbauen und dafür sorgen,
dass ich mit meiner Codierung dann eben mehr Bit benötiger als der eigentliche Informationsgehalt,
dadurch dann aber eben feststellen kann,
dass also bei der Übertragung zum Beispiel dann massiv gelaufen ist.
Gut, als nächster Begriff jetzt aus der Kodierungstheorie dann
noch kurz der Begriff der Entropie. Alles,
was ich vorher beschrieben hatte, also sprich Informationen oder Informationsgehalt eines Zeichens,
ergibt sich jetzt nur aus der Wahrscheinlichkeit dieses einzelnen Zeichens oder dieses Begriffes.
Wenn ich jetzt sage, was ist also, sag mal,
Durchschnittliche Informationsgehalt beim Empfang einer Nachricht oder eines Symbols.
Dann spricht man eben vom mittleren Informationsgehalt oder eben auch von der Entropie.
Das heißt, ich habe jetzt eine Menge von Ereignissen mit ihnen
jeweils zugehörigen Wahrscheinlichkeiten. Insgesamt sorgt dann für die Wahrscheinlichkeiten gelten,
dass die Summe dann also gleich eins ist.
Und die Entropie hier dann immer als Haar abgekürzt,
entspricht dann quasi dem Erwartungswert über alle Informationsgehalte,
formelmäßig mache ich dann also nichts anderes,
als dass ich jetzt den Informationsgehalt eines Zeichens oder einer Nachricht nehme,
also iVon A,
das multipliziere mit dessen Wahrscheinlichkeit und das dann eben
über alle Zeichen aufsummiere
Ich war es dann also hier quasi formal-mäßig mit diesen drei Summen letztendlich beschrieben ist. So,
was man daraus dann eben auch erst mal rausziehen kann,
also ich hatte es ja eben auch schon für einzeichen gesagt,
also der Begriff der Entropie ist eben auch erst mal nur bezogen auf dieses stochastische Modell.
Das heißt also, welche Zeichen, mit welcher Wahrscheinlichkeit, das hat erst mal noch nichts weiter mit der Kodierung zu tun. Beispiele zu dem Begriff der Entropie,
also angenommen, ich habe jetzt hier drei mögliche Ereignisse mit den Wahrscheinlichkeiten an halb ein Drittel und ein Sechstel,
dann ist die Entropie hier jetzt einfach formelmäßig in das,
was das auf der Folie vorher drin stand, eingesetzt,
ausgerechnet, dann 1,4591. Angenommen, ich habe jetzt irgendwie eine Binärstelle,
also sprich 0 oder 1, die empfange ich mit den Wahrscheinlichkeiten,
die 0 mit einer Wahrscheinlichkeit, QD1 mit einer Wahrscheinlichkeit 1,
Minuskuh für Kuhgleicheinhalb, also das heißt 0 und 1 sind gleich wahrscheinlich,
erhalte ich dann eben auch für die Enthopie als Wert.
Eins, das heißt also der mittlere Informationsgehalt beim Befang einer Binährstelle,
wenn die Wahrscheinlichkeit jeweils gleich ist, ist genau ein Bit.
Wenn die Wahrscheinlichkeit nicht gleich ist, das ist das,
was sie jetzt mit dieser Kurve dann aufgeplottet ist, ist,
dass wenn ein Zeichen wahrscheinlicher ist, dass andere demzufolge unwahrscheinlicher,
dass dann eben die Entropie entsprechend abnimmt, Einzeichen quasi nie auftritt.
Das heißt, dessen Wahrscheinlichkeit null ist, demzuvollkommen mit einem anderen Zeichen
die Wahrscheinlichkeit eins. Das ist also quasi hier oder hier jeweils
der Fall, ist die Entropie auch gleich null.
Und ansonsten habe ich eben immer den Effekt,
dass wenn ich was weiß ich,
jetzt eine Null mit Anna Wahrscheinlichkeit von 20 Prozent habe und in 80 Prozent eine Eins,
das dann also entsprechend dieser Formel dann eben die Entropie,
also hier irgendwie im Bereich von 0,72 liegt.
Ist dann einfach Durch entsprechendes Einsetzen der Wahrscheinlichkeiten beziehungsweise ein formelmäßig direkt auszurechnen.
Gut, mittlere Informationsgehalt ist genau Nodan ein, mittlerweile Symbole gleichwahrscheinlich sind,
hatte ich gerade eben gezeigt. Nicht bei entsprechend größeren Symbolmengen,
also gehen wir jetzt wieder zu realistischen Beispielen,
also sprich irgendwie sowas wie Zeichensatzkodierung oder sowas,
wo ich dann also ach, 256 Symbole habe,
acht Bit, alle gleich wahrscheinlich.
Gut genau, dann ist die Entropie quasi dann auch genauso groß wie die Kodierung erstmal.
Eigenschaften der Entropie, wenn alle Wahrscheinlichkeiten gleichwahrscheinlich sind,
das heißt also PI ist gleich eins durch N,
N ist die Aushalt der Symbole, dann ist die Entropie maximal.
Für zwei Symbole war das eben genau das, gerade eben in dieser entsprechenden Verteilungskurve.
Dann ist der Begriff der Entropie quasi Symmetrisch, das heißt,
für die Permutation der Wahrscheinlichkeiten gilt, dass die Entropien dann quasi gleich sind.
Also auch das sieht man im Prinzip hier schon,
nicht wenn ich sage, also das eine bei zwei Zeichen,
also das eine Zeichen hat die Wahrscheinlichkeit von 0,2.
Und das andere hätte die Wahrscheinlichkeit von 0,8. Nicht,
dann ist das im Prinzip identisch mit dem, wo ich dann sage,
das Zeichen null hätte ihm jetzt nicht 0,2 als Wahrscheinlichkeit,
sondern 0,8.
Dafür hat er dann eben entsprechend
das Zeichen einzeln
Den entsprechend anderen Wert. Und genau das Gleiche gilt dann
eben auch für größere Mengen von Zeichen,
wo ich dann einfach jetzt hier die entsprechenden Wahrscheinlichkeitswerte permutiert,
das heißt irgendwie anders angeordnet habe.
Die Entropie, wenn ich in meinen Wahrscheinlichkeiten eben ein Zeichen
mit einer Wahrscheinlichkeit eins habe,
alle anderen werden dann logischerweise die Wahrscheinlichkeit null haben,
ist dann eben
gleich null
Eigentlich klar und einleuchten. Da hatte ich einen eingangs,
also auch schon beschrieben, weil da weiß ich halt einfach,
es wird immer nur dieses eine Zeichen kommen.
Echt, das wäre also jetzt vergleichsweise jetzt los.
Dann kann ich eben sagen, wenn die Wahrscheinlichkeit eines Zeichens null ist,
kann ich das dann also letztendlich auch komplett weglassen.
Hier geht es ja nur darum,
dass wenn die Anzahl der Zeichenmenge größer wird,
dann auch die Entropie größer werden wird.
Stetigkeit, Additivität ergibt sich dann also einfach Direktes aus der
rechenmäßigen Formel
Wie gesagt, da ist jetzt nur noch mal ein paar mathematische Eigenschaften zur Entropie.
Gut, alles bislang Informationsgehalt, Entropie waren Begriffe,
die sich also jetzt mathematisch nur aus Zeichen und ihren Häufigkeiten heraus ergaben.
Das, womit wir jetzt auch immer arbeiten, sind jetzt irgendwelche Codierungen,
die ich jetzt vielleicht geschickt, vielleicht noch sehr ungeschickt gewählt habe,
wo es jetzt eben wirklich darum geht, wie jetzt irgendwelche Symbole kodiert sind.
Und dafür kann man dann eben auch berechnen,
wie jetzt also der mögliche Informationsgehalt, hier dann immer als H0 beschrieben,
sich aus der Kodierung der entsprechenden Symbole heraus ergibt.
Und zwar kann ich dann eben sagen,
wenn ich jetzt also eine bestimmte Kotwortlänge habe, dieses L,
dass dann der mögliche Informationsgehalt eben bestimmt ist,
indem ich also jetzt die Wahrscheinlichkeiten der entsprechenden Codierung dann also auch jetzt wieder über alle Symbole aufsummiere.
Das ist also im Prinzip genau das Gleiche,
was hier vorne auch bei der Entropie drin steht.
Bloß hier habe ich letztendlich das stochastische Modell stehen,
das heißt also eins durch PI, während hier geht es,
also dann also um die Länge in der Kodierung,
das heißt also die Anzahl der Zeichen,
Q hoch LI, mal ihrer Kotwortlänge.
Und das hiermit habe ich dann also quasi einen Begriff dann dementsprechend für die Metallkohle. So,
wenn ich binärkodes habe, das heißt also im Prinzip,
also ein kunäres Alphabet mit entsprechend vielen Zeichen,
beim binären Alphabet hätte ich dann eben genauer zwei Zeichen,
ergibt sich dann an dieser Stelle, ja, Zwei Hoch-LE-Logarithmus,
Duales von zwei hoch.
X tauchte also ganz am Anfang mal bei den Rechenregeln auf.
Dann kann ich nämlich den Logarithmus komplett weglassen und dann gilt eben für Minärcodes,
dass der mögliche Informationsgehalt dann eben die Wahrscheinlichkeit,
diese Codierung ist mal ihrer Länge.
So, wenn ich jetzt binäre Blockcodes habe, was waren Blockcodes?
Blockcodes waren Codes, bei denen alle Zeichen gleich lang kodiert sind,
mit einer Wortlänge von Enbit, dann entspricht eigentlich der mögliche Informationsgehalt,
dann eben auch entsprechend der Wortlänge.
Wenn ich Beispiele habe, was ja vorhin auch schon der Fall war,
wo jetzt also wirklich alle Zeichen auch benutzt werden,
also 256 Zeichen in 8 Bit kodiert,
auch mit ihren Wahrscheinlichkeiten
jeweils von einem
Das war also, dieses Beispiel dann ist,
wo die Intropie, das heißt, dass, ha,
genauso groß wie jetzt bei diesem Beispiel dann eben auch der mögliche Informationsgehalt.
So, jetzt als letzten Begriff, um alle dann
Vollendste verwirren, dann eben noch der Begriff der Redundance.
Das ist dann nämlich jetzt genau die Differenz zwischen den möglichen und
dem tatsächlichen genutzten Informationsgehalt. Das heißt also Redundanz wäre H.0,
der mögliche Informationsgehalt, dass der sich aus der Kodierung,
aus der Wortlänge heraus ergibt, minus der Entropie,
die Entropie ergibt sich jetzt aus den Wahrscheinlichkeiten der Symbole.
Das ist dann eben das, was man als Redundanz bezeichnet,
kann man dann eben entweder als absoluten Wert haben,
das wäre dann eben entsprechend dieser Formel oder dann eben als relative Redundanz,
wo ich das Ganze dann quasi mit H0,
Normiere und dann eben entsprechend einen Wert zwischen 0 und 1 letztendlich bekomme.
Goodbye, binären Blockcodes mit einer Wortlänge von Enbit,
gilt die der mögliche Informationsgehalt H.0 wäre dann eben genau leichte Wortlänge, nämlich En.
Für die Entropie würde ich dann entsprechend jetzt dieser Formel rechnen Hanull minus Han.
Ha, war, also Entropie war dann eben formenmäßig dieser Ausdruck hier in der Klammer.
Hanull ist ja genau in dem Fall,
dass wir jetzt einen Blogcode haben, die Anzahl der Bits,
die benötigt werden, also N plus diesem Ausdruck da.
Damit kann man dann eben im Prinzip die Redundanz eines Codes ausrechnen.
Gut, dann noch zu dem Begriff der Kanalkapazität.
Da geht es jetzt nämlich also auch um diese Eigenschaften,
Codierung, was erreiche ich damit, wofür brauche ich überhaupt diesen Begriff,
wofür brauche ich dann eben auch die Redundanz.
Alles, was ich bislang so vorgestellt hatte,
diese ganze Informationstheorie, da geht es ja letztendlich darum zu sagen,
ich habe Informationen,
die soll von A nach B übertragen werden
Ich also hier nochmal als Erinnerung, die Folie hatte ich,
also relativ am Anfang der Vorlesung,
also schon mal drauf, wo es eben sagt,
ich habe also eine Informationsquelle,
ich habe dann also hier einen Sender,
der das Ganze irgendwie kodiert,
ich habe einen Übertragungskanal,
Information wird hier empfangen und hier dekodiert und beide Übertragungen in diesem Kanal habe ich eben bestimmte Störungen,
das heißt also irgendwelche Zeichen können verschluckt werden,
können verfälscht werden und ich fange da jetzt eben entsprechend irgendwie
was anderes
Worum es uns da dann eben dabei geht, ist,
dass man jetzt eben sagt, okay,
wie kriege ich jetzt also hier die Kodierung auf der Senderseite
beziehungsweise die Dekodierung auf der Empfängerseite dann eben so hin,
dass sich jetzt also irgendwelche Störungen,
die hier also auf dem Kanal auftreten können,
möglichst meine Information nicht verfälschen.
Gut, dazu kommen dann eben erstmal theoretisch noch
der Begriff der Kanalkapazität, also jetzt aus der Informationstheorie.
Und zwar ist das dann Wenn ich jetzt also ein binären,
symmetrischen Kanal habe. Das heißt also, ich habe jetzt
Sender-Empfänger, konnte theoretisch Informationen in beide Richtungen schicken.
Ich habe zwei Zeichen 0 und 1. Nicht dann wäre eben
die Kanalkapazität C beschrieben als 1 minus die Entropie eines
irgendwie Fehlermodells und das Fehlermodell ergibt sich dann eben daraus,
was sich hier letztendlich in diesem Kanal tut
Wie wirkt sich das aus? Angenommen,
ich habe jetzt eben so einen binären symmetrischen Kanal, beide Symbole,
0 und 1 sind gleich wahrscheinlich und ich habe eben eine Wahrscheinlichkeit,
GroßP, dass, wenn ich eine Null übertrage,
da draußen eine 1 wird und umgekehrt dann eben die Wahrscheinlichkeit 1 minus P,
dass aus einer 1 eine 0 wird.
Gleichzeitig habe ich dann noch als Voraussetzung, dass solche Bit-Fehler erstmal unabhängig voneinander sind.
Das heißt eigentlich für jedes Zeichen oder für jedes Bit,
was sich eben über den Kanal übertrage, kann bei der nächsten Übertragung mit gleicher Wahrscheinlichkeit dann eben wieder ein Fehler auftreten. So,
dann gilt jetzt für dieses HRF, also die Entropie des Fehlerverhaltens,
dass sich das dann eben berechnen würde, als die Wahrscheinlichkeit P, mal Logariten,
was du alles von eins durch P plus Jetzt eben dem gegenteiligen Effekt,
also 1-p, Malugott musst du alles von 1 durch 1,
minus P, und könnte das dann eben entsprechend ausrechnen und hätte dann eben Fehlerverhalten abhängig von dieser Wahrscheinlichkeit P.
Und die Kanalkapazität, das war das,
was also hier schon als Formel drin war, wäre dann eben eins,
minus H von F. Das heißt, rein praktisch gesehen erstmal,
und das sollte uns dann nun nicht unbedingt überraschen,
dass je größer die Wahrscheinlichkeit ist, dass ein Fehler auftritt,
Umso kleiner wird dann also die Kanalkapazität nicht,
weil das sorgt dann eben dafür,
dass also die Enthopie dieses Fehlerverhaltens größer wird und das ziehe ich dann eben von dem 1 ab.
Dadurch sinkt die Kanalkapazität. So, wenn man das in so ein Diagramm auftritt,
ist das eigentlich nichts anderes, als dieses andere Diagramm vorneweg einmal gedreht,
beziehungsweise einfach dann eben als 1, minus der Entropie der Symbole gerechnet,
wo ich dann eben sage, wenn die Bittfehlerwahrscheinlichkeit einhalb ist,
also 0,5, dann ist die Kanalkapazität,
wie man dann hier sieht, auf null gesunken.
Warum? Ich empfange irgendwas und ich kann also jetzt nicht sicher sagen,
ist das, was ich empfangen habe, ist also ein Bit,
was zufällig gekippt ist mit der Wahrscheinlichkeit einhalb oder ist das ein Bit,
was also vielleicht richtig übertragen wurde mit der Wahrscheinlichkeit einhalb.
Wenn die Wahrscheinlichkeiten jetzt hier kleiner sind, also ich mit 20 Prozent Wahrscheinlichkeit, da sind Fehler drin habe. Dann habe ich eben hier noch eine Kanalkapazität von knapp 0,3. Hier andersrum gesehen,
das ist jetzt wieder mehr so ein rein akademischer Fach,
kann ich jetzt natürlich sagen, okay,
wenn die Fehlerwahrscheinlichkeiten deutlich größer werden und vielleicht dann sogar wieder grenzwertig auf eins zu gehen,
dann kann ich sagen, ja gut,
dann stört mich der Fehler nicht, weil dann weiß ich,
ich übertrage eine Null, beim Empfänger kommt eine Eins an,
weil ich habe ja als Fehlerwahrscheinlichkeit,
also jetzt hier eins angenommen und weiß einfach,
jedes Bit wird verfügbar gefälscht übertragen und demzufolge kann ich dann auch immer sagen,
wenn ich eine Einzelempfang habe, der Sender hat eine Null gesendet,
wenn ich eine Null empfangen habe,
der Sender hat eine Eins gesendet.
Echt, das ist also das, was dann eigentlich hier
so auf der rechten Seite passiert, wenn ich größer als 0,5 bin.
Gut, das Ganze, was ich gerade eben textuell beschrieben habe,
ist also hier dann nochmal auf der Folie kurz skizziert,
also das heißt, wie sich das Ganze dann entsprechend verhält.
Quintessenz von dem Ganzen ist dann erstmal nur die Kanalkapazität,
ist im Prinzip sowas wie eine obere Schranke. Das heißt also,
im Prinzip eine Kanalkapazität von 1 wird in der Regel nicht erreicht,
sondern es treten eben irgendwo Übertragungsfehler auf,
nicht bloß glücklicherweise sind hier die Bittfehler wahrscheinlich danebenentsprechend klein,
beziehungsweise das, was jetzt gleich,
womit ich eigentlich mit dieser ganzen Mathematik dann also auch nur hinleiten will,
das, was jetzt live vorgestellt wird,
man hat dann eben entsprechende mathematische Kodierung oder entsprechende Kodierungen gewählt,
die dann eben dafür sorgen,
dass sich Fehler erkennen und vielleicht sogar korrigieren kann
Gut, dann irgendwie zwischenzeitlich gingen immer mal irgendwelche Hände hoch
mit Fragen, haben die sich jetzt schon erledigt? Gut,
ja, abschließend hier auch nur noch mal,
also diese ganze Sache mit dieser Kanalkodierung ist dann eben zusammengefasst in einem Theorie von Claude Channon,
der, also 1949, also quasi jetzt beschrieben hat,
also was eben bei solchen Kanälen und Übertragung, alles passieren kann.
Und dass Shen-Triorim sagt jetzt eben,
dass wenn die Übertragungsrate kleiner ist als die Kanalkapazität,
da findet man zu dem Epcylon eine Kodierung mit einer bestimmten Übertragungsrate.
Das heißt, also ich nehme meine Symbole, kodiere die,
übertrage das dann mit dieser Übertragungsrate durch den Kanal und kann eben gewährleisten,
dass die Fehlerdekodierwahrscheinlichkeit kleiner als Epsilon ist.
Und das Ganze gilt für jedes Y. Umgangssprachlich kann man dann also sagen,
solange die Übertragungsrate kleiner ist als die Kanalkapazität,
existieren kurz die beliebig zuverlässig sind.
Das ist erst mal jetzt nur Theorie,
die sich also aus dem mathematischen Modell heraus ergibt.
Das, was dann eigentlich dann noch dahinter steht,
nämlich wie sieht dann also eine Kodierung aus und wie kommt man dazu,
das hat uns der Shen North 49 dann also noch nicht weiter verraten.
Inzwischen kann man also sagen, es gibt also entsprechend effiziente Codes,
die sowas machen und nachher so gerade beispielsweise in der Raumfahrttechnik nicht,
also nehmen wir jetzt hier aktuelles Beispiel.
Nicht die Länder von Rosetta ist jetzt also gerade auf dem Kometen gelandet. Also das,
was dort an Nachrichten übertragen wird zu dem Modul bzw. was
dann zurückübertragen wird und vielleicht also nach einer zweimal 28 Minuten
dann also wieder irgendwie bei uns angekommen ist,
sind halt eben Nachrichten,
die also entsprechend da nur sehr wenig Leistung zur Verfügung steht und das Ganze über ungeheure Entfernung passiert.
Sehr stark und sehr schnell verfälscht werden können.
Und da setzt man eben entsprechend effiziente Codes ein,
um dann eben auch wirklich mit den Daten noch was anfangen zu können.
Rein praktisch heißt es aber,
dass ich also für eine Nutzinformation von NBT,
also ein Vielfaches an Daten eigentlich übertragen muss,
um dann eben entsprechende Fehlererkennungs- und Fehlerkorrekturcodes noch dort einzubauen,
die dafür dann eben sorgen,
dass diese Fehler
auch entsprechend korrigiert werden können
So, damit sind wir jetzt also bei diesem Teil Fehler
erkennende Codes, beziehungsweise Fehler korrigierende Codes. Also wie gesagt,
das Ganze ergibt sich eben eigentlich aus diesen mathematischen Hintergründen.
Aber sagt eben, dass im Prinzip dann so eine
entsprechend effiziente Daten- oder zuverlässige Datenübertragung erstmal möglich ist.
Wobei ich da dann eben, je nachdem, welche Maßnahmen man da einsetzt,
beziehungsweise miteinander kombiniert. Also ganz am Ende dieses Kapitels will ich schon,
also mal so ein paar in Anführungszeichen einfache Beispiele vorstellen,
wo dann also teilweise wirklich schon drei oder vierstufige Kurdierungen mit eingesetzt werden,
wo es also im Prinzip jetzt über, um Übertragungsverfahren geht,
die wir eigentlich auch tagtäglich und ständig in der Informatik benutzen werden. Gut,
welche Arten von Fehler kann man sich jetzt eben überhaupt erstmal ausdenken,
wenn ich jetzt sage,
also ich habe jetzt irgendwie meinen Nachrichtenkanal,
will eine Nachricht von A nach B irgendwie verschicken,
also zum einen kann es natürlich erstmal ganz stumpf sein,
dass ich sage, also ich habe ein bestimmtes Zeichen,
das wird irgendwie verwechselt und beim Empfänger als ein anderes Zeichen interpretiert,
nicht dann hat man häufig dann sowas wie so ein Vertauschen benachbarter Zeichen,
Vertauschen entfernter Zeichen oder eben irgendwie solche Mehrfachfehler,
die dann da Zwillingsfehler da dann eben auch noch mit auftreten können.
So je nachdem, worum es sich handelt, das heißt,
Wie soll die Information übertragen oder in diesem Fall vielleicht auch gespeichert werden?
Muss man dann eben gucken, welche Arten von Fehler können da
typischerweise auftreten und dann eben auch entsprechend geeignete Kodierungen wählen?
Nicht also ein Beispiel,
ich habe es lange immer nur irgendwie so Nachrichtenübertragung beschrieben,
aber Beispiel ist eben zum Beispiel sowas, wenn ich jetzt sage,
okay, ich nehme jetzt eine CD oder eine DVD und speichere da Informationen drauf.
Das ist ja nur was, was wir mehr oder minder tagtäglich benutzen.
Nicht dann sollte die Kodierung darauf eben so sein,
dass ich die Informationen auch noch hoffentlich zuverlässig runterlesen kann
Nicht nur, wenn ein oder zwei Bits vielleicht mal falsch ausgelesen werden,
sondern also wenn da also auch schon ein bisschen mehr kaputt gegangen ist.
Und wenn ich eben sage,
ich habe also jetzt irgendwie auf der Oberfläche sowas wie ein Kratzer,
dann wäre das eben irgendwie so ein Bündelfehler.
Das heißt also,
das ist einfach so ein ganzer Bereich von Bits letztendlich dann irgendwie falsch ausgelesen wird,
beziehungsweise er kann eben gar nicht ausgelesen werden und die Frage ist dann eben nur,
bis zu welcher Dimension vom Fehler kann man das dann also
quasi jetzt mit den Codierungen dann eben noch wieder entsprechend zurückrechnen
und korrigieren
Wenn ich so bei Fondübertragung ist klar,
da hat man dann typischerweise dann auch entsprechende Fehlermöglichkeiten.
Und gut bei dem, was wir jetzt also irgendwie beschreiben,
eingeben, wenn ich da immer typischerweise Buchstaben drehe,
dass ich dann also irgendwie beim Tippen auf der Tastatur dann also irgendwie zum Dreher drin habe.
Auch das lässt sich Nachrichten theoretisch natürlich auch erfassen.
Ja, zu dem Codierung bzw. jetzt nochmal zu den Begriffen
Blockcode sind dann eben kurz, wo ich dann eben sage,
ich nehme eine Anzahl von Informationssbits und die werden dann in eine Anzahl von kodierten Bits hineinkodiert.
Echt typische Weise ist dann,
habe ich dann eben irgendwie so und so viele Informationsbits,
K und N, größer als K,
dann wird es in meinem Code, Veraltungscodes sind dann kurz,
wo ich dann sage, ich habe einen Bittstrom,
der also quasi jetzt bitseriell irgendwie eingelesen wird und dann eben in einen Code mit Strom umgerechnet wird,
der dann eben eine entsprechend höhere Bittrate hat.
Das sind dann also Sachen, die also beispielsweise bei der Nachrichtenübertragung auftreten.
Das, was ich jetzt im Folgenden immer ja beschreibe,
geht dann eigentlich mehr in diese Richtung Blockcodes.
Dann wird auch noch als Begriff auftauchen, lineare N-K-Codes.
Da geht es darum, dass man Jetzt auch wieder mit mathematischen Modellen beschreibt.
Eigentlich auch, dass ich sage, ich habe K-Nutzbits,
N-Bits jetzt in meinem Code und das Ganze bildet mir dann mathematisch gesehen
ein Unterraum von zwei Hoch-N. GF steht dann also für Galoire-Field,
werde ich nachher nochmal kurz was zu sagen.
Letztendlich ist es damit eigentlich auch erstmal nur ausgedrückt, dass ich sage,
gut, also wenn ich NBit für die Kodierung habe,
habe ich theoretisch erst mal zwei Hochendzeichen.
Ich und das,
was dann also mit dem GF von 2 auch Envy jetzt wieder gemalt ist,
dass sie ja so von diesen zwei Hochendzeichen jetzt eben an bestimmte Menge nehme für meinen Coach,
bestimmte Elemente ausschließe und dann eben auch nur einige von diesen möglichen Kombinationen zulasse und das Ganze dann aber eben so wieder,
dass es bestimmte mathematische Eigenschaften hat,
dass eben gültige Codewörter auch wieder nur auf andere gültige Codewörter
abgebildet werden und so weiter
Ein modifizierter Code wäre dann eben im Prinzip etwas,
wo ich dann eben auch sowas sage,
dass,
wenn ich in meinem Code stellen systematisch veränder,
also beispielsweise eine bestimmte Stelle in dem Code,
also meinetwegen das fünfte Bit immer invertiere,
dann wäre das quasi dann sowas wie ein modifizierter Code,
wo man da dann eben auch
Abhängigkeiten machen kann
Gut, nicht linearer Code. Da nur etwas, was
kein kardimensionaler Unterraum von GF2 auch N ist. Beispiele,
wo das Ganze dann also noch mal kurz erklärt wird, folgen.
Gut, was ist im Prinzip mit diesem GF2 bzw. GF2
hoch N gemeint? Also hier nur der Verweis noch mal
auf beispielsweise deutsche oder englischsprachige Wikipedia. Das, was wir
bislang kennengelernt hatten, war also ganz normale Butsche Algebra.
Das heißt, ich habe und oder und Negation
Und im Sinne einer Algebra kann ich sagen,
und entspricht der Multiplikation oder entspricht der Addition.
Das, was es aber eben nicht gibt,
ist im Prinzip so was wie ein inverses Element der Addition.
Das heißt also, eine Bulsche Algebra ist mathematisch gesehen eben
keinen Körper. Körperaktion würde eben beinhalten,
dass sich also ein inverses Element, mein Additionsoperation habe.
Galoire fällt mit zwei Elementen, also GF2, eben etwas,
was dann also quasi mathematisch gesehen ein Körper ist.
Das heißt, da habe ich auch zwei Verknüpfungen und als Multiplikation,
aber da benutze ich also nicht das oder jetzt als Addition,
sondern das Exklusiv-Oder, was dann also quasi einer Addition Modulu 2 entspricht.
Und da habe ich dann nämlich ein additives Inversus,
wo ich dann eben sage, x,
exklusiv oder seinem eigenen Wert ist dann eben
immer null
Gut, dann nochmal wieder zurück jetzt zu den Begriffen,
systematische Codes sind kurz, wo die Informationen,
die ich kodieren möchte,
direkt in dem Codewort eins zu eins enthalten ist,
wird uns also dann auch gleich noch bei den Hemming Codes begegnen,
wo ich dann eben sage,
ich kann die Stelle und die Stelle und die Stelle
meines Codeworts nehmen und das ist dann eben das,
was ich eigentlich vorher in die Kodierung reingesteckt habe und könnte
es da direkt auslesen
Zyklische Codes wären dann eben kurz zum einen erstmal einen Blockcodes müssen es sein.
Das heißt also, alle Codewörter haben identische Codewortlänge.
Und es muss dann eben auch gelten, dass zyklische Verschiebungen,
das heißt Rotate Left, Rotate Right von gültigen Codewörtern auch wieder gültige Codewörter sind.
Das kann man also zum Beispiel nehmen,
um bei der seriellen Übertragung dafür zu sorgen,
dass man also solche Bündelfehler Das heisst,
wenn jetzt also gleich Gruppen von Zeichen ihre Informationen ändern oder falsch empfangen werden,
dass man das dort dann eben entsprechend effizient feststellen kann,
weil das führt dann eben dazu,
dass dieses mit diesen zyklischen Verschiebungen dann eben nicht mehr gilt,
beziehungsweise wenn man da dann eben entsprechend einfach korrigieren kann.
Gut, grundsätzlich, ja aber ein Empfänger, da hat eine Nachricht,
das wird irgendwie kodiert durch einen gestörten Kanal übertragen wird,
irgendwie hinterher dann beim Empfänger dekodiert,
aufgrund einer hoffentlich geschickten Kodierung wird dann eben festgestellt,
da ist irgendwie was schiefgelaufen,
welche grundsätzlichen Möglichkeiten habe ich jetzt überhaupt erst mal zur Fehlerbehandlung,
das Einfachste ist es natürlich, wenn ich jetzt also quasi symmetrischen Kanal habe.
Das heißt also auch Informationen zurückschicken kann, dass der Empfänger eben feststellt,
okay, da ist was falsch angekommen und er sagt dann eben,
okay, schicken wir das nochmal. Das wäre dann also etwas,
was vom Malgesehen dann eben automatic Repeat Request oder ARQ abgekürzt,
bezeichnet wird, nicht wo man dann eben wirklich sagen kann,
okay, die Informationen möchte ich nochmal gesendet haben und der Empfänger muss dann eben nochmal entsprechend das Ganze wiederholen. Wie gesagt,
bei einigen Protokollen kann man das dann eben auch machen,
hat dann aber natürlich den Nachteil,
dass wenn ich also entsprechend aufwendige Netze habe,
entsprechend große Entfernungen habe oder wenn ich jetzt also irgendwelche Echtzeitanforderungen habe,
das heißt, also wenn jetzt hier das Lecture-to-go-Bild jetzt also irgendwie live gestreamt wird im Netz,
dann würde das natürlich nicht funktionieren, dass also jetzt bei irgendeinem Client,
der das jetzt also quasi als Livestream empfängt,
der dann also sagt, also schick mir hier irgendwie den Teil, also von dem Bild nochmal, weil da ist, also irgendwie bei der Übertragung was schiefgegangen.
Eine Frage
Also die Frage war jetzt, wie würde jetzt ein Empfänger
jetzt für so ein Automatic Repeat to Re-Re-Quest überhaupt erst mal erkennen,
dass ein Zeichen falsch übertragen worden ist, beziehungsweise durch den Übertragungskanal da eine Störung reingekommen ist.
Also auch das setzt überhaupt erst mal voraus,
dass der Code im Prinzip über eine Fehlererkennung verfügt Nicht,
das heißt also, auch da kann ich jetzt nicht sagen,
ich nehme jetzt also irgendwie ein 8-Bit-Zeichen und codiere das in 8-Bit oder schicke die 8 mit einfach direkt eins zu eins rüber,
sondern man muss da dann eben auch schon irgendwelche Prüfbits oder irgendwelche Prüfmechanismen mit rangehängt haben,
dass der Empfänger überhaupt erst mal kennt,
also da ist irgendwo in der Übertragung ein einzelnes Bit gekippt.
Nicht, also hier mit diesem Verfahren ist,
er sieht es überhaupt erst mal nur grundsätzlich gesagt,
also okay, was kann man machen,
wenn man jetzt einen Fehler festgestellt hat,
nicht und das Einfachste wäre jetzt eben erst,
dass ich sage, okay,
also wenn ich jetzt Fehlerkennung habe und ich habe jetzt keine Echtzeitanforderungen und das Protokoll gibt das her,
kann ich eben sagen, schicken wir das nochmal.
Ansonsten hat man eben,
was dann aber eben dann auch wieder zu aufwendigeren Codes dann nochmal führt,
dann eben sowas wie Fehlerkorrekturmaßnahmen, typischerweise in der Nachrichtentechnik dann auch immer bezeichnet,
als Vorwärtsfehlerkorrektur, beziehungsweise im Englischen Forward Error Correction,
wo ich dann eben entsprechend Sofia-Redundanz in meinem Code einbaue.
Das heißt, so viele Prüfziffern und Prüfmechanismen da hinzufüge,
dass der Empfänger quasi das, was falsch übertragen worden ist,
von sich aus selbstständig korrigieren kann.
Wobei auch das natürlich nur bis zu einem gewissen Ausmaß von Fehlern
funktioniert und auch nur und immer nur unter bestimmten Voraussetzungen dann hinsichtlich der Atemerfehler,
nicht aber das eigentlich erst mal so grob, die beiden möglichen Maßnahmen.
Je nach Ata Übertragung, beziehungsweise das, was da kodiert werden soll,
hat man dann eben beide Verfahren, beziehungsweise dann also noch beliebige Kombinationen.
Wie gesagt, also Beispiele werde ich dann also nachher nochmal
kurz so eigentlich auch nur namentlich vorstellen.
Also im Prinzip so typischerweise sowas wie diese Kodierung von irgendwie CD-Informationen,
die ganzen komprimierten Bildformate, also irgendwie JPEG, MPEG,
da sind also alle möglichen Kombinationen von Fehlererkennungs- und Fehlerkorrekturmaßnahmen
letztendlich dann mit drin
Gut, vorneweg nochmal. Begriff Hemming-Abstand. Was ist das
? Das ist im Prinzip die Anzahl der Stellen,
an denen sich zwei Binär-Code-Wörter, die jetzt also W-Bit umfassen, unterscheiden.
Hemming-Gewicht ist der Hemming-Abstand eines Codeworts vom Null-Wort. Als Beispiel,
ich habe hier zwei Wörter A und B,
der Hemming-Abstand dieser beiden Wörter ist drei,
weil die unterscheiden sich An dieser Stelle an dieser Stelle und an dieser Stelle,
also sprich, die unterscheiden sich genau an drei Bits,
Hemming-Abstand 3, Hemming-Gewicht, Hemming-Abstand vom Null-Wort oder rein praktisch gesagt nichts anderes,
als deswegen hier Bitcoin,
die Anzahl der Einsen.
Das heißt also, das Hemming-Gewicht von B ist fünf,
weil das hält genau 5-1 Bits.
Jetzt zu praktischen Mechanismen, wie kann man Fehler erkennende oder Fehler
korrigierende Codes überhaupt erst mal aufbauen. Genau dafür benutzt man jetzt nämlich das,
was ich ja so eingangs angeführt hatte, die Redundanz,
dass ich dann nämlich sage, zum einen habe ich die Wahrscheinlichkeitsverteilung,
zum anderen habe ich jetzt also über die Kodierung oder die Wortlänge der Kodierung,
also in mittleren Informationsgehalt und wenn die beiden weit genug voneinander abweichen und nicht entsprechend viel Redundanz eingebaut habe,
kann ich eben sowohl eine Fehlererkennung und vielleicht dann eben sogar auch eine Fehlerkorrektur in meinen Code mit einbauen.
Oder rein praktisch die Repräsentation enthält eben deutlich, mehr Bits als für Reihenspeicherung notwendig wären. Das,
was man dort dann macht,
deswegen also vorher dieser Begriff des Hemming-Abstands, ist,
dass ich dann eben sage, wenn ich zwei Codewörter habe,
und die Codewörter oder alle Codewörter eines Codes so gewählt sind,
dass sie eben paarweise ein Hemming-Abstand haben,
dann ist das also letztendlich der Minimalabstand in meinem Code.
Also hier in dem Beispiel, jetzt hier nur mit den zwei Wörtern,
wäre ja der Hamming-Abstand 3. Ich will nicht jetzt also
einen Code habe mit mehr Code-Wörtern und alle Kombinationen von Code-Wörtern,
also paarweise alle dann eben so einen Hamming-Abstand von 3 haben.
Das wäre dann eben der Minimalabstand in dem Code.
So eine Fehlerkorrektur kann ich machen,
wenn der Code jetzt eben ein Minimalabstand von D hat,
bis zu Deho minus 1 fehlerhaften Stellen.
Nein, du willst eine Fehlerkennung. Und eine Fehlerkorrektur bis zu
Deho minus 1 Halben stellen. Ähm, die minus 1
natürlich. Ja, das sind, sorry. Nein,
nein, also da habe ich mich jetzt so gerade versprochen.
Also Fehlererkennung bis zu dem minus 1. Fehlerhaften Stellen Fehlerkorrektur,
bis du die minus 1 halbe Fehlerhaften stellen.
Also da hatte ich minus eins gesagt,
aber das ist hier auf der Folie
diesmal richtig
Gut, wird uns gleich noch bei irgendwelchen Beispielen dann,
also begegnen, wo man das da so rein praktisch sieht.
Grundidee bei dem Ganzen oder bei dieser Idee ist es,
ist halt eben, weswegen brauche ich oder weswegen macht man
das jetzt mit diesem Hemming-Abstand und weswegen kann man darüber sowas definieren.
Also wenn ich beispielsweise jetzt hier einen Kot habe,
wo jetzt alle Kotwörter wie hier,
also ein Hemming-Abstand von drei haben, dann Kann ich sagen,
wenn sich jetzt eben ein einzelnes Bit in einem Codewort geändert hat?
Dass man dann letztendlich sieht, welchem Codewort, weil ich ja weiß,
also wirklich zwei gültige Codeworter haben also mindestens einen Hamming-Abstand 3.
Wenn sich jetzt wirklich nur ein einzelnes Bit geändert hat,
kann ich immer noch sagen,
also welchem Codewort quasi dieses empfangene Wort am ähnlichsten ist
Wenn sich zwei Bit geändert haben, dann würde ich schon quasi falsch raten,
weil dann würde ich das also vielleicht schon sagen, das ist also B am ähnlichsten,
obwohl ich also hier so ein verfälschtes A übertragen habe.
Also das ist die Grundidee, die jetzt eigentlich bei diesem Hemming-Abstand dahinter steht,
dass man also zwischen gültige Code-Worte möglichst viele ungültige Worte legt und
wenn sich jetzt eben entsprechend wenig Bits immer nur geändert haben,
kann man sagen, okay, also am wahrscheinlichsten ist, dass das zu dem kommt. So,
wenn ich ihnen jetzt natürlich zu viele,
ich komme gleich auf die Frage zurück,
wenn ich jetzt natürlich zu viele falsche Bits habe,
kann ich auch sagen dann, okay, dann habe ich einen Fehler,
den ich eben nicht mehr weder erkennen noch korrigieren kann,
also angenommen, hier würden jetzt also entsprechend drei Bits sich ändern und die liegen jetzt zufällig,
also genau an den Stellen,
dass da eben aus dem Wort A das Wort B wird,
dann würde der Empfänger sagen, ja, hurra,
ich habe einen B-Empfang,
das ist gültig und Hat dann also in dem Fall dann wirklich falsche Informationen bekommen.
Nicht. Das heißt also, man kann natürlich immer Beispiele konstruieren,
wo ich dann also entsprechend jetzt also weder Fehlererkennung noch eine Fehlerkorrektur machen kann,
aber bis zu einer bestimmten Anzahl von Bits,
und das ist eben genau das, was also da nicht hier drin steht,
wenn ich eben diesen Minimalabstand, die habe,
kann ich also dann Fehler erkennen bzw. Fehler korrigieren.
So, jetzt zu Ihrer Frage
Ja. Ja, also Frage war jetzt,
ob das Hemming-Gewicht dann sowas ist wie die Quersumme für Binärzahlen.
Und Hemming-Gewicht war ja, also der Abstand des Codeworts vom
Null-Wort oder rein praktisch gesehen eben die Anzahl der Einsen.
Da kommen wir jetzt wieder zu dem,
was ja so am Anfang nah mit diesen,
als es also um diese Blitzschiebereien ging,
also mit diesem Beispiel dann mit dem Bitcounterin hatte,
war das genau für solche Sachen in der Kodierungstheorie
braucht man dann beispielsweise
diese Funktion
Ja. Jetzt sind die gleichen Feen gefunden.
Ähm... Ja. Also, äh... Ich hab jetzt erst so ein bisschen das Problem,
dass sie die Frage erst nochmal passen, zu wiederholen.
Also, es ging jetzt also im Prinzip eben auch nochmal um diese Art und Weise,
wie ich jetzt, also mit dem Hemming-Abstand eigentlich beschreibe,
dass sie also Fehler erkennen bzw. Fehler korrigieren kann.
Was dann eigentlich dahintersteht. Und Grundidee oder Grundaussage von dem Hemming-Abstand ist wirklich,
dass ich Also wenn ich jetzt paarweise die Kotworte habe und die sich also hinreichend weit voneinander unterscheiden.
Dass ich dann eben eine Fehlererkennung bzw. eine Fehlerkorrektur habe, machen kann. Und die Idee ist halt,
dass ich sage,
jetzt eben bei einer bestimmten Anzahl von Bits kann ich natürlich jetzt nur,
also nehmen wir hier jetzt als Beispiel mal,
also hier irgendwie diese sechs Bits,
dass ich dann eben jetzt sage, okay,
wenn ich jetzt also entsprechend wenig Kotworte überhaupt erst mal in meinem Code zulasse und immer sage,
als Hemmingabstand, das ist ja eine Eigenschaft,
die erst mal generell für den Code gilt,
das heißt paarweise alle,
ups,
paarweise alle Kotworte unterscheiden sich
mindestens um diesen Hemmingabstand
Dass wenn ich dann ein einzelnes Codewort empfange, ich immer sagen kann,
liegt das jetzt näher an dem Wort oder liegt das näher an dem Wort?
Das ist ja das, was dann also quasi jetzt über
diesen Haming-Abstand letztendlich definiert ist. Ich finde, je nachdem,
wie weit die jetzt also paarweise dann auch immer auseinander sind,
also man kann sich das immer vorstellen,
ich habe hier ein gültiges Codewort,
hier irgendwelche ungültigen und hier wieder ein gültiges Codewort.
So, und die unterscheiden sich dann immer durch den Haming-Abstand,
das, was ich empfange,
ist dann immer irgendwas,
was meinetwegen jetzt hier liegt
Ich und vorne Fehlererkennung, muss ich erst mal nur sagen,
okay, da genügt letztendlich ein Hemmingabstand von zwei. Das heißt,
zwischen zwei Kotworten habe ich ein ungültiges und wenn ich
da jetzt erst mal nur einen einzelnen einen Bittfehler habe,
dann habe ich erst mal ein ungültiges Wort erhalten und kann sagen,
okay, ich habe den Fehler erkannt.
Wenn ich einen Zwei-Bitt-Fehler habe, funktioniert das nicht mehr,
weil dann können natürlich schon zwei Bitt so quasi sich ändern,
dass sie also aus einem gültigen Kotwort hier ein anderes gültiges Kotwort habe.
Bei der Fehlerkorrektur muss ich inzwischen jetzt eben noch mehr Platz haben,
kann dann eben sagen, das empfange ich.
Daher kommt dann auch dieses mit dem D-Minus in halbe und kann dann eben letztendlich sagen,
okay, also wenn ich hier irgendwie was empfange,
dann wird das wahrscheinlicher, also von dem aus durch entsprechende Fehler entstanden worden sein.
Aber grundsätzlich geht es da eben wirklich immer erstmal nur darum zu sagen,
zwischen Kotworten habe ich erstmal Sehr viele ungültige Kotworte mit entsprechendem Hemming-Abstand.
Und ich kann, wenn es eben nicht zu viele Bittfehler auftreten,
dann noch in die richtige Richtung korrigieren.
Gut, welche Möglichkeiten gibt es jetzt, sagen wir mal,
solche Prüfinformationen mit hinzuzufügen, beziehungsweise zu generieren,
zu überrechnen
Hier sind jetzt also unten erstmal verschiedene unterschiedliche Verfahren, quasi benahmst,
ich werde hier nur die wirklich allereinfachsten überhaupt, dass man vorstellen war,
also auch damit kann man dann eigentlich schon wieder ganze Vorlesungen füllen.
Und wie gesagt, das, was man damit macht,
mit dieser Prüfinformation oder auch Prüfnummer, ist dann eben wirklich so eine Fehlererkennung oder Fehlerkorrektur,
was eigentlich auch immer klar ist, ist,
wenn ich jetzt irgendeinen Code habe mit einem bestimmten Hemming-Abstand,
dass ich dann eben den Code jetzt so aufgebaut habe,
dass ich bestimmte einfache Fehler meinetwegen erkennen kann.
Wenn ich jetzt mehr oder schwerere Fehler hätte,
also beispielsweise jetzt hier meine gültigen Codeworte und ich habe jetzt also mehrere Bit-Fehler und das führt dann eben dazu,
dass ich also irgendwas empfange, was eigentlich aus diesem Wort entstanden ist,
was dann aber meinetwegen durch Kippen von Fear Bit,
also eigentlich schon hier irgendwo gelandet ist, Dann kann ich sagen,
gut, also wenn ich damit jetzt eine Fehlerkorrektur machen würde,
würde ich daraus hier ein falsches Wort generieren.
Ich kann aber zumindest sagen, das ist ja etwas,
weswegen man vorher mit dieser ganzen Übertragungstheorie und Kanalkapazität,
das also überhaupt erstmal mathematisch versucht zu beschreiben und zu modellieren,
dass ich dann eben zumindest sage, okay,
also für den Kanal oder für die ich es Störverhalten,
mache ich damit jetzt also keine Fehlerkorrektur,
sondern überhaupt erstmal nur eine Fehlererkennung.
Und dann könnte ich dann eben beispielsweise auch ein Vierbit-Fehler,
wenn ich also hier einen Hemming-Abstand von fünf habe, Erkennen.
Ich kann ihn zwar nicht mehr korrigieren,
aber ich kann zumindest sagen, okay,
also zwei gültige Worte unterscheiden sich, um mindestens fünf Bit.
Nicht aus einem gültigen Wort, was ich sende,
sind vier Bit quasi gekippt.
Dann erhalte ich auf jeden Fall ein ungültiges Wort.
Gut. Ja, also deswegen Prüfinformationen,
einfachstes Verfahren ist,
sind Prüfziffern oder Paritäten
Werde ich gleich als erstes vorstellen. Dann hat man oft solche mathematischen Verfahren,
Summenbildung, wie das das beispielsweise bei diesen ERN beziehungsweise bei
diesem Buchcode der Fall ist. Andere Verfahren aus Kodierung,
also CRC, Cyclic Redunten, Seecheck,
werden ihnen also vielleicht bei der Programmierung nochmal irgendwo,
zumindest vom Namen her begegnen, nicht und sowas wie also BCH-Codes,
Reed Solomon Codes und so weiter,
sind dann also schon vergleichsweise auch wenige mathematische Verfahren,
also auf die ich jetzt hier auch dann aus Zeitgründen
nicht weiter eingehen werde
Wie gesagt, allereinfachstes Verfahren, Paritätscoach ist halt eben,
dass ich sage, also zu einem einer Menge von Bits
aus einem Binärcode wird eben ein einzelnes Paritätsbit hinzugefügt.
Damit erreiche ich letztendlich,
dass ich zwischen zwei Codewörtern immer anhemming Abstand von zwei habe,
womit ich dann eben ein Bitfehler und eben auch nur Einblickfehler sicher erkennen kann.
Wenn ich einen Zweifelfehler habe, kann das schon wieder falsch sein,
weil dann habe ich eben aus einem eimgültigen Worten ein anderes gültiges Wort gemacht.
Superität wird berechnet, indem ich jetzt quasi einfach alle Stellen aufsummiere.
Modulu 2 beziehungsweise rein praktisch jetzt wieder in die Bullshit-Agebar gegangen,
beziehungsweise in diesem Fall dann in eine GF2,
indem ich die Bits jeweils über alles dann mit
dem XO verknüpfe
So, und dann kann man jetzt eben bilden,
die gerade Parität, das heißt, es muss dann eben gelten,
so über alle Bits, Model nur 2,
ist gleich null oder eben ungerade Parität, Summe über alle Bits,
Model nur 2, ist dann eben gleich eins.
In der Praxis wird, also auch wenn ich jetzt,
also hier auf den Folien immer meistens mit der geraden Parität rechne,
in der Praxis wird er aus technischen Gründen meistens mit einer ungeraden Parität gerechnet,
einfach deswegen, weil ich damit erreiche, dass ich in einem Ach so,
jetzt hätte ich die mal dran stehen lassen können,
dass ich eben in einem Codewort auch immer mindestens eine Null und eine Eins mit drin habe.
Also wenn ich jetzt also als einfachstes Wort,
was ich übertragen möchte, jetzt wirklich nur nehme,
ein einzelnes Bild,
nämlich entweder Null oder Eins,
dann wäre jetzt bei einer geraden Parität demzufolge hier eine Null
anzufügen bei der Eins
Würde ich dann, also China 1 als Prüfbild anfügen und hätte dann also
quasi mit 2-Bit für meine Codierung dann also eine gerade Parität gemacht,
so wenn ich das mit einer ungeraden Parität mache,
würde ich eben aus der Null dann als Prüfbildner 1 hinzufügen und bei der 1 eben der Null. Das heißt,
da wären dann die Code,
also bei einer geraden Parität wären die Codeworte 0-0 und 1-1 und bei der Ongardenparität 0-1 und 1-0,
so wie man unschwer sieht,
habe ich eben bei einer Ungardenparität immer mindestens eine 0 und eine 1 drin,
weswegen man das gerne macht, rein technischer Grund,
was mir passieren kann, ich übertrage Bits irgendwie seriell auf einer Leitung,
wenn ich Stecker zieht, ich kriege hier keine Verbindung,
wenn ich das mit der Ungardenparität mache, stellt man einfach fest,
es muss mindestens eine 1 übertragen werden oder eine Null,
dann stellt man einfach rein technisch gesehen fest,
kommt da überhaupt was über die Leitung
Nicht, wenn ich jetzt,
also quasi jetzt in Elektroschleitung durchgeschnitten habe und ich empfange lauter Nullen,
kann das bei der geraden Parität immer noch gültig sein.
Nicht, dass einfach der Grund,
weswegen man da gerne eigentlich mit einer Ungarnparität arbeiten würde.
Gut, wie gesagt, das zu den allereinfachsten Paritätscode,
was man damit erreicht, ist dann eben,
dass jeweils zwei Codeworte sich mit einem Hemmingabstand zwei bewegen,
was man eben an diesen beiden Kotworten 0011 beziehungsweise 01 und
1-0, der dann also auch direkt sieht,
dass die dann immer jeweils paarweise diesen Hamming-Abstand von zwei haben.
Damit kann ich dann eben alle ein mit Fehler erkennen.
Und wenn ich jetzt das entsprechend längere Kotworte hatte,
könnte ich dann eben alle ungeraden Anzahlen von Mehrbettfehlern auch noch erkennen.
Da war ich da dann eben auch entsprechende Konstruktionsvorschrift
dann eben beim ungültigen Kotwort gelandet bin
Was man dann teilweise auch mitmachen kann,
was hier dann also auch noch kurz beschrieben ist,
ist dann so was wie solche Arten von zweidimensionalen oder generell mehrdimensionalen Paritäten,
indem ich dann also die Daten oder die Informationsbits dann also
matrixartig anordne und dann eben Zeilen und Spaltenweise Paritäten berechne.
Und damit kann man dann in den Zeilen oder in den Spalten
entsprechender ein Bit-Fehler erkennen und wenn ich jetzt eben einen einzelnen
einen mit Fehler habe, den dann eben auch korrigieren,
beziehungsweise dann eben unter bestimmten Voraussetzen dann eben auch mehrere N-Bit-Fehler korrigieren.
So, zwecks der Anschauung ist das Ganze hier jetzt natürlich
nur zweidimensional gemacht. Theoretisch lässt sich das dann aber auch
noch, also auf mehr Dimensionen erweitern.
Wie sieht das aus? Ich habe hier Großbuchstaben askikodiert und
hier eine gerade Parität
Schreibe hier quasi als,
oder möchte ich es als dringend übertragen, Hemming,
was ich dann also hier durch die entsprechenden 7-Bit-Kombinationen so anordnen würde.
Zusätzlich werden jetzt eben sowohl zahlenweise,
das heißt für jeden Buchstaben als auch Spaltenweise,
dann also in diesem Fall jetzt hier für jede Stelle
entsprechend gerade Paritäten berechnet
Was dann eben zu dem hier führt,
war es dann also rechts, beziehungsweise unterhalb dieser Linie ist.
Und es wird dann auch noch jeweils für die entsprechenden Prüfsummen die Parität berechnet,
beziehungsweise sie ist da dann also auch logischerweise dann richtig da und identisch,
sodass ich dann quasi aus den sieben mal sieben
Bit dann eben hier noch entsprechend 15 Bit für die Parität
hinzugegefügt habe
Ich finde das Ganze dann eben übertragen würde und was man dann eben machen kann,
wenn man eben jetzt Kotworte empfängt, die Fehler enthalten,
dass man die dann eben teilweise erkennen oder korrigieren kann.
Also hier wäre dann mal so ein Block, wo dann also ich unten mit Rot eingezeichnet, also mögliche Fehler sind.
Bei der ganzen Kodierung oder Kodierungstheorie ist dann natürlich auch immer mit zu betrachten der Fall oder mit zu berücksichtigen,
dass sich natürlich ein Fehler nicht nur in meinen ursprünglichen Bits drin habe,
sondern dass ich den logischerweise natürlich auch in irgendwelchen generierten Prüfbits drin habe,
egal ob das jetzt hier nur so ein einzelner Spit für eine Parität ist oder wie die dann also wirklich bei Hemmingcodes,
wie ich sie dann also nächste Woche vorstellen werde,
wo ich dann also mehrere Prüfspitze habe,
wo dann eben auch die fehlerhaft sein können.
Gut, hier jetzt nun mal als, also wie gesagt,
hier sind jetzt so ein paar mehr Fehler mit eingezeichnet.
Der Code selber ist aber eben so,
dass er also erstmal nur Einzelfehler erkennt und korrigieren kann.
Das ist also im Prinzip jetzt,
dass ich hier einmal angedeutet und zwar angenommen dieses
eine Bit ist entsprechend gekippt
Ja, und da ist eigentlich relativ offensichtlich, was dann passiert. Der Empfänger,
der also jetzt quasi dieses hier empfangen hat,
berechnet dann eben selber die Zahlenweise bzw. spaltenweise Parität und stellt eben fest,
dass hier, ja, also selber eine andere Parität berechnet hat,
als das, was er empfangen hat.
Gleiches gilt dann eben hier für diese Spalte und demzufolge kann man dann einfach direkt zurückrechnen,
beziehungsweise quasi dann zurückschließen und sagen, an dieser einen Stelle hat sich das eine Bit geändert. Und der Verenger kann dann eben dadurch dann auch diesen einen einzelnen Einbittfehler entsprechend korrigieren. So,
wenn ich jetzt mehr Fehler drin habe oder mehrfach Fehler,
also sprich so eine Situation, wie sie hier jetzt irgendwie angedeutet ist,
dann wird in der Regel natürlich eine Korrektur nicht klappen,
beziehungsweise wenn, wenn man jetzt eben solche Sachen hat,
wo also die Fehler zum Beispiel dann irgendwie jetzt in der gleichen Zeile oder in einer gleichen Spalte liegen,
führt das dann dazu, dass ich dann also hier,
wenn ich also hier zum Beispiel diese, statt dieser Nullen eine Eins hätte,
dass der Zeilenweise dann hier zwar eine falsche Parität hätte,
aber spaltenweise haben sich die beiden Fehler dann quasi,
wie jetzt wieder ausgeglichen und dann kann ich nur noch feststellen,
es ist was schief gelaufen,
aber ich kann nicht mehr zurückrechnen oder eine Fehlerkorrektur machen.
So, letzte Folie für heute, das Ganze gilt auch unabhängig davon,
ob ich das jetzt binär mache für Andere Beispiele,
hier das Ganze quasi jetzt als zweidimensionale Parität im DC-Mal-System,
wo ich jetzt also quasi jetzt irgendwelche Daten übertrage, also die Zivalzahlen.
Und auch Zahlen und Spaltensummen berechne, die dann aber quasi Module 10 berechnen.
Letztendlich Parität ist nichts anderes als Module 2 wäre in der Berechnung gewesen. So,
jetzt habe ich hier als Daten 374 4, 54,
8, 135,
Parität wäre quasi Quersumme 3 plus 7 plus 4 in 14,
Module 10, Paritätsbit oder Paritätsinformationen ist in dem Fall,
ist ja kein Bit, ist dann vier.
Hier hätte ich dann sieben, neun und so weiter.
Und auch hier kann man jetzt eben sagen, wenn ein Fehler auftritt,
also es wird hier statt der acht eine drei übertragen,
führt das dazu, dass hier bei der Paritätsberechnung auf einmal eine zwei auftaucht in der Prüfsumme.
Es wurde aber letztendlich eine sieben Empfang an dieser Stelle auch
Und was man da nämlich also auch gleich direkt erkennt,
die Abweichung zwischen der 7 oder 2,
das heißt die 5 muss ich dann einfach nur zu diesem falschen Wert
hinzuaddieren und lande dann an meinem richtigen Wert bei der Acht.
Und auch da ist dann eben der Trick über diese Zahlen und spaltenweise Bildung eine Parität,
kann man das in dem Fall dann entsprechend zuordnen.
Gut, das für diese Woche zu der Kodierungstheorie,
einige andere kurz, die dann Paritäten beziehungsweise Prüfsummen berechnen,
Fehlerkorrekturmaßnahmen machen,
werde ich dann also nächsten Mittwoch noch vorstellen und dann eben
dieses Kapitel auch abschließen und dann wie üblich am Freitag,
schönes Wochenende