So, nochmal kurz ergänzend zu die 40 Freitag gemacht habe,
weil hinterher kamen noch ein paar Fragen hinsichtlich dieser Idee Hemming-Abstand,
Hemming-Gewicht, wo ich dann also noch ein paar Sachen an der Tafel versucht hatte zu skizzieren.
Ich habe das Ganze jetzt also nochmal richtig gemacht und nochmal zwei zusätzliche Folien gemacht.
Also im Prinzip Hemming-Abstand ist ja paarweise zwischen zwei Codewörtern,
die Anzahl der Stellen, an denen sich diese Codewörter jetzt unterscheiden. Das heißt also,
je nachdem, wie viele Bits das sind, dreidimensional,
das heißt,
mit einem drei Bitwort kann man das dann immer noch in Form,
sind es Würfels repräsentieren,
wo ich dann also quasi jetzt eigentlich für jede Achse oder für
jede Dimension hier dann letztendlich eine Stelle oder eine Stellenwertigkeit habe und alle acht möglichen Codewörter dann eben an den Ecken so ein, ist Würfels anordnen kann.
Und wenn ich jetzt eben beispielsweise einen Code wähle mit Hemmingabstand 2,
Das, was dann also hier rot markiert ist,
dann sieht man nämlich eigentlich auch schon sehr schön,
dass beim Übergang von einem zum nächsten Codewort,
ich eben im Prinzip zwei Kanten des Würfels durchlaufen muss.
Das heißt, mit jeder, jedem Übergang von einem Wort
hier zu einem anderen Wort über eine Kante ändere ich dann
eben entsprechend genau ein Bit.
Und demzufolge, das heißt,
hier ein Vater Länge 2 entspricht dann eben immer
einem Hemmingabstand von zwei
Das heißt also,
bei den acht Codewörtern mit Hemmingabstand 2 könnte ich dann eben letztendlich hier noch vier wählen,
mit Hemmingabstand 3 bleiben dann eben immer jetzt parweise nur zwei Codewörter über,
die dann also in dem Sinne hier jetzt an so einer Visualisierung,
in so einem Würfel eben genau an den jeweils gegenüberliegenden Ecken liegen würden,
beispielsweise dann eben hier 0-1,
0 und dann eben das invertierte Wort 1,
0-1 und egal über welchen Pfad hierüber,
hierüber,
hierüber ich dann also auch quasi dahin gehe,
der hat dann eben immer genau
die Länge drei
Hier ist das Ganze dann also auch noch mal kurz gezeigt für
ein Hamming-Abstand von fünf. Ich war, hat er gesagt,
Fehlererkennung geht eben bis die minus eins fehlerhafte Stellen,
Fehlerkorrektur bis dminus eins, halbe.
Wenn ich jetzt also hier mit fünf Bit die 32 möglichen Kombinationen habe und sage,
das ist mein eines gültiges Kotwort und das ist mein anderes
gültiges Kotwort und alle anderen ungültigen Kotworte ist alles,
was dazwischen liegt
Dann sieht man im Prinzip jetzt, also von diesem Wort ausgerechnet,
jeweils den jeweiligen Hemming-Abstand und Fehlerkorrektur heißt Fehler, nein,
andersrum, also Fehlerkennung heißt jetzt eben einfach, ich lande hier bei irgendeinem ungültigen Wort.
In diesem Fall jetzt bei Hemming-Abstand 5, dminus 1,
wäre dann quasi das, was ich erkennen kann.
Das sind also quasi jetzt hier 4bit und Fehlerkorrektur funktioniert dann eben folgendermaßen,
dass sich, wenn ich hier jetzt irgendein ungültiges Wort erhalte,
ich quasi immer eine nähere Distanz entweder zu dem einen oder zu dem anderen Code-Wort habe,
demzufolge dann Hemming-Abstand 5, Fehlerkorrektur, wer nach der Formel,
D-Minus 1, halbe, also zwei Bit,
die ich korrigieren kann.
Das heißt, in diesem Fall,
man trennt sich das Ganze hier quasi in der Mitte auf,
was hiermit angedeutet sein soll.
Und wenn ich eben irgendwie hier oder hier ein Wort habe,
wird das dann eben zu diesem Wort hier korrigiert und jeweils aus diesen Gruppen in die andere Richtung.
Das ist eigentlich die Grundidee, so ein bisschen visualisiert von
dem Hemming-Abstand
Also, die Frage war jetzt, was passiert,
wenn ich jetzt also an Hemming-Abstand von sechs habe?
Dann habe ich also hier in die Formel 1 eingesetzt,
5 Falbe, zweieinhalb Stellen, die ich korrigieren kann,
beziehungsweise wenn ich mir das dann also hier irgendwie so aufzeichnen würde,
würde man dann eben sehen,
dass es hier so einen ganzen Satz von Wörtern entsprechend in einer Mitte gibt.
Und da kann man halt nur sagen, gut,
Und das sind dann eben auch welche, die man letztendlich dann nicht korrigieren kann,
sondern nach der Formel hätte ich also 2,5 Bit zu korrigieren.
In dem Fall wird das dann also nur ganz zahlig gemacht.
Das heißt also, ich kann dann also die 2 Bit,
also sprich die beiden Spalten jeweils in den nächstgelegenen korrigieren und alles,
was hier dann letztendlich in der Mitte noch liegen würde,
kann man nur sagen, Pech gehabt.
Gut, das war jetzt also noch Ergänzung zu dem,
Was ich letztes Mal am Freitag vorgestellt hatte,
danach hatte ich ja noch kurz zur Fehlererkennung,
Paritätscode eingeführt und dann eben nochmal als Beispiel für die Korrektur sind es einzelnen Einbitt-Fehlers,
dann eben so eine zweite Verfahren zur zweidimensionalen Parität motiviert.
Wobei dann eben auch sagen kann,
das Ganze lässt sich eben auch auf andere Zahlensysteme übertragen,
wie dann eben beispielsweise das Dezima-System
Ein anderes Beispiel für fehlererkennende Codes, was man dann auch immer gerne findet, ist dann im Prinzip diese ISBN-Nummer,
also das womit Bücher eindeutig weltweit gekennzeichnet sind. Früher waren das also zehn Ziffern,
inzwischen ist man bei ISBN 13, hat dann also 13 Ziffern,
ist von der Idee her auch so ähnlich aufgebaut,
wie der IEAN-Code, dieser European Artikel Number, das ist das,
was man dann immer so als Barcode auf irgendwelchen Artikeln hart,
beziehungsweise wo man jetzt sagt nicht, also dafür habe ich jetzt genau meine App,
die mir das also irgendwie scannt und damit dann also irgendwelche Preisvergleiche, Produktinformationen oder sonstiges liefert.
Und auch das ist im Prinzip ein Code,
der also jetzt noch eine zusätzliche Prüfinformation hat, aufgebaut,
also jetzt hier nur mal kurz skizziert am Beispiel dieser ISBN-Nummer,
dass man sagt, also bei diesen ESBN-13-Nummern,
wo ich jetzt noch drei zusätzliche Stellen habe,
gibt es da nochmal drei Stellen als Prefix,
dann wird im Prinzip der Sprachraum beschrieben,
wo ich dann eben sagen kann, für die Sprachen,
wo es sehr, sehr viele Bücher gibt, nämlich eine kurze Kodierung,
für die, wo es entsprechend nur wenige Bücher gibt,
nennt man eine deutlich längere Kodierung.
Das heißt, das, was man dort dann hat,
ist im Prinzip ein Farno-Code,
wo ich dann eben sage, häufigen Sprachen,
hat man dann eben die Ziffer 0 bis 7,
0 und 1 ist Englisch, 2 ist Französisch,
3 ist Deutsch und so weiter und für irgendwelche exotischen Sprachen hat man dann eben deutlich längere Ziffern.
Das Ganze ist dann eben auch immer so aufgebaut,
dass das dann nie alles präfixfreie Beschreibung, also Farno kurz sind.
Nicht dann kommt anschließend dann Kodierung, in denen der Verlag kodiert ist.
Auch da haben dann die großen Verlage, mal,
die größten 20 Verlage dann im Prinzip die Möglichkeiten.
Also dann diese zweistelligen Kodierungen zu nehmen und je nachdem,
wie viele Titel dann eben die Verlage noch haben,
werden dann die Kodierungen immer länger.
Nicht dann hat man eine Verlagsinterne Nummer und das,
was jetzt dann eigentlich interessant ist, eben hinten noch sowas wie eine Prüfziffer,
wo man dann eben sehen kann, ob der Code generell gültig ist.
Und hier nur mal kurz als Beispiel vorgestellt,
wie dann so ein Prüfverfahren aussieht.
Also hier jetzt
einer ESBN-10-Zahl
Wenn ich jetzt hier meine zehn Ziffern habe,
beschrieben durch die normalen Dezimalzahlen 0 bis 9 und einem zusätzlichen Symbol X für die Ziffer 10,
dann wird quasi Informationen selber in den ersten neuen Ziffern kodiert.
Also sprich, das, was Gruppennummer,
Verlag und Verlagsinterne Nummer sind und die zehnte Ziffer,
in diesem Fall und diese Prüfziffer, wird dann berechnet als Summe
Die einzelnen Ziffern multipliziert mit ihrer Stelle von links nach rechts durchgezählt und das Ganze Modullo 11.
Und für die Prüfung hinterher wird dann quasi abgefragt,
ob dann eben die Summe über die ersten neuen Ziffern plus der Prüfziffer,
Modullo 11, dann eben gleich Null ist. Hier als Beispiel,
also dass wir jetzt hier von dem Buch von Hennessee und Patters,
nee, Brian und Joe Helleran,
der ESBN-Code, englischsprachiges Buch, entsprechend großer Verlag,
dann eben eine verlagsinterne Nummer und hinten als Prüfziffer,
die 7. Das Ganze wird dann quasi,
oder diese 7 wird dann dadurch berechnet, dass ich sage,
erste Ziffer mal null, plus zweite Ziffer mal 1,
plus dritte Ziffer mal 3 und so weiter.
Er gibt als Summe 161, Modulu 11 ist 7.
Damit ist dann also diese Prüfziffer berechnet und um zu gucken,
ob das dann eben eine gültige Zahl ist,
muss ich quasi dieses Ganze noch rechnen und dann eben zusätzlich
noch hier hinten für die Prüfziffer, dann eben zehnmal sieben,
231 und das Modul U11 ist dann eben gleich null.
Das heißt, damit hat man dann eine gültige Zahl erkannt.
Was man damit dann eben im Prinzip machen kann, ist jetzt überhaupt,
dass wir nur erkennen, ob das eine gültige Ziffer ist.
Das heißt also, wenn irgendeine Ziffer falsch gesetzt wurde,
wenn zwei Ziffern vertauscht wurden oder wenn jetzt irgendeine Ziffer quasi gedoppelt wurde,
kann man das damit feststellen. Also hier nur als Beispiel,
Wenn ich also zwei Ziffern I und J paarweise miteinander vertausche,
was passiert, die normale Berechnung wäre,
I mal Set I plus J mal Set J,
was dann also im Prinzip jetzt einfach hier ganz normal irgendwo in dieser Formel drinsteht,
was durch diese Vertausschung passiert, als Abweichung,
dass ich dann also quasi an der Jottenstelle die Ziffer I stehen habe und an der Itenstelle die Ziffer J.
Und wenn ich das jetzt also davon abziehe,
habe ich dann eben quasi eine Differenz, die dann dazu führt,
dass das Ganze dann im Prinzip einen falschen Wert liefert und dann eben Ungleichnull ist.
Nicht das nur als so ein mögliches Verfahren,
wie eben solche Prüfziffern jetzt in irgendwelchen Dezimalsystemen dann aussehen.
Und ähnliche Verfahren begegnen uns also relativ häufig im täglichen Leben,
sprich bei diesem ERN-Code ist das auch mit drin,
also der bei diesem ganz normalen Artikel-Code für Nummern,
das, was dann eben typischerweise im Barcode mit drin ist,
bei den IBAN-Nummern Bei der Bankverbindung ist sowas im Prinzip auch mit drin.
Das heißt, wenn ich jetzt, also irgendwo meine Online-Überweisung mache und sage,
abschicken und das Programm sagt mir sofort ungültige I-Bahn,
dann hat es also noch nicht zwingend irgendwo bei irgendeinem Server nachgefragt,
ob das Konto bei der und der Bank existiert,
sondern allein aufgrund der Prüfinformationen konnte man dann eben schon sagen,
das kann es nicht geben.
Gut, jetzt noch weiter zu den kurz,
um Fehlerkorrekturen zu machen
Ein erst mal vergleichsweise einfaches triviales Verfahren. Hier erstmal wunderbar
mathematisch beschrieben. Wäre ein 3-1-Hemming-Code oder dreifach Wiederholungscode.
Rein praktisch kann ich einfach sagen, für jedes Datenbit,
was ich sende, sende ich dieses Bit genau dreimal.
Wenn sich irgendwie was ändert, ein Bit,
kann ich über ein Mehrheitsentscheid quasi sagen,
Was gesendet wurde und mit dieser dreifachen Wiederholung habe ich dann eigentlich letztendlich genau erreicht,
dass sich dann eben auch ein Helming-Abstand von drei da draus gemacht habe.
Formal gesehen kann ich sagen, es gibt eine Generator-Matrix,
als Vector 1-1-1.
Und die Kotwörter ergeben sich dann als Multiplikation,
der Generator Matrix, mit einem Informationsvektor. Das heißt also,
ich nehme jetzt hier diese 1-1-1,
multipliziert jetzt mit meinem einen Bit und erhalte dann eben aus
der einen 0-3-0 aus der einen 1
-3
Nicht wundern, was das Tee hier so,
das ist jetzt auch nur mathematisch korrekt geschrieben, nicht wo man sagt,
weil ich hier wenig Platz habe und das also jetzt nicht richtig senkrecht schreiben wollte,
habe ich das waagerecht geschrieben und dann hat der eine Kollege gleich,
ja, da muss man mal die transformiert daran setzen,
um zu zeigen,
dass sie meine transformierte Matrix ist.
Da sieht man also, wie man wunderschön mit Mitteln im Mathematik
vergleichsweise einfach verständliche Sachen dann,
also auch schick formelmäßig beschreiben kann
Gut, das ist, denke ich mal, sicherlich klar,
wie das funktioniert. Nachteil bei dem ganzen Verfahren ist natürlich,
wenn ich also aus jedem Bit, was ich sende,
drei Bit habe, die ich übertrage oder drei Bit generiere,
die ich übertrage,
dass das dann natürlich also deutlich auf die Performance geht.
Das heißt, die Datenrate entsprechend klein wird.
So ein besser geeignetes, allgemeines Verfahren ist dann das,
was dann wirklich so als Hemmingcode immer beschrieben wird bzw. in
der Literatur
drin ist
Da ist eben auch die Idee zu sagen,
ich erreiche einen Hamming-Abstand von drei. Damit kann man dann
eben Einbittfehler erkennen. Nein, Einbittfehler korrigieren. Und eben
viele zwei wird und teilweise auch drei Bit-Fehler zumindest erkennen.
So, wie sieht so ein Hamming-Code aus?
Geschrieben wird das immer als quasi ein Tupel aus zwei Ziffern.
Die erste, die ist Groß-N, ist die Anzahl
der Gesamtbits
Die zweite ist Cline-N, die Anzahl der Nutzbits.
Deswegen hier drei, ein Semming kurz,
weil ich habe ein Nutzbit und übertrage drei Bit.
In diesem Fall kann ich jetzt eben sagen,
ich habe ein Datenwort von N-Bit und dieses Datenwort von N-Bit
wird jetzt um K-Prüfbit ergänzt.
Mein Gesamtcodewort hat dem zuvor ge N plus Carbit.
So, und jetzt geht es nur darum,
wie viele Prüfbits brauche ich, um für eine gegebene Menge von N-Bits
Ein Hamming-Abstand von drei Hänze bekommen. Und da kann man
jetzt eben sagen, eine Fehlerkorrektur kann ich gewährleisten,
wenn zwei hochkarg größer gleich N plus 1 ist.
So. Warum? Die Grundidee dabei ist, dass ich,
also K ist die Anzahl der Prüfbits,
mit zwei hochkar Prüfbits,
kann ich zwei hochkarg
unterschiedliche Positionen in meinem Datenwort markieren
Oder adressieren. So, und es muss sich quasi mit
den zusätzlichen Prüfbits beschreiben, dass ich entweder keinen Fehler habe.
Das ist die Plus 1. Oder dass ich eben beschreiben kann,
an welcher Stelle im Datenwort ein Fehler aufgetreten ist.
Beziehungsweise nicht nur für das Datenwort, sondern für das Gesamtwort,
also für dieses Großen, deswegen Dieses hier.
Nicht dem zufolge hier noch mal grob die Idee dazu.
Ich habe also zwar auch keine Kombination.
Ich habe einen Fehlerfall und ich habe aus meinem Gesamtwort,
also aus diesem N plus Carbits, N zu markierende Bitfehler,
weil mit Fehler treten dann natürlich nicht nur bei den Datenbits auf,
sondern können genauso gut ja auch bei den Prüfsplätzen auftreten.
Gut, das erst mal zu den Anzahlen,
die man da jetzt berechnet, nicht. Und je nachdem,
wie groß meine Datenworte jetzt sind, also ob ich sage,
ich habe 4-0-Spits, ich habe acht Nutz,
bis ich habe 16 Nutz-Spits,
muss ich dann eben entsprechend viele Prüfbits hinzufügen.
Hier war eine Frage
Dann kommen die zwei Argumentationen zur Stadt.
Also die Frage war, wie die zwei Hochkarr-Kombinationen zustande kommen.
Das ist jetzt einfach rein im Dualsystem abgezielt. Ich habe
insgesamt jetzt kein Prüfbett. Und wenn ich die Vinär jetzt einfach durchzähle,
kann ich von null bis 2 hochk minus 1 zählen.
Also 2 Hochkarr-Kombinationen gibt es dann insgesamt jetzt für diese Prüfbets.
Und die benutze ich, um zu sagen,
ich habe null Fehler oder ich habe einen Fehler in Position 1,
2,
3 bis n minus
So, wie wird dieser Code jetzt generiert? Dann gibt es dann so ein schickes Verfahren,
wo die Prüfbitzen und die Datenbitz dann quasi ineinander verschränkt werden.
Sieht erstmal relativ unübersichtlich aus, wird, denke ich mir,
gleich ein bisschen klarer, wenn ich dann das auf der nächsten Folie nochmal zeige.
Also die Idee ist erstmal,
dass ich als erstes bestimmen muss, wie viele Prüfbit,
K, ich benötige, um jetzt eben zu sagen,
für meine ursprünglichen N-Bit kann ich diese Informationen jetzt mit unterbringen.
Das heißt also, zwei hochk, minus eins,
das ist der Fehlerfall, fehlerfreie Fall, minus k,
weil Fehler ja auch in den Prüfbitz drin sein können,
die muss ich also ja auch noch irgendwie mitmarkieren und dann
habe ich noch entsprechend viele Nutzbits über und diese Anzahl muss dann eben größer sein,
als die Anzahl der Nutzbits zählen.
So,
dann werden die Prüfbits
immer untergebracht
Wenn ich das jetzt einfach von links nach rechts durchnummeriere,
mit eins beginnt, an den Positionen 2 hoch 0,
2 hoch 1 und so weiter bis 2 hochkam minus 1. Das heißt,
an Position 1 habe ich mein erstes Prüfbit,
an Position 2 habe ich mein zweites Prüfbit,
an Position 4 habe ich mein drittes Prüfbit,
dazwischen kann ich also hier schon das erste Datenbit unterbringen,
an Position 5,
6 und 7 sind dann wieder Datenbit an Position 8,
also in diese Falllandswahl hoch.
Drei hätte ich dann eben das nächste Prüfbit und so weiter
und so fort. Und was man jetzt eben immer macht,
ist, dass man letztendlich abhängig davon,
wie viele Daten bitte ich insgesamt unterbringen muss.
Hiervon dann die ersten In-Positionen mitbenutzt. So,
und bei den Prüfbits, also im Prüfbitti,
wird dann immer berechnet als Modulo 2-Summe
Der Bits, bei denen in der Positionsnummer das Gesetz bett, dieses Prüfbits enthalten ist. Das heißt,
das Prüfbit 1 berechnet sich dadurch, dass ich sage,
alle Positionen, die an der niedrigsten Stelle eine Eins haben,
muss ich nehmen oder alle Bits,
die an der niedrigsten Stelle eine Eins haben,
muss ich nehmen und mit einem X-Ohr verknüpfen.
Das heißt, Hier die 3, also das D1,
die 5, das D2, die 7, D4,
die 9, D5, das heißt,
das prüft mit 1, berechnet sich dann durch das X-Ohr,
hier jeweils der ungeraden Witz, das erste ausgenommen.
Für das zweite Prüfbett, muss jetzt das zweite Bit in
der binären Kodierung gesetzt sein. Das ist der Fall,
an der Stelle 3, An vier wieder nicht,
an fünf auch wieder nicht, an sechs und an sieben,
an acht mich, an neun nicht,
an zehn wäre es dann wieder.
Das heißt also, dieses P2 berechnet sich dann eben als D1,
XO D3, XO D4, XO D6,
das wäre dann eben hier der Zehnte und so weiter und so fort.
Hier habe ich das Ganze jetzt mal versucht,
noch ein bisschen anschaulicher zu visualisieren
Wo du also quasi jetzt hier mit C jeweils die entsprechenden Stellen
des Codewards stehen. P steht dann jeweils für die Prüfbits,
die dann eben quasi immer angraden mit Positionen sind.
Also 2 hoch 0, 2 hoch 1,
2 hoch 2, 2 hoch 3, 2 hoch 4.
Und hier mit den farbigen Punkten ist dann jeweils markiert,
wie sich ein Prüfbit berechnet.
Also das erste berechnet sich dann quasi aus dem XO
hier jeweils
Jedes zweiten Bits, was dann an entsprechender Position steht.
Dieses Prüfbild würde sich dann eben berechnen durch alle Indizes hier,
wo dann eben das zweite Bit gesetzt ist.
Also C3, C6, C7, 10, 11,
14, 15 und so weiter. Das heißt,
da habe ich dann immer hier, jeweils da alle zwei,
das nächste Prüfbit wäre dann eben hier die Dreibit, die wieder nicht,
dann immer jeweils solche Viererbit-Gruppen und so weiter und so fort.
So und je nachdem, wie viele bis ich jetzt kodieren möchte,
kann ich jetzt eben sagen, okay, also ein 7-4-Hemming-Code,
dass wir dann quasi hier dieser Tal bis zu dem,
wo ich jetzt also hier gerade mit dem Chor so ein bisschen rumhühne,
hätte dann eben 4 Not-Spits und 3 Prüfbits.
Wenn ich jetzt mehr Not-Spits hätte, das heißt,
mit 8 Nut-Spits müsste ich schon ein viertes Prüfbit mit einführen
und damit komme ich dann eben letztendlich bis zu zum Hamming-Code 15,11,
wo ich dann also im Prinzip elf Nurd Spits und 15 Bits drin habe.
Und wenn ich dann eben wieder jetzt noch mehr habe,
porsche ich dann hier wieder ein Prüfbild mehr. So,
und was man hierbei dann eben auch ganz gut sieht,
je länger das Codewort wird,
umso besser ist eben das Verhältnis von Datenbits zu Not Spits,
was ja aufgrund dieses Verfahrens sich einfach dadurch ergibt,
dass sich quasi jetzt mit der Nein, Datenwitze zu übertragen im Witz,
dass sich eben die Anzahl der Prüfbilds benötige,
um jetzt hier quasi mit 2 hochka,
die Stellen zu markieren, wo ein Fehler aufgetreten sein kann.
Nicht, dass ich dann aber dem zuvorge,
das dann also natürlich nicht linear anwächst. Gut,
das Ganze kann man sich jetzt natürlich hier irgendwie so einzeln
immer irgendwie herleiten und dann also in Form von irgendwie solchen aratmetischen Ärgerbranchen ausdrücken,
dann letztendlich berechnen,
ein bisschen eleganter kann man das dann im Prinzip dann mit der Matrix-Rechnung machen,
wo ich dann im Prinzip für beispielsweise jetzt hier so ein 7-4-Hemming-Code mir hier eine Generator-Matrix erzeugen kann.
Das heißt, das ist ja genau das,
was ich dann quasi hier drin habe,
wo ich dann eben mit den Sieben Bits, die ich übertrage.
Drei Prüfbits und eben die vier Not Spits letztendlich drin habe.
Das heißt also, dieser Ausdruck hier wird durch diese Matrix beschrieben.
Und ein Kotwort ergibt sich dann eben im Prinzip direkt aus
der Matrix-Multiplikation, der Generator Matrix, mal einem Fearbit-Wort.
So, wie kommt man zu dieser Generator Matrix?
Also auch das könnte man sich jetzt hier aus dem Dieser Grafik hier letztendlich ablesen,
wo ich dann eben sage, okay,
für die niederwärtigste Stelle hier geht eben ein,
was dann also im Prinzip jetzt dieser Zeile entspricht,
also für die niederwärtigste Stelle geht eben im Prinzip ein,
dass Datenbit.
Eins, Datenbit zwei und Datenbit. Vier. Was dann
eben hier genau das erste, das zweite und das vierte Bit sind,
nicht Datenbit drei, wird dafür eben nicht benötigt.
Die nächste Stelle wäre jetzt eben das zweite Prüfbit, setzt sich dadurch zusammen,
dass ich die eins benötige, D3 und D4, also als Vector
1011. An der nächsten Stelle habe ich jetzt mein erstes Nutzbit,
nämlich mein erstes Datenbit, demzufolge ist da der Vector 1 000,
dann hätte ich jetzt das nächste Prüf-Bit,
was dann im Prinzip D2, D3 und D4 benötigt,
nämlich hier die Drei folgende Elemente, demzufolge die Eins nicht.
Die 2D3 und E4, das sind genau die drei Einsen.
Und anschließend hätte ich jetzt eben noch wieder drei einzelne Nutzbits,
was dann genau jeweils nur eine einzige Einzelsinnerspalte oder in so einer Zeile entspricht.
Analog dazu kann man dann eben als orthogonale Matrix eine Prüfmatrix erstellen,
wo ich dann eben sagen kann, wenn ich ein Codewort habe,
das wurde übertragen, das mit dieser Prüf-Matrix multipliziere, dann muss ein Null-Vektor rauskommen.
Wenn ich ein ungültiges Codewort habe,
erhalte ich dann eben aus dieser Multiplikation Codewort mal Prüf-Matrix,
irgendwas, Ungleichnull und das,
was dort als Ergebnis oder als Vektor rauskommt,
liefert mir dann also ein sogenanntes Fehlersyndrom,
nämlich quasi eine Kodierung an welcher Stelle in meinem Codewort
ein Bit gekippt ist
Beispiel dazu, folgt gleich noch, dann sieht man das
nämlich auch, wie das also wirklich rein praktisch funktioniert.
Was ich damit eben erreiche, ist, dass ich,
hatte ich ja schon gesagt, mit entsprechend größeren Wortlängen,
also ein besseres Verhältnis von uns zu Prüfbitz habe.
Es ist, wenn man es verstanden hat, eigentlich vergleichsweise einfaches Prinzip. Nachteil ist,
verglichen mit anderen Kodierungsschema da,
also da gibt es eben auch noch bessere,
die dann aber dann wieder mit deutlich längeren Codewörtern auch nur arbeiten,
die ich jetzt also hier aufgrund der Zeit,
er ist also auch nicht weiter vorstellen werde,
weil also auch darüber kann man dann also eigentlich relativ viel noch an eigenen Vorlesungen mitmachen.
Gut, hier mal als Beispiel, Generator Matrix,
G, genau das, was er da eben schon hat.
Ich habe hier als Vector 0110,
soll jetzt eben mit entsprechenden Prüfbitz versehen werden und das,
was man jetzt hier also quasi macht,
ist dann eben entsprechende Matrix-Multiplikation, das heißt jeweils die Zeile mal spalte
Und das, was man dann erhält,
liefert dann eben hier die entsprechende Position in meinem Ausgangsvektor.
Also eins, mal null, ist null. Eins mal eins ist eins,
null mal eins ist null und einmal null ist auch null.
Das heißt, ich hatte hier eine Eins,
ist die hier. Hier genau das Gleiche,
einmal null ist null, null mal eins ist null,
einmal eins ist eins, einmal null ist null,
Summe eins
Hier, Multiplikation liefert null. Hier die Multiplikation liefert null.
Manuel S0. Einmal eins bis eins. Einmal eins ist nochmal eins.
Und ein Manuel S0. Jetzt hatte ich hier zwei Einsen.
Das, was ich jetzt hier mache,
ist im Prinzip in GF2 Addition und Multiplikation,
die Multiplikation war die Unverknüpfung, die Addition war Addition Modello 2, die Oder-Verknüpfung.
In dem Fall, ich habe jetzt hier zwei Einsen,
die oder die Exklusiv-Oder-Verknüpfung. Ich hatte jetzt hier zwei Einsen,
eins, X-Ohr 1 ist null,
deswegen steht an dieser Stelle hier wieder eine Null.
Nicht, das ist also das,
was dort dann eigentlich mathematisch dahinter steht.
Gut, und darüber kriegt man dann eben hier entsprechend
diesen Ergebniswerk
noch raus
Gut, der wird übertragen. Das, was der Empfänger
jetzt macht, ist jetzt eben diese Prüfmatrix zu nehmen.
Dort genau das gleiche Verfahren zu machen.
Und dann eben zu gucken, einmal eins ist eins,
Nummer eins ist null, ein Mal 0 ist null,
0 mal 0 ist ja auch null.
Dann habe ich hier wieder einmal eins, das ist nochmal eine Eins,
exklusiv oder dieser ersten Eins ist wieder eine Null.
Nummer eins ist null und einmal 1 ist null.
Damit habe ich diese Null berechnet. Genau das mache ich
dann hier für die anderen beiden Positionen, habe hier null Vektor und siehe da
Es ist eben kein Fehler aufgetreten. Was passiert im Fehlerfall
? Hier wurde jetzt mal ein Bit modifiziert,
statt der Null wurde hier eine 1 übertragen.
Wenn ich das jetzt hier entsprechend durchrechne,
mit diesem fehlerhaften Wert, erhalte ich dann hier als Fehlersyndrom
1111110. So, und was man jetzt machen kann,
und das ist jetzt eben eigentlich der Trick dabei,
ist, dass ich dann sage, gut,
in diese 110 ist quasi jetzt rein kodiert,
an welcher Bit-Position in dem Vektor der Fehler aufgetreten ist
Das heißt, da gucke ich jetzt hier quasi in meiner Prüfmatrix nach.
1-1-0 ist hier die dritte Position.
Deswegen weiß ich hier an der dritten Position,
ist der Fehler aufgetreten. Und dieses Bit müsste ich kippen.
Und dann hätte ich nämlich auch genau das richtige Wort erhalten.
Das ist also die Art und Weise,
wie jetzt so ein Hemmingcode nach diesem Verfahren
letztendlich funktioniert
Gute, nach zwei Fragen. Gerne. Das ist das Tiefmatrix,
die hat ganz gespaltenweise, wie der jetzt sagt,
das ist ein Falk, das ist tatsächlich. Ne,
das, also die Frage war jetzt,
wenn man sich jetzt hier die Prüfmatrix anguckt,
dass das also ja wirklich,
also spaltenweise dann also auch sowas wie Benärzahlen sind, das heißt also,
ich nehme dieses hier als niederwärtigstes Bit dieses als zweites,
dieses als höchstwertigstes Bild und da habe ich eben hier von eins bis sieben letztendlich,
also irgendwie meine Zahlen durchkodiert.
Die Frage war jetzt, ist das Zufall oder ist das
immer so
Das ist immer so. Das ist nämlich eigentlich genau die Idee von der Art und Weise,
weswegen man das hier so komisch umständlich aufbaut,
dass sich quasi über dieses Prüfwort diese Indizes hier beschreibe und eben sage,
wenn ich einen Index null habe, ist es der fehlerfreie Fall.
Und ansonsten entspricht der Index eben immer genau der Stelle,
wo der Fehler aufgetreten ist. Und diese Binärkodierung,
das sieht man ja auch schon so ein bisschen hier so an diesem farbigen Punktschema,
ergibt sich dann eben quasi dann auch dadurch,
dass ich sage, okay,
hier in dem ersten Prüfbett benullt oder dort geht eben immer mit ein,
alle Positionen, wo das niederwärtigste wird.
Eins ist, demzufolge hier dann eben wirklich jedes zweite Bit und das
ist im Prinzip ja dann also auch genau wie in der Binärkodierung dann,
also die niederwärtigste Stelle. Das heißt also,
dieses hier ist dann eigentlich auch immer schon sowas wie niederwärtigstes zweitwertiges 2 hoch 3,
2 hoch 4 Bit und daraus ergibt sich dann eben auch
genau diese Eigenschaft jetzt bei dieser Prüfbit-Berechnung,
dass man dann also hier raus quasi dann direkt ablesen kann,
an welcher Stelle hier der Fehler aufgetreten ist
Gut, die Frage, wo man beantwortet. Eine neue Frage. Also Frage war,
was passiert, wenn jetzt zwei Bits falsch übertragen werden?
Da kann man sagen, dann hat man Pech gehabt,
weil das, was ich also mit diesem Code ja erreicht habe,
ist, dass ich einen Hemmingabstand von drei habe,
wenn ich da zwei Bit-Fehler habe, würde das also letztendlich,
also woanders hin korrigiert werden.
Also wenn ich jetzt also bei dieser Würfelabweichung quasi bleibe,
beziehungsweise hier, wenn man das also mal durchspielt oder durchrechnet,
würde man sehen,
kriege ich dann eben also hier irgendwie ein völlig falsches Fehlersyndrom und
ich würde dann also hier irgendwie was dann eben zu einem anderen gültigen Codewort quasi wieder zurückkorrigieren,
aber nicht zu dem, was da passiert ist.
Und das ist eben genau die Sache, wo man dann auch sagt,
naja gut, also abhängig von der Aufgabenstellung, das heißt,
welche Daten sollen gesendet werden, wie zuverlässig soll das passieren,
was kann einem im Kanal alles passieren,
wie für Rauschen kommt da rein,
muss ich mir dann eben auch letztendlich mal eine Kodierung überlegen und sagen,
okay, wenn ich mit einem einer Fehlerkorrekturverein wird auskomme,
kann ich das nach diesem Verfahren machen?
Das ist erstmal das Allereinfachste. Und für alles andere,
Haming-Abstand von zwei, drei, vier oder noch deutlich mehr,
gibt es dann also auch entsprechende mathematische Verfahren.
Dann würde ich die aber hier,
also eine gute Stunde lang beschreiben und denken,
das geht dann doch deutlich über das hinaus.
Also wie gesagt, hier nur, also grob das Grundverständnis, wie das aussieht.
Aber man kann eben mit entsprechenden Verfahren auch deutlich mehr machen.
Also ganz am Ende, hier habe ich dann Beispiele,
wo dann also so auch nochmal Realzahlen sind.
Also wenn ich mir zum Beispiel also irgendwie so Fehlerkorrekturmaßnahmen nehme,
bei stark gestörten Medien, Uraltbeispiel, CD,
da gibt es dann also quasi Kodierung oder sowas,
Blöcke, wo man da sagen kann,
da können also 7.000 Bit gestört werden und die lassen sich dann immer noch korrigieren in so einem Block von,
weiß nicht, also zweieinhalb oder zwei Megabit oder sowas,
können dann so viel darin sein,
dann ist aber eben noch deutlich mehr Prüfinformation drin und also noch andere Codes.
Andererseits bei so einem Billigmedium,
wo man dann eben schnell Kratzer drin haben kann,
wovon sich aus schon irgendwie was drin ist,
dann tut das eben auch Not.
Noch eine Frage
Das ist das Amt. Also die Frage war, was passiert,
wenn ich jetzt dann übers Internet übertrage, wie viele Fehler dort auftreten?
Muss ich passen? Also habe ich jetzt also keine Zahlen,
wie häufig oder wie groß dort die Mitfehlerwahrscheinlichkeiten sind. Kann jetzt höchstens versuchen,
das also bis Freitag nochmal rauszufinden und dann also entsprechend die Antwort zu liefern in der Hoffnung,
dass also der Kollege aus dem Bereich der Datenübertragungstechnik sich da weit damit auskennt.
Ansonsten kann ich nur sagen,
also nachher eins von diesen anderen Prüfverfahren ist dann auch was,
was dann typischerweise in der Internetkommunikation mit benutzt,
aber wie groß da jetzt also quasi die Korrekturrahen sind und wie groß,
also jetzt wirklich, also die statistischen Untersuchungen sind,
also was dort auftritt,
um dann eben zu sagen,
mit der und der Art von Fehlerkorrektur habe ich das erschlagen,
weiß ich,
also jetzt aus dem Kopf
auch erstmal nicht
Gut, hier jetzt auch noch mal kurz angesprochen,
Begriff der Fehlerrate, also wie gesagt,
das waren jetzt also immer sehr kleine Beispiele,
wo ich dann eben sage, ich habe also irgendwie kein Informations-Bits,
die werden insgesamt N oder eigentlich Groß-N-Bits irgendwie kodiert mit einem Minimalabstand der Kotwörter untereinander,
wo ich dann eben entsprechend dann mit Fehler korrigieren kann,
wenn ich mehr Fehler habe.
Ne, das war das,
was hier dann auch die erste Frage schon mit war.
Gut, dann ist das eben letztendlich nicht mehr korrigierbar,
beziehungsweise hat man dann was,
was falsch ist
Das, was man dann eben auch noch betrachten muss,
ist eben typischerweise wird für einen Übertragungskanal oder sowas wie eine Bittfehlerwahrscheinlichkeit angegeben.
Das heißt, wie groß die Wahrscheinlichkeiten sind,
dass ein einzelnes Bit sich ändert.
Hier interessiert mich jetzt ja wieder eigentlich die Wortfehlerwahrscheinlichkeit,
weil ich jetzt ja so insgesamt ein Wort von N-Bits rüberschicke,
was dann eben letztendlich,
wenn ich jetzt sowas für eine einzelne Bittfehlerwahrscheinlichkeit habe,
dann eben eine Summe der Wahrscheinlichkeiten entspricht
Hier ist es ganz,
jetzt also auch noch mal so ein bisschen grafisch visualisiert.
Also jetzt hier für so ein 7-4-Hemming-Code.
Kann man bedingt gut lesen. Also im Prinzip hier
die schwarze Linie ist im Prinzip jetzt eine unkodierte Übertragung,
wo ich dann also hier unten die Bit-Fehlerrate im Kanal
habe und dann im Prinzip hier eine Wortfehlerrate sich daraus
dann ergibt
Und rot wäre dann eben bei der Hemming-Kodierung
die Bit-Fehlerrate und die blaue Linie dann eben die Wortfehlerrate,
wo ich dann eben sagen muss, okay,
das ist dann dementsprechend die Summe der Wahrscheinlichkeit nebenzufolge,
ist, dass da dann natürlich dann deutlich größer.
Denn was man hier dann eben sieht,
dass sich also bei einer entsprechend Kleinbit-Fehlerrate,
also überhaupt erst mal mit so einem Verfahren besser bin,
als es Burner Uncodierten Übertragung.
Warum bin ich hier jetzt also nur so viel wenig besser?
Liegt jetzt eben einfach daran, dass ich sage, na gut,
also beim 7-4 Hemming-Code Übertrage ich unkodiert Vierbitt.
Wenn ich das Hemming kodiere, muss ich sieben Bett übertragen.
Und wenn ich jetzt also quasi über die Summe der Fehler Wahrscheinlichkeiten rechne,
habe ich da dann natürlich wieder jetzt eine größere Chance,
mir da also vielleicht mal einen Fehler irgendwo einzufangen.
Nicht deswegen ist es dann eben nur für sehr kleine Bettfehlerraten
wirklich besser als eine unkodierte Übertragung
Wir haben ja jetzt also entsprechende andere Codes nimmt. Wie gesagt,
der Name tut jetzt erstmal nichts zur Sache,
aber wo ich dann also auch mit deutlich mehr und deutlich größeren Bittlängen arbeite,
dann sieht man,
dass sich das Ganze eben entsprechend verschieben kann und dass man dann eben wirklich sagen kann,
also bis zu so einer Kanal mit Fehlerrate von 0,25,
weil da kommt man dann sowieso nicht drüber hinaus,
kann ich dann eben erreichen,
dass ich dann also hier Im Prinzip die Wortfehlerrate entsprechend klein mache.
Andererseits dieses hier ist dann eh mal ein Code,
wo ich also quasi acht Nutzbills in 2048 Bit kodiere.
Und dann kann man sagen, gut,
da habe ich dann also wirklich so viel Redundanz drin,
so großen Hemmingabstand, dass dann eben,
auch wenn jetzt hier Fehler auftreten,
man das eigentlich relativ zuverlässig korrigieren kann
Andere Verfahren, die eigentlich auch sehr häufig eingesetzt werden,
die ich jetzt hier auch nur ganz kurz skizzieren werde,
oder die Grundidee, vielmehr, sind zyklische Codes, das,
was uns häufig mal in irgendwelchen Datenblättern und in irgendwelchen Beschreibungen als CRC,
Circlec Reduntance See Jack begegnet, ist mathematisch aufgebaut auf sogenannten Binärpolynomen,
wo ich sage, ich habe Ein N-Bit-Wort, das soll irgendwie übertragen werden.
Und mathematisch kann ich dieses Wort eigentlich interpretieren als ein Polynom über dem Körper 0 und 1. Das heißt,
wenn ich dieses Wort 1, 0, 0,
1, 1, 0, 1 habe,
ist das jetzt eigentlich nicht irgendeine Zahl oder irgendeine Information,
die ich übertrage, sondern ist das nur eine Kurzschreibweise für so ein Polynom,
beispielsweise ein, nenne ich das in der AFID,
jetzt die entsprechenden Faktoren, also einmal 10 Uhr 6,
plus 0 mal 10.5 plus 0 mal 10, nicht 10, x, hoch 4, plus einmal x hoch 3 und so weiter und so fort.
Das heißt also, hiermit beschreibe ich dann eigentlich so was wie so eine Funktion.
Letztendlich, das ist also hier unten mit angedeutet,
ist es auch egal, wie diese Indie-Cs jetzt gewählt sind.
Es geht dann eigentlich immer nur um die relativen Abstände der Stellen zueinander.
Das heißt, ich kann das genauso gut andersrum sortieren oder
eben hier irgendwie einen negativen Bereich.
So, jetzt habe ich Hiermit beschrieben im Prinzip so ein Binärpolinom.
Und mit diesen Polynomen kann man jetzt eben mathematisch gesehen also auch rechnen.
Auch damit sind Additionen, Subtraktionen, Multiplikationen, Divisionen möglich.
Also auch das fällt dann eigentlich entsprechend stark in die Mathematik der Galoisfelder.
Und das, was man damit dann macht,
sind dann eben solche CRC-Codes, wo im Prinzip mit Polynom,
Multiplikation bzw. Polynom-Division gerechnet wird.
Und das, was sich dann mit so einem CRC-Code eigentlich mache,
ist, dass ich den nehme,
um Prüfbit zu erzeugen
Zyklisch heißt das Ganze deswegen, weil die weiligen Kotwörter dann
nämlich dort durchschieben, beziehungsweise durch Modulo 2-Summe.
Das heißt also X-Or-Verknüpfung gebildet werden. Und damit kann man,
also sagen wir mal,
so eine ganze Familie von kurz zur Fehlererkennung generieren,
die entsprechend gut oder entsprechend schlecht funktionieren,
hängt dann immer davon ab, wie ich dieses Polynom jetzt gewählt habe.
Und da gibt es eben mathematisch gesehen jetzt also Polynome,
die sich besonders gut eignen,
welche,
die sich nicht
so gut eignen
Eins, was also relativ weit verbreitet ist,
ist also im Prinzip hier, es sind 32 Bit-Polynomen,
was also hexadezimal durch diese Darstellung entspricht,
findet sich dann in der Literatur dann auch immer unter CAC 32 und das ist etwas,
was dann also beispielsweise im Ethernet-Protokoll mit drin ist,
aber eben auch in diversen Kompressionsverfahren, also ein ZIP-Algorithmus,
PNG-Kodierung ist es eben unter anderem auch mit drin,
ansonsten sind eben solche CRC-Codes,
also in vielen anderen praktischen Beispielen, also im USB-Protokoll,
ISDN, PGP-Verschlüsselung, sind eben eigentlich alles Verfahren,
wo dann eben solche Codes hier mit drin sind.
Das, was man jetzt,
dass ich hier zum Beispiel mit diesem CRC 32 mache,
ist, dass man also lässt sich damit dann also 32 zusätzliche Prüfbitz generiert für einen bestimmten Blog,
der dann natürlich dann auch eine fixe Länge hat.
Und der ist Ich sag mal jetzt,
charmanter an diesen CRKC kurz ist, dass die sich also relativ,
eine Polynomdivision hört sich jetzt erstmal ganz grauslich an,
dass die sich aber relativ effizient erzeugen lassen,
sei das in Software, sei das aber auch durch irgendwelche spezielle Hardware.
Und zwar benutzt man dazu dann sogenannte rückgekoppelte Schieberegister,
beziehungsweise dann im entsprechenden XO-Verknüpfung, findet sich dann eben in der Literatur,
beziehungsweise wenn man danach sucht,
dann auch oft unter dem englischen Begriff, linear Feedback,
Shift Register oder LFSR.
Was dann im Prinzip so aussehen würde,
also wenn ich jetzt hier einen Polynom hätte,
XO5 plus XO4 plus XO2 plus 1, würde das dieser Hardwarestruktur entsprechen.
Und zwar jeder von diesen Blöcken P entspricht jetzt quasi
einem Einbett Register.
Dieses hier sind XO-Verknüpfung
Und hier wird ein Datenbett hineingeschoben. Und das, was jetzt passiert,
ist, dass die hier alle mit null initialisiert werden.
Ich dann eben quasi rechne, mein Datenbit, XOR, P5.
Das war dann eben hier in P1 reingeschoben im ersten Tag. Alles,
was hier drin ist, wird einen weitergeschoben, alles,
was hier drin ist, wird dann eben quasi x der
Verknüpfung damit hier reingeschoben und so weiter und so fort.
Und je nachdem, Mit welchen Wertigkeiten, ja,
ich arbeite, habe ich dann also quasi hier diese Verknüpfung,
also das XO5 äußert sich dadurch, dass also P5 XOr verknüpft wird, hier.
XO4 wäre die Verknüpfung mit dem P4,
XO2, an dieser Stelle die XOr Verknüpfung mit dem P2.
Und das Plus 1 wäre dann eben Auch für ihre Kopplung mit dem Dateneingang. So,
und damit kann ich jetzt aus meinem Datenbitz,
die jetzt also hier quasi im ersten Tag, im zweiten Tag,
den dritten Tag, dann also irgendwie ein, zwei,
drei, Bits da irgendwie so sukzessive rein waren dann.
Also hier ein immer wechselndes Bitmuster erzeugen. Und dieses Bitmuster,
also diese fünf Bits, wären dann eben mein Prüfpolinumkat,
was ich dann eben an mein Datenwort noch zusätzlich ranhängen muss,
damit ich dann eben mein Kotwort erhalten habe.
Und das, was er dann macht, ist,
dass er dann also quasi jetzt diese Prüfbiss an die Daten bis ranhängt.
Und für die Dekodierung, das ist jetzt eben auch das Interessante,
macht man im Prinzip genau das Gleiche.
Man nimmt jetzt also quasi die Datenworte und die Prüfbiss,
schiebt das entsprechend dann auch inidentische Hardwarereien.
Und wenn hinterher hier in allen Registern eine Null steht,
es ist ein gültiges Wort, wenn dort keine Null steht.
Das heißt, der Registerinhalt Ungleichnull ist, dann habe ich
leider einen Fehler gehabt. So, je nach Art des Polynoms,
also sprich der Anzahl der Prüfbitz,
arbeiten diese Verfahren unterschiedlich gut oder schlecht,
was sie dann eben quasi als Fehler erkennen,
beziehungsweise was
man dann benutzen kann
Teilweise ja auch vor Fehlerkorrekturen. Gut. Hier
noch so ein ganzer Satz von links in die Wikipedia,
wo man dazu dann noch was findet. Also wie gesagt,
jetzt weiter auf die Mathematik, wollte ich da jetzt also nicht eingehen,
aber da ist auch nur so grob als Idee, falls einem sowas mal begegnet, beziehungsweise der Begriff begegnet. Wo das beispielsweise auch mit angewandt wird, ist bei Selbsttestmaßnahmen in der Hardware. Sprich,
wenn ich jetzt irgendwo hier in meinen Beispielsweise jetzt also irgendwie hier mein Auto starte,
dann geht also nach einer Zeit,
also irgendwie erstmal so Erbekontrollleuchte an und dann auch wieder aus und nicht und das,
was dann ja passiert ist,
dass also die irgendwie dahinter liegende Hardware, also irgendwelche Tests macht,
wo dann geguckt wird, sind die Sensoren in Ordnung,
empfange ich Werte und wo dann eben auch zumindest bei solchen kritischen Sachen dann eben auch mal geguckt wird,
ist die Hardware jetzt also noch in Ordnung oder ist da also irgendwo wirklich jetzt noch einen zusätzlichen Hardwarefehler aufgetreten und für solche Sachen benutzt man dann solche rückgekoppelten Schieberegister ganz gerne,
weil man damit dann eben auch dann quasi so Pseudo-Zufallszahlen machen kann,
um beispielsweise jetzt,
also irgendwie sowas wie ein Speicher-Selbsttest zu machen oder um in der Hardware zu gucken,
ob jetzt zwischenzeitlich was kaputt gegangen ist, beziehungsweise,
wobei das ist dann wieder ein anderes Thema,
bei der Fertigung oder bei der Herstellung von Hardware-Komponenten gehen wir jetzt natürlich davon aus,
dass wenn ich also irgendwo in den Laden gehe und mir einen Prozessor irgendwo kaufe,
dass der fehlerfrei ist.
So, jetzt kann man natürlich sagen, okay,
wenn ich also jetzt irgendwo so ein einen größeren Prozessor habe
mit 8 Milliarden Transistoren und der wirkt irgendwo bei Samsung IntelliTSMC oder wie auch immer, also letztendlich gefertigt.
Es ist relativ unwahrscheinlich, dass alles,
was bei denen also aus der Fertigung rauskommt, fehlerfrei ist,
sondern das, was dort passiert, ist, dass nach der Fertigung der Chips. Das heißt,
bevor also im Prinzip die Siliziumscheiben, also die großen Wafer,
überhaupt erst mal zersägt und auseinandergenommen werden,
wird schon über Selbsttestmaßnahmen und über andere Maßnahmen also geguckt,
ob das, was also hinterher auf dem Chip drauf ist,
dann eben Fehler frei ist und richtig funktionieren würde oder ob irgendwo bei der Fertigung,
also dann vielleicht doch irgendwo ein Staubkorn eingeschlagen ist und deswegen
ein paar tausend Transistoren kaputt gegangen sind und das dann
der Chip nicht tut und die gelangen dann eben normalerweise sowieso
schon mal gar nicht in den Handel
Nicht. Und das, was dort dann also an Fehlermaßnahmen oder Fehler erkennen,
Maßnahmen passiert, also gerade da wären dann also auch häufig solche Prüfmechanismen mit eingesetzt.
Gut, so war es jetzt eben hier noch zu den CLC-Codes.
Hier nochmal, Praxisbeispiel eher in 13 Produktcode,
also das, was diese European Artikel number ist.
Auch da hat man im Prinzip dann wieder so Prüfmuster,
ähnlich wie bei dieser ISBN-Nummer, wo ich dann ja also hier immer diese Abfolge weißer und schwarzer Balken habe.
Hier dann also nochmal im Klartext die Zahl,
dass wenn der Scanner das nicht richtig erkennen kann,
also zumindest irgendeine arme Kassiererin an der Kasse das noch abtippen darf.
Und also auch das ist dann im Prinzip so ähnlich wie bei diesem Buchcode etwas,
wo man dann also hier so ein Bitmuster hat,
wo dann also Nullen und Einsen letztendlich drin sind,
dann also auch noch über entsprechende Kodierungszeichen so gemacht sind,
dass das unabhängig davon ist,
also ob jetzt der Scan, der Laserstrahl vom Scanner,
das von links nach rechts oder von rechts nach links liest,
war man dann also aus dem Code auch erkennen kann,
wie die Leserichtung ist und dann gegebenenfalls also auch die Zahlen auch vertauschen kann.
Solche Sachen und wie gesagt, da sind dann also verschiedene Maßnahmen mit eingebaut. Also wen sowas interessiert,
also auch hier dieses Bild hatte ich also jetzt hier zum Beispiel mal aus dem zack,
Wikipedia-Artikel rausgenommen, wo dann eben wirklich auch noch genau beschrieben ist,
wie eigentlich dieses Verfahren aussieht,
wie jetzt hier irgendwie einzelne Ziffern gebildet werden,
nicht wo Grundidee ist,
aber dann eben auch immer über mehrere Abfolgen von hellen und dunklen Streifen quasi zu kodieren,
welche Zahlen das sind.
Und da gibt es dann eben hier noch sehr viele unterschiedliche Kombinationen,
wie das dann also letztendlich funktionieren kann,
beziehungsweise wie das so aufgebaut ist,
dass es dann eben entsprechend so auch geht
Gut, anderes Beispiel, Fehlerkorrektur, hat er ja schon gesagt,
Kompaktes, können wir nicht beziehungsweise inzwischen mördern und sagen,
na gut, also DVD, Blu-Ray, was auch immer.
Also sprichst du ein Datenmedium,
was also möglichst wenig kosten darf, billigste Fertigung eigentlich hat,
demzufolge dort natürlich also relativ häufig Fehler auftreten können.
Wie kriegt man das dann entsprechend hin,
dass dann eben keine Fehler drauf sind und
auch dort werden dann eben sehr umfangreiche und auch mehrstufige
Fehlerkorrekturmaßnahmen eingesetzt
Also bei einer CD sieht das ja so aus.
Also ich habe da im Prinzip so eine Spiralförmige Spur,
entsprechend viele Windungen, habe da dann also quasi in dieser spiralförmigen Spur
dann sowas wie so eine Abfolge von Erhöhung beziehungsweise flacheren Teilen.
Ich weiß hier,
dass wir jetzt eben ein Sympath in einer Spur und letztendlich
sind da dann immer kodiert bei so einem Wechsel von einem niedrigen zu einem erhöhten Teil,
was dann immer Land bzw. Pit genannt wird, das markiert mir eine Eins.
Und wenn ich dann eben hier aufeinanderfolgenden Punkt,
Abtastpunkten dann eben keinen Wechsel habe, markiert das eine Null.
Darüber habe ich dann also ähnlich wie bei so einem Greycode dann ein Bitmuster drin kodiert. In das,
was man damit dann eben macht, ist, dass man dann,
weil das Ganze eben letztendlich schnell Fehler beinhalten kann,
Mehrere mehr oder minder aufwendige Fehlerkorrekturmaßnahmen mit einbaut,
wo ich dann eben sage, gut,
Anforderungen sind halt eben bei einer Audio-CD,
dass ja die nicht korrigierbaren Fehler, zumindest also so wenig sind,
dass man die also immer noch irgendwie entsprechend interpolieren kann.
Und nur wenn das Ding also wirklich richtig kaputt und sehr krass ist,
dass dann also auch der Audio-Player damit nichts mehr anfangen kann.
Und bei Daten-CDs hat man dann eben noch mal wieder deutlich mehr Fehlerkorrektur darin als bei irgendwelchen Audiodaten
In der Regel kann man es sagen, also nicht korrigierbare Fehler,
werden da so auf Bit-Fehler raten unter 10.11 Uhr gebracht,
was, wenn man das so Pi mal Daumen durchrechnet,
650 Mibibyte-Kapazität, kann man dann sagen, na gut,
das ist dann so alle 17, 18 CDs,
wo dann also wirklich mal nicht korrigierbare Fehler mit drin ist.
Hier auch nur ein paar Daten zu der Art und Weise,
was dann also in dieser Kodierung passiert, nur um zu zeigen,
wie aufwendig das dann, also selbst bei solchen einfachen,
billig Medien, das im Prinzip schon ist.
Also wie gesagt, Details erspare ich uns jetzt hier,
wird also auch in den Übungsaufgaben nicht weiter abgefragt, ist von daher auch nicht prüfungsrelevant.
Also hier ist die Idee, dass sie eben Aufsage,
also die Daten werden quasi in Blöcke,
sogenannte Frames aufgeteilt, die dann wieder in Sektoren,
dann habe ich dann eben irgendwie 2300 bald Nutzdaten,
pro Sektor werden dann 784 bald Fehlerkorrektur hinzugefügt und insgesamt kann ich dann eben mit diesem Code dann also bis zu 7000 fehlende Bits korrigieren
Nicht dein Erfolg dann nochmal wieder eine Modulation,
wo ich dann eben aus 8-Bit nutze,
daten,
14-Code-Bits erzeuge und das Ganze dann eben wie in so einer Art Greycoach dann eben auch immer zum einen dafür sorge,
dass ich wechsle zwischen Nullen und Einzeln habe,
dass ich also jetzt nicht andauernd nur Nullen übertrage oder nur Einzeln übertrage,
weil dann könnte sich der Laser dann auch nicht mehr kalibrieren,
sondern man muss eben auch schon mal immer so
ein bisschen Wechsel stattfinden
Nicht ansonsten immer durch diesen Wechsel,
dann letztendlich diese Informationen, also so ein Pitland-Übergang,
Informationen 1 gesendet wird und alles andere wäre dann eben null.
Bei der Daten-CD gibt es dann zusätzlich noch so eine Art 2D-Code,
der dann auch noch mit angewendet wird,
wo ich dann eben auch noch zusätzliche Fehlerkorrekturmaßnahmen damit einbaue und das Ganze entsprechend hinkriege.
Andere Beispiele für Kodierung, Farbbildkodierung,
das was also typischerweise bei den Kameraformaten haben,
Nicht seit 1992 standardisiert, von der Joint, Picture, Experts Group.
Daher kommt der Name dann nämlich auch. Kann im Prinzip
erst mal Verluft behaftetes Verfahren sein. Hier jetzt auch nur angedeutet,
wo man einfach erst mal sieht, dass das,
was wir eben so auch als Datenformaten verwenden,
eben schon relativ viel von diesen Umkodierungsmaßnahmen und Konvertierungsmaßnahmen eigentlich mit benutzt.
In dem Fall wird also im Prinzip der Farbraum erst mal umgerechnet von RGB in Y-U-V.
Also RGB hätte ich dann im Prinzip jeweils ein Pixel als
rot-grün- und Blauanteil, dann beispielsweise in jeweils acht Bit kodiert.
Y-U-V ist ein Format, wo ich beschreibe den Grauwert,
also die Helligkeit, dass die Y-Kommonente und mit U-U-V
wird dann quasi ein Farbvektor beschrieben in einem zweidimensionalen Farbraum.
Und was man da dann teilweise noch macht, ist,
dass ich jetzt eben nicht jedes RGB-Pixel dann eben in Y-UV-Umsätze,
sondern deswegen teilweise verlustbehaftet. Wenn ich jetzt nicht Y444 nehme,
werden dann nämlich quasi Gruppen von Bits auch schon zusammengefasst und gesagt wird,
also meinetwegen zwei aufeinanderfolgende Bits haben zwar unterschiedliche Helligkeit,
die kriegen aber die gleiche Farbkodierung.
Was man also bei vielen Bildern eben auch schon relativ häufig eigentlich hat,
beziehungsweise wenn ich da dann eine kleine Abweichung habe,
wird man das so mit dem Auge
erstmal nicht weiter wahrnehmen
Nicht anschließend wird das Ganze dann eben in Blöcke zusammengepackt.
Die werden dann über eine DCT diskredite Kursindustransformation und also quasi nochmal umgerechnet.
Dann hat man das, was dann typischerweise immer so
als Regler für die Qualität hat, nämlich den Quantisierung.
Nicht, wo ich dann eben sagen kann, okay,
ich kann dort dann auch 100 Prozent einstellen,
dann ist es eben auch verlustfrei.
Ansonsten verlustbehaftet, wo dann eben quasi jetzt für diese Blöcke,
da nämlich ausgewählt wird,
wie viele davon übertragen werden bzw. wovon dann da jetzt
was weggelassen wird
Und anschließend Erfolg dann eben auch nochmal einen Hafen in Codiero. So,
das war ein Standbild bei Videobildformaten,
also zum Beispiel MPEG sieht das ja nämlich so aus,
dass das dann noch beliebig viel komplizierter darauf dann wieder aufbaut,
dass ich sage, also ein Ampact-Video, also Einzelbilder,
kann ich dann also quasi wie so ein JPEG-Bild übertragen.
Was man da noch macht,
ist natürlich, wenn ich jetzt sage,
okay, ich nehme ein Video auf,
ich habe jetzt also 25 oder 30 Bilder pro Sekunde,
könnte ich jedes Bild einzeln nehmen
JPEG codieren und das übertragen. Wenn ich jetzt natürlich sage,
ich möchte also irgendwo Datenrate oder ein Streaming hinbekommen,
wo ich jetzt also wirklich für Mobilgeräte nicht mit irgendwelchen riesen Datenströmhandtiere,
die ich also jetzt vielleicht also irgendwie über mein Funknetz,
also gar nicht mehr übertragen bekomme,
muss dann das also noch weiter komprimieren.
Dazu nutzt man dann die Idee, dass man sagt,
zwischen einem Bild und dem nächsten Bild,
wenn ich jetzt nicht gerade einen Schnitt in meinem Film habe,
habe ich erstmal relativ wenig Änderungen.
Klassisches Beispiel ist also irgendwie Übertragung eines Fußballspiels. Man hat also
im Hintergrund erstmal irgendwo grünen Rasen und da ist ein Spieler und okay,
wenn er jetzt nicht gerade schläft, sondern also irgendwie ein bisschen läuft,
dann hat er sich im nächsten Bild ein bisschen bewegt.
Und das, was ja eigentlich noch übertragen muss,
ist also nicht mehr der grüne Rasen, der sich nicht geändert hat,
sondern nur, wie hat er sich bewegt und dann also quasi eine Änderung zu irgendeinem vorherigen Bild übertrage.
Nicht und genau das macht man da,
indem da dann also unterschiedliche Arten von Bildern übertragen werden,
das nennt sich da dann also beim Impact-Verfahren und immer I-Frames,
Pee-Frames und B-Frames, wo ich dann sage,
also ein I-Frame ist das quasi sowas wie ein Standard-Einzelbild,
ein P-Frame berechnet sich dadurch,
dass ich also quasi jetzt ein I-Frame und alle Bilder davor benötige,
um das Bild zu berechnen.
Ich übertrage dann aber eben von einem Pee-Frame zum nächsten
eben wirklich nur noch solche differenziellen Änderungen und ein B-Frame brauche ich eben alle Informationen davor und alle dahinter bis zum nächsten IFrame.
Damit kann man dann noch mehr interpolieren. Über entsprechende Verfahren,
wie das jetzt so miteinander geschachtelt wird,
kann man dann letztendlich den Datenstrom oder die Datenrate dann eben auch dynamisch anpassen an das Medium und eben sagen, okay,
wenn ich jetzt eben auf meinem Kanal entsprechend so und so viele Bilddatenströme übertragen möchte und ich dann eben nur noch,
was weiß ich, so und so viel 100 Mega Bit pro Sekunde zu habe,
muss ich das eben so und so kodieren und dem zuvorgeht,
da dann eben natürlich dann entsprechend die Qualität runter,
aber eben wie gesagt,
also aufgrund dieser Tricksereien sieht man das dann eben bei vielen Sachen erstmal nicht.
Und so war es es dann eben in diesen ganzen Formaten für Digitalfernsehen
letztendlich dann alles mit drin. Also das ist also das,
was wir jetzt also beim Satellitenfernsehen oder beim Kabel bzw. DVBT letztendlich sehen,
wo man dann also gelegentlich vielleicht mal sieht,
wenn jetzt also irgendwie der Betreiber einen Ausfall hat oder irgendwie die Leitung gestört ist.
Dann hat man also diese typischen Blogartefakte,
dass also in dem Fernsehbild auf einmal irgendwie was stehen bleibt
oder also irgendwie so relativ große Teile des Bildes,
also auf einmal irgendwie wie so ein Kasten, so ein Block stehen bleiben.
Da gehen dann eben genau solche Effekte mit rein,
wie dann also hier diese Blockbildung und diese Effekte also aus der DCT,
die da im Prinzip dann dahinter stehen.
Gut, also das jetzt nur nochmal so als Beispiel genannt,
wo überhaupt jetzt also und solche Kodierungsverfahren auch täglich eigentlich begegnen. Gut,
das war jetzt eigentlich dieser Abschnitt, Kapitel 9, Codierung,
dann kommen wir jetzt heute die letzte Viertelstunde beziehungsweise dann eben entsprechend am Freitag dann wieder in die Logik,
beziehungsweise Ziffern- und Zahndarstellung, solche Sachen, die Bereiche wieder zurück,
das heißt in die Bulsche Algebra und dazu Kommt jetzt also quasi als zehntes Kapitel,
das Kapitel mit den Charlet-Funktionen.
Von der Definition her schalt Funktion,
wie er ja auch mathematisch beschrieben,
Funktionen da mit drinsteht, ist also letztendlich eine Zuordnungsvorschrift,
die jetzt eben aus einer Wertekombination von in Variablen ein Wert berechnet.
Also sprich das, was wirklich stumpf gesehen mathematische Funktion ist.
Nicht das heißt YSF von Irgendwie eine Anzahl von Variablen.
Das, womit wir dann natürlich jetzt typischerweise arbeiten,
sind dann eben Binäre. Schaltvariablen beziehungsweise binäre Werte,
die dann hier am Ausgang herauskommen können.
Als Ausgangsvariablen. Was wir eigentlich schon ganz am Anfang
aus dem Bereich kennen, sind also quasi die trivialen
elementaren Schaltfunktionen
And or X or formal gesehen sind das dann eben auch Schaltfunktionen von zwei Variablen.
Und ich fuhr ich dann eben aus zwei,
wie in der Variablen, dann eben meine End-or-X-Off-Funktion herausbekomme.
Das, was jetzt eben folgt,
ist dazu dann eben die entsprechende Verallgemeinerung auf End-Variablen.
Wie kann man Schaltfunktionen beschreiben? Da gibt es also
sehr viele sehr unterschiedliche Beschreibungsmöglichkeiten. Das kann textuell passieren,
das kann in Form von Tabellen passieren,
das kann grafisch passieren
Beispiele dazu folgen jetzt also zuhauf, beziehungsweise dann also auch in den Übungsaufgaben,
die dann ab nächster Woche dann letztendlich rauskommen.
Ab heute Abend sind dann ja sagen wir mal so die Übungsaufgaben,
wo es dann auch um die Kodierung geht, mit dran.
Nicht aber jedenfalls, also wird uns dieser Begriff eine Charles-Funktion,
gerade weil er auch relativ zentral ist,
auch für die nachfolgenden Kapitel da dann eben noch entsprechend
häufig begegnen
Was dort dann auch immer noch unterschieden wird,
bei solchen Beschreibungen ist also eine Unterscheidung zwischen Verhaltensbeschreibung und Strukturbeschreibung,
Verhaltensbeschreibung in dem Sinne, sowas wie eine Textelebeschreibung,
wo ich eigentlich beschreibe, was die Funktion machen soll,
Strukturbeschreibung,
sei das jetzt grafisch dargestellt durch irgendwelchen baumartigen Darstellungen oder sei das also irgendwelche Schaltbilder oder eben auch Schaltalgebranche Ausdruck.
Auch das wäre dann eigentlich so was wie eine Strukturbeschreibung,
wo ich dann eben sage,
aus welchen Teilelementen oder aus welchen Garten sich so eine Schaltfunktion zusammensetzt.
Einfachste Beschreibungsmöglichkeit wäre, so was wie eine Funktionstabelle.
Also ich habe als Schaltfunktion F von X berechnet mir einen
Ausgangswert Y. X ist quasi jetzt ein Vektor mit I-Angängen.
Und das, was ich jetzt eben mache,
ist einfach entsprechend der Anzahl der möglichen Kombinationen für X,
die alle aufzulisten, binär. Du warst also jetzt hier
bei so einem Drei-Bit-Wektor dann eben hier entsprechend die acht Möglichkeiten ergibt.
Und hier in einer zusätzlichen Spaltern eben zu sagen,
okay, für welche Eingangskombinationen, welche Ausgangskombinationen die Funktion liefert.
Ja, und dann kann ich hier einfach direkt ablesen,
wenn ich als Eingangswektor 001 habe,
kriege ich eine Null raus, wenn ich eins eingangs wecke,
der 01111 habe,
kriege ich
eine 1 raus
So, trivial, straight forward. Häufig wird das Ganze
dann auch noch dadurch ein bisschen verkürzt, vereinfacht,
dass sie dann sagen, okay, es wird einfach,
oder ich gehe impliziert davon aus,
dass es binär irgendwie durchnummeriert wird.
Und ich schreibe dann einfach nur die Funktionswerte heraus.
Das heißt also, das, was hier steht als Beschreibung,
also dieses 001111 und so weiter,
ist dann nichts anderes als hier von oben nach unten
diese Spalte abgelesen.
Ähm, Nachteil von dem Ganzen, die Funktionstabelle,
wenn ich hier in Eingänge habe, muss natürlich alle möglichen Eingangskombinationen auflisten.
Bei allen N-Eingängen sind das zwar hochends Stück. Demzufolge wächst natürlich
der Speicherbedarf exponentiell mit N und selbst für relativ einfache und triviale Funktionen.
Möchte man sowas dann also nicht mehr aufschreiben?
Hier als Beispiel, wenn ich sowas wie ein 16-Bild-Adira beschreibe.
Ich habe 2016 bezahlen und ich habe vielleicht auch noch einen Carry in Eingang,
hätte ich 32 Eingangsvariablen, also demzufolge eine Tabelle mit 2 hoch 33 Zeilen.
Das heißt, die Beschreibung als Funktionstabelle für so ein Beispiel
wäre natürlich dann also irgendwie nicht mehr sonderlich gut geeignet.
Erweiterung zu diesen Funktionstabellen, sogenannte Don't Cars,
werde ich nachher dann noch, beziehungsweise schätzweise am Freitag,
einführen, wo man dann eben letztendlich beschreiben kann,
wenn die Funktion unvollständig definiert sind.
Das heißt also, nicht alle Eingangskombinationen benutzt werden,
dann lasse ich hier die Ausgänge quasi offen bzw. Sätze
dort dann so ein Sternchen als Don't Care ein und kann
das später für Minimierungsverfahren hier drin entsprechend gut benutzen.
Echt deswegen,
also Don't Care
Weil ich dann sage, okay, das ist ein,
in Anführungszeichen, ungültige Eingangskombination.
Beispiel wäre zum Beispiel sowas wie ein Code in so einer BCD-Kodierung.
BCD, was war das noch? Bin recoded Desimal. Das heißt,
ich benutze vier Bit, kodiere damit meine dezimal ziffern von 0 bis 9. So,
das, was wir dann natürlich jetzt in der Hexer-Dezimalkodierung haben,
das heißt,
die Kombination 10 bis 15 oder A bis F benötige ich
nicht und für die könnte ich dann eben sowas wie so ein Don't Care eintragen und sagen,
okay,
die sollen jetzt bei meinem Code erstmal nicht weiter vorkommen und denen zufolge interessiert es mich da auch erstmal nicht,
was dann bei so einer Kodierung dann rauskommt.
Gut, also das als Beschreibung über Funktionstabellen,
Verhaltensbeschreibung kann ich jetzt natürlich also irgendwie textuell machen.
Nachteil bei solchen textuellen Beschreibungen,
also gerade wenn ich das irgendwie umgangssprachlich formuliere,
dass das eben entsprechend sehr schnell mehrdeutig wird.
Beispiel dazu dann gleich auf der nächsten Folie
Was man als Verhaltensbeschreibung dann noch macht, ist,
dass sich im Prinzip logische Ausdrücke in Programmiersprachen entsprechen,
in dem Sinne auch Verhaltensbeschreibung von Charles-Funktionen und wo das dann eigentlich noch am häufigsten eingesetzt wird,
ist das wirklich so auf der Ebene von Hardware-Beschreibungssprachen,
VDL-Varylock, System C,
wo man dann eben auch mit entsprechenden Beschreibungshilfsmitteln sowas macht.
Gut, ich hatte schon gesagt,
umgangssprachliche Formulierungen sind oft mehrdeutig
Beispiel, es soll also jetzt hier quasi die Steuerung vom Schiebedach irgendwie gemacht werden.
Und ich sage also, das Schiebedach ist okay,
wenn der Öffnungskontakt oder der Schließkontakt funktionieren oder beide nicht aktiv sind.
Nicht, wenn ich das jetzt versuche,
formal als Schaltfunktion zu beschreiben, kann ich sagen,
okay, Schiebedach, okay, wäre Die Ausgangsvariable meiner Schaltfunktion.
Ich möchte nämlich wissen, es ist okay, es ist nicht okay.
Öffnungskontakt ist die eine Eingangsvariable, schießt Kontakt, ist die andere Eingangsvariable.
So, und wie sieht jetzt die Funktion aus?
Und was dann hier eigentlich letztendlich mit drin ist, also in diesem Text,
nicht, also wenn der Öffnungskontakt oder der Schließkontakt funktionieren,
ja, was ist mit dem oder gemeint?
Ist das jetzt eben wirklich ein logisches oder oder ist das so ein Exklusiv-Oder,
was man ja so häufig in der Sprachformulierung mit drin hat,
Oder die andere Sache dann eben, wenn beide nicht aktiv sind.
Was heißt jetzt das? Es kann natürlich sein, dass
X1 und X2 nicht aktiv sind. Das heißt also,
ich habe dann eigentlich so eine Funktion,
wo ich das schreiben würde als X1. Und naja, gut.
X0. Und das Ganze negiert
Ich könnte aber auch sagen, X-1 nicht und X-0 nicht,
was dann heißt nicht X-1 und nicht X-0.
Das heißt also hier letztendlich dann so eine Klammerung haben.
Und das sind natürlich dann, also schon mal grundsätzlich
ganz andere Funktionen, die sich dann dahinter verbergen.
Und demzufolge habe ich dann also auch nie in einer Interpretation
dann entsprechend
unterschiedliche Schaltungen
Gut, eine Folie noch, dann würde ich
an dieser Stelle jetzt hier den Schluss für heute machen.
Also wie gesagt, das Verhaltensbeschreibung, wobei eben, wie gesagt,
diese Mehrdeutigkeit da ein bisschen schlecht ist. Deswegen das,
was man dann häufig benutzt, sind dann eben letztendlich Strukturbeschreibungen,
wo ich dann im Prinzip mit der Spezifikation gleich mit beschreibe,
wie diese Funktion auch realisiert wird.
Beispielsweise So wie das hier schon drauf ist, nämlich als so ein Schaltalgebarsche-Ausdruck,
wo ich dann eben sage, ich habe hier meine Variablen,
ich habe das jetzt hiermit und mit dem Nicht irgendwie zusammengefasst.
Ich habe das geklammert und das ist dann eben auch schon eine eindeutige Beschreibung.
Also demzufolge, also sowas wie diese vollständig geklammerten Ausdrücke.
Und dann gibt es eben noch andere Beschreibungen, Datenschlussgrafen,
Schaltpläne mit Gaddan, das wird uns dann also im nächsten Kapitel auch noch begegnen oder eben andere Beschreibungsmöglichkeiten. Das erstmal grob zu der Idee,
Verhaltensbeschreibung, Strukturbeschreibung und am Freitag werde ich dann also auch nochmal auf die Art und Weise eingehen,
wie man solche Beschreibungen dann aufbauen kann,
beziehungsweise das ist jetzt eben auch das Interessante,
wie ich das dann auch wirklich eindeutig machen kann,
dass eben, wenn ich zwei gegebene Beschreibungen habe,
auch sagen kann, die sind identisch oder die sind nicht identisch,
weil bei logischen Ausdrücken habe ich grundsätzlich erstmal die Möglichkeit,
die also auf beliebig viele Gleichartige Weisen zu beschreiben.
Die Frage ist jetzt eben, kriege ich sowas wie so
eine Minimalbeschreibung hin oder eben sowas wie eine einheitliche Beschreibung,
wo ich dann eben solche Eigenschaften direkt ablesen kann.
Gut, das wird dann am Freitag,
sprich übermorgen folgen und damit jetzt aber wirklich am Schluss für heute