Gut, ich hatte ja letzte Woche aufgehört mit dem Thema Fehlererkennung,
Fehlerkorrektur, wo es im Prinzip jetzt erstmal darum geht zu sagen,
wie kann man das prinzipiell machen?
Grundidee ist halt eben wieder zusätzlich Redundanz hinzufügen. Das heißt,
neben irgendwelchen zu übertragenen Bits werden dann eben noch zusätzliche sogenannte Prüfbitze hinzugefügt.
Und das geht eben im ganz einfachen Fall,
jetzt erstmal nur für eine Fehlererkennung,
indem ich dann also beispielsweise sowas wie eine Parität bilde
Für die Fehlerkorrektur, brauche ich dann eben ein deutlich größeren Hemming-Abstand.
Was ist Hemming-Abstand? Wenn ich einen Code habe,
für alle Paare von Codewörtern, an wie vielen Bittstellen,
die sich dann eben jeweils unterscheiden.
Und wenn ich dann eben einen Hemming-Abstand in einem Code von D habe,
dann kann ich eben eine Fehlererkennung für dminus 1 Fehler machen,
eine Fehlerkorrektur für dminus 1,
halbe Fehler
Da ist eben diese Grundidee, das, was wir an den Würfeln visualisiert hatte,
dass man dann quasi jetzt guckt, wenn entsprechend wenig Fehler drin sind,
in welcher Richtung liegt das jetzt also quasi noch näher an irgendwie gültigen Kotwörtern.
Gut, um jetzt eine Fehlerkorrektur zu machen, beziehungsweise um das jetzt also systematisch zu machen,
haben wir also dann das schon kennengelernt, gibt es dann also im Prinzip unterschiedliche Möglichkeiten. Eine war dann sowas wie so ein 2D-Paritätscode,
dazu gibt es das jetzt ja dann auch irgendwie dann eine Übungsaufgabe in den neuen Aufgaben,
Zettel 6, eine andere Möglichkeit war dann einfach so ein 3-1-Code,
also spricht, dass sich eben beispielsweise jedes Bit Nutz mitnehme,
verdreifache und dann also quasi einfach über einen Mehrheitsentscheid sage,
wenn ich jetzt eine Einbittfehler habe,
dass ich dann eben eine Fehlerkorrektur machen kann und eben sagen kann,
wenn es sowas wie 1-1-0 empfangen wurde,
okay, das eine Bit hat gekippt,
aber die A-Nsen sind eben noch entsprechend öfter und demzufolge ist das.
Anderes, auch häufig verwendet es noch vergleichsweise einfaches Verfahren,
ist dann eben sowas wie sogenannte Hemming-Code, wo es dann darum geht,
eben auch als Hemming-Abstand erstmal nur drei zu erreichen.
Das heißt, damit kann man Einbittfehler korrigieren und viele zwei
beziehungsweise dreibittfehler dann eben auch erkennen. Letztendlich hängt es,
also gerade so bei Fehlererkennung, Fehlerkorrektur,
dann eben auch immer teilweise noch so ein bisschen ab,
dass man sagen kann, einige Fehler,
also zum Beispiel gerade so bei 2D-Paritätscodes,
also da ist dann eben in dieser Aufgabe auch so ein bisschen nachgefragt.
Also da kann man dann eben mit diesem Code also auch
noch teilweise sowas wie Vierbittfehler erkennen unter bestimmten Eigenschaften.
Und deswegen sind solche Codes dann eben auch nur Bedingt geeignet,
beziehungsweise wenn ich dann eben entsprechend größere Fehlererkennung oder Fehlerkorrektur brauche,
brauche ich dann eben auch noch entsprechend mehr Prüfbilds. Gut,
aber jetzt zu den Hemming-Codes, da geht es eben erstmal darum,
dass man sagen kann, okay, ich habe einen Nutz-Bits,
ich habe irgendwie K zusätzliche Bits jetzt um von diesen N-Nots-Bits dann also quasi eine Fehlerkorrektur zu erreichen,
beziehungsweise dann eben den Hemming-Abstand, Reize erreichen,
sodass sich ein Befehler hier daran erkennen und korrigieren kann.
So, und jetzt ist ja erstmal die Frage,
wie viele zusätzliche Bits brauche ich und das war so das,
womit ich also letztendlich am Freitag aufgehört habe, dass man sagen kann,
okay, mit diesen Carbits muss ich folgende Eigenschaften kodieren können,
nämlich einmal, dass gar kein Fehler aufgetreten ist.
Und ich muss eben beschreiben können, an welcher Stelle dieser eine Einblick Fehler,
den ich korrigieren möchte, wurde aufgetreten ist. So,
und da habe ich jetzt natürlich nicht nur die Nutzbits-Arztstellen,
sondern da habe ich dann natürlich also auch noch die zusätzlichen Prüfbezahlsstellen,
in demzufolge muss daran eben immer gelten, wie viele Bits brauche ich zusätzlich,
dass ich eben sage, zwei Hochk ist eben größer, gleich
Endlos 1. Nicht also Ennios als Gesamtsumme der Bits,
um eben quasi zu kodieren, an welcher Stellenfehler aufgetreten ist.
Oder eben um den Fehlerfreien Fall zu kodieren,
dass es eben dann diese Plus 1. So, wie wird dieser Code jetzt erzeugt? Dazu gibt es dann folgendes Verfahren,
dass man also jetzt erstmal sagt, wenn ich jetzt in Nutzbits habe,
dass man also erstmal also quasi bestimmt,
wie groß dieses K sein soll,
also sprich En-Planert-like 2 hochk minus k minus 1,
was hier also quasi direkt einfach hier raus ergibt,
dann werden, wenn man das jetzt also systematisch macht,
im Prinzip an bestimmten Positionen, prüft Bits eingefügt.
Das heißt also jetzt anders als das hier auf der Tafel ist,
werden jetzt also diese Prüfbits nicht hier irgendwo hinten an das Wort angehängt,
sondern das ist dann nämlich eigentlich jetzt für diese Codierung,
wo der Fehler aufgetreten ist, wichtig, werden die also quasi hier reingestreut.
Und zwar letztendlich genau an den Bit-Positionen, die Zweierpotenzen entsprechen. Das heißt,
wenn ich jetzt hier also meine Man kodiert es Datenwort habe,
dass ich dann eben quasi an der ersten Position ein Prüfbit anbringe,
an der zweiten Position, also sprich hier 2 hoch 0,
2 hoch 1, dann habe ich das erste Datenbit überhaupt erst,
dann an der dritten Position oder Blödsinn an der vierten Position,
das dritte Prüfbit, nicht und dann kommen jetzt wieder drei Datenbits und das Ganze geht dann dementsprechend fort.
Wenn man das also jetzt hier sieht,
wie das also jetzt auf der nächsten Folie drauf ist,
dann sieht man das also quasi mit letztendlich immer größeren Wortbreiten,
dann eben auch das Verhältnis von Prüfbitz zu Daten,
wird es also auch immer besser, beziehungsweise immer günstiger wird.
Wenn ich also gerade so bei diesen sehr kleinen Wahlspielen ist das
natürlich dann erstmal so relativ erschreckend, dass man sagt,
also ich habe hier irgendwie lauter Prüfbitz und relativ wenig an Datendichte übertrage.
Das, was hier jetzt immer noch mit bezeichnet ist,
zum Beispiel, ist dann also der 7-4-Hemming-Coach,
das heißt, ich habe insgesamt 7 Witz, davon 4 Notspits,
das wäre dann also quasi letztendlich in dieser Tabelle bis zu der Stelle hier.
So, und jetzt geht es natürlich darum, wie berechnet sich das Prüfbitt?
Und das Prüfbitt ist dann eben so eine Model-U2-Summe,
beziehungsweise nichts anderes als die XOR-Operation, von den Datenbits,
deren Position quasi jetzt hier dieses Bit von dem Prüfbitt gesetzt hat. Das heißt,
das erste Prüfbitt berechnet sich, das ist ja quasi,
wenn ich das jetzt einfach hier binär kodiere,
die Eins, 0-0, 0-1,
nicht berechnet sich dann ja also aus der dritten Position der fünften Position,
der siebten Position, wenn ich den Code jetzt noch länger machen würde,
würde dann eben noch dieses hier mit hinzukommen.
Das heißt also in dem Fall, also letztendlich alle ungeraden Positionen.
Das zweite Prüfbild berechnet sich dann eben aus der dritten Position,
weil dieses markiert quasi jetzt die Stelle zwei hoch eins,
der sechsten Position der siebten Position, das heißt immer den Worten,
wo dann eben diese entsprechenden Bits, die also auch markiert sind.
Das ist also das,
was ich hier versucht habe in dieser Zeichnung,
so ein bisschen mit diesen Farben so ein bisschen darzustellen,
dass man da einfach erstmal sieht, woher diese komischen Nummern kommen,
beziehungsweise was das dann auf sich hat nicht.
Und damit kann man dann eben letztendlich für seine Codes systematisch dann eben erstellen,
an welchen Stellen die Prüfbitz sind und woraus die sich letztendlich errechnen.
Gut, der für den 7-4-Hemming-Code,
das heißt also für diesen Tal bis jeder Tabelle,
ist, da sind eben quasi diese drei Prüfbitz,
die sich dann eben hier entsprechend berechnen.
Also hier ist das Ganze auch nochmal mit solchen diesen farbigen
Punkten so ein bisschen visualisiert für ein 15-11-Hemming-Code,
das heißt insgesamt 15-Bit,
Das würde einem im Prinzip genau bis hier gehen,
werden dann also die Prüfspitz eben entsprechend hier rüber berechnet. So,
rein praktisch wird man das Ganze jetzt also auch nicht so machen,
dass man diese Sachen oder diese Prüfspitz,
also sich dann also hier irgendwie so eine Tabelle aufzeichnet und das daraus abliest,
sondern rein praktisch macht man das dann natürlich ein bisschen mathematisch exakter und einfacher,
indem ich das im Prinzip dann nämlich über eine Matrix bzw.
Vektormultiplikation mache und berechnen kann
Dass man also zum Beispiel sagen kann, also für ein 7-
4-Hemming-Code kann man dann eben sowas in eine sogenannte Generator-Matrix aufstellen.
Das heißt, hiermit bezeichne ich,
welches Prüfbild oder welches Bit in meinem Codewort sich als X-Or-Verknüpfung,
welcher Bits in meinem Datenwort ergibt.
Das heißt also, in dem Fall wäre jetzt,
prüft Bit 1, berechnet sich aus Daten Bit 1,
Daten Bit 2 und Daten
Was also quasi hier drin ist, prüft mit 1,
das ist also jetzt hier quasi die erste Zeile,
wäre Datenbit 1, Datenbit 2,
Datenbit 3 nicht und Datenbit 4, prüft P2,
berechnet sich auf Datenbit 1, Datenbit 3 und Datenbit
4. Ich möchte, dass es dieses und prüft P3 aus die 2,
D3, beziehungsweise die 2, Ex oder die 3,
Ex oder die 4, was einem in diesem Fall dann hier drin ist,
Nach diesen ersten beiden prüft Bits kommt,
in die sie jetzt das erste Daten wird.
Was berechnet sich da natürlich jetzt nur aus dem Datenbitt und
hieraus nichts anderem. Dies wäre jetzt das dritte Prüfbit und das
sind dann eben die drei folgenden Datenbits. So,
und dann kann ich nämlich letztendlich das Codewort einfach über die Multiplikation
dieser Generatormatrix mal dem Eingabevektor, also meinen Datenbitz berechnen,
indem ich dann eben letztendlich das Ganze dann hier einmal ausrechne.
So, wenn ich dann einen Vektor empfangen habe,
kann man dann eben auch jetzt wieder über eine entsprechende orthogonale Matrix dazu.
Das Ganze dann eben zurückrechnen in einen Vektor,
der mir angibt, wo ist der Fehler aufgetreten,
beziehungsweise wenn dieser Vektor null ist, ist eben kein Fehler aufgetreten.
Das wäre jetzt also hier zu diesem 7-4-Hemming-Code die entsprechende Prüfmatrix.
Gut, was ich ja ja schon gesagt habe,
also wie gesagt, bei größeren Wortlängen,
Also irgendwie der Umlaut so ein bisschen.
Habe ich natürlich ein bisschen besseres Verhältnis von Nutz zu Prüfspitz.
Es ist eben vergleichsweise einfaches Prinzip. Man kann es also auch
entsprechend gut berechnen. Verglichen mit anderen Codes ist dieser noch nicht sehr effizient,
sondern da gibt es also auch noch deutlich bessere Codes.
So zu der Anwendung von dem der Generator Matrix bzw.
der Prüfmatrix kommt jetzt hier also nochmal so ein Beispiel.
Also ich habe jetzt einen Vektor,
der soll eben sein
Daraus wird als Codewort berechnet, 1-1,
0-0, 1-1, 0,
indem ich dann eben quasi diese Generatormatrix mit diesem Vektor hier multipliziere.
Also sprich Zeile, mal spalte. Und wie gesagt,
das Ganze berechnet sich dann eben als Multiplikation in GF2 ist die Untoperation,
Addition in GF2, ist das XO,
nicht das ist da,
also da dann ihm letztendlich dadurch dann eben auch das Äquivalent
dann zu dem mathematischen konstruktiert,
also hier dieser Vektormultiplikation
Und so. Und dann kann ich dann eben AFA durch
eine Matrix-Multiplikation hier entsprechen. Mein Codewort erzeugen,
kann das irgendwo senden und könnte dann eben mit der Multiplikation der entsprechenden Prüfmatrix,
mit diesem Wort dann eben ein Vektor wieder ausrechnen,
der mir dann eben sagt, ist ein Fehler aufgetreten oder nicht.
Wenn ich das jetzt also hier für diesen,
dieses übertragene Wort mache, kommt hier eben ein Vektor aus Nullen raus.
Das heißt, ich habe keinen Fehler. Interessant ist es natürlich
der Fehlerfall. Also während der Übertragung hat sich hier dieses eine Bit geändert Was passiert jetzt,
wenn ich hier die Prüfmatrix berechne, dass ich eben hier letztendlich erhalte,
eins, mal eins ist eins, nun mal eins ist null,
plus eins, mal eins ist wieder eins,
multipliziert ist in dem Fall dann, null, dann null,
manu ist null, dann habe ich hier eins mal eins,
das ist dann wieder eine Eins,
multipliziert ist da nämlich die Eins
Nur mal eins ist 0-1, mal 0 ist 0.
Das heißt, an der Stelle habe ich hier eine Eins erhalten.
So durch Multiplikation dieser Zeile mit dem Vektor erhalte ich dann
eben hier auch eine Eins.
Das heißt, auch hier erhalte ich dann hier eine Eins.
Hier eine Eins. Und in dem Fall dann an dieser Stelle eine Eins,
auch wieder eine ungerade Anzahl von Einsen,
deswegen auch hier quasi dann mit der Ex-Org-Operation dann eben
eine Eins
Multiplikation, von dem ergibt eine Null. So,
mit diesem Vektor hier,
der kodiert mir eben jetzt genau an welcher Stelle der Fehler aufgetreten ist,
weil den, Entschuldigung, den kann ich jetzt nämlich einfach nehmen und sagen,
okay, das ist jetzt einfach, wie näher kodiert,
wo ist der Fehler, wenn ich ihn binär kodiert,
wenn man jetzt sagt, das ist das Höchstwertigste,
dass es das niederwertigste Bit ist,
das ist also quasi eine 3 und an der Stelle 3 ist dann nämlich dieser Fehler aufgetreten,
das ist dann nämlich also dieses Bit und das kann dann eben entsprechend geändert werden.
Wenn ich das jetzt eben gemacht hätte,
ein anderes Bit gekillt also jetzt an diesem Fall hier eine Null übertragen und beispielsweise hier dieses eine,
dieses Bit hätte sich jetzt geändert zu einer Eins,
würde dann eben entsprechend hier als Fehlersyndrom, sorry,
Fehlersyndrom eben in diesem Fall dann,
also sowas wie eine Sieben rauskommen und markieren,
dass sich dann dementsprechend dieses Bit geändert hat.
Gut, das ist also erstmal die Funktionsweise von dem Hammingode,
wie der im Prinzip funktioniert,
jetzt für eine Fehlerkorrektur und wie gesagt,
das kann man dann eben sehr elegant über so eine
Matrix-Multiplikation machen
Nicht die ganzen entsprechenden Generator, Prüfmarkttratzen sind also alle
irgendwo jetzt für einen Code für die Länge entsprechend hinterlegt.
Und damit kann man dann dementsprechend arbeiten.
Ja, eine Frage. Also die Frage war jetzt,
wie in Bezug auf die Höhe der Prüfmatrix.
Das heißt, wie viele Bits,
also sie meinen damit, wie viele Zahlen hier jetzt
drin sind
Habe ich das richtig interpretiert, genau. So, und da muss man sagen,
genau, das ist immer eigentlich letztendlich äquivalent zu den,
also im Prinzip, also auch Logarithmus,
Wales von der Anzahl der Gesamtbitz, beziehungsweise davon dann eben die obere Grenze.
Letztendlich jede Zeile entspricht eigentlich immer ein Prüfbild. Nicht,
das heißt also, mit dieser Zeile ist kodiert,
wie dieses Prüf oder woraus sich dieses Prüfbild zusammensetzt,
beziehungsweise wenn ich jetzt also hier nochmal entsprechend zurück scorle,
also auf dieses hier kann ich sagen,
also es prüft Bit 1, berechnet sich ja nun aus,
einmal das Bit selber, dieses Bit nicht.
Das heißt, die habe ich jede zweite Stelle.
Das heißt 101010110110110110110101011. Das ist letztendlich genau diese Zeile hier. Das zweite Prüfbit,
hier setzt sich zusammen, diese Stelle wird nicht berücksichtigt,
die Stelle wird berücksichtigt, die Stelle wird berücksichtigt, also 0110 011.
Und das ist dann genau diese Zeile und so weiter. Das heißt also,
direkt hier drin steckt dann eigentlich eben auch die Kodierung,
die letztendlich beschreibt, wo der Fehler aufgetreten ist.
Dieser Fall mit lauter Nullen, das ist nämlich genau der
Fehlerfreie Fall, der ist hier nicht mit drin.
Und ansonsten sagt eben letztendlich eben dieser Vector 0001 an der ersten Stelle ist der Fehler,
01, 0 an der zweiten Stelle ist der Fehler,
nicht also so rum gelesen ist,
dass sie ja nichts anderes als einfach 1, 2,
3, 4, 5 und so weiter binär durchgezählt.
Genau, also die Anzahl der zusätzlichen Bits, die ich
da mit drin habe. Wenn ich jetzt also einen Hemming-Code hätte,
eben 15, 11, dann habe ich vier Prüfbits,
dann hätte ich da in dem zufolge dann vier Zeilen.
Wenn ich jetzt weniger Not-Spits habe,
also meinetwegen jetzt acht Datenwitz, irgendwie kodieren möchte,
nützt es mir nichts, dann brauche ich auch vier Prüfbitz,
um letztendlich dann eben entsprechend viele Fehlerstellen beschreiben zu können.
Und gut, dann wären eben in dem Fall dann,
also letztendlich, also hier irgendwie der Reiz,
zusätzlich Daten beziehe ich, also hätte dann auch irgendwie verschenkt.
Gut, aber auch das ist dann also so eine Sache,
also hier tauchen ja dann gleich noch irgendwie so Begriffe,
Golai-Code und Sonstiges auf. Also auch über diese gesamte Kodierungstheorie
und so weiter kann man also auch wieder eigene Vorlesungen machen. Also wie gesagt,
das hier ist jetzt also nur Kleiner Ausschnitt soll eigentlich nur so ein bisschen veranschaulichen,
wie so ein sehr einfacher Code funktioniert und eben auch wieder systematisch, also sprich mit welchem mathematischen Hintergrund sowas erzeugt werden kann. Wie gesagt,
wenn man sich jetzt so ein bisschen spezieller in die gesamte,
den gesamten Hintergrund, also Galoire-Felder mathematisch noch einarbeitet,
also das ist dann nämlich das,
womit man dann also letztendlich die Berechnung machen kann jetzt,
also für bessere Codierungen beziehungsweise für andere Codierungsverfahren noch,
aber auch da muss er immer sagen, also das,
was sich also hier irgendwie zeitlich dann vorstellen kann,
ist also quasi der kleinen Teaser,
um so ein bisschen zu motivieren, was gibt es,
warum gibt es vielleicht eben auch, um zu beschreiben,
warum man sowas macht.
Aber ansonsten kann ich dann eben auch immer nur verweisen auf Veranstaltungen,
die dann im Zweifelsfall dann nach dem Bachelor,
also sprich irgendwann im Mastermodul dann also vielleicht noch kommen,
wo es dann eben speziell dann noch irgendwie an die entsprechenden Vertiefungen geht,
weil man sich also jetzt in irgendeinem Bereich weiter spezialisieren würde.
Gut, Ja, das hatte ich ja schon gesagt,
gut, das, was man hiermit im Prinzip jetzt erst mal macht,
ist, dass ich also quasi K-Informationsbits in insgesamt in Nurzbits kodiere,
mit irgendwie einem Minimalabstand und dass man damit dann,
also eine Fehlerkorrektur eben von diesen D-minus A ins Halbe,
wenn ich also D jetzt, also das Hemming-Distanz habe für meinen Code erreichen kann.
Was dann natürlich jetzt nicht korrigierbar ist, ist,
wenn ich jetzt also letztendlich mehr Fehler habe.
Denn das führt uns dann eben auch wieder jetzt zurück zu dem,
wo ich eigentlich mal angefangen hatte jetzt,
also bei diesen stochastischen Modellen für die Datenübertragung,
also sprich für die Übertragungskanäle,
dass man dann ja eigentlich auch für die Übertragungskanäle irgendwelche Modelle aufstellt und sagt,
mit einer gewissen Wahrscheinlichkeit wird aus einer 0 nach 1 oder aus einer einzelnen Null.
Und dass man dadurch dann eben guckt,
wie muss ich jetzt meinen Code anlegen, um,
wenn ich jetzt eben über dieses Medium übertrage,
eine Fehlerkorrektur vorausgesetzt, ich möchte eine Vorwärtsfehlerkorrektur haben,
zu erreichen, Weil da muss er auch mal sagen,
das ist natürlich dann auch immer irgendwie so ein Zielkonflikt bei der Datenübertragung.
Nicht, weil auf der einen Seite kann ich jetzt sagen, ja gut,
nach dem Shen-Theorien kann ich beliebig viele Bittfehler haben und kann die eigentlich auch korrigieren.
Aber dann geht natürlich die Datenübertragungsrate beliebig weit runter. Das heißt also,
ich habe dann also kurz, wo ich dann also wirklich
sehr viele Fehler korrigieren kann, habe acht Nutzbits und übertrage dann also irgendwie 2048 Bits.
Also das folgt jetzt gleich zwei, drei Folien später
Wenn ich das jetzt zu Hause irgendwie bei meiner DSL-Leitung habe und nicht,
dann würde ich mich also bei einem Anbieter beschweren und sagen, das ist aber ein langsamer Internetanschluss.
Nicht, weil die Datenrate eben entsprechend weit runtergegangen ist,
weil natürlich jetzt also für die Datenübertragung, um die jetzt möglichst effizient möglichst schnell zu machen,
möchte man natürlich viele Nutzdaten übertragen und nicht unendlich viele Prüfbilds. Deswegen ist das dann immer so eine Sache,
dass man wirklich abhängig davon,
über welches Medium übertrage ich das nicht, mache ich das mit Lichtwellenleiter,
mache ich das jetzt also irgendwie elektrisch über ein Kupferkabel,
mache ich das über irgendein Funkmedium, wie auch immer,
dass man dann eben wirklich erstmal genau untersuchen muss,
wie sehen diese Fehlermodelle aus, wie wahrscheinlich sind Fehler,
um dann eben so eine Art Optimum zu finden,
dass man sagen kann, okay,
damit kriege ich jetzt noch eine Fehlerkorrektur hin,
unter diesen Annahmen,
aber ich mache jetzt eben auch nicht zu viele an Fehlerkorrektur,
weil das kostet mich dann natürlich irgendwo Übertragungskapazität.
So, was man dann auch immer noch gucken oder betrachten muss,
ist, wenn ich jetzt sage,
ich betrachte jetzt nicht nur ein einzelne Spits,
sondern ich betrachte jetzt also ein Wort aus mehreren Bits.
Dann haben wir ja nun wunderbar, also hier mit unserem logarithmischen Mars,
von dem Bit ja letztendlich die, sowas eingeführt,
was eigentlich dann eben eine additive Größe ist.
Das heißt, ich kann dann eben sowas wie Bittfehler Wahrscheinlichkeiten dann eben
quasi als Wortfehler Wahrscheinlichkeit einfach aufsummieren und dann eben sagen kann,
wie wahrscheinlich ist es,
dass in einem Wort ein Fehler auftaucht
Und das ist also das, was also hier in diesen Grafiken irgendwie mit drauf ist.
Also die sind nicht fürchterlich klein geplottet. Geht auch nicht darum,
dass sie das jetzt also hier irgendwie zwingend auswendig lernen und sehen.
Also hier geht es eigentlich nur darum, dass man sagt,
also hier für so ein 7-4-Hemming-Code habe ich also hier unten als schwarze Linie letztendlich eine unkodierte Übertragung.
Das heißt, wenn ich die, also Bittfehler rate im Kanal,
also die beginnt hier bei null und geht dann eben hier bis 0,5,
wenn die eben entsprechend immer größer wird.
Demzufolge wird dann natürlich die Hier erstmal so eine Bittfehlerrate, demzufolge natürlich auch linear ansteigend.
Wenn ich da jetzt ein 7-4-Hemming-Code nehme und dann eben die Bittfehlerrate,
dann erreiche ich,
dass ich eben bis zu einer bestimmten Bittfehlerrate in dem Kanal letztendlich hier eben eine Fehlerkorrektur machen kann,
wenn Die Bittfehlerrate größer ist,
dann werde ich also in dem Sinne hier nämlich schon wieder schlechter,
weil das, was natürlich jetzt also mit dem Code ja passiert,
ist, dass ich in diesem Fall dann ja nicht vier Nutzbits übertrage,
sondern sieben Bits.
Und da natürlich, also jetzt pro Bit gesehen, letztendlich die Wahrscheinlichkeit,
dass ein Fehler auftritt, dann eben größer wird. Und eine Wortfehlerrate,
das ist das, was also diese blaue Kurve zeigt,
ist, da ist das jetzt natürlich dann nochmal entsprechend,
wenn ich jetzt also insgesamt was über diese sieben Bits nehme,
dann sodass ich eben hier im sehr kleinen Bereich dann überhaupt erst noch besser bin,
als dann war so nah und kodieren übertragen.
So und was man hier schon sieht,
also das ist jetzt also irgendwie so ein Code,
wo also mit zwölf Notspits, 23 Datenbit,
also sprich elf Prüfbits, sind irgendwie da hinzugekommen,
mit überträgt und eben als du eins und ein Extrem dann eben so ein Code,
wo also für acht Datenbit 2048 Bit übertragen werden,
also sprich 2040 Prüfbit, nicht wo man dann sagen kann,
okay,
damit erreiche ich dann eben letztendlich,
dass ich also bis zu einer wird Fehlerrate von über 0,2 letztendlich erst mal quasi eine Wortfehlerrate nahe Null habe.
Das heißt, da kann ich die Fehler korrigieren.
Nicht aber irgendwann dann kann ich das auch nicht mehr.
Und das ist dann eben so eine Anpassung,
dass man die Kodierung letztendlich dann immer danach wählen muss,
wie wahrscheinlich sind jetzt für mein Übertragungsmedium eben solche Fehlerhäufigkeiten bzw. Fehlerwahrscheinlichkeiten.
Gut, ein anderes häufig verwendet es Verfahren,
um Fehlerkorrektur zu erzeugen, also oder eben auch systematisch zu erzeugen,
basiert also auch auf dem mathematischen Verfahren, wo man sogenannte Binärpolinome nutzt.
Da ist im Prinzip der Hintergrund, dass man sagt,
also wenn ich jetzt ein Nbit-Wort habe von Nbit,
dass das sowas ist wie eine Schreibweise für ein Polynom,
über dem Körper jetzt, also der Binären Zeichen,
also sprich Dieser Vector, 1-0, 0,
1-1,
0-1,
den kann ich interpretieren als eine Kurzschreibweise für beispielsweise einmal x hoch 6 plus 0 mal x x 5 plus Nummer exo 4 und so weiter.
Das heißt, ich habe dann hier so was wie mein
Eingangswert x davon dann eben in die entsprechenden Potenzen und das
dann eben hier quasi jetzt nur geschrieben dann die Koeffizienten dazu
Das Ganze, also sprechen kurz schreibweise,
würde dann dieser Vector sowas wie dieses Polynom darstellen.
So, das Ganze ist da auch nicht eindeutig,
weil das kann man dann auch noch sagen,
beziehungsweise mathematisch gesehen sind die dann wieder äquivalent.
Hinsichtlich der Nummerierung dieser Indizes kann ich das also auch noch beliebig irgendwie,
nein, nicht beliebig, aber eben entsprechend verschieben,
dass ich dann eben sagen kann,
also entweder ich spiegel das Ganze oder ich verschiebe das Ganze
linear,
indem ich das also dann beispielsweise in dieses oder so
ein Polynom umsetze
So, mathematisch gesehen kann man jetzt mit diesem Polynom rechnen,
nämlich Addiren, Subtrahieren, multiplizieren und dividieren, also sprich die grundreichen Arten ausführen.
Und das ist dann Basis von etwas,
was in der Informatik dann immer als zyklische Codes,
beziehungsweise CRC, steht dann immer für Cycling Reduntancy Shek drin ist,
was mathematisch eben auf so einer Polynom-Division im Prinzip beruht,
wo auch als systematischer Code, beziehungsweise das Blockcode, dann eben solche Prüfbitz generiert werden.
Und das Ganze, das ist jetzt eben das Schöne oder Elegante ist,
die Codewörter werden im Prinzip durch Schieben und Modulo 2-Summe dann eben ineinander überführt,
beziehungsweise das entspricht dann eben genau dieser Polynom die Vision.
Und das kann man in Hardware jetzt wieder vergleichsweise elegant und einfach lösen. Das,
was man damit erreicht, dass man dann so eine ganze Variante von unterschiedlichen Codes,
also für Fehlererkennung macht, oder sich erzeugen kann,
nicht also je nachdem, wie da also die Hemming-Abstände sein sollen,
dann eben passende Polynome sich aus, nein, nicht ausdenkt, sondern auswählt.
Und damit dann solche Fehler berechnet. Und das wird also
bei sehr vielen Standards benutzt, benutzen wir also tagtäglich. In der Regel müssen wir uns jetzt nicht drum kümmern,
sondern da sagt man einfach nur, okay,
ich berechne dann eben irgendwie so einen CAC-Check oder so eine CLC-Check-Prüfsumme von meinem Wort und erhalte dann eben das Ganze automatisch,
ist im Ethernet-Protokoll drin, das ist in verschiedenen Datenformaten drin,
also irgendwie sowas wie in ZIP in der Kompression ist es auch als ein Schritt,
unter anderem dann am Ende nochmal irgendwo mit drin, in irgendwelchen Bilddatenformaten,
PNG ist es mit drin, in diversen Datenübertragungsstandards, in Verschlüsselung und, und, und.
Und je nachdem, worum es da geht,
hat man dann eben irgendwelche spezifischen Podinome,
die da also letztendlich genommen werden und hinter so einem Polynom
verbirgt sich dann eben nichts anderes als eben so ein Vektor als nur ein Einsen,
der mathematisch gesehen in sowas übergeführt werden kann und technisch gesehen in sowas umgesetzt wird.
Das, was da angedeutet ist, ist,
sag mal jetzt also so eine Art Hardware-Äquivalent,
wird uns dann also im nächsten beziehungsweise übernächsten Kapitel dann auch
benehmen in den überübernächsten und im Kapitel danach dann noch begegnen,
was damit gemalt ist, wo das Ganze dann letztendlich realisiert werden kann.
Das, was ich hinter dieser Grafik verbirgt, wie gesagt,
Müssen sie jetzt also nicht noch nicht zwingend wissen, ist also im Prinzip folgendes.
Also jedes von diesen Elementen hier entspricht sowas wie einem Speicher für ein einzelnes Bild.
Das ist also ein sogenanntes vorderflankengesteuertes Flipflop,
sprich hierrin kann ich also sowas wie ein Bitch speichern.
Ich habe hier ein Taktsignal, was also hier quasi an alle Elemente geht.
Die haben hier einen Dateneineineingang und einen Datenausgang. Das heißt,
was passiert, der Takt kommt, das,
was hier als Signal anliegt, wird hier drin gespeichert,
entweder eine Null oder eine Eins und liegt hier am Ausgang an mit dem nächsten Takt,
wird dann quasi dieser Wert hier hier reingetan und der Inhalt hier entspricht dann eben dem, was also quasi vor dem Taktsignal hier am Eingang lag.
Das heißt, so rumgesehen passiert hier nichts anderes,
als das beispielsweise, wenn jetzt diese beiden Elemente betrachte,
mit jedem Takt dieser Inhalt hier eine Stelle weiter wandert.
So, und zwischenzeitlich hier drin sind jetzt immer noch diese Exklusiv-Oder-Operationen.
So, und das, was dieses jetzt hier macht,
nennt sich dann eben rückgekoppeltes Schieberegister
Also im Englischen findet man das dann immer.
Und da LFSR-Linie, Feedback, Shift-Register. Und das,
was dann eben passiert, ist, dass ich also hier
so einen Datenstrom habe, der hier quasi einfach reinwandert.
Am Ende, das, was hier quasi berechnet wurde,
wird dann eben hier für diese XO-Operation auch als Argument genommen,
um dann eben entweder diese Stellen oder
eben den Eingangsdatenstrom zu modifizieren
So, und das, was so ein Register jetzt eben realisiert,
wäre dann eben technisch gesehen sowas wie so ein Polynom.
In diesem Fall XO5 plus XO4 plus XO2 plus 1.
Und diese koeffizienten entsprechenden, nämlich den XO-Operationen an der entsprechenden Stelle.
Also das heißt, vor dem fünften Bit habe ich hier
Nee, also jetzt habe ich mich gerade reingerissen,
also die ist plus eins,
ist dann also quasi entsprechend dann dieses hier,
also das ist dann Stelle eins, Stelle zwei,
schnelle vier und demzufolge ist das dann immer entsprechend dann um ein verschoben,
also das wäre eins, dann xo 0,
x hoch zwei,
x hoch drei,
das wäre xo 4 und der letzte geht dann eben wieder
zurück.
Jedenfalls also das, was damit eigentlich ist, ja erstmal nur,
klar ist das, wie gesagt, warum das Ganze funktioniert.
Da müsste man jetzt also auch via entsprechend weiter in die Mathematik reingucken.
Wollen wir hier jetzt nicht machen, wird in der Klausur nicht abgefragt.
Gibt es auch keine bösartige Übungsaufgabe dazu. Also von daher
kann ich da schon mal Entwarnung geben. Man sollte aber eben mal gehört haben,
was mit so einem CRC-Code irgendwo gemeint ist,
weil wie gesagt, Diese CAC-Codes, also Cyclic Redunt,
Seed Check, werden in der Informatik,
also sehr häufig und sehr oft benutzt.
Und sind eben in vielen Protokollen, Codierungsverfahren und so weiter mit drin.
So, und was man hier jetzt nämlich macht,
deswegen ist das Ganze eben, sagen wir mal, wirklich vergleichsweise schick zu benutzen.
Also wie gesagt, das ist einfach direkt durch so eine Hardware-Struktur realisierbar. Und was man eben macht,
ist, dass ich jetzt also irgendein Datenwort habe,
das verlängere ich jetzt quasi um den Grad des Polynoms,
mit Nullbitz, schiebe jetzt dieses gesamte Datenwort,
also meine gesamten Nutzbits, und die sind zusätzlich Nullbits,
durch so ein, genau dieses Schieberegister durch.
Und wenn ich jetzt meine Gesamtanzahl an Bits, Datenwort,
plus Grad des Polynums, Bits hier durchgeschoben habe,
dann habe ich eben hier meine zusätzlichen CRC,
also meine Checkbits,
die dann eben anstatt der Nullen angehängt werden,
die ich dann mit übertrage
Und für die Prüfung von dem Ganzen schiebe ich
die übertragenen Bits eben in genau die gleiche Hardware-Struktur.
Und wenn nach den entsprechenden, nach der entsprechenden Anzahl von Takten
hier drin lauter Nullen stehen, habe ich keinen Fehler.
Wenn dort ein irgendwas anderes drinsteht,
habe ich eben einen Fehler und je nachdem,
wie also letztendlich dieser CRC-Code aufgebaut ist,
kann ich damit dann eben teilweise auch eine Fehlerkorrektur machen
Nicht, also das nur zu der Art und Weise,
was sich also hinter solchen CRC-Codes letztendlich verbirgt. Wie gesagt,
auch da kann man jetzt nur sagen, für alles andere,
hier nun mal schnell rausgesucht, sowas wie Wikipedia,
da sind also ein paar einführende Sachen dazu beschrieben.
Ansonsten muss man da dann eben entsprechend weiter in die Mathematik einsteigen.
Stichwort ist also auch hier dann wieder sowas wie Galoire-Felder.
So war es, beziehungsweise solche Mechanismen oder solche ähnlichen Mechanismen
werden also auch immer ganz gerne benutzt für Pseudo-Zufallszahlen.
Auch das ist immer ein Thema, wo man sagt,
naja, wofür brauche ich das? Auch das wird häufig gemacht,
also gerade beim Selbsttest von irgendwelchen Hardware-Sachen, wo man auch mal sagen muss,
beim Standard PC oder Laptop kann es halt auch mal sein,
dass irgendwo in der Hardware irgendwas kaputt geht.
Und dann sieht man dann also irgendwelche Bruce Greens, der Reichner Budet nicht mehr oder Sonstiges.
Das ist natürlich dann ärgerlich. Ein bisschen schlechter oder kritischer ist das,
wenn das also beispielsweise jetzt beim ESP-System im Auto passiert,
wo dann also quasi nach dem Einschalten dann also irgendwo die Steuerung,
die letztendlich dafür verantwortlich ist,
dass quasi als Anti-Schleuder-Programm dann also irgendwie mal gezielt Rede abgebremst werden.
Wenn die nicht funktionieren würde,
dann wäre das also schon ein bisschen schlecht,
wenn die jetzt also aufgrund irgendwelcher falschen Sensorwerte
oder war da innen drin was kaputt gegangen ist
Also war Tempo 120 auf der Autobahn,
also auf die Idee kommt, also das linke Vorderrad mal kurz abzubremsen,
weil dann würde man also sofort abgehen.
Ja, das soll da also nicht passieren, bei sicherheitskritischen Anwendungen.
Demzufolge muss man dann eben sagen, naja, auch Hardware kann kaputt gehen.
Und typischerweise wird da dann eben Folgendes gemacht,
dass man sagt, also ich habe solche Mechanismen,
wo ich dann also quasi über solche rückgekoppelten Schieberegister,
sowas wie Pseudezufallszahlen generiere
Kann man sich also auch relativ einfach mal selber überlegen oder einfach mal durchspielen oder eben Java-Programm dazu schreiben,
also sprich mal so eine, einfach so eine Struktur,
wo ich also jetzt quasi einfach einen Vektor habe,
mit Nullen initialisiere,
an einigen Stellen dann eben so ein XOR mit reinbringe und das,
was ich also quasi dann hier immer irgendwie durchschiebe,
das, was ich am Ende habe,
dann also an einigen Stellen dann eben mit diesen XORs entsprechend verknöpfe.
Wenn man sich anguckt, wenn ich das jetzt laufen lasse
und einfach meine Vektoren durchschiebe, dass da relativ,
es kommt zwar immer eine Folge von Zahlen mit raus,
aber die sieht also quasi immer erstmal Pseude zufällig aus.
Also ist natürlich, sind keine Zufallszahlen,
weil von dem Startwert kommt, nach einem Takt,
dass der Wert raus nach dem zweiten Takt ein anderer wert und diese Folge ist immer fest,
aber anders als jetzt irgendwie so ein binärer Zähler,
der 0-1, 2-3 zählt,
kriegt man da erstmal ein relativ wildes Bitmuster irgendwie an Zahlen.
Und sowas kann man dann eben nehmen,
um eben beispielsweise Prozessoren oder Speicher oder was auch immer ich
jetzt also irgendwie kritisch als Hardware irgendwo verbaut habe
Zu testen,
indem ich da also zum Beispiel in den Speichermuster reinschreibe,
die hinterher rauslese, damit feststelle,
habe ich da jetzt eben wieder die richtigen Werte gelesen,
man kann sowas eben auch machen,
um jetzt quasi bei den Prozessoren bestimmte Folgen von irgendwelchen Eingaben zu generieren,
um zu sagen, okay,
der soll jetzt erstmal das und das und das berechnen,
meinetwegen 5000 oder 10.000 Takte lang,
also einfach irgendwie so ein paar einfache Berechnungen machen und hinterher muss ich eben an der Stelle im Speicher 43 drin stehen haben.
Und wenn das nicht der Fall ist, weiß ich,
der hat irgendwie falsch gerechnet. Und sowas kann man eben
relativ einfach mit solchen mathematischen Strukturen, beziehungsweise solchen rückgekoppelten Schieberegistern machen.
Und da ist das also nun entsprechend häufig dann eben auch verbaut.
Also wie gesagt, sicherheitskritische Sachen, anderer Ansatz ist
auch beim Test von Chips beziehungsweise Schaltung nach der Fertigung.
Auch da muss man jetzt immer sagen, ja,
was ist jetzt mit Test nach der Fertigung
überhaupt gemeint
Und da geht es eben letztendlich darum, dass man sagt,
naja, ich habe, hier irgendwo ist mal eine Schaltung,
die hat so und so viele Milliarden Transistoren und soll irgendwie was machen.
Die wurde jetzt irgendwo über 200 Prozessschritte bei Firma XY in Taiwan irgendwo gefertigt.
Und hinterher kommt dann irgendwie so ein Stück Silizium raus.
Und was dann eben sein kann, ist,
dass von diesen so und so vielen Milliarden Transistoren irgendwo dann doch mal
ein Staubpown raufgefallen ist und eben ein paar davon kaputt gegangen sind.
Und das Problem ist natürlich, der Hersteller will mir jetzt also nicht
für Mehrere hundert Euro, also irgendwie einen teuren Prozessor verkaufen.
Ich setze den in den Rechner rein und der tut nicht richtig,
weil irgendwo innen drin, da war es kaputt gegangen ist.
Sondern das, was also in den Laden kommt,
sind eben wirklich nur funktionierende Teile. So,
und um jetzt aber nach der Fertigung quasi Fertigungsfehler zu finden,
baut man eben teilweise wirklich bis zu 20 oder 30 Prozent Zusatzhardware mit ein,
die eben solche Selbsteststests machen, die eben letztendlich dafür sorgen,
dass alles,
was da an möglichen Fehlern oder Fehlerquellen in der Fertigung
gewesen sein kann,
entdeckt worden ist
Und entsprechend dann eben diese kaputten Teile letztendlich schon vorher,
bevor die überhaupt verpackt werden, aussortiert wird.
Oder was man eben zum Beispiel machen kann bei hochregulären Strukturen,
also bei Speicherstrukturen, kann man das machen.
Und bei Grafikkarten kann man das machen, dass man sagt,
okay, ich habe in meiner Grafikkarte XY,
also irgendwie so und so viele tausend Recheneinheiten.
Davon habe ich jetzt über so ein Selbstfest festgestellt, zwei Prozent sind kaputt.
Und ich habe dann eben irgendwie spezielle Hardwarestrukturen,
mit denen ich einfach sagen kann, diese zwei Prozent werden abgeschaltet
Und ich nehme dann eben nur die anderen in Betrieb und
verkaufe das dann eben, als das quasi nächst kleinere Modell.
Also das ist dann eben auch so eine Sache,
dass man natürlich versucht,
aus seinem teuren Fertigungsprozess dann eben auch noch entsprechend möglichst viel
an Output zu erzeugen und dann eben entweder von vornherein so eine Art Hardware-Redundanz vorsieht,
um dann ein paar Sachen rauszunehmen oder eben entsprechend das Ganze dann umsortiert und damit machen.
Gut, also wie gesagt, solche Sachen,
also auch da wird relativ viel mit solchen CRC-Codes
letztendlich gemacht
Gut, jetzt folgen hier auf den nächsten Folien eigentlich nur noch so kurz,
ein paar Beispiele, also jetzt aus dem praktischen Leben,
zu Fehlererkennung, Fehlerkorrektur, die ich jetzt aber nicht größer beschreiben werde,
sondern eigentlich jetzt also wirklich nur mal so ein bisschen einfach so als Motivation noch mal kurz wurscht stellen werde,
also das eine, wo also noch relativ viel drin ist,
was uns also täglich begegnet ist, also das,
was ja immer so als eher in 13 Code haben,
also sprich der Barcode, der eigentlich also auf allen Produkten,
die wir irgendwo kaufen, irgendwo mit drauf ist,
also sprich das,
was dann in der Kasse gescannt wird.
Und also auch das setzt sich eigentlich zusammen aus so einer Kombination sehr viele unterschiedliche Kodierungen,
wie das also bei den meisten praktischen Codes auch der Fall ist,
was man hier nämlich macht, ist,
dass das hier drin dann ähnlich wie bei diesem ESBN-Code für Bücher,
also irgendwie mit drin ist, aus welchem Land irgendwie was kommt,
zu welchem Unternehmen das gehört, welche Artikelnummer und dann eben irgendwelche Prüfsummen,
um dann eben festzustellen, ist es ein gültiger Code oder nicht.
Und bei diesem Code wird dann also letztendlich so ein Bitmuster hier drin kodiert,
wo dann eben drin ist, ein schwarzer Balken entspricht einer Eins, ein weißer Balken entsprechende Null.
Dann gibt es noch so ein paar Sachen,
also hier am Rand und in der Mitte Strukturen,
die dann also da letztendlich mit drin sind,
die dann also quasi erst mal für den Barcode-Leser,
der das Ganze letztendlich mit dem Leser beleuchtet und abtastet,
normiert, weil da weiß ich genau,
da kommt halt eben ein schwarzer Balken, ein weißer Balken,
ein schwarzer Balken und dadurch kann ich dann also zum Beispiel schon mal ausmessen,
groß ist jetzt der Betrachtungsabstand, weil da weiß ich genau,
am Anfang habe ich eben immer dieses Muster 101 und wenn ich das jetzt quasi den Scanner sehr nah über mein Produkt halte, ist das natürlich letztendlich größer dargestellt.
Also wenn ich das über eine weitere Entfernung habe,
nicht dadurch passiert dann so eine Art Normierung,
nicht nur anschließend wären dann eben hier irgendwelche Muster aus 0 und Einsen
rausgemacht und die werden dann also nach einem relativ komplizierten Verfahren letztendlich kodiert,
wo ich dann also die Leserichtung noch unterscheide,
an welcher Stelle das Ganze ist und so weiter und so fort.
Und eine von diesen Ziffern ist dann eben letztendlich
auch noch sowas wie so eine Prüfsumme
Anderes Beispiel, auch noch vergleichsweise alt. Nicht inzwischen müsste ich sagen,
okay, müsste man sowas wie irgendwie Blu-ray oder so nehmen.
Kompaktes, also hier einfach so eine Audio- bzw. Daten-CD-Rom. Nicht,
also auch da muss man sagen,
habe ich also in dieser Polycarbonatscheibe irgendwo hier so eine spiralförmige Datenstruktur mit drin,
die letztendlich dadurch gekennzeichnet ist,
was man also hier in dieser Raste-Elektronen-Mikroskop-Aufnahme sieht,
dass sich da eben irgendwie Erhöhung oder eben keine Erhöhung habe.
Das wird eben vom Leser abgetastet,
demzufolge werden da dann eben auch Nullen oder Einsen gelesen
Ja. Und in dieser Abtastung,
also sprich in dieser Spiralförmigen Struktur drin,
habe ich dann eben jetzt quasi bei einer klassischen CD,
also was wie ungefähr 650 Megabyte an Kapazität mit drin und das Ganze ist dann,
würde dann gleich auf der nächsten Folie kommen,
dann eben auch über alle möglichen Arten von Codierungsverfahren und Prüfsummengeneratoren und so weiter dann eben so kodiert,
dass es eben sein kann, Wenn,
dann Kratzer drauf ist, wenn es irgendwelche Fertigungsfehler gibt,
dass man das also,
bis es oder bis zu einem gewissen Grad eben noch ganz gut eine Fehlerkorrektur machen kann.
Ich weiß auch, das ist wieder so ein klassisches Beispiel.
Nicht in der Fertigung darf es zum Teil natürlich nichts kosten.
Ich habe da irgendwie Staub drauf, ich habe da Kratzer drauf,
weil das natürlich nichts kosten darf, können wir jetzt also
in der Fertigung selber auch irgendwie schon Probleme aufgetreten sein und so weiter.
Und das, was man natürlich haben möchte, ist,
dass sie jetzt bei einer Audio-CD letztendlich, also Fehler,
die ich jetzt nicht korrigieren kann, zumindest mal irgendwie dann noch interpolieren.
Das heißt, da wird jetzt einfach entsprechend nochmal gerechnet und irgendwelche
fehlenden Samples quasi bis zu einer gewissen Größe können dann also letztendlich auch noch irgendwie nachgerechnet werden.
Bei Daten-CDs gibt es da dann eben auch entsprechend weitere Kodierungen.
Nicht so ein Bittfehlerraten sind da dann eben auch noch kleiner als 10.11.
So die Kodierung selber, also hier jetzt für eine Audio-CD,
da werden dann eben die Daten in mehreren Strukturen erst in
Frames und dann irgendwie in Sektoren verpackt.
Und was man dann hier schon sieht,
wenn ich jetzt also irgendwie so und so viele Nutzdaten habe,
wird also noch mal ein Drittel dieser Daten,
also insgesamt ein Viertel der Daten dann eben noch mal als Fehlerkorrektur hinzugefügt.
Das heißt also ein Viertel von dem,
was da jetzt wirklich an Daten drauf ist, ist eine reine Fehlerkorrektur.
Nicht damit kann man dann aber Kratzer und eben,
sagen wir mal,
bis zu 7000 fehlende Bits in so einem Bereich
dann eben auch entsprechend korrigieren
Nicht bei Daten-CDs sind das dann wieder noch ein bisschen andere Verfahren.
Da gibt es da dann eben auch pro Nutzdaten so und so viel Byte an,
in diesem Fall über so ein 2D-Code,
der dann eben auch noch nach einem bestimmten Verfahren aufgebaut ist, dann eben auch irgendwelche Fehlerkorrekturdaten.
Und das Ganze ist, dass es dann etwas,
wer jetzt also mit diesem Begriff Enter Leaving nichts anfangen kann,
dann eben auch so aufgebaut,
dass ich natürlich jetzt nicht meine Nutzdaten und dann angehängt die Fehlerdaten habe oder die Fehlerkorrekturdaten,
sondern das Ganze ist dann eben ineinander verschachtet,
beziehungsweise teilweise sind dann eben auch noch diese Sektoren ineinander verschachtelt.
Das heißt,
wenn beim Lesen in einem Bereich jetzt also hier irgendwie was Größeres ausfällt,
dann betrifft das eben ein Tal der Nutzdaten und ein Tal
der Prüfdaten aus einem Sektor und dann auch noch ein paar aus dem anderen Sektor,
dass man dadurch dann eben eine gewisse Wahrscheinlichkeit hat,
dass die Fehlerkorrektur dann immer noch funktioniert,
solange dieser Ausfall dann eben nicht zu groß geworden ist
Gut. Ähnliches auch bei Bilddatenformaten, auch da jetzt,
wie gesagt, was ich ja auch nur als Beispiel,
eben sehr viele sehr unterschiedliche Codierungs- und Fehlerkorrektur und sonstige Verfahren,
die da eingesetzt werden,
wo man dann eben auch sagen kann,
da wird es eben nicht nur eins dieser Verfahren eingesetzt,
sondern eben auch immer sehr viele.
Also beispielsweise JPEG-Bildformat, also sprich das,
was man typischerweise als Aufnahmeformat jetzt also von Smartphones,
Kameras oder sonstiges irgendwie hat, also sprich Speicherung von Farbfotos oder Bildern,
in der Regel erst mal ein verlustbehaftetes Format.
Das heißt, je nach Con Einstellung kann ich da dann
eben auch entsprechend nicht mehr die Originalqualität wieder zurückerzeugen.
Auf der anderen Seite kriegt man dann eben auch wieder höhere Kompressionsraten hin.
Und das geht dann eben auch in diesem Fall jetzt also
über fünf Kodierungsschritte, nicht als erstes werden die Farben
erst mal ein bisschen umkodiert
Und zwar das, was sie ja schon vorgestellt habe,
was man meistens immer hat,
beziehungsweise wenn man so in der Computergrafik erst mal anfängt,
ist also RGB, also sprich ein Farbmodell mit Rot-Grün- und Blauanteil.
Nicht dann jeweils kodiert in so und so viele Bits.
Das, was ich vorgestellt hatte, beispielsweise jetzt,
als ich diese Maskierung und diese Bitweisen-Operation beschrieben hatte,
war ja dann so ein Modell,
wo das also quasi jetzt in acht Bit-Farbkodierung dargestellt wird.
Das heißt, in so einem 32-Bit-Wort kriege ich
ein Pixel
Da quasi reinkodiert und beispielsweise noch sowas wie ein Alpha-Kanal.
Was man dann häufig macht, ist als Farbdarstellung ein anderes Farbmodell,
wo ich jetzt also nicht rot, Grün und Blauanteil nehme,
sondern Helligkeit und Farbe, nennt sich dann Juf,
das ist eigentlich noch, also YUV,
ist eigentlich auch noch herkommt aus dem alten Fernsehdatenformaten.
Sieht so aus, dass man sagt,
also aus dem Farbbild habe ich eben quasi erstmal ein Schwarz-Weiß-Bild
für ein Schwarz-Weiß-Bild,
brauch ich für das Pixel erstmal
nur die Helligkeit
Brauche ich jetzt aber keine Farbunterscheidung mehr. Und dann gibt es quasi die Farben dargestellt,
dann, als sind zweidimensionalen Vektor,
wo ich dann einfach einen Farbraum habe,
wo ich dann die unterschiedlichen Farben habe und dann eben sage,
auf welcher Farbe quasi dieser Pfeil,
also man kann sich das dann eben wirklich vorstellen,
wie so ein Vektor an so einem Koordinatensystem,
wo ich dann eben einfach sage,
also welche Farbe ist hiermit dann bezeichnet,
indem ich dann also hier eben entsprechend dann also ein U&V-Anteil habe und dann eben quasi sagen kann,
jeder Punkt auf diesem Kreis entspricht einer Farbe und mit diesem Y habe ich dann die Helligkeit.
So, damit kann man nämlich sehr einfach Schwarz-Weiß-Bilder machen,
indem ich also U und V wegschmeiße.
Und was man dann eben auch macht, das ist dann nämlich das,
was dann in dieser Sache dann häufig auch noch passiert,
ist eine Unterabtastung. Das heißt also,
für jedes Pixel beschreibe ich jetzt nicht Helligkeit und die beiden Farbwerte,
sondern da das Auge empfindlich ist, für Helligkeitsunterschiede,
aber nicht so empfindlich für Farbunterschiede, dass man sagt,
ich nehme zwei Pixel oder vier Pixel
Und die kriegen die gleiche Farbe, die kriegen aber
vielleicht noch unterschiedliche Helligkeiten. Das ist das,
was also hier mit diesen Grafiken angedeutet ist, dass man sagt,
also ich habe hier für einen Pixel Helligkeit und die Farbvektoren
und für das nächste Pixel nur noch die Helligkeit und der Farbvektor hier gilt hier auch.
Oder ich mache eine Unterabtastung, wo ich dann also
die Farben sogar nur für vier benachbarte Pixel habe.
Dadurch spart man natürlich dann deutlich Datenrate. Das heißt,
dadurch kann ich dann in solchen Formaten Bei so einer Farbraumkonvertierung gegebenenfalls,
dann nämlich also auch schon die Daten entsprechend deutlich kleiner machen.
Nicht dann wird das Ganze dann auch wieder jetzt in Gruppen zusammengefasst,
dann läuft er mathematisch gesehen dann wieder eine Operation diskreditorikursindus Transformation,
dann wird das, was dann dort als Vektor rausgerechnet wurde, quasi quantisiert.
Und dabei kann ich dann eben diese Qualität einstellen und eben nochmal eine deutliche Kompression machen.
Am Ende kommt dann so eine Halfman-Kodierung. Da sieht man eigentlich,
mit vielen unterschiedlichen Schritten, wie dann so ein Format letztendlich aufgebaut ist. So,
das war das Standbild, jetzt kommen wir zu bewegten Bildern,
also auch hier nur, wie gesagt,
also auch da nur das Beispiel aus den 90er Jahren, MPAC-Video.
Nicht da macht man dann eben auch Folgendes,
dass man quasi so Einzelbilder erstmal wie so ein JPEG,
also nach diesen ganzen unterschiedlichen Formaten kodiert, was man dann macht,
ist eine Differenzbildung über mehrere Bilder, weil Ich habe jetzt einen Videodatenstrom.
Das berühmte Fußballspielen. So, und was man dort hat,
ist von einem Bild zum nächsten Teilbild, das,
wenn ich jetzt nicht gerade einen ganz schnellen Schwenk mache oder irgendwie umgeschnitten wird,
sich mindestens 90 Prozent des Bildes nicht ändern.
Weil das ist immer noch der gleiche grüne Rasen im Hintergrund
und der Ball hat sich bewegt und hoffentlich einige Spieler haben sich bewegt. So,
und das, was man dort dann eben macht,
ist, dass man sagt, zwischen zwei Bildern sage ich,
ich übertrage einmal das Ausgangsbild und übertrage im nächsten Schritt nur noch,
was hat sich geändert und nehme sonst den Teil von dem ersten Bild einfach eins zu eins weiter.
Denn wie gesagt, solange ich jetzt nicht mit der Kamera einen Schwenk mache,
also sprich, wenn jetzt also hier gerade mit Lecture to Go aufgezeichnet wird,
und ich stehe hier,
dann hampel ich hier noch rum und bewege mich und gelegentlich kommt hier mal eine neue Folie,
aber ansonsten ist das meiste von dem Bild eben auch erstmal eins zu eins das vorherige Bild.
Demzufolge kann man da dann eben auch eine hervorragende Bilddatenkompression machen,
indem man dann sagt, Bildinhalt, der sich jetzt nicht gerade geändert hat,
wird vom vorhergehenden Bild übernommen und nur diese Änderungen würden übertragen.
Und das ist eben bei diesen, eigentlich der Grund dafür,
weswegen man dann eben auch in solchen Videodatenformaten,
eben Bewegtbilder dann eben mit einer relativ kompakten Datenrate übertragen kann und jetzt nicht rechnen muss, na gut,
also ich habe jetzt hier mein hochauflösendes Fernsehen mit 4K Auflösung,
ich übertrage jetzt für jedes Pixel mindestens 32 Bit an Nicht,
wenn ich jetzt also in HDR gehe, würde ich sogar noch mehr übertragen, an letztendlich Farbinformation.
Nicht, dann kann man einfach ausrechnen,
dass also diese Datenrate einfach schon so groß wäre,
dass man damit, also sagen wir mal, die meisten normalen Internetanschlüsse eben locker sprengen kann.
Nicht beziehungsweise sagen kann, solange wir hier nicht alle
die Glasfaser unten direkt im Haus liegen haben,
ist das also damit dann noch nicht machbar.
Wir haben das auch, wie gesagt, bei solchen Videodatenströmen
wird da dann eben relativ viel gemacht an unterschiedlichen Einzelkodierungen. Wie gesagt,
wird, wenn sich beispielsweise jetzt mit Bildverarbeitung befassen,
irgendwann später im Studium vielleicht nochmal kommen,
nicht aber das nochmal als ein, so ein Beispiel für Sachen,
die letztendlich Oder wo jetzt so im täglichen Leben doch jetzt eben entsprechend viel an Codierung eingesetzt wird.
Gut, damit kommen wir jetzt eigentlich wieder zum nächsten Kapitel,
was jetzt also wieder so ein bisschen mehr uns jetzt wieder in die Logik,
in die Schaltalge war, zurückführt, wo man jetzt eigentlich sagt,
gut, was haben wir bislang kennengelernt?
Also jetzt vor an den Kapiteln,
da ging es also mal um die Bulschalgebra
Als Algebraisches Konstrukt, wo wir jetzt gesehen haben,
Basisfunktionen und oder und nicht von jeweils zwei Variablen.
Eine Verallgemeinerung von dem Ganzen beziehungsweise von dem Konzept ist dann eben das,
was Schaltfunktionen sind. Schaltfunktionen jetzt wirklich als eine Funktion,
die aus N-Variablen ein Ausgangswert, Y letztendlich berechnet und in das,
was wir jetzt natürlich haben oder haben wollen,
sind dann natürlich irgendwelche die nähern Schaltvariablen, beziehungsweise binäre Werte.
Das heißt also in diesem Fall sowohl die Ausgangswerte als auch
die Vektoren hier sind dann eben entsprechend aus anabinären Mängel.
Ich schalt variable dann eben Argumente der Funktion, Ausgangsvariable dann eben das,
was alles. Gut, was wir eben schon kennengelernt haben,
sind also quasi diese einfachsten Schaltfunktionen und oder dvises,
negieren, beziehungsweise das Negieren und so weiter.
Als allgemeines Konzept, also als Funktion jetzt von N-Variablen,
Wie beschreibt man jetzt solche Funktionen?
Da gibt es eben viele verschiedene Möglichkeiten.
Also zum einen kann ich das natürlich irgendwie textuell machen.
Hat einiges an Nachteilen, wen wir gleich entsprechend sehen.
Ich kann sowas tabellarisch machen. Ich kann sowas grafisch machen
. Auch das sind alles letztendlich jetzt unterschiedliche Varianten,
die dann im Rahmen dieses Kapitels dann also noch ein bisschen weiter vorgestellt werden.
Was in Bezug jetzt auf die Begrifflichkeit dann eigentlich auch immer noch interessant ist,
man unterscheidet dann häufig immer noch sogenannte Verhaltensbeschreibungen,
wo es darum geht, Was beschreibe ich und Strukturbeschreibung,
wo es also darum geht,
wie wird das Ganze dann eben auch schon so was wie technisch umgesetzt.
Das wird uns dann im nächsten Kapitel begegnen. Verhaltensbeschreibung,
Strukturbeschreibung sind im Prinzip jetzt gerade eben schon aufgetaucht. Und zwar,
wenn ich jetzt also hier sowas sage und nehme und sage,
ich habe hier also irgendwie sowas wie so ein Binärpolynom,
dann wäre das letztendlich sowas wie eine Verhaltensbeschreibung.
Strukturbeschreibung entspricht da nämlich eigentlich hier so einem technischen Aufbau,
wenn ich jetzt hier so ein linear rückgekoppeltes Schieberegister habe,
wo letztendlich dahinter schon steht eine Struktur aus irgendwelchen Funktionselementen,
die dann eben auch wirklich so in Hardware existieren,
um das Ganze letztendlich zu machen.
Vielleicht auch nochmal dazu als Anmerkung, warum reitet er jetzt
immer so auf so eine Hardware oder solchen Strukturen Rom?
Auch da muss ich jetzt natürlich sagen, okay,
im Prinzip kann ich sowas hier natürlich auch immer machen,
mit der Programmiersprache in Software.
Das heißt, ich habe jetzt irgendwie Vector aus 0 und 1
, was diesem hier entspricht.
Ich kann diesen Wegwerts-Bitweise schieben. Ich kann an bestimmten Stellen
das jetzt mit irgendwelchen anderen Vektoren miteinander verrechnen und damit dann
also letztendlich sowas wie so ein Exklusiv-Oder machen.
Das ist eben das, was eben beispielsweise bei
der Berechnung von solchen Prüfsummen in Software bzw. in Bibliotheken
Bei vielen Sachen ist es aber eben so,
wenn ich jetzt also beispielsweise solche Prüfsummen einsetze,
um beispielsweise für Ethernet-Protokoll oder für irgendwas in irgendwelchen Switches,
Datenströme, die reinlaufen, zu nehmen,
damit irgendwas zu machen,
die entsprechend schnell wieder rauslaufen zu lassen,
dann werde ich das jetzt also nicht mit irgendeinem Standardprozessor machen,
der das also erstmal beliebig viele Takte macht und das Ganze irgendwie ausbremst,
weil mein Gigabit-Ethernet-Anschluss kriege ich damit dann also nicht
in Echtzeit durchgerechnet
Nicht, dass es dann einfach rein technisch schon mal das Problem,
sondern dafür baut man dann eben wirklich das Ganze in Hardware und hat da dann eben seine speziellen Einheiten,
die einem dann gerade da, wenn es jetzt darauf ankommt,
mitten in einer möglichst hohen Datenrate oder mit einer möglichst kurzen Latenz irgendwie was zu berechnen,
das Ganze dann eben entsprechend zu machen.
Nicht generell, ganz am Anfang ist das ja auch schon mal aufgetaucht bei diesen Begriffen oder Begrifflichkeiten,
nicht, was ist Hardware, was ist Software, was,
wo habe ich einen Interpreter, nicht wo es also darum ging,
dass Hardware, also nichts anderes ist als versteinerte Software,
also auch das sieht man hier dann immer,
je nach Einsatzzweck wird sowas teilweise mit Bibliotheken gemacht,
teilweise aber im Motto auch durch entsprechende Spezial-Hardware,
nicht deswegen so ein bisschen so die Sache.
So und wie gesagt, die Spezial-Hardware,
das wäre dann eben quasi die Strukturbeschreibung,
die Software, das wäre dann eben letztendlich die Verhaltensbeschreibung
Gut, wenn ich jetzt solche Funktionen habe,
also jetzt allgemein Schaltfunktionen und sage, wie sollen die letztendlich beschrieben werden?
Einfachste Variante wäre natürlich zu sagen, ich bringe das Ganze in eine Tabelle,
wo ich also letztendlich meine Eingänge oder meine Eingangsvariablen hier habe
und dann eben meinen Ausgangswert und dann eben für alle Kombinationen von Eingängen beschreibe,
welcher Ausgang kommt daraus.
Und dann muss ich einfach nur nachgucken,
wenn ich jetzt eben für meine Schaltfunktion als Eingangsvektor 010 habe,
dass ich dann eben sage, hier an entsprechender Zeile muss ich dann eben rauslesen,
wie ist dann eben der entsprechende Ausgangswert.
Gut, das ist vergleichsweise einfach handhabbar. Dafür kann man das Ganze dann auch noch so ein bisschen kurz schreiben,
weil wenn ich weiß,
die Funktionswerte werden jetzt also einfach binär durchgezählt,
dann kann ich also hier auch nur entsprechend die Ausgangswerte notieren,
also sprich das Ganze hier so rum einfach ablesen und sich
dann eben entsprechend als Interpretation dahinter sehen,
dass das den Eingangsvektoren von null bis sieben
entspricht und dann eben hier an entsprechender Stelle den Funktionswert auslesen
Ein Nachteil von dem Ganzen ist natürlich,
wenn ich jetzt also eine große Anzahl an Eingängen habe,
wird die Funktionsteilbelehr natürlich exponentiell wachsen.
Das heißt, also bei N-Eingängen habe ich zwar auch N-Einträge. Das heißt,
wenn ich jetzt sowas, sowas mache jetzt für ein Adira,
der also 2016 bezahlen addieren soll und das in so einer Funktionstabelle aufschreibe,
dass ich dann sage, na, ich habe für jeden Eingangsvektor 16 Bit
Bei zwei Eingängen, vielleicht habe ich noch so was wie
ein Eingangs-Carry. Warum ist ein Eingangs-Carry vielleicht noch interessant?
Das war genau die Sache mit dem Zweier-Kompliment.
Wenn wir dann im nächsten Kapitel da nämlich auch noch sehen,
wo man sagen kann, Zweier-Kompliment einer Zahl,
war ja nichts anderes als einer Kompliment plus eins.
Einer Kompliment ist nichts anderes als Bitweise negieren. Das heißt,
wenn ich jetzt zwei Zahlen habe, ich rechne hier also A,
plus B, dann kann ich sagen, okay,
dass die ganzen, diese beiden Zahlen werden dann eben entsprechend mitweise addiert,
wenn ich rechnen möchte.
A, minus B, ist das ja nichts anderes als
die Addition von A plus Zweierkompliment von B.
Und das wäre dann A, plus B negiert.
Das ist dann das eine Kompliment plus 1. Und damit habe
ich dann letztendlich A minus
Realisiert. Also dieses hier wäre dann das Zweier-Kompliment und Addition
des Zweier-Kompliments, wie ja dann eben die Subtaktion.
So, deswegen hier noch der eine zusätzliche Eingang,
der ist dann nämlich für die Plus 1,
die ich bei der Negation brauche,
während bei der Addition wird dann eben plus null gerechnet.
Dadurch kann ich dann sagen, ich habe eine Schaltung,
die kann eben einfach nur addieren,
beziehungsweise dann eben hier an der niedererwertigsten Stelle noch eine Eins hinzufügen und
diese Schaltung kann ich sowohl für die Addition als auch für die Subtraktion benutzen.
Das ist dann nämlich das, was eben in den Alus,
also den Arrithmetisch-logoischen Recheneinheiten, Computern und eben letztendlich verbaut ist.
Gut, jedenfalls, wenn ich das jetzt mache,
für sehr kleine Zahlen, 16 Bits,
dann habe ich also dann da schon 2 hoch 33 Bit.
Das kann man natürlich dann zwingenderweise also nicht mehr so richtig schön als Tabelle aufschreiben,
weil die dann also schon entsprechend groß ist.
So, das heißt, Funktionstabelle ist für viele Funktionen da dann eben auch nicht mehr geeignet.
Gut, zu dem Thema Verhaltensbeschreibung, also sprich,
wenn ich jetzt also beschreibe, funktional oder umgangssprachlich?
Wie soll sich irgendein System verhalten? Dass man da dann eben wirklich sagen muss,
okay, gerade bei der Umgangssprachlichen Beschreibung habe ich eben häufig dieses Problem,
dass das Ganze oder die Formulierung eben entsprechend sehr schnell mehr deutlich ist.
Beispiel kommt dazu. Ansonsten hatten wir mich eben als Verhaltensbeschreibung so was wie logische Ausdrücke in Programmiersprachen. Das ist also das,
was wir jetzt vor ein paar Kapiteln quasi gerade kennengelernt haben,
wo ich dann eben gesagt habe,
mit den Regeln zu der Bulschen Algebra Und, oder Negation,
beziehungsweise das Ganze dann eben entweder als Bulsche-Werter interpretiert oder eben bittweise für so einen ganzen Vector,
kann ich eben das Verhalten beschreiben oder wo sowas eingesetzt wird, ist dann eben bei Hardware-Beschreibungssprachen.
Das sind eben spezielle Sprachen, die genutzt werden,
um Prozessoren bzw. um die Hardware zu entwerfen,
weil auch da muss man sagen,
nicht in den 60er Jahren wurden also,
sagen wir mal, die Hardware-Strukturen, also dadurch entworfen,
dass man also wirklich noch einzeln gesagt hat für den und den Fertigungsprozess,
da soll dieser Transistor hin und der soll die und die Dimensionen haben und den hat man dann also auch noch irgendwie in 20 Schritten quasi einzeln irgendwie gezeichnet,
also wirklich mit so einer Art Grafikprogramm,
indem ich sage,
also an der Stelle sollen Metall hin,
an der Stelle soll irgendwie die und die Art von Diffusion in dem
ein Kristall oder in dem Silizium letztendlich passieren und dadurch hat man dann eben irgendwie sowas wie einen Transistor aufgebaut und die dann eben einzeln miteinander verbunden.
Nicht damit kommt man natürlich nicht sehr weit,
dann landet man also bei Komplexität der ersten Prozessoren, so nicht 4.000, 8.000, 16.000 Transistoren.
Ist aber natürlich nicht das, womit wir heute hantieren. Dann ging das eben zu Beschreibungshilfsmitteln,
wo ich das dann letztendlich über Bibliotheken und logische Ausdrücke gemacht habe,
wo ich gesagt habe, ich beschreibe jetzt nicht mehr einzelne Transistoren,
sondern ich beschreibe sowas wie und, und, oder Gatter,
die habe ich fertig aus Bibliotheken und kann damit letztendlich jetzt mit den Mitteln der Bulschen Algebar mein System beschreiben.
Auch da kommt man natürlich dann also auch nicht mehr so richtig weit. Und das,
was dann quasi als nächste Generation kam, waren halt eben Hardware-Beschreibungssprachen,
wo ich eigentlich ähnlich wie jetzt in der Arathmetik oder in Programmiersprachen eben sagen kann,
A plus B und je nachdem,
also ob jetzt A oder B, 32 Bit,
Unsigned oder Signed oder irgendwie die und die, der Datentyp ist,
wird das Ganze dann eben in entsprechende Transistor-Schaltung automatisch über mehrere Schritte umgesetzt.
Und damit beschreibe ich dann eben das Verhalten der Struktur,
aber muss ja jetzt nicht mal jedem Transistor einzeln begrüßen. Und gut,
als Erweiterung von dem geht das jetzt eben inzwischen auch so weit,
dass man dann eben schon ganze größere Blöcke, also sprich einzelne Prozessoren,
dann eben fertig einkaufen kann und sagen kann, okay,
an der Stelle brauche ich jetzt eben noch sowas wie Armprozessor,
um jetzt also beispielsweise in irgendeinem eingebetteten System da jetzt also irgendwie das und das dann noch zusätzlich zu realisieren.
Gut, also Verhaltensbeschreibung begegnet uns jetzt natürlich in der Regel
erst mal in umgangssprachlichen Formulierungen und genau da haben wir jetzt
natürlich dann also irgendwie so ein bisschen das Problem,
dass da also zumindest die deutsche Sprache umgangssprachlich dann also doch sehr ungenau ist.
Also sprich, wenn ich jetzt sage,
Steuerung von Schiebedach im Auto, nicht das ist okay,
wenn der Öffnungskontakt oder der Schließkontakt funktionieren oder beide nicht
aktiv sind
So, was ist damit gemeint? Jetzt kann ich also sagen,
Schiebedach soll also hier meine Ausgangsfunktion oder meinen Ausgangswert sein.
Ich habe hier zwei freie Variablen, Öffnungskontakt und Schließkontakt. So,
und jetzt taucht hier aber eben einmal irgendwie oder auf,
ist das oder jetzt, oder im Sinne, Bulschalgebra Or,
oder ist es ausschließlich, also ein Exklusiv-Oder?
Beide nicht aktiv, also sprich Mittelstellung des Daches wieder ganz
vorn am Anschlag noch ganz zurückgefahren, sondern irgendwo dazwischen.
Beide nicht aktiv, was ist damit gemeint
Als Shart-Argebasche-Ausdruck, X1 und X2 nicht. Also sprich,
als Bulsche Algeba, X1 und X2, nee,
X0 war das so.
So rum, nicht. Oder X1 nicht und X0 nicht.
Also das kann ich also jetzt zumindest so aus dem Text
erstmal nicht so richtig herauslesen,
ist aber natürlich eine völlig unterschiedliche Bulsche Funktion,
hat ein
völlig unterschiedliches Verhalten
Deswegen sieht man eigentlich schon,
dass so ein Umgangssprachliche Beschreibung da also doch schlecht geeignet ist.
Nicht deswegen hat man dann eben häufig andere Beschreibungen oder Beschreibungshilfsmittel.
Was man jetzt natürlich machen kann, ist also wirklich
eine Art Strukturbeschreibung, also sprechende Spezifikation der konkreten Realisierung.
Theoretisch ist sie natürlich auch möglich über vollständig geklammerte Algebrage-Ausdrücke.
Das heißt, wenn ich jetzt eben wirklich sowas habe,
wie X1 exklusiv oder X2 oder X3, Schalpläne mit Göttern
werden uns also quasi im nächsten Kapitel dann noch begegnen.
Datenflussgrafen sind dann also auch noch andere Mechanismen, sind hier
aber in der Vorlesung dann also auch nicht weiter vertreten.
Gut, um jetzt Funktionen irgendwie zu beschreiben oder beschreiben zu können,
möchte man jetzt natürlich überhaupt erstmal einen Mechanismus haben,
mit dem ich alle Arten von Funktionen beschreiben kann.
Das heißt, das, was ich brauche,
ist sowas wie eine sogenannte Funktionalvollständige Basismenge
So, da kam er jetzt wieder in die Bulsche Algebra zurückgehen und sagen,
okay, welche Verknüpfung haben wir jetzt also beispielsweise in dem Körper
GF2 und da gab es dann ja, also letztendlich,
dass man sagen kann, okay, ich habe,
brauchen Unverknüpfung und ich brauche die ist exklusiv oder habe damit
also wirklich einen Vollständen mathematisch gesehen, dann eben vollständigen Körper,
beziehungsweise rein praktisch würde man jetzt sagen, ich habe entweder
Die Beschreibung der Bulschen Algebra und oder und nicht.
Und damit lassen sich dann eben alle Bulschen ah Ausdrücke beschreiben und modellieren.
Oder ich habe andere Mechanismen. Eine Form,
die dann im Prinzip also auf dem hier aufbaut,
wäre dann und exklusiv oder und die eins,
die ich also quasi jetzt als neutrales Element der Multiplikation brauche,
beziehungsweise brauche, um die in Verse zu bilden.
Oder ich habe Mengen, die dann also jetzt aus Sowas bestehen,
wie dieses hier nennt, also A und B und das Ganze negiert.
Auch das ist eine funktional vollständige Basismenge. Wann ist sie
funktional vollständig, wenn ich damit alles darstellen kann,
was im Prinzip hiermit realisierbar ist, beziehungsweise mit der Bulschen Algebahr.
Das heißt, ich müsste jetzt sagen, wie kann ich also
aus so einem Ausdruck aus nähen und, ein oder oder nicht realisieren.
Und das geht beispielsweise, wenn ich jetzt sowas hier habe,
also ich habe jetzt hier erst mal zwei Variablen A und B,
mit so einem Nant, doch mal die Tafel, nehmen so.
Wie kriege ich damit eine Negation hin, also nicht,
indem ich da einfach sage, A und A,
negiert, ist nichts anderes als Nicht-A. Ist zwar nicht elegant,
aber nach dem Bulschen Alge war er natürlich richtig.
So, jetzt möchte ich sowas wie ein oder realisieren
Oder andersrum, weil jetzt andersrum, ich habe jetzt mal die Negation,
ich möchte jetzt sowas wie ein einfaches und realisieren.
Ja gut, da kann ich ja nun sagen,
ich habe hier eine Negation und dann muss ich ja
nichts anderes machen als A und die nennt,
das muss ich jetzt hier nochmal negieren,
dann ist das ja nichts anderes als A und
Und dieses erreiche ich dann eben,
indem ich das jetzt quasi hier entsprechend einsetze,
indem ich dann also letztendlich sage, A und B nicht.
Und A und B nicht. Und das Ganze dann eben hier nochmal,
also sprich mit 1, 2, 3 von diesen Nance,
daraus dann also letztendlich diesen Ausdruck bilde.
So und jetzt müsste ich noch beschreiben A oder
Ja, wie kriege ich das? Also hiermit hin.
Und auch das geht also relativ einfach,
wenn man jetzt also irgendwie die Regeln der Bulschen Algebra kennt.
In dem Fall dem Morgen, also A.
Und B negiert wäre dann ja nichts anderes als A. Oder
Also das stimmt hier jetzt natürlich noch nicht. Also wenn ich den jetzt hier nehme,
nach dem Morgen wäre das ja nichts als A, nicht oder wenig.
Jetzt müsste ich die hier nochmal wieder negieren,
um daraus jetzt also quasi A oder B rauszumachen.
Würde ich dieses hier wieder entsprechend einsetzen und hätte dann eben
auch wieder jetzt mit entsprechend drei von diesen Mans dann eben realisiert,
A oder B. Das heißt also mit dieser einen Funktion nennt,
Kann ich funktional vollständig oder vollständig,
also letztendlich diese Funktion der Bullschnalgebra, mir herleiten.
Also das nur als Beispiel für so eine Funktionalvollständige. Basismenge, das,
was ich jetzt hier gerade vorgestellt hatte, war sonst eigentlich immer eine Übungsaufgabe.
Vielleicht wird das noch fürs Nore kommen, vielleicht auch nicht.
Im Prinzip haben sie jetzt aber zumindest schon mal gesehen,
wie man das relativ einfach lösen kann, mit ein bisschen Trickserei und Umrechnen,
nicht aber jedenfalls das erstmal nur als Hinweis,
dass auch sowas funktional vollständige Basismenge ist.
Gut, wie ich jetzt aber mit diesen Mengen allgemein Schaltfunktionen beschreibe,
beziehungsweise damit dann eben entsprechend aufbaue,
das soll jetzt übermorgen folgen und damit mache ich für heute
Schluss und wünsche einen schönen Abend