diff --git a/.gitignore b/.gitignore index 74d5b41..8355e61 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,5 @@ +.vscode + ## Core latex/pdflatex auxiliary files: *.aux *.lof diff --git a/Advanced Operating Systems.md b/Advanced Operating Systems.md new file mode 100644 index 0000000..d6a9448 --- /dev/null +++ b/Advanced Operating Systems.md @@ -0,0 +1,4011 @@ +# Einführung +Betriebssysteme stecken nicht nur in Einzelplatzrechnern, sondern z.B. auch in: +- Informationssystemen + - Gesundheitswesen + - Finanzdienstleister +- Verkehrsmanagement-Systemen + - Eisenbahn + - Flugwesen +- Kommunikationssystemen + - Mobilfunk + - Raumfahrt +- eingebettetenSystemen + - Multimedia + - Fahrzeugsysteme + - Sensornetze +- ... $\rightarrow$ verschiedenste Anforderungen! + +Konsequenz: Spezialbetriebssysteme für Anforderungen wie ... +- Robustheit +- Echtzeitfähigkeit +- Energieeffizienz +- Sicherheit +- Adaptivität +- ... + +Gegenstand dieser Vorlesung: Konstruktionsrichtlinien für solche ,,High-End Betriebssysteme'' + +## Funktionale und nichtfunktionale Eigenschaften +- Beispiel: Autokauf ,,Mit unserem Fahrzeug können Sie einkaufen fahren!'' +- Beispiel: Handykauf ,,Mit unserem Telefon können Sie Ihre Freunde und Familie anrufen!'' + +- Anforderungen (Requirements) + - Funktionale und nichtfunktionale Eigenschaften (eines Produkts, z.B. Softwaresystems) entstehen durch Erfüllung von funktionalen und nichtfunktionalen Anforderungen +- funktionale Eigenschaft + - legt fest, was ein Produkt tun soll. + - Bsp Handykauf: Das Produkt soll Telefongespräche ermöglichen. +- eine nichtfunktionale Eigenschaft (NFE) + - legt fest, wie es dies tun soll, also welche sonstigen Eigenschaften das Produkt haben soll. + - Bsp Handykauf: Das Produkt soll klein, leicht, energiesparend, strahlungsarm, umweltfreundlich,... sein. +- andere Bezeichnungen nichtfunktionaler Eigenschaften + - Qualitäten bzw. Qualitätsattribute (eines Software-Produkts): + - Nichtfunktionale Anforderungen bzw. Eigenschaften eines Software-Systems bzw. -Produkts oft auch als seine Qualitäten bezeichnet. + - einzelne realisierte Eigenschaft ist demzufolge ein Qualitätsattribut (quality property) dieses Systems bzw. Produkts. + - Weitere in der Literatur zu findende Begriffe in diesem Zusammenhang: + - Non-functionalrequirements/properties + - Constraints + - Quality ofservice(QoS) requirements + - u.a. +- ,,~ilities'' + - im Englischen: nichtfunktionale Eigenschaften eines Systems etc. informell auch als seine ,,ilities'' bezeichnet, hergeleitet von Begriffen wie + - Stability + - Portability + - ... + - im Deutschen: ( ,,itäten'',,,barkeiten'', ... möglich aber sprachästhetisch fragenswert) + - Portab-ilität , Skalier-barkeit, aber: Offen-heit , Performanz, ... + +## Konsequenzen für Betriebssysteme +### Hardwarebasis +Einst: Einprozessor-Systeme + +Heute: +- Mehrprozessor-Systeme +- hochparallele Systeme +- neue Synchronisationsmechanismen erforderlich +- $\rightarrow$ unterschiedliche Hardware und deren Multiplexing aufgrund unterschiedlicher nichtfunktionaler Eigenschaften + +### Betriebssystemarchitektur +Einst: Monolithische und Makrokernel-Architekturen + +Heute: +- Mikrokernel(-basierte) Architekturen +- Exokernelbasierte Architekturen ( Library-Betriebssysteme ) +- Virtualisierungsarchitekturen +- Multikernel-Architekturen +- $\rightarrow$ unterschiedliche Architekturen aufgrund unterschiedlicher nichtfunktionaler Eigenschaften + +### Ressourcenverwaltung +Einst: sog. Batch-Betriebssysteme: Stapelverarbeitung von Jobs (FIFO, Zeitgarantie: irgendwann) + +Heute: +- Echtzeitgarantien für Multimedia und Safety-kritische Anwendungen (Unterhaltung, Luft-und Raumfahrt, autonomes Fahren) +- echtzeitfähige Scheduler, Hauptspeicherverwaltung, Ereignismanagement, Umgangmit Überlast und Prioritätsumkehr ... +- $\rightarrow$ unterschiedliche Ressourcenverwaltung aufgrund unterschiedlicher nichtfunktionaler Eigenschaften + +### Betriebssystemabstraktionen +- zusätzliche Abstraktionen und deren Verwaltung ... + - ... zur Reservierung von Ressourcen ($\rightarrow$ eingebettete Systeme) + - ... zur Realisierung von QoS-Anforderungen ($\rightarrow$ Multimediasysteme) + - ... zur Erhöhung der Ausfallsicherheit ($\rightarrow$ verfügbarkeitskritische Systeme) + - ... zum Schutz vor Angriffen und Missbrauch ($\rightarrow$ sicherheitskritische Systeme) + - ... zum flexiblen und modularen Anpassen des Betriebssystems ($\rightarrow$ hochadaptive Systeme) +- $\rightarrow$ höchst diverse Abstraktionen von Hardware aufgrund unterschiedlicher nichtfunktionaler Eigenschaften + +### Betriebssysteme als Softwareprodukte +- Betriebssystem: + - eine endliche Menge von Quellcode, indiziert durch Zeilennummern: MACOSX = $\{0, 1, 2, ..., 4399822, ...\}$ + - ein komplexes Softwareprodukt ...welches insbesondere allgemeinen Qualitätsanforderungen an den Lebenszyklusvon Softwareprodukten unterliegt! +- an jedes Softwareprodukt gibt es Anforderungen an seine Nutzung und Pflege $\rightarrow$ Evolutionseigenschaften +- diese können für Betriebssysteme höchst speziell sein (Korrektheitsverifikation, Wartung, Erweiterung, ...) +- $\rightarrow$ spezielle Anforderungen an das Softwareprodukt Betriebssystem aufgrund unterschiedlicher nichtfunktionaler Eigenschaften + +## NFE von Betriebssystemen +Funktionale Eigenschaften (= Funktionen, Aufgaben) ... von Betriebssystemen: +- Betriebssysteme: sehr komplexe Softwareprodukte +- Ein Grund hierfür: besitzen Reihe von differenzierten Aufgaben - also funktionale Eigenschaften + +Grundlegende funktionale Eigenschaften von Betriebssystemen: +1. **Hardware-Abstraktion** (Anwendungen/Programmierern eine angenehme Ablaufumgebung auf Basis der Hardware bereitstellen) +2. **Hardware-Multiplexing** (gemeinsame Ablaufumgebung zeitlich oder logisch getrennt einzelnen Anwendungen zuteilen) +3. **Hardware-Schutz** (gemeinsame Ablaufumgebung gegen Fehler und Manipulation durch Anwendungen schützen) + +Nichtfunktionale Eigenschaften (Auswahl) von Betriebssystemen: +- Laufzeiteigenschaften + - Sparsamkeit und Effizienz + - Robustheit + - Verfügbarkeit + - Sicherheit (Security) + - Echtzeitfähigkeit + - Adaptivität + - Performanz +- Evolutionseigenschaften + - Wartbarkeit + - Portierbarkeit + - Offenheit + - Erweiterbarkeit + +Klassifizierung: Nichtfunktionale Eigenschaften unterteilbar in: +1. Laufzeiteigenschaften (execution qualities) + - zur Laufzeit eines Systems beobachtbar + - Beispiele: ,,security'' (Sicherheit), ,,usability'' (Benutzbarkeit), ,,performance'' + (Performanz), ... +2. Evolutionseigenschaften (evolution qualities) + - charakterisieren (Weiter-) Entwicklung- und Betrieb eines Systems + - Beispiele: ,,testability'' (Testbarkeit), ,,extensibility'' (Erweiterbarkeit) usw. +- liegen in statischer Struktur eines Softwaresystems begründet + +## Inhalte der Vorlesung +Auswahl sehr häufiger NFE von Betriebssystemen: +- Sparsamkeit und Effizienz +- Robustheit +- Verfügbarkeit +- Sicherheit (Security) +- Echtzeitfähigkeit +- Adaptivität +- Performanz + +Diskussion jeder Eigenschaft: (Bsp.: Echtzeitfähigkeit) +- Motivation, Anwendungsgebiete, Begriffsdefinition(en) (Bsp.: Multimedia- und eingebettete Systeme) +- Mechanismen und Abstraktionen des Betriebssystems (Bsp.: Fristen, Deadline-Scheduler) +- unterstützende Betriebssystem-Architekturkonzepte (Bsp.: Mikrokernel) +- ein typisches Beispiel-Betriebssystem (Bsp.: QNX) +- Literaturliste + + +# Sparsamkeit und Effizienz +## Motivation +Sparsamkeit (Arbeitsdefinition): Die Eigenschaft eines Systems, seine Funktion mit minimalem Ressourcenverbrauchauszuüben. + +Hintergrund: sparsamer Umgang mit einem oder mehreren Ressourcentypen = präziser: Effizienz bei Nutzung dieser Ressourcen + +Effizienz: Der Grad, zu welchem ein System oder eine seiner Komponenten seine Funktion mit minimalem Ressourcenverbrauch ausübt. (IEEE) + +Entwurfsentscheidungen für BS: +1. Wie muss bestimmter Ressourcentyp verwaltet werden, um Einsparungen zu erzielen? +2. Welche Erweiterungen/Modifikationen des Betriebssystems (z.B. neue Funktionen, Komponenten, ...) sind hierfür notwendig? + +Konkretisierung: Ressource, welche sparsam verwendet wird. + +Beispiele: +- mobile Geräte: Sparsamkeit mit Energie +- kleine Geräte, eingebettete Systeme: + - Sparsamkeit mit weiteren Ressourcen, z.B. Speicherplatz + - Betriebssystem (Kernel + User Space): geringer Speicherbedarf + - optimale Speicherverwaltung durch Betriebssystem zur Laufzeit +- Hardwareoptimierungen im Sinne der Sparsamkeit: + - Baugrößenoptimierung(Platinen-und Peripheriegerätegröße) + - Kostenoptimierung(kleine Caches, keine MMU, ...) + - massiv reduzierte HW-Schnittstellen (E/A-Geräte, Peripherie, Netzwerk) + +Mobile und eingebettete Systeme (eine kleine Auswahl) +- mobile Rechner-Endgeräte + - Smartphone, Smartwatch + - Laptop-/Tablet-PC +- Weltraumfahrt und -erkundung +- Automobile + - Steuerung von Motor-und Bremssystemen + - Fahrsicherheit + - Insasseninformation (und -unterhaltung) + - (teil-) autonomes Fahren +- verteilte Sensornetze (WSN) +- Chipkarten +- Multimedia-und Unterhaltungselektronik + - eBookReader + - Spielkonsolen + - Digitalkameras + +Beispiel: Weltraumerkundung +- Cassini-Huygens (1997-2017) + - Radionuklidbatterien statt Solarzellen + - Massenspeicher: SSDs statt Magnetbänder +- Rosetta (2004-2016) + - 31 Monate im Energiesparmodus +- Opportunity (2003-2019) + - geplante Missionsdauer: 90 d + - Missionsdauer insgesamt: >> 5000 d +- Hayabusa (2003-2010) + - Beschädigung der Energieversorgung + - Energiesparmodus: um 3 Jahre verzögerte Rückkehr +- Voyager 1 (1977 bis heute) + - erste Flugphase: periodisch 20 Monate Standby, 20 Stunden Messungen + - liefert seit 40 Jahren Daten + +## Energieeffizienz +Hardwaremaßnahmen +- zeitweiliges Abschalten/Herunterschalten momentan nicht benötigter +Ressourcen, wie +1. Laufwerke: CD/DVD, ..., Festplatte +2. Hauptspeicherelemente +3. (integrierte/externe) Peripherie: Monitor, E/A-Geräte, ... + +Betriebssystemmechanismen +1. Dateisystem-E/A:energieeffizientes Festplatten-Prefetching(2.2.1) +2. CPU-Scheduling: energieeffizientes Scheduling(2.2.2) +3. Speicherverwaltung:minimale Leistungsaufnahme durchSpeicherzugriffe mittels Lokalitätsoptimierung [DGMB07] +4. Netzwerk:energiebewusstes Routing +5. Verteiltes Rechnen auf Multicore-Prozessoren: temperaturabhängige Lastverteilung +6. ... + +### Energieeffiziente Dateizugriffe +Hardwarebedingungen: Magnetplatten (HDD), Netzwerkgeräte, DRAM-ICs,... sparen nur bei relativ langen Inaktivitätsintervallen Energie. + +- Aufgabe: Erzeugen kurzer, intensiver Zugriffsmuster $\rightarrow$ lange Inaktivitätsintervalle (für alle Geräte mit geringem Energieverbrauch im Ruhezustand) +- Beobachtung bei HDD-Geräten: i.A. vier Zustände mit absteigendem Energieverbrauch: + 1. Aktiv: einziger Arbeitszustand + 2. Idle (Leerlauf): Platte rotiert, aber Plattenelektronik teilweise abgeschaltet + 3. Standby: Rotation abgeschaltet + 4. Sleep: gesamte restliche Elektronik abgeschaltet +- ähnliche, noch stärker differenzierte Zustände bei DRAM (vgl. [DGMB07] ) + +Energiezustände beim Betrieb von Festplatten: +- ![](Assets/AdvancedOperatingSystems-energiezustände-festplatte.png) +- Schlussfolgerung: durch geringe Verlängerungen des idle - Intervalls kann signifikant der Energieverbrauch reduziert werden. + +#### Prefetching-Mechanismus +- Prefetching (,,Speichervorgriff'', vorausschauendes Lesen) & Caching + - Standard-Praxis bei moderner Datei-E/A + - Voraussetzung: Vorwissen über benötigte Folge von zukünftigen Datenblockreferenzen (z.B. Blockadressen für bestimmte Dateien, gewonnen durch Aufzeichnung früherer Zugriffsmuster beim Start von Anwendungen -Linux: readahead syscall) + - Ziel: Performanzverbesserungdurch Durchsatzerhöhung u. Latenzzeit-Verringerung + - Idee: Vorziehen möglichst vieler E/A-Anforderungen an Festplatte + zeitlich gleichmäßige Verteilung der verbleibenden + - Umsetzung: Caching (Zwischenspeichern) dieser vorausschauend gelesenen Blöcke in ungenutzten Hauptspeicherseitenrahmen ( pagecache ) +- Folge: Inaktivitätsintervalle überwiegend sehr kurz $\rightarrow$ Energieeffizienz ...? +- Zugriffsoperation: (durch Anwendung) + - access(x) ... greife (lesend/schreibend) auf den Inhalt von Festplattenblock x im Page Cache zu +- Festplattenoperationen: + - fetch(x) ... hole Block x nach einem access(x) von Festplatte + - prefetch(x) ... hole Block x ohne access(x) von Festplatte + - beide Operationen schreiben x in einen freien Platz des Festplattencaches; falls dieser voll ist ersetzen sie einen der Einträge gemäß fester Regeln $\rightarrow$ Teil der (Pre-) Fetching-Strategie +- Beispiel für solche Strategien: Anwendung ... + - mit Datenblock-Referenzstrom A, B, C, D, E, F, G, ... + - mit konstanter Zugriffsdauer: 10 Zeiteinheiten je Blockzugriff + - Cache-Kapazität: 3 Datenblöcke + - Zeit zum Holen eines Blocks bei Cache-Miss: 1 Zeiteinheit +- Beispiel: Traditionelles Prefetching + - Fetch-on-demand-Strategie (kein vorausschauendes Lesen) + - Strategie entsprechend Prefetching- Regeln nach Cao et al. [CFKL95] (= traditionelle Disk-Prefetching- Strategie) + - traditionelle Prefetching-Strategie: bestimmt + - wann ein Datenblock von der Platte zu holen ist (HW-Zustand aktiv ) + - welcher Block zu holen ist + - welcher Block zu ersetzen ist + - Regeln für diese Strategie: + 1. Optimales Prefetching: Jedes _prefetch_ sollte den nächsten Block im Referenzstrom in den Cache bringen, der noch nicht dort ist. + 2. Optimales Ersetzen: Bei jedem ersetzenden _prefetch_ sollte der Block überschrieben werden, der am spätesten in der Zukunft wieder benötigt wird. + 3. ,,Richte keinen Schaden an'': Überschreibe niemals Block A um Block B zu holen, wenn A vor B benötigt wird. + 4. Erste Möglichkeit: Führe nie ein ersetzendes _prefetch_ aus, wenn dieses schon vorher hätte ausgeführt werden können. +- Energieeffizientes Prefetching + - Optimale Ersetzungsstrategie und 3 unterschiedliche Prefetching-Strategien: + - Fetch-on-demand-Strategie: + - Laufzeit: 66 ZE für access(A) ... access(F) , 7 Cache-Misses + - Disk-Idle-Zeit: 6 Intervalle zu je 10 ZE + - Strategie entsprechend Prefetching-Regeln [CFKL95] (traditionelle Disk-Prefetching-Strategie): + - Laufzeit: 61 ZE für access(A) ... access(F) , 1 Cache-Miss + - Disk-Idle-Zeit: 5 Intervalle zu je 9 ZE und 1 Intervall zu 8 ZE (= 53 ZE) + - Energieeffiziente Prefetching-Strategie, die versucht Länge der Disk-Idle-Intervalle zu maximieren: + - gleiche Laufzeit und gleiche Anzahl Cache-Misses wie traditionelles Prefetching + - Disk-Idle-Zeit: 2 Intervalle zu 27 bzw. 28 ZE (= 55 ZE) +- Auswertung: Regeln für energieeffiziente Prefetching-Strategie nach Papathanasiou elal.: [PaSc04] + 1. Optimales Prefetching: Jedes _prefetch_ sollte den nächsten Block im Referenzstrom in den Cache bringen, der noch nicht dort ist. + 2. Optimales Ersetzen: Bei jedem ersetzenden _prefetch_ sollte der Block überschrieben werden, der am spätesten in der Zukunft wieder benötigt wird. + 3. ,,Richte keinen Schaden an'': Überschreibe niemals Block A um Block B zu holen, wenn A vor B benötigt wird. + 4. Maximiere Zugriffsfolgen: Führe immer dann nach einem _fetch_ oder _prefetch_ ein weiteres _prefetch_ aus, wenn Blöcke für eine Ersetzung geeignet sind. (i.S.v. Regel 3) + 5. Beachte Idle-Zeiten: Unterbrich nur dann eine Inaktivitätsperiode durch ein _prefetch_ , falls dieses sofort ausgeführt werden muss, um einen Cache-Miss zu vermeiden. + +Allgemeine Schlussfolgerungen +1. Hardware-Spezifikation nutzen: Modi, in denen wenig Energie verbraucht wird +2. Entwicklung von Strategien, die langen Aufenthalt in energiesparenden Modi ermöglichen , und dabei Leistungsparameter in vertretbarem Umfang reduzieren +3. Implementieren dieser Strategien in Betriebssystemmechanismen zur Ressourcenverwaltung + +### Energieeffizientes Prozessormanagement +Hardware-Gegebenheiten +- z.Zt. meistgenutzte Halbleitertechnologie für Prozessor-Hardware: CMOS ( Complementary Metal Oxide Semiconductor) +- Komponenten für Energieverbrauch: $P = P_{switching} + P_{leakage} + ...$ + - $P_{switching}$: für Schaltvorgänge notwendige Leistung + - $P_{leakage}$: Verlustleistung durch verschiedene Leckströme + - ...: weitere Einflussgrößen (technologiespezifisch) + +#### Hardwareseitige Maßnahmen +Schaltleistung: $P_{switching}$ +- Energiebedarf kapazitiver Lade-u. Entladevorgänge während des Schaltens +- für momentane CMOS-Technologie i.A. dominanter Anteil am Energieverbrauch +- Einsparpotenzial: Verringerung von + 1. Versorgungsspannung (quadratische Abhängigkeit!) + 2. Taktfrequenz +- Folgen: + 1. längere Schaltvorgänge + 2. größere Latenzzwischen Schaltvorgängen +- Konsequenz: Energieeinsparung nur mit Qualitätseinbußen(direkt o. indirekt) möglich + - Anpassung des Lastprofils ( Zeit-Last-Kurve? Fristen kritisch? ) + - Beeinträchtigung der Nutzererfahrung( Reaktivität kritisch? Nutzungsprofil? ) + +Verlustleistung: $P_{leakage}$ +- Energiebedarf baulich bedingter Leckströme +- Fortschreitende Hardware-Miniaturisierung $\Rightarrow$ zunehmender Anteil von $P_{leakage}$ an P +- Beispielhafte Größenordnungen zum Einsparpotenzial: + | Schaltkreismaße | Versorgungsspannung | $P_{leakage}/P$ | + | --------------- | ------------------- | --------------- | + | 180 nm | 2,5 V | 0, | + | 70 nm | 0,7 V | 0, | + | 22 nm | 0,4 V | > 0,5 | +- Konsequenz: Leckströme kritisch für energiesparenden Hardwareentwurf + +#### Regelspielraum: Nutzererfahrung +- Nutzererwartung: wichtigstes Kriterium zur (subjektiven) Bewertung von auf einem Rechner aktiven Anwendungen durch Nutzer $\rightarrow$ Nutzerwartung bestimmt Nutzererfahrung +- Typ einer Anwendung + - entscheidet über jeweilige Nutzererwartung + 1. Hintergrundanwendung (z.B. Compiler); von Interesse: Gesamt-Bearbeitungsdauer, Durchsatz + 2. Echtzeitanwendung(z.B. Video-Player, MP3-Player); von Interesse: ,,flüssiges'' Abspielen von Video oder Musik + 3. Interaktive Anwendung (z.B. Webbrowser); von Interesse: Reaktivität, d.h. keine (wahrnehmbare) Verzögerung zwischen Nutzer-Aktion und Rechner-Reaktion + - Insbesondere kritisch: Echtzeitanwendungen, interaktive Anwendungen + +Reaktivität +- Reaktion von Anwendungen + - abhängig von sog. Reaktivität des Rechnersystems ≈ durchschnittliche Zeitdauer, mit der Reaktion eines Rechners auf eine (Benutzerinter-) Aktion erfolgt +- Reaktivität: von Reihe von Faktoren abhängig, z.B.: + 1. von **Hardware** an sich + 2. von **Energieversorgung** der Hardware (wichtig z.B. Spannungspegel an verschiedenen Stellen) + 3. von **Software-Gegebenheiten** (z.B. Prozess-Scheduling, Speichermanagement, Magnetplatten-E/A-Scheduling, Vorgänge im Fenstersystem, Arten des Ressourcen-Sharing usw.) + +Zwischenfazit: Nutzererfahrung +- bietet Regelspielraum für Hardwareparameter ( $\rightarrow$ Schaltleistung) $\rightarrow$ Versorgungsspannung, Taktfrequenz +- Betriebssystemmechanismen zum energieeffizienten Prozessormanagement müssen mit Nutzererfahrung(jeweils erforderlicher Reaktivität) ausbalanciert werden (wie solche Mechanismen wirken: 2.2.3) +- Schnittstelle zu anderen NFE: + - Echtzeitfähigkeit + - Performanz + - Usability + - ... + +#### Energieeffizientes Scheduling +- so weit besprochen: Beschränkung des durchschnittlichen Energieverbrauchs eines Prozessors +- offene Frage zum Ressourcenmultiplexing: Energieverbrauch eines Threads/Prozesses? +- Scheduling-Probleme beim Energiesparen: + 1. Fairness (der Energieverteilung)? + 2. Prioritätsumkehr? +- Beispiel: Round Robin (RR) mit Prioritäten (Hoch, Mittel, Niedrig) +- Problem 1: Unfaire Energieverteilung + - Beschränkung des Energieverbrauchs (durch Qualitätseinbußen, schlimmstenfalls Ausfall)ab einem oberen Schwellwert $E_{max}$ + - Problem: energieintensive Threads behindern alle nachfolgenden Threads trotz gleicher Priorität $\rightarrow$ Fairnessmaß von RR (gleiche Zeitscheibenlänge T ) untergraben + - ![](Assets/AdvancedOperatingSystems-round-robin-unfair.png) +- Problem 2: energieintensive Threads niedrigerer Priorität behindern später ankommende Threads höherer Priorität + - ![](Assets/AdvancedOperatingSystems-prioritätsumkehr.png) + +Energiebewusstes RR: Fairness +- Begriffe: + - $E_i^{budget}$ ... Energiebudget von $t_i$ + - $E_i^{limit}$ ... Energielimit von $t_i$ + - $P_{limit}$ ... Leistungslimit: maximale Leistungsaufnahme [Energie/Zeit] + - $T$ ... resultierende Zeitscheibenlänge +- Strategie 1: faire Energieverteilung (einheitliche Energielimits) + - ![Darstellung nach Klee08](Assets/AdvancedOperatingSystems-energiebewusstes-rr.png) + - $1\leq i\leq 4: E_i^{limit} = P_{limit}* T$ + - (Abweichungen = Wichtung der Prozesse $\rightarrow$ bedingte Fairness) + +Energiebewusstes RR: Reaktivität +- faire bzw. gewichtete Aufteilung begrenzter Energie optimiert Energieeffizienz +- Problem: lange, wenig energieintensive Threads verzögern Antwort-und Wartezeiten kurzer, energieintensiver Threads + - Lösung im Einzelfall: Wichtung per $E_i^{limit}$ + - globale Reaktivität ( $\rightarrow$ Nutzererfahrung bei interaktiven Systemen) ...? +- Strategie 2: maximale Reaktivität ( $\rightarrow$ klassisches RR) + - ![](Assets/AdvancedOperatingSystems-energiebewusstes-rr-reaktivität.png) + +Energiebewusstes RR: Reaktivität und Fairness +- Problem: sparsame Threads werden bestraft durch Verfallen des ungenutzten Energiebudgets +- Idee: Ansparen von Energiebudgets $\rightarrow$ mehrfache Ausführung eines Threads innerhalb einer Scheduling-Periode +- Strategie 3: Reaktivität, dann faire Energieverteilung + - ![](Assets/AdvancedOperatingSystems-energiebewisstes-rr-2.png) + +##### Implementierungsfragen +- Scheduling-Zeitpunkte? + - welche Accounting-Operationen (Buchführung über Budget)? + - wann Accounting-Operationen? + - wann Verdrängung? +- Datenstrukturen? + - ... im Scheduler $\rightarrow$ Warteschlange(n)? + - ... im Prozessdeskriptor? +- Kosten ggü. klassischem RR? (durch Prioritäten...?) + +- Pro: + - Optimierung der Energieverteilung nach anwendungsspezifischen Schedulingzielen( $\rightarrow$ Strategien) + - Berücksichtigung von prozessspezifischen Energieverbrauchsmustern möglich:fördert Skalierbarkeit i.S.v. Lastadaptivität, indirekt auch Usability ( $\rightarrow$ Nutzererfahrung) +- Kontra: + - zusätzliche sekundäre Kosten: Energiebedarf des Schedulers, Energiebedarf zusätzlicher Kontextwechsel, Implementierungskosten (Rechenzeit, Speicher) + - Voraussetzung hardwareseitig: Monitoring des Energieverbrauchs (erforderliche/realisierbare Granularität...? sonst: Extrapolation?) +- **generelle Alternative:** energieintensive Prozesse verlangsamen $\rightarrow$ Regelung der CPU-Leistungsparameter (Versorgungsspannung) (auch komplementär zum Schedulingals Maßnahme nach Energielimit-Überschreitung) +- Beispiel: Synergie nichtfunktionaler Eigenschaften + - Performanz nur möglich durch Parallelität $\rightarrow$ Multicore-Hardware + - Multicore-Hardware nur möglich mit Lastausgleich und Lastverteilungauf mehrere CPUs + - dies erfordert ebenfalls Verteilungsstrategien: ,,Energy-aware Scheduling'' (Linux-Strategie zur Prozessorallokation -nicht zeitlichem Multiplexing!) + +### Systemglobale Energieeinsparungsmaßnahmen +- Traditionelle Betriebssysteme: Entwurf so, dass zu jedem Zeitpunkt Spitzen-Performanzangestrebt +- Beobachtungen: + - viele Anwendungen benötigen keine Spitzen-Performanz + - viele Hardware-Komponenten verbringen Zeit in Leerlaufsituationen bzw. in Situationen, wo keine Spitzen-Performanz erforderlich +- Konsequenz (besonders für mobile Systeme) : + - Hardware mit Niedrigenergiezuständen(Prozessoren und Magnetplattenlaufwerke, aber auch DRAM, Netzwerkschnittstellen, Displays, ...) + - somit kann Betriebssystem **Energie-Management** realisieren + +#### Hardwaretechnologien +- DPM: Dynamic Power Management + - versetzt leerlaufende/unbenutzte Hardware-Komponenten selektiv in Zustände mit niedrigem Energieverbrauch + - Zustandsübergänge durch Power-Manager (in Hardware) gesteuert, dem bestimmte _DPM-_ Strategie (Firmware) zugrunde liegt, um gutes Verhältnis zwischen Performanz/Reaktivität und Energieeinsparung zu erzielen +- DVS: Dynamic Voltage Scaling + - effizientes Verfahren zur dynamischen Regulierungvon Taktfrequenz gemeinsammit Versorgungsspannung + - Nutzung quadratischer Abhängigkeitder dynamischen Leistung von Versorgungsspannung + - Steuerung/Strategien: Softwareunterstützungnotwendig! + +Dynamisches Energiemanagement (DPM)- Strategien (Klassen) bestimmt, wann und wie lange eine Hardware-Komponente sich in Energiesparmodusbefinden sollte +- Greedy: Hardware-Komponente sofort nach Erreichen des Leerlaufs in Energiesparmodus, ,,Aufwecken'' durch neue Anforderung +- Time-out: Energiesparmodus erst nachdem ein definiertes Intervall im Leerlauf, ,,Aufwecken'' wie bei Greedy-Strategien +- Vorhersage: Energiesparmodus sofort nach Erreichen des Leerlaufs, wenn Heuristik vorhersagt,dass Kosten gerechtfertigt +- Stochastisch: Energiesparmodus auf Grundlage eines stochastischen Modells + +Spannungsskalierung (DVS) +- Ziel: Unterstützung von DPM-Strategien durch Maßnahmen auf Ebene von Compiler, Betriebssystem und Applikationen: + - **Compiler** + - kann Informationen zur Betriebssystem-Unterstützung bezüglich Spannungs-Einstellung in Anwendungs-Code einstreuen, + - damit zur Laufzeit Informationen über jeweilige Arbeitslast verfügbar +- **Betriebssystem (prädiktives Energiemanagement)** + - kann Benutzung verschiedener Ressourcen (Prozessor usw.) beobachten + - kann darüber Vorhersagen tätigen + - kann notwendigen Performanzbereich bestimmen +- **Anwendungen** + - können Informationen über jeweils für sie notwendige Performanz liefern +- $\rightarrow$ Kombination mit energieefizientemScheduling! + +## Speichereffizienz +- ... heißt: Auslastung des verfügbaren Speichers + - oft implizit: Hauptspeicherauslastung (memoryfootprint) + - besonders für kleine/mobile Systeme: Hintergrundspeicherauslastung +- Maße zur Konkretisierung: + - zeitliche Dimension: Maximum vs. Summe genutzten Speichers? + - physischer Speicherverwaltung? $\rightarrow$ Belegungsanteil pAR + - virtuelle Speicherverwaltung? $\rightarrow$ Belegungsanteil vAR +- Konsequenzen für Ressourcenverwaltung durch BS: + - Taskverwaltung (Accounting, Multiplexing, Fairness, ...) + - Programmiermodell, API (besonders: dynamische Speicherreservierung) + - Sinnfrage und ggf. Strategien virtueller Speicherverwaltung (VMM) +- Konsequenzen für Betriebssystem selbst: + - minimaler Speicherbedarfdurch Kernel + - minimale Speicherverwaltungskosten (durch obige Aufgaben) + +### Hauptspeicherauslastung +- ![](Assets/AdvancedOperatingSystems-speicherverwaltung.png) + +Problem: externe Fragmentierung +- ![](Assets/AdvancedOperatingSystems-externe-fragmentierung.png) +- Lösungen: + - First Fit, Best Fit, WorstFit, Buddy + - Relokation +- Kompromissloser Weg: kein Multitasking! + +Problem: interne Fragmentierung +- ![](Assets/AdvancedOperatingSystems-interne-fragmentierung.png) +- Lösung: + - Seitenrahmengröße verringern + - Tradeoff: dichter belegte vAR $\rightarrow$ größere Datenstrukturen für Seitentabellen! + +- direkter Einfluss des Betriebssystems auf Hauptspeicherbelegung: + - $\rightarrow$ Speicherbedarf des Kernels + - statische(Minimal-) Größe des Kernels (Anweisungen + Daten) + - dynamischeSpeicherreservierung durch Kernel + - bei Makrokernel: Speicherbedarf von Gerätecontrollern (Treibern)! + +weitere Einflussfaktoren: Speicherverwaltungskosten +- VMM: Seitentabellengröße $\rightarrow$ Mehrstufigkeit +- Metainformationen über laufende Programme: Größe von Taskkontrollblöcken( Prozess-/Threaddeskriptoren ...) +- dynamische Speicherreservierung durch Tasks + +##### Beispiel 1: sparsam +Prozesskontrollblock (PCB, Metadatenstruktur des Prozessdeskriptors) eines kleinen Echtzeit-Kernels (,,DICK''): +```cpp +// Process Control Block (PCB) +struct pcb { + char name[MAXLEN +1]; // process name + proc (*addr)(); // first instruction + int type; // process type + int state; // process state + long dline; // absolute deadline + int period; // period + int prt; // priority + int wcet; // worst-case execution time + float util; // processor utilization + int *context; + proc next; + proc prev; +}; +``` + +##### Beispiel 2: eher nicht sparsam +Linux Prozesskontrollblock (taskstruct): +```cpp +struct task_struct { + volatile long state; /* - 1 unrunnable, 0 runnable, >0 stopped */ + void *stack; + atomic_t usage; + unsigned int flags; /* per process flags, defined below */ + unsigned int ptrace; +#ifdef CONFIG_SMP + struct llist_node wake_entry; + int on_cpu; +#endif + int on_rq; +// SCHEDULING INFORMATION + int prio, static_prio, normal_prio; + unsigned int rt_priority; + const struct sched_class *sched_class; +// Scheduling Entity + struct sched_entity se; + struct sched_rt_entity rt; +#ifdef CONFIG_CGROUP_SCHED + struct task_group *sched_task_group; +#endif +#ifdef CONFIG_PREEMPT_NOTIFIERS + struct hlist_head preempt_notifiers; /* list of struct preempt_notifier */ +#endif + unsigned char fpu_counter; +#ifdef CONFIG_BLK_DEV_IO_TRACE + unsigned int btrace_seq; +#endif + unsigned int policy; + cpumask_t cpus_allowed; +#ifdef CONFIG_PREEMPT_RCU + int rcu_read_lock_nesting; + char rcu_read_unlock_special; + struct list_head rcu_node_entry; + struct rcu_node *rcu_blocked_node; +#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */ +#ifdef CONFIG_RCU_BOOST + struct rt_mutex *rcu_boost_mutex; +#endif /* #ifdef CONFIG_RCU_BOOST */ +#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT) + struct sched_info sched_info; +#endif + struct list_head tasks; +#ifdef CONFIG_SMP + struct plist_node pushable_tasks; +#endif +// virtual address space reference + struct mm_struct *mm, *active_mm; +#ifdef CONFIG_COMPAT_BRK + unsigned brk_randomized:1; +#endif +#if defined(SPLIT_RSS_COUNTING) + struct task_rss_stat rss_stat; +#endif +/* task state */ + int exit_state; + int exit_code, exit_signal; + int pdeath_signal; /* The signal sent when the parent dies */ + unsigned int jobctl; /* JOBCTL_*, siglock protected */ + unsigned int personality; + unsigned did_exec:1; + unsigned in_execve:1;/* Tell the LSMs that the process is doing an * execve */ + unsigned in_iowait:1; +/* Revert to default priority/policy when forking */ + unsigned sched_reset_on_fork:1; + unsigned sched_contributes_to_load:1; +#ifdef CONFIG_GENERIC_HARDIRQS +/* IRQ handler threads */ + unsigned irq_thread; +#endif + pid_t pid; + pid_t tgid; +#ifdef CONFIG_CC_STACKPROTECTOR +/* Canary value for the -fstack-protector gcc feature */ + unsigned long stack_canary; +#endif +// Relatives + struct task_struct __rcu *real_parent; /* real parent process */ + struct task_struct __rcu *parent; /* recipient of SIGCHLD, wait4() reports */ +/* children/sibling forms the list of my natural children */ + struct list_head children; /* list of my children */ + struct list_head sibling; /* linkage in my parent's children list */ + struct task_struct *group_leader; /* threadgroup leader */ + struct list_head ptraced; + struct list_head ptrace_entry; +/* PID/PID hash table linkage. */ + struct pid_link pids[PIDTYPE_MAX]; + struct list_head thread_group; + struct completion *vfork_done; /* for vfork() */ + int __user *set_child_tid; +... + unsigned long timer_slack_ns; + unsigned long default_timer_slack_ns; + struct list_head *scm_work_list; +#ifdef CONFIG_FUNCTION_GRAPH_TRACER +/* Index of current stored address in ret_stack */ + int curr_ret_stack; +/* Stack of return addresses for return function tracing */ + struct ftrace_ret_stack *ret_stack; +/* time stamp for last schedule */ + unsigned long long ftrace_timestamp; +... +``` + +### Hintergrundspeicherauslastung +Einflussfaktoren des Betriebssystems: +- statische Größe des Kernel-Images, welches beim Bootstrapping gelesen wird +- statische Größe von Programm-Images (Standards wie ELF) +- statisches vs. dynamisches Einbinden von Bibliotheken: Größe von Programmdateien +- VMM: Größe des Auslagerungsbereichs (inkl. Teilen der Seitentabelle!) für Anwendungen +- Modularisierung (zur Kompilierzeit) des Kernels: gezielte Anpassung an Einsatzdomäne möglich +- Adaptivität (zur Kompilier-und Laufzeit) des Kernels: gezielte Anpassung an sich ändernde Umgebungsbedingungen möglich ($\rightarrow$ Cassini-Huygens-Mission) + +## Architekturentscheidungen +- bisher betrachtete Mechanismen: allgemein für alle BS gültig +- ... typische Einsatzgebiete sparsamer BS: eingebettete Systeme +- eingebettetes System: (nach [Manl94] ) + - Computersystem, das in ein größeres technisches System, welches nicht zur Datenverarbeitung dient,physisch eingebunden ist. + - Wesentlicher Bestandteil dieses größeren Systems hinsichtlich seiner Entwicklung, technischer Ausstattung sowie seines Betriebs. + - Liefert Ausgaben in Form von (menschenlesbaren)Informationen, (maschinenlesbaren)Daten zur Weiterverarbeitung und Steuersignalen. +- BS für eingebettete Systeme: spezielle, anwendungsspezifische Ausprägung der Aufgaben eines ,,klassischen'' Universal-BS + - reduzierter Umfang von HW-Abstraktion, generell: hardwarenähere Ablaufumgebung + - begrenzte (extrem: gar keine) Notwendigkeit von HW-Multiplexing & -Schutz +- daher eng verwandte NFE: Adaptivitätvon sparsamen BS +- sparsame Betriebssysteme: + - energieeffizient ~ geringe Architekturanforderungen an energieintensive Hardware (besonders CPU, MMU, Netzwerk) + - speichereffizient ~ Auskommen mit kleinen Datenstrukturen (memory footprint) +- Konsequenz: geringe logische Komplexität des Betriebssystemkerns +- sekundär: Adaptivität des Betriebssystemkerns + +### Makrokernel (monolithischer Kernel) +![](Assets/AdvancedOperatingSystems-makrokernel.png) +- User Space: + - Anwendungstasks + - CPU im unprivilegiertenModus (Unix ,,Ringe'' 1...3) + - Isolation von Tasks durch Programmiermodell(z.B. Namespaces) oder VMM(private vAR) +- Kernel Space: + - Kernelund Gerätecontroller (Treiber) + - CPU im privilegierten Modus (Unix ,,Ring'' 0) + - keine Isolation (VMM: Kernel wird in alle vAR eingeblendet) + +### Mikrokernel +![](Assets/AdvancedOperatingSystems-mikrokernel.png) +- User Space: + - Anwendungstasks, Kernel-und Treiber tasks ( Serverprozesse, grau) + - CPU im unprivilegiertenModus + - Isolation von Tasks durch VMM +- Kernel Space: + - funktional minimaler Kernel(μKernel) + - CPU im privilegierten Modus + - keine Isolation (Kernel wird in alle vAR eingeblendet) + +### Architekturkonzepte im Vergleich +- Makrokernel: + - ✓ vglw. geringe Kosten von Kernelcode (Energie, Speicher) + - ✓ VMM nicht zwingend erforderlich + - ✓ Multitasking ($\rightarrow$ Prozessmanagement!)nicht zwingend erforderlich + - ✗ Kernel (inkl. Treibern) jederzeit im Speicher + - ✗ Robustheit, Sicherheit, Adaptivität +- Mikrokernel: + - ✓ Robustheit, Sicherheit, Adaptivität + - ✓ Kernelspeicherbedarf gering, Serverprozesse nur wenn benötigt ($\rightarrow$ Adaptivität) + - ✗ hohe IPC-Kosten von Serverprozessen + - ✗ Kontextwechselkosten von Serverprozessen + - ✗ VMM, Multitasking i.d.R. erforderlich + +## Beispiel-Betriebssysteme +### TinyOS +- Beispiel für sparsame BS im Bereich eingebetteter Systeme +- verbreitete Anwendung: verteilte Sensornetze (WSN) +- ,,TinyOS'' ist ein quelloffenes, BSD-lizenziertes Betriebssystem +- das für drahtlose Geräte mit geringem Stromverbrauch, wie sie in + - Sensornetzwerke, ($\rightarrow$ Smart Dust) + - Allgegenwärtiges Computing, + - Personal Area Networks, + - intelligente Gebäude, + - und intelligente Zähler. +- Architektur: + - grundsätzlich: monolithisch (Makrokernel) mit Besonderheiten: + - keine klare Trennung zwischen der Implementierung von Anwendungen und BS (wohl aber von deren funktionalen Aufgaben!) + - $\rightarrow$ zur Laufzeit: 1 Anwendung + Kernel +- Mechanismen: + - kein Multithreading, keine echte Parallelität + - $\rightarrow$ keine Synchronisation zwischen Tasks + - $\rightarrow$ keine Kontextwechsel bei Taskwechsel + - Multitasking realisiert durch Programmiermodell + - nicht-präemptives FIFO-Scheduling + - kein Paging$\rightarrow$ keine Seitentabellen, keine MMU +- in Zahlen: + - Kernelgröße: 400 Byte + - Kernelimagegröße: 1 - 4 kByte + - Anwendungsgröße: typisch ca. 15 kB, Datenbankanwendung: 64 kB +- Programmiermodell: + - BS und Anwendung werden als Ganzes übersetzt: statische Optimierungen durch Compilermöglich (Laufzeit, Speicherbedarf) + - Nebenläufigkeit durch ereignisbasierte Kommunikation zw. Anwendung und Kernel + - $\rightarrow$ command: API-Aufruf, z.B. EA-Operation (vglb. Systemaufruf) + - $\rightarrow$ event: Reaktion auf diesen durch Anwendung + - sowohl commands als auch events : asynchron +- Beispieldeklaration: + ```cpp + interface Timer { + command result_t start(char type, uint32_t interval); + command result_t stop(); + event result_t fired(); + } + interface SendMsg { + command result_t send(uint16_t address, uint8_t length, TOS_MsgPtr msg); + event result_t sendDone(TOS_MsgPtr msg, result_t success); + } + ``` + +### RIOT +[RIOT-Homepage: http://www.riot-os.org] +- ebenfalls sparsames BS,optimiert für anspruchsvollere Anwendungen (breiteres Spektrum) +- ,,RIOT ist ein Open-Source-Mikrokernel-basiertes Betriebssystem, das speziell für die Anforderungen von Internet-of-Things-Geräten (IoT) und anderen eingebetteten Geräten entwickelt wurde.'' + - Smartdevices, + - intelligentes Zuhause, intelligente Zähler, + - eingebettete Unterhaltungssysteme + - persönliche Gesundheitsgeräte, + - intelligentes Fahren, + - Geräte zur Verfolgung und Überwachung der Logistik. +- Architektur: + - halbwegs: Mikrokernel + - energiesparendeKernelfunktionalität: + - minimale Algorithmenkomplexität + - vereinfachtes Threadkonzept $\rightarrow$ keine Kontextsicherung erforderlich + - keine dynamische Speicherallokation + - energiesparende Hardwarezustände vom Scheduler ausgelöst (inaktive CPU) + - Mikrokerneldesign unterstützt komplementäre NFE: Adaptivität, Erweiterbarkeit + - Kosten: IPC (hier gering!) +- Mechanismen: + - Multithreading-Programmiermodell + - modulare Implementierung von Dateisystemen, Scheduler, Netzwerkstack +- in Zahlen: + - Kernelgröße: 1,5 kByte + - Kernelimagegröße: 5 kByte + +Implementierung +- ... kann sich jeder mal ansehen (keine spezielle Hardware, beliebige Linux-Distribution, FreeBSD, macOSX mit git ): + ```bash + $ git clone git://github.com/RIOT-OS/RIOT.git + $ cd RIOT + $ cd examples/default/ + $ make all + $ make term + ``` +- startet interaktive Instanz von RIOT als ein Prozess des Host-BS +- Verzeichnis RIOT: Quellenzur Kompilierung des Kernels, mitgelieferte Bibliotheken, Gerätetreiber, Beispielanwendungen; z.B.: + - RIOT/core/include/thread.h: Threadmodell, Threaddeskriptor + - RIOT/core/include/sched.h, + - RIOT/core/sched.c: Implementierung des (einfachen) Schedulers +- weitere Infos: riot-os.org/api + + +# Robustheit und Verfügbarkeit +## Motivation +- allgemein: verlässlichkeitskritischeAnwendungsszenarien + - Forschung in garstiger Umwelt + - Weltraumerkundung + - hochsicherheitskritische Systeme: + - Rechenzentren von Finanzdienstleistern + - Rechenzentren von Cloud-Dienstleistern + - hochverfügbare System: + - all das bereits genannte + - öffentliche Infrastruktur(Strom, Fernwärme, ...) + - HPC (high performancecomputing) + +## Allgemeine Begriffe +- Verlässlichkeit, Zuverlässigkeit (dependability) + - übergeordnete Eigenschaft eines Systems [ALRL04] + - Fähigkeit, eine Leistungzu erbringen, der man berechtigterweise vertrauen kann +- Taxonomie: umfasst entsprechend Definition die Untereigenschaften + 1. Verfügbarkeit (availability) + 2. Robustheit (robustness, reliability + 3. (Funktions-) Sicherheit (safety) + 4. Vertraulichkeit (confidentiality) + 5. Integrität (integrity) + 6. Wartbarkeit (maintainability) (vgl.: evolutionäre Eigenschaften) +- 1., 4. & 5. auch Untereigenschaften von IT-Sicherheit (security) +- $\rightarrow$ nicht für alle Anwendungen sind alle Untereigenschaften erforderlich + +### Robustheitsbegriff +- Teil der primären Untereigenschaften von Verlässlichkeit: Robustheit (robustness, reliability) +- Ausfall: beobachtbare Verminderung der Leistung, die ein System tatsächlich erbringt, gegenüber seiner als korrekt spezifizierten Leistung +- Robustheit: Verlässlichkeit unter Anwesenheit externer Ausfälle (= Ausfälle, deren Ursache außerhalb des betrachteten Systems liegt) +- im Folgenden: kurze Systematik der Ausfälle ... + +### Fehler und Ausfälle ... +- Fehler $\rightarrow$ fehlerhafter Zustand $\rightarrow$ Ausfall + - grundlegende Definitionen dieser Begriffe (ausführlich: [ALRL04, AvLR04] ): + - Ausfall (failure): liegt vor, wenn tatsächliche Leistung(en), die ein System erbringt, von als korrekt spezifizierter Leistung abweichen + - fehlerhafter Zustand ( error ): notwendige Ursacheeines Ausfalls (nicht jeder error muss zu failure führen) + - Fehler ( fault ): Ursache für fehlerhaften Systemzustand ( error ), z.B. Programmierfehler + - ![](Assets/AdvancedOperatingSystems-fehler.png) + +### ... und ihre Vermeidung +- Umgang mit ... + - faults: + - Korrektheit testen + - Korrektheit beweisen($\rightarrow$ formale Verifikation) + - errors: + - Maskierung, Redundanz + - Isolationvon Subsystemen + - $\rightarrow$ Isolationsmechanismen + - failures: + - Ausfallverhalten (neben korrektem Verhalten) spezifizieren + - Ausfälle zur Laufzeit erkennen und Folgen beheben, abschwächen... + - $\rightarrow$ Micro-Reboots + +## Fehlerhafter Zustand +- interner und externer Zustand (internal & external state) + - externer Zustand (einer Systems oder Subsystems): der Teil des Gesamtzustands, der an externer Schnittstelle (also für das umgebende (Sub-) System) sichtbar wird + - interner Zustand: restlicher Teilzustand + - (tatsächlich) erbrachte Leistung: zeitliche Folge externer Zustände +- Beispiele für das System ( Betriebssystem-) Kernel : + - Subsysteme: Dateisystem, Scheduler, E/A, IPC, ..., Gerätetreiber + - fault : Programmierfehler im Gerätetreiber + - externer Zustand des Treibers (oder des Dateisystems, Schedulers, E/A, IPC, ...) ⊂ interner Zustand des Kernels + - ![](Assets/AdvancedOperatingSystems-treiber-kernel.png) + +### Fehlerausbreitung und (externer) Ausfall +- Wirkungskette: + -[X] Treiber-Programmierfehler (fault) + -[X] fehlerhafter interner Zustand des Treibers (error) + - Ausbreitung dieses Fehlers ( failure des Treibers) + - = fehlerhafter externer Zustand des Treibers + - = fehlerhafter interner Zustand des Kernels( error ) + - = Kernelausfall!( failure ) + - [X] Auswirkung: fehlerhafter interner Zustand eines weiteren Kernel-Subsystems (z.B. error des Dateisystems) +- $\rightarrow$ Robustheit: Isolationsmechanismen +- ![](Assets/AdvancedOperatingSystems-treiber-kernel-fehler.png) + +## Isolationsmechanismen +- im Folgenden: Isolationsmechanismen für robuste Betriebssysteme + - durch strukturierte Programmierung + - durch Adressraumisolation +- es gibt noch mehr: Isolationsmechanismen für sichere Betriebssysteme + - all die obigen... + - durch kryptografische Hardwareunterstützung: Enclaves + - durch streng typisierte Sprachen und managed code + - durch isolierte Laufzeitumgebungen: Virtualisierung + +### Strukturierte Programmierung +Monolithisches BS... in historischer Reinform: +- Anwendungen +- Kernel + - gesamte BS-Funktionalität + - programmiert als Sammlung von Prozeduren + - jede darf jede davon aufrufen + - keine Modularisierung + - keine definierten internen Schnittstellen + +#### Monolithisches Prinzip +- Ziel: Isolation zwischen Anwendungen und Betriebssystem +- Mechanismus: Prozessor-Privilegierungsebenen ( user space und kernel space ) +- Konsequenz für Strukturierung des Kernels: Es gibt keine Strukturierung des Kernels ... +- ... jedenfalls fast: Ablauf eines Systemaufrufs (Erinnerung) + - ![](Assets/AdvancedOperatingSystems-systemaufruf.png) + +#### Strukturierte Makrokernarchitektur +- Resultat: schwach strukturierter (monolithischer) Makrokernel +- ![](Assets/AdvancedOperatingSystems-makrokernelarchitektur.png) + - nach [TaWo05], S. 45 +- Weiterentwicklung: + - Schichtendifferenzierung ( layered operating system ) + - Modularisierung (Bsp.: Linux-Kernel) + | Kernelcode | + | ------------------------- | + | VFS | + | IPC, Dateisystem | + | Scheduler, VMM | + | Dispatcher, Gerätetreiber | +- Modularer Makrokernel: + - alle Kernelfunktionen in Moduleunterteilt (z.B. verschiedene Dateisystemtypen) $\rightarrow$ Erweiterbarkeit, Wartbarkeit, Portierbarkeit + - klar definierte Modulschnittstellen(z.B. virtualfilesystem, VFS ) + - Module zur Kernellaufzeit dynamisch einbindbar ($\rightarrow$ Adaptivität) + +#### Fehlerausbreitung beim Makrokernel +- strukturierte Programmierung: + - ✓ Wartbarkeit + - ✓ Portierbarkeit + - ✓ Erweiterbarkeit + - O (begrenzt) Adaptivität + - O (begrenzt) Schutz gegen statische Programmierfehler: nur durch Compiler (z.B. C private, public) + - ✗ kein Schutz gegen dynamische Fehler + - $\rightarrow$ Robustheit...? +- nächstes Ziel: Schutz gegen Laufzeitfehler... $\rightarrow$ Laufzeitmechanismen + +### Adressraumisolation +- zur Erinnerung: private virtuelle Adressräume zweier Tasks ($i\not= j$) + - ![](Assets/AdvancedOperatingSystems-private-virtuelle-adressräume.png) +- private virtuelle vs. physischer Adresse + - ![](Assets/AdvancedOperatingSystems-virtuelle-vs-physische-adresse.png) + +#### Private virtuelle Adressräume und Fehlerausbreitung +- korrekte private vAR ~ kollisionsfreie Seitenabbildung! +- Magie in Hardware: MMU (BS steuert und verwaltet...) +- Robustheit: Was haben wir von privaten vAR? + - ✓ nichtvertrauenswürdiger (i.S.v. potenziell nicht korrekter) Code kann keine beliebigen physischen Adressen schreiben (er erreicht sie ja nicht mal...) + - ✓ Kommunikation zwischen nvw. Code (z.B. Anwendungstasks) muss durch IPC-Mechanismen explizit hergestellt werden (u.U. auch shared memory) + - $\rightarrow$ Überwachung und Validierung zur Laufzeit möglich + - ✓ Kontrollfluss begrenzen: Funktionsaufrufe können i.A. (Ausnahme: RPC) keine AR-Grenzen überschreiten + - $\rightarrow$ BS-Zugriffssteuerungkann nicht durch Taskfehler ausgehebelt werden + - $\rightarrow$ unabsichtliche Terminierungsfehler(unendliche Rekursion) erschwert ... + +#### Was das für den Kernel bedeutet +- private virtuelle Adressräume + - gibt es schon so lange wie VMM + - gab es lange nur auf Anwendungsebene + - $\rightarrow$ keine Isolation zwischen Fehlern innerhalb des Kernels! + - ![](Assets/AdvancedOperatingSystems-virtuelle-kernel-adressräume.png) +- nächstes Ziel: Schutz gegen Kernelfehler (Gerätetreiber)... $\rightarrow$ BS-Architektur + +## Mikrokernelarchitektur +- Fortschritt ggü. Makrokernel: + - Strukturierungskonzept: + - strenger durchgesetzt durch konsequente Isolation voneinander unabhängiger Kernel-Subsysteme + - zur Laufzeit durchgesetzt $\rightarrow$ Reaktion auf fehlerhafte Zustände möglich! + - zusätzlich zu vertikaler Strukturierung des Kernels: horizontale Strukturierungeingeführt + - $\rightarrow$ funktionale Einheiten: vertikal (Schichten) + - $\rightarrow$ isolierteEinheiten: horizontal (private vAR) +- Idee: + - Kernel (alle BS-Funktionalität) $\rightarrow$ μKernel (minimale BS-Funktionalität) + - Rest (insbes. Treiber): ,,gewöhnliche'' Anwendungsprozesse mit Adressraumisolation + - Kommunikation: botschaftenbasierteIPC (auch client-server operating system ) + - Nomenklatur: Mikrokernelund Serverprozesse + +### Modularer Makrokernel vs. Mikrokernel +- ![Abb. nach [Heis19]](Assets/AdvancedOperatingSystems-modularer-makrokernel.png) +- minimale Kernelfunktionalität: + - keine Dienste, nur allgemeine Schnittstellenfür diese + - keine Strategien, nur grundlegende Mechanismenzur Ressourcenverwaltung +- neues Problem: minimales Mikrokerneldesign + - ,,Wir haben 100 Leute gefragt...'': Wie entscheide ich das? +- ![Abb. nach [Heis19]](Assets/AdvancedOperatingSystems-modularer-makrokernel-2.png) + - Ablauf eines Systemaufrufs + - schwarz: unprivilegierteInstruktionen + - blau:privilegierte Instruktionen + - rot:Übergang zwischen beidem (μKern $\rightarrow$ Kontextwechsel!) + +#### Robustheit von Mikrokernen +- = Gewinn durch Adressraumisolation innerhalb des Kernels + - ✓ kein nichtvertrauenswürdiger Code im kernelspace , der dort beliebige physische Adressen manipulieren kann + - ✓ Kommunikation zwischen nvw. Code (nicht zur zwischen Anwendungstasks)muss durch IPC explizit hergestellt werden $\rightarrow$ Überwachung und Validierung zur Laufzeit + - ✓ Kontrollfluss begrenzen: Zugriffssteuerung auch zwischen Serverprozessen, zur Laufzeit unabhängiges Teilmanagement von Code (Kernelcode) möglich (z.B.: Nichtterminierung erkennen) +- Neu: + - ✓ nvw. BS-Code muss nicht mehr im kernelspace (höchste Prozessorprivilegierung) laufen + - ✓ verbleibender Kernel (dessen Korrektheit wir annehmen): klein, funktional weniger komplex, leichter zu entwickeln, zu testen, evtl. formal zu verifizieren + - ✓ daneben: Adaptivitätdurch konsequentere Modularisierung des Kernels gesteigert + +### Mach +- Mikrokernel-Design: Erster Versuch + - Carnegie Mellon University (CMU), School of Computer Science 1985 - 1994 +- ein wenig Historie + - UNIX (Bell Labs) - K. Thompson, D. Ritchie + - BSD (U Berkeley) - W. Joy + - System V - W. Joy + - Mach (CMU) - R. Rashid + - MINIX - A. Tanenbaum + - NeXTSTEP (NeXT) - S. Jobs + - Linux - L. Torvalds + - GNU Hurd (FSF) - R. Stallman + - Mac OS X (Apple) - S. Jobs + +#### Mach: Ziele +Entstehung +- Grundlage: + - 1975: Aleph(BS des ,,Rochester Intelligent Gateway''), U Rochester + - 1979/81: Accent (verteiltes BS), CMU +- gefördert durch militärische Geldgeber: + - DARPA: Defense AdvancedResearch Projects Agency + - SCI: Strategic Computing Initiative + +Ziele +- Mach 3.0 (Richard Rashid, 1989): einer der ersten praktisch nutzbaren μKerne +- Ziel: API-Emulation(≠ Virtualisierung!)von UNIX und -Derivaten auf unterschiedlichen Prozessorarchitekturen +- mehrere unterschiedliche Emulatoren gleichzeitig lauffähig + - Emulation außerhalb des Kernels + - jeder Emulator: + - Komponente im Adressraum des Applikationsprogramms + - 1...n Server, die unabhängig von Applikationsprogramm laufen + +Mach-Server zur Emulation +- ![Abb.: [TaBo15]](Assets/AdvancedOperatingSystems-mach-server.png) +- Emulation von UNIX-Systemen mittels Mach-Serverprozessen + +μKernel-Funktionen +1. Prozessverwaltung +2. Speicherverwaltung +3. IPC-und E/A-Dienste, einschließlich Gerätetreiber + +unterstützte Abstraktionen ($\rightarrow$ API, Systemaufrufe): +1. Prozesse +2. Threads +3. Speicherobjekte +4. Ports (generisches, ortstransparentes Adressierungskonzept; vgl. UNIX ,,everything is a file'') +6. Botschaften +7. ... (sekundäre, von den obigen genutzte Abstraktionen) + +Architektur +- ![](Assets/AdvancedOperatingSystems-mach-architektur.png) + +- Systemaufrufkosten: + - IPC-Benchmark (1995): i486 Prozessor, 50 MHz + - Messung mit verschiedenen Botschaftenlängen( x - Werte) + - ohne Nutzdaten (0 Byte Botschaftenlänge): 115 μs (Tendenz unfreundlich ...) + - ![Heis19](Assets/AdvancedOperatingSystems-mach-systemaufruf.png) +- Bewertung aus heutiger Sicht: + - funktional komplex + - 153 Systemaufrufe + - mehrere Schnittstellen, parallele Implementierungen für eine Funktion + - $\rightarrow$ Adaptivität (Auswahl durch Programmierer) +- Fazit: + - zukunftsweisender Ansatz + - langsame und ineffiziente Implementierung + +Lessons Learned +- erster Versuch: + - Idee des Mikrokernelsbekannt + - Umsetzung: Designkriterienweitgehend unbekannt +- Folgen für Performanz und Programmierkomfort: [Heis19] + - ✗ ,,complex'' + - ✗ ,,inflexible'' + - ✗ ,,slow'' +- wir wissen etwas über Kosten: IPC-Performanz, Kernelabstraktionen +- wir wissen noch nichts über guten μKern-Funktionsumfangund gute Schnittstellen... +- $\rightarrow$ nächstes Ziel! + +### L4 +- Made in Germany: + - Jochen Liedtke (GMD, ,,Gesellschaft für Mathematik und Datenverarbeitung''), Betriebssystemgruppe (u.a.): J. Liedtke, H. Härtig, W. E. Kühnhauser + - Symposium on Operating Systems Principles 1995 (SOSP '95): ,,On μ-Kernel Construction'' [Lied95] +- Analyse des Mach-Kernels: + 1. falsche Abstraktionen + 2. unperformanteKernelimplementierung + 3. prozessorunabhängige Implementierung + - Letzteres: effizienzschädliche Eigenschaft eines Mikrokernels + - Neuimplementierung eines (konzeptionell sauberen!) μ-Kerns kaum teurer als Portierung auf andere Prozessorarchitektur + +L3 und L4 +- Mikrokerne der 2. Generation + - zunächst L3, insbesondere Nachfolger L4: erste Mikrokerne der 2. Generation +- vollständige Überarbeitung des Mikrokernkonzepts: wesentliche Probleme der 1. Generation (z.B. Mach) vermieden +- Bsp.: durchschnittliche Performanz von User-Mode IPC in L3 ggü. Mach: Faktor 22 zugunsten L3 + - heute: verschiedene Weiterentwicklungen von L4 (bezeichnet heute Familie ähnlicher Mikrokerne) + + | First generation | Second Generation | Third generation | + | --------------------------------------------------- | ---------------------------------------------------- | --------------------------------------------------- | + | Eg Mach [87] | Eg L4 [95] | seL4 [09] | + | ![](Assets/AdvancedOperatingSystems-l4-first-g.png) | ![](Assets/AdvancedOperatingSystems-L4-second-g.png) | ![](Assets/AdvancedOperatingSystems-l4-third-g.png) | + | 180 syscalls | ~7 syscalls | ~3 syscalls | + | 100 kLOC | ~10 kLOC | 9 kLOC | + | 100 $\mu s$ IPC | ~1 $\mu s$ IPC | $0,2-1 \mu s$ IPC | + +#### Mikrokernel-Designprinzipien +- Was gehört in einen Mikrokern? + - Liedtke: Unterscheidung zwischen Konzepten und deren Implementierung + - bestimmende Anforderungen an beide: + - Konzeptsicht $\rightarrow$ Funktionalität, + - Implementierungssicht $\rightarrow$ Performanz + - $\rightarrow$ 1. μKernel-Generation: Konzept durch Performanzentscheidungen aufgeweicht + - $\rightarrow$ Effekt in der Praxis genau gegenteilig: schlechte (IPC-) Performanz! + +> ,,The determining criterion used is functionality, not performance. More precisely, a concept is tolerated inside the μ-kernel only if moving it outside the kernel, i.e. permitting competing implementations, would prevent the implementation of the systems‘s required functionality .'' [Jochen Liedtke] + +Designprinzipien für Mikrokernel-Konzept: +- $\rightarrow$ Annahmen hinsichtlich der funktionalen Anforderungen: +1. System interaktive und nicht vollständig vertrauenswürdige Applikationen unterstützen ($\rightarrow$ HW-Schutz, -Multiplexing), +2. Hardware mit virtueller Speicherverwaltung und Paging + +Designprinzipien: +1. Autonomie: ,,Ein Subsystem (Server)muss so implementiert werden können, dass es von keinem anderen Subsystem gestört oder korrumpiert werden kann.'' +2. Integrität: ,,Subsystem (Server) $S_1$ muss sich auf Garantien von $S_2$ verlassen können. D.h. beide Subsysteme müssen miteinander kommunizieren können, ohne dass ein drittes Subsystem diese Kommunikation stören, fälschen oder abhören kann.'' + +L4: Speicherabstraktion +- Adressraum: Abbildung, die jede virtuelle Seite auf einen physischen Seitenrahmen abbildet oder als ,,nicht zugreifbar'' markiert +- Implementierung über Seitentabellen, unterstützt durch MMU-Hardware +- Aufgabe des Mikrokernels (als gemeinsame obligatorische Schicht aller Subsysteme): muss Hardware-Konzept des Adressraums verbergen und durch eigenes Adressraum-Konzept überlagern (sonst Implementierung von VMM-Mechanismen durch Server unmöglich) +- Mikrokernel-Konzept des Adressraums: + - muss Implementierung von beliebigen virtuellen Speicherverwaltungs-und -schutzkonzepten oberhalb des Mikrokernels (d.h. in den Subsystemen) erlauben + - sollte einfach und dem Hardware-Konzept ähnlich sein +- Idee: abstrakte Speicherverwaltung + - rekursive Konstruktion und Verwaltung der Adressräume auf Benutzer-(Server-)Ebene + - Mikrokernel stellt dafür genau drei Operationen bereit: + 1. grant(x) - Server $S$ überträgt Seite $x$ seines AR in AR von Empfänger $S‘$ + 2. map(x) - Server $S$ bildet Seite $x$ seines AR in AR von Empfänger $S‘$ ab + 3. flush(x) - Server $S$ entfernt (flusht) Seite x seines AR aus allen fremden AR + +Hierarchische Adressräume +- Rekursive Konstruktion der Adressraumhierarchie + - Server und Anwendungenkönnen damit ihren Klienten Seiten des eigenen Adressraumes zur Verfügung stellen + - Realspeicher: Ur-Adressraum, vom μKernel verwaltet + - Speicherverwaltung(en), Paging usw.: vollständig außerhalb des μ-Kernels realisiert + - ![](Assets/AdvancedOperatingSystems-adressraumhierarchie.png) + +L4: Threadabstraktion +- Thread + - innerhalb eines Adressraumesablaufende Aktivität + - $\rightarrow$ Adressraumzuordnung ist essenziell für Threadkonzept (Code + Daten) + - Bindung an Adressraum: dynamisch oder fest + - Änderung einer dynamischen Zuordnung: darf nur unter vertrauenswürdiger Kontrolle erfolgen (sonst: fremde Adressräume les- und korrumpierbar) +- Designentscheidung + - $\rightarrow$ Autonomieprinzip + - $\rightarrow$ Konsequenz: Adressraumisolation + - $\rightarrow$ entscheidender Grund zur Realisierung des Thread-Konzepts innerhalb des Mikrokernels + +IPC +- Interprozess-Kommunikation + - Kommunikation über Adressraumgrenzen: vertrauenswürdig kontrollierte Aufhebung der Isolation + - $\rightarrow$ essenziell für (sinnvolles) Multitasking und -threading +- Designentscheidung + - $\rightarrow$ Integritätsprinzip + - $\rightarrow$ wir haben schon: vertrauenswürdige Adressraumisolation im μKernel + - $\rightarrow$ grundlegendes IPC-Konzepts innerhalb des Mikrokernels (flexibel und dynamisch durch Server erweiterbar, analog Adressraumhierarchie) + +Identifikatoren +- Thread-und Ressourcenbezeichner + - müssen vertrauenswürdig vergeben (authentisch und i.A. persistent) und verwaltet(eindeutig und korrekt referenzierbar)werden + - $\rightarrow$ essenziell für (sinnvolles) Multitasking und -threading + - $\rightarrow$ essenziell für vertrauenswürdige Kernel-und Server-Schnittstellen +- Designentscheidung + - $\rightarrow$ Integritätsprinzip + - $\rightarrow$ ID-Konzept innerhalb des Mikrokernels (wiederum: durch Server erweiterbar) + +Lessons Learned +1. Ein minimaler Mikrokernel + - soll Minimalmenge an geeigneten Abstraktionenzur Verfügung stellen: + - flexibel genug, um Implementierung beliebiger Betriebssysteme zu ermöglichen + - Nutzung umfangreicher Mengeverschiedener Hardware-Plattformen +2. Geeignete, funktional minimale Mechanismen im μKern: + - Adressraum mit map-, flush-, grant-Operation + - Threadsinklusive IPC + - eindeutige Identifikatoren +3. Wahl der geeigneten Abstraktionen: + - kritischfür Verifizierbarkeit ( $\rightarrow$ Robustheit), Adaptivität und optimierte Performanz des Mikrokerns +4. Bisherigen μ-Kernel-Abstraktionskonzepte: + 1. ungeeignete + 2. zu viele + 3. zu spezialisierte u. inflexible Abstraktionen +5. Konsequenzen für Mikrokernel-Implementierung + - müssen für jeden Prozessortyp neu implementiert werden + - sind deshalb prinzipiell nicht portierbar $\rightarrow$ L3-und L4-Prototypen by J. Liedtke: 99% Assemblercode +6. innerhalb eines Mikrokernels sind + 1. grundlegende Implementierungsentscheidungen + 2. meiste Algorithmen u. Datenstrukturen + - von Prozessorhardware abhängig + +- Fazit: + - Mikrokernelmit akzeptabler Performanz: hardwarespezifische Implementierung minimalerforderlicher, vom Prozessortyp unabhängiger Abstraktionen + - ![Heis19](Assets/AdvancedOperatingSystems-l4-ipc-performance.png) + +Heutige Bedeutung +- nach Tod von J. Liedtke (2001) auf Basis von L4 zahlreiche moderne BS +- L4 heute: Spezifikation eines Mikrokernels (nicht Implementierung) +- ![Heis19](Assets/AdvancedOperatingSystems-l4-family.png) +- Einige Weiterentwicklungen: + - TU Dresden (Hermann Härtig): Neuimplementierung in C++ (L4/Fiasco), Basis des Echtzeit-Betriebssystems DROPS, der VirtualisierungsplattformNOVA (genauer: Hypervisor) und des adaptiven BS-Kernels Fiasco.OC + - University ofNew South Wales (UNSW), Australien (Gernot Heiser): + - Implementierung von L4 auf verschiedenen 64 - Bit-Plattformen, bekannt als L4/MIPS, L4/Alpha + - Implementierung in C (Wartbarkeit, Performanz) + - Mit L4Ka::Pistachio bisher schnellste Implementierung von botschaftenbasierterIPC (2005: 36 Zyklen auf Itanium-Architektur) + - seit 2009: seL4, erster formal verifizierter BS-Kernel (d.h. mathematisch bewiesen, dass Implementierung funktional korrekt ist und nachweislich keinen Entwurfsfehler enthält) + +Zwischenfazit +- Begrenzung von Fehlerausbreitung ( $\rightarrow$ Folgen von errors ): + - konsequent modularisierte Architektur aus Subsystemen + - Isolationsmechanismen zwischen Subsystemen +- Konsequenzen für BS-Kernel: + - statische Isolation auf Quellcodeebene $\rightarrow$ strukturierte Programmierung + - dynamische Isolation zur Laufzeit $\rightarrow$ private virtuelle Adressräume + - Architektur, welche diese Mechanismen komponiert: Mikrokernel +- Was haben wir gewonnen? + - ✓ Adressraumisolation für sämtlichen nichtvertrauenswürdigen Code + - ✓ keine privilegierten Instruktionen in nvw. Code (Serverprozesse) + - ✓ geringe Größe (potenziell: Verifizierbarkeit) des Kernels + - ✓ neben Robustheit: Modularitätund Adaptivitätdes Kernels +- Und was noch nicht? + - ✗ Behandlung von Ausfällen ( $\rightarrow$ abstürzende Gerätetreiber ...) + +## 3.5 Micro-Reboots +- Beobachtungen am Ausfallverhalten von BS: + - Kernelfehler sind (potenziell) fatal für gesamtes System + - Anwendungsfehler sind es nicht + - $\rightarrow$ kleiner Kernel = geringeres Risiko von Systemausfällen + - $\rightarrow$ durch BS-Code in Serverprozessen: verbleibendes Risiko unabhängiger Teilausfälle von BS-Funktionalität (z.B. FS, Treiberprozesse, GUI, ...) +- Ergänzung zu Isolationsmechanismen: + - Mechanismen zur Behandlung von Subsystem-Ausfällen + - = Mechanismen zur Behandlung Anwendungs-, Server- und Gerätetreiberfehlen +- $\rightarrow$ Micro-Reboots + +Ansatz +- wir haben: + - kleinen, ergo vertrauenswürdigen (als fehlerfrei angenommenen)μKernel + - BS-Funktionalität in bedingt vertrauenswürdigen Serverprozessen (kontrollierbare, aber wesentlich größere Codebasis) + - Gerätetreiber und Anwendungen in nicht vertrauenswürdigen Prozessen (nicht kontrollierbare Codebasis) +- wir wollen: + - Systemausfälle verhindern durch Vermeidung von errors im Kernel $\rightarrow$ höchste Priorität + - Treiber-und Serverausfälle minimieren durch Verbergen ihrer Auswirkungen $\rightarrow$ nachgeordnete Priorität (Best-Effort-Prinzip) +- Idee: + - Systemausfälle $\rightarrow$ μKernel + - Treiber-und Serverausfälle $\rightarrow$ Neustart durch spezialisierten Serverprozess + +Beispiel: Ethernet-Treiberausfall +- ![](Assets/AdvancedOperatingSystems-ethernet-treiberausfall.png) +- schwarz: ausfallfreie Kommunikation +- rot: Ausfall und Behandlung +- blau: Wiederherstellung nach Ausfall + +Beispiel: Dateisystem-Serverausfall +- ![](Assets/AdvancedOperatingSystems-dateisystem-serverausfall.png) +- schwarz: ausfallfreie Kommunikation +- rot: Ausfall und Behandlung +- blau: Wiederherstellung nach Ausfall + +## Beispiel-Betriebssystem: MINIX +- Ziele: + - robustes Betriebssystems + - $\rightarrow$ Schutz gegen Sichtbarwerden von Fehlern(= Ausfälle) für Nutzer + - Fokus auf Anwendungsdomänen: Endanwender-Einzelplatzrechner (Desktop, Laptop, Smart*) und eingebettete Systeme + - Anliegen: Robustheit > Verständlichkeit > geringer HW-Bedarf +- aktuelle Version: MINIX 3.3.0 + +Architektur +- Kommunikationsschnittstellen ... + - ![](Assets/AdvancedOperatingSystems-minix-architektur.png) + - ... für Anwendungen (weiß): Systemaufrufe im POSIX-Standard + - ... für Serverprozesse (grau): + - untereinander: IPC (botschaftenbasiert) + - mit Kernel: spezielle MINIX-API (kernel calls), für Anwendungsprozesse gesperrt +- Betriebssystem-Serverprozesse: + - ![](Assets/AdvancedOperatingSystems-minix-architektur-bs.png) + - Dateisystem (FS) + - Prozessmanagement (PM) + - Netzwerkmanagement (Net) + - Reincarnation Server (RS) $\rightarrow$ Micro-Reboots jeglicher Serverprozesse + - (u. a.) ... +- Kernelprozesse: + - systemtask + - clocktask + +Reincarnation Server +- Implementierungstechnik für Micro-Reboots: +- Prozesse zum Systemstart ( $\rightarrow$ Kernel Image): system, clock, init, rs + - system, clock: Kernelprogramm + - init: Bootstrapping (Initialisierung von rs und anderer BS-Serverprozesse), Fork der Login-Shell (und damit sämtlicher Anwendungsprozesse) + - rs: Fork sämtlicher BS-Serverprozesse, einschließlich Gerätetreiber +- ![](Assets/AdvancedOperatingSystems-minix-reincarnation-server.png) + +MINIX: Ausprobieren +- [ausführliche Dokumentation](https://wiki.minix3.org/doku.php?id=www:getting-started:start) +- [vorkompiliertes Kernel-Image zum Installieren (VirtualBox, VMWare, ...)](https://wiki.minix3.org/doku.php?id=www:download:start) + +## Verfügbarkeit +- komplementäre NFE zu Robustheit: Verfügbarkeit ( availability ) + - Zur Erinnerung: Untereigenschaften von Verlässlichkeit + 1. Verfügbarkeit (availability) + 2. Robustheit (robustness, reliability) +- Beziehung: + - Verbesserung von Robustheit $\Rightarrow$ Verbesserung von Verfügbarkeit + - Robustheitsmaßnahmen hinreichend , nicht notwendig (hochverfügbare Systeme können sehr wohl von Ausfällen betroffen sein...) +- eine weitere komplementäre NFE: + - Robustheit $\Rightarrow$ Sicherheit (security) + +Allgemeine Definition: Der Grad, zu welchem ein System oder eine Komponente funktionsfähig und zugänglich (erreichbar) ist,wann immer seine Nutzung erforderlichist. (IEEE) + +genauer quantifiziert: +- Der Anteil an Laufzeit eines Systems, in dem dieses seine spezifizierte Leistung erbringt. +- ![](Assets/AdvancedOperatingSystems-verfügbarkeit-laufzeit.png) +- Availability= Total Uptime/ Total Lifetime= MTTF / (MTTF + MTTR) + - MTTR: Mean Time to Recovery ... Erwartungswert für TTR + - MTTF: Mean Time to Failure ... Erwartungswert für TTF +- einige Verfügbarkeitsklassen: + | Verfügbarkeit | Ausfallzeit pro Jahr | Ausfallzeit pro Woche | + | ------------- | -------------------- | --------------------- | + | 90% | > 1 Monat | ca. 17 Stunden | + | 99% | ca. 4 Tage | ca. 2 Stunden | + | 99,9% | ca. 9 Stunden | ca. 10 Minuten | + | 99,99% | ca. 1 Stunde | ca. 1 Minute | + | 99,999% | ca. 5 Minuten | ca. 6 Sekunden | + | 99,9999% | ca. 2 Sekunden | << 1 Sekunde | +- Hochverfügbarkeitsbereich (gefeierte ,,five nines'' availability) +- Maßnahmen: + - Robustheitsmaßnahmen + - Redundanz + - Ausfallmanagement + +### QNX Neutrino: Hochverfügbares Echtzeit-BS +Überblick QNX: +- Mikrokern-Betriebssystem +- primäres Einsatzfeld: eingebettete Systeme, z.B. Automobilbau +- Mikrokernarchitektur mit Adressraumisolation für Gerätetreiber +- (begrenzt) dynamische Micro-Rebootsmöglich +- $\rightarrow$ Maximierung der Uptime des Gesamtsystems + +Hochverfügbarkeitsmechanismen: +1. ,,High-Avalability-Manager'': Laufzeit-Monitor, der Systemdienste oder Anwendungsprozesse überwacht und neustartet $\rightarrow$ μReboot-Server +2. ,,High-Availability-Client-Libraries'': Funktionen zur transparenten automatischen Reboot für ausgefallene Server-Verbindungen + +# Sicherheit + +## Motivation +Medienberichte zu IT-Sicherheitsvorfällen: +- 27.-28.11.2016: Ausfälle von über 900.000 Kundenanschlüssen der Deutschen Telekom + - Bundesamt für Sicherheit in der Informationstechnik (BSI): weltweiter Angriff auf ausgewählte Fernverwaltungsports von DSL-Routern, um angegriffene Geräte mit Schadsoftware zu infizieren + - Angreiferziel: Missbrauch der Hardware für eigentliche Angriffe (Botnet) +- 15.05.-06.06.2019: Ransomware-Angriff zur Erpressung der Heise Verlagsgruppe + - Infektion eines Rechners im lokalen Netz durch Malware in eMail-Anhang (Trojaner) + - Täuschung des Nutzers: Schadcode mit Administratorrechten ausgeführt (Spezialfall von Malware: _Root Kit_) + - Malwareziel: Verschlüsselungvon Nutzerdaten + - Angreiferziel: Erspressungvon Lösegeld für Entschlüsselung + +Was sichere Betriebssysteme erreichen können ... und was nicht: [youtube](https://www.youtube.com/watch?v=opRMrEfAIiI&t=) + +## Terminologie +Achtung zwei unterschiedliche ,,Sicherheiten'' + +1. Security (IT-Sicherheit, Informationssicherheit) + - Ziel: Schutz **des** Rechnersystems + - hier besprochen + - Systemsicherheit +2. Safety (Funktionale Sicherheit, Betriebssicherheit) + - Ziel: Schutz **vor** einem Rechnersystem + - an dieser Stelle nicht besprochen + +Eine (unvollständige) Taxonomie: +- ![](Assets/AdvancedOperatingSystems-sicherheit-taxonomie.png) + +## Sicherheitsziele +Allgemeines Ziel von IT-Sicherheit i.S.v. Security ... + ein Rechnersystem sicher zu machen gegen Schäden durch zielgerichtete Angriffe, insbesondere in Bezug auf die Informationen, die in solchen Systemen gespeichert, verarbeitet und übertragen werden. (Programme sind somit ebenfalls als Informationen zu verstehen.) + +Cave! Insbesondere für Sicherheitsziele gilt: Daten $\not=$ Informationen + +Sicherheitsziele: sukzessive Konkretisierungen dieser Allgemeinformel hinsichtlich anwendungsspezifischer Anforderungen + +##### Abstrakte Ziele: +1. Vertraulichkeit (Confidentiality) +2. Integrität (Integrity) +3. Verfügbarkeit (Availability) +4. Authentizität (Authenticity) +5. Verbindlichkeit = Nichtabstreitbarkeit (Non-repudiability) + +Abstrakte Ziele dienen zur Ableitung konkreter Sicherheitsziele. Wir definieren sie als Eigenschaften von gespeicherten oder übertragenen Informationen ... +- Vertraulichkeit: ... nur für einen autorisierten Nutzerkreis zugänglich (i.S.v. interpretierbar) zu sein. +- Integrität: ... vor nicht autorisierter Veränderung geschützt zu sein. +- Verfügbarkeit: ... autorisierten Nutzern in angemessener Frist zugänglich zu sein. +- Authentizität: ... ihren Urheber eindeutig erkennen zu können. +- Verbindlichkeit: ... sowohl integer als auch authentisch zu sein. + +##### Schadenspotenzial +1. Vandalismus, Terrorismus + - reine Zerstörungswut +2. Systemmissbrauch + - illegitime Ressourcennutzung, Ziel i.d.R.: hocheffektive Folgeangriffe + - Manipulationvon Inhalten ($\rightarrow$ Desinformation) +3. (Wirtschafts-) Spionage und Diebstahl + - Verlust der Kontrolle über kritisches Wissen ($\rightarrow$ Risikotechnologien) + - immense wirtschaftliche Schäden ($\rightarrow$ Technologieführer, Patentinhaber) + - z.B. Diebstahl von industriellem Know-How +4. Betrug, persönliche Bereicherung + - wirtschaftliche Schäden +5. Sabotage, Erpressung + - Außerkraftsetzen lebenswichtiger Infrastruktur (z.B. schon Registrierkassen) + - Erpressung von ausgewählten (oder schlicht großen ) Zielgruppen durch vollendete, reversible Sabotage ($\rightarrow$ Verschlüsselung von Endanwenderinformationen) + +##### Bedrohungen +1. Eindringlinge (intruders) + - im engeren Sinne menschliche Angreifer ( ,,Hacker'' ), deren Angriff eine technische Schwachstelleausnutzt ( exploit ) +2. Schadsoftware (malicious software, malware) + - durch Ausnutzung einer (auch menschlichen) Schwachstelle zur Ausführung gebrachte Programme, die (teil-) automatisierte Angriffe durchführen + - Trojanische Pferde (trojan horses): scheinbar nützliche Software, die verborgene Angriffsfunktionalität enthält + - Viren, Würmer (viruses, worms): Schadsoftware, die Funktionalität zur eigenen Vervielfältigung und/oder Modifikation beinhaltet + - Logische Bomben (logicbombs): Code-Sequenz in trojanischen Pferden, deren Aktivierung an System-oder Datumsereignisse gebunden ist + - Root Kits +3. Bots und Botnets + - (weit-) verteilt ausgeführte Schadsoftware + - eigentliches Ziel i.d.R. nicht das jeweils infizierte System + +##### Professionelle Malware: Root Kit +- Programm-Paket, das unbemerkt Betriebssystem (und ausgewählte Anwendungen) modifiziert, um Administratorrechte zu erlangen + - Administrator-bzw. Rootrechte: ermöglichen Zugriff auf alle Funktionen und Dienste eines Betriebssystems + - Angreifer erlangt vollständige Kontrolle des Systems und kann + - Dateien (Programme) hinzufügen bzw. ändern + - Prozesse überwachen + - über die Netzverbindungen senden und empfangen + - bei all dem Hintertüren für Durchführung und Verschleierung zukünftiger Angriffe platziere + - Ziele eines Rootkits: + - seine Existenz verbergen + - zu verbergen, welche Veränderungen vorgenommen wurden + - vollständige und irreversible Kontrolle über BS zu erlangen +- Ein erfolgreicher Root-Kit-Angriff ... + - ... kann jederzeit + - ... mit hochaktuellem und systemspezifischem Wissen über Schwachstellen + - ... vollautomatisiert, also reaktiv unverhinderbar + - ... unentdeckbar + - ... nicht reversibel + - ... die uneingeschränkte Kontrolle über das Zielsystem erlangen. +- Voraussetzung: eine einzige Schwachstelle... + +##### Schwachstellen +1. Passwort (begehrt: Administrator-Passwörter...) + - ,,erraten'' + - zu einfach, zu kurz, usw. + - Brute-Force-Angriffe mit Rechnerunterstützung + - Abfangen ( eavesdropping ) + - unverschlüsselte Übertragung (verteilte Systeme) oder Speicherung +2. Programmierfehler (Speicherfehler...!) + - im Anwenderprogrammen + - in Gerätemanagern + - im Betriebssystem +3. Mangelhafte Robustheit + - keine Korrektur fehlerhafter Eingaben + - buffer overrun/underrun (,, Heartbleed'' ) +4. Nichttechnische Schwachstellen + - physisch, organisatorisch, infrastrukturell + - menschlich ($\rightarrow$ Erpressung, socialengineering ) + +##### Zwischenfazit +- Schwachstellen sind unvermeidbar +- Bedrohungen sind unkontrollierbar + - ... und nehmen tendeziellzu! + +Beides führt zu operationellen Risiken beim Betrieb eines IT-Systems + +$\rightarrow$ Aufgabe der Betriebssystemsicherheit: Auswirkungen operationeller Risiken reduzieren (wo diese nicht vermieden werden können...) + +Wie dies geht: Security Engineering + +## Sicherheitspolitiken +- Herausforderung: korrekte Durchsetzung von Sicherheitspolitiken +- Vorgehensweise: Security Engineering + +| | +| ---------------------- | ----------------------------------------------------------------------------------------- | +| Sicherheitsziele | Welche Sicherheitsanforderungen muss das Betriebssystem erfüllen? | +| Sicherheitspolitik | Durch welche Strategien soll es diese erfüllen? ($\rightarrow$ Regelwerk) | +| Sicherheitsmechanismen | Wie implementiert das Betriebssystem seine Sicherheitspolitik? | +| Sicherheitsarchitektur | Wo implementiert das Betriebssystem seine Sicherheitsmechanismen (und deren Interaktion)? | + +##### Sicherheitspolitiken und -modelle +Kritischfür korrekten Entwurf, Spezifikation, Implementierung der Betriebssystem-Sicherheitseigenschaften! + +Begriffsdefinitionen: +- Sicherheitspolitik (Security Policy): Eine Menge von Regeln, die zum Erreichen eines Sicherheitsziels dienen. +- Sicherheitsmodell (Security Model): Die formale Darstellung einer Sicherheitspolitik zum Zweck + - der Verifikation ihrer Korrektheit + - der Spezifikation ihrer Implementierung. + +##### Zugriffssteuerungspolitiken +... geben Regeln vor, welche durch Zugriffssteuerungsmechanismen in BS durchgesetzt werden müssen. + +Zugriffssteuerung (access control): Steuerung, welcher Nutzer oder Prozess mittels welcher Operationen auf welche BS-Ressourcen zugreifen darf (z.B.: Anwender darf Textdateien anlegen, Administrator darf Dateisysteme montieren und System-Logdateien löschen, systemd - Prozess darf Prozessdeskriptoren manipulieren, ...) + +Zugriffssteuerungspolitik: konkrete Regeln, welche die Zugriffssteuerung in einem BS beschreiben + +Zugriffssteuerungsmodell: Sicherheitsmodell einer Zugriffssteuerungspolitik + +Zugriffssteuerungsmechanismus: Implementierung einer Zugriffssteuerungspolitik + +##### Beispiele für BS-Zugriffssteuerungspolitiken +klassifiziert nach Semantik der Politikregeln: +- IBAC (Identity-basedAccess Control): Politik spezifiziert, welcher Nutzer an welchen Ressourcen bestimmte Rechte hat. + - Bsp.: ,,Nutzer Anna darf Brief.docx lesen, aber nicht schreiben.'' +- TE (Type-Enforcement): Politik spezifiziert Rechte durch zusätzliche Abstraktion (Typen): welcher Nutzertyp an welchem Ressourcentyp bestimmte Rechte hat. + - Bsp.: ,,Nutzer vom Typ Administrator dürfen Dateien vom Typ Log lesen und schreiben.'' +- MLS (Multi-Level Security): Politik spezifiziert Rechte, indem aus Nutzern und Ressourcen hierarchische Klassen (Ebenen, ,,Levels'') gleicher Kritikalität im Hinblick auf Sicherheitsziele gebildet werden. + - Bsp.: ,,Nutzer der Klasse nicht vertrauenswürdig dürfen Dateien der Klasse vertraulich nicht lesen.'' +- DAC (Discretionary Access Control, auch: wahlfreie Zugriffssteuerung ): Aktionen der Nutzer setzen die Sicherheitspolitik (oder wesentliche Teile davon) durch. Typisch: Begriff des Eigentümers von BS-Ressourcen. + - Bsp.: ,,Der Eigentümer einer Datei bestimmt (bzw. ändert), welcher Nutzer welche Rechte daran hat.'' +- MAC (MandatoryAccess Control, auch: obligatorische Zugriffssteuerung ): Keine Beteiligung der Nutzer an der Durchsetzungeiner (zentral administrierten) Sicherheitspolitik. + - Bsp.: ,,Anhand ihres Dateisystempfads bestimmt das Betriebssystem, welcher Nutzer welche Rechte an einer Datei hat.'' + +##### Einige Beispiele ... +| | DAC | MAC | +| ---- | ----------------------- | -------------------------------------- | +| IBAC | Unixoide,Linux, Windows | Linux AppArmor, Mac OS Seatbelt | +| TE | - | SELinuxEnterprise Linux (RHEL), RedHat | +| MLS | Windows UAC | SELinux, TrustedBSD | + +... und ein Verdacht +Eindruck der Effektivität von DAC: ,,[...] so the theory goes. By extension, yes, there may be less malware, but that will depend on whether users keep UAC enabled, which depends on whether developers write software that works with it and that users stop viewing prompts as fast-clicking exercises and actually consider whether an elevation request is legitimate.'' (Jesper M. Johansson, TechNet Magazine) +[https://technet.microsoft.com/en-us/library/2007.09.securitywatch.aspx, Stand: 10.11.2017] + +### Traditionell: DAC, IBAC +Auszug aus der Unix-Sicherheitspolitik: +- es gibt Subjekte (Nutzer, Prozesse) und Objekte (Dateien, Sockets ...) +- jedes Objekt hat einen Eigentümer +- Eigentümer legen Zugriffsrechte an Objekten fest ($\rightarrow$ DAC) +- es gibt drei Zugriffsrechte: read, write, execute +- je Objekt gibt es drei Klassen von Subjekten, für die individuell Zugriffsrechte vergeben werden können: Eigentümer (,,u''), Gruppe (,,g''), Rest der Welt (,,o'') + +In der Praxis: +- identitätsbasierte (IBAC), wahlfreie Zugriffssteuerung (DAC) +- hohe individuelle Freiheit der Nutzer bei Durchsetzung der Politik +- hohe Verantwortung ( ,,Welche Nutzer werden jemals in Gruppe vsbs sein...?'' ) + +```bash +-rw- rw- r-- 1 amthor vsbs 397032 2017-11-19 12:12 paper.pdf +``` + +##### Modellierung: Zugriffsmatrix +| acm | paper.pdf | aos-05.pptx | gutachten.tex | worse-engine | +| ---------- | --------- | ----------- | ------------- | ------------ | +| kühnhauser | rw | - | rw | rx | +| schlegel | rw | - | - | rx | +| amthor | rw | rw | - | rx | +| krause | r | - | - | - | + +- acm (access control matrix): Momentaufnahme der globalen Rechteverteilung zu einem definierten ,,Zeitpunkt t'' +- Korrektheitskriterium: Wie kann sich dies nach t möglicherweise ändern...? (HRU-Sicherheitsmodell)[HaRU76] + +##### Modellkorrektheit: Rechteausbreitung +- Änderungsbeispiel: kühnhauser nimmt krause in Gruppe vsbs auf ... +- Rechteausbreitung ( privilegeescalation ), hier verursacht durch eine legale Nutzeraktion ($\rightarrow$ DAC) + - (Sicherheitseigenschaft: HRU Safety , $\rightarrow$ ,,Systemsicherheit'') + +### Modern: MAC, MLS +Sicherheitspolitik der Windows UAC ( user account control): +- es gibt Subjekte (Prozesse) und Objekte (Dateisystemknoten) +- jedem Subjekt ist eine Integritätsklasse zugewiesen: + - Low: nicht vertrauenswürdig (z.B. Prozesse aus ausführbaren Downloads) + - Medium: reguläre Nutzerprozesse, die ausschließlich Nutzerdaten manipulieren + - High: Administratorprozesse, die Systemdaten manipulieren können + - System: (Hintergrund-) Prozesse, die ausschließlich Betriebssystemdienste auf Anwenderebene implementieren (etwa der Login-Manager) +- jedem Objekt ist analog eine dieser Integritätsklassen zugewiesen (Kritikalität von z.B. Nutzerdaten vs. Systemdaten) +- sämtliche DAC-Zugriffsrechte (die gibt es auch) müssen mit einer Hierarchie der Integritätsklassen konsistent sein ($\rightarrow$ ein bisschen MAC) +- Nutzer können diese Konsistenzanforderung selektiv außer Kraft setzen ($\rightarrow$ DAC) + +##### MAC-Modellierung: Klassenhierarchie +Beispiel: Modelliert durch Relation $\leq$: gleich oder kritischer als + +$\leq=\{( High , Medium ), ( High , Low ), ( Medium , Low ), ( High , High ), ( Medium , Medium ), ( Low , Low )\}$ +- repräsentiert Kritikalität hinsichtlich des Sicherheitsziels Integrität (Biba-Sicherheitsmodell) [Biba77] +- wird genutzt, um legale Informationsflüsse zwischen Subjekten und Objekten zu modellieren $\rightarrow$ Schutz vor illegalem Überschreiben +- leitet Zugriffsrechte aus Informationsflüssen ab: + - Prozess Datei: schreiben + - Prozess Datei: lesen + +##### DAC-Modellierung: Zugriffsmatrix +![](Assets/AdvancedOperatingSystems-dac-zugriffsmatrix.png) + +##### Modellkorrektheit: Konsistenz +- Korrektheitskriterium: Garantiert die Politik, dass acm mit $\leq$ jederzeit konsistent ist? ( BLP Security ) [BeLa76] +- elevation-Mechanismus: verändert nach Nutzeranfrage ($\rightarrow$ DAC) sowohl acm als auch $\leq\rightarrow$ konsistenzerhaltend? +- andere BS-Operationen: verändern unmittelbar nur acm (z.B. mittels Dateisystemmanagement) $\rightarrow$ konsistenzerhaltend? + +## Autorisierungsmechanismen +Begriffsdefinitionen: +- Sicherheitsmechanismen: Datenstrukturen und Algorithmen, welche die Sicherheitseigenschaften eines Betriebssystems implementieren. + - $\rightarrow$ Sicherheitsmechanismen benötigt man zur Herstellung jeglicher Sicherheitseigenschaften (auch jener, die in unseren Modellen implizit angenommen werden!) + - Nutzerauthentisierung ( login - Dientsprogramm, Passwort-Hashing, ...) + - Autorisierungsinformationen (Metainformationen über Rechte, MLS-Klassen, TE-Typen, ...) + - Autorisierungsmechanismen (Rechteprüfung, Politikadministration, ...) + - kryptografische Mechanismen (Verschlüsselungsalgorithmen, Hashfunktionen, ...) +- Auswahl im Folgenden: Autorisierungsmechanismen und -informationen + +### Traditionell: ACLs, SUID +Autorisierungsinformationen: +- müssen Subjekte (Nutzer) bzw. Objekte (Dateien, Sockets ...) mit Rechten assoziieren $\rightarrow$ Implementierung der Zugriffsmatrix ( acm ), diese ist: + - groß ($\rightarrow$ Dateianzahl auf Fileserver) + - dünn besetzt + - in Größe und Inhalt dynamisch veränderlich + - $\rightarrow$ effiziente Datenstruktur? +- Lösung: verteilte Implementierung der acm als Spaltenvektoren, deren Inhalt in den Objekt-Metadaten repräsentiert wird: Zugriffssteuerungslisten ( Access Control Lists , ACLs) + +##### ACLs: Linux-Implementierung +- objektspezifischer Spaltenvektor = Zugriffssteuerungsliste +- Dateisystem-Metainformationen: implementiert in I-Nodes +```bash +-rw- rw- r-- 1 amthor vsbs 397032 2017-11-19 12:12 paper.pdf +``` + +#### ACLs: Linux-Implementierung +Modell einer Unix acm ... +| | lesen | schreiben | ausführen | +| --------------------- | ----- | --------- | --------- | +| Eigentümer (,,u'') | ja | ja | ja | +| Rest der Welt (,,o'') | ja | nein | ja | +| Gruppe (,,g'') | ja | nein | ja | + +- 3 - elementige Liste +- 3 - elementige Rechtemenge +- $\rightarrow$ 9 Bits +- dessen Implementierung kodiert in 16-Bit-Wort: 1 1 1 1 0 1 1 0 1 +- ... und dessen Visualisierung in Linux: + +```bash +$ ls -alF +drwxr-xr-x 2 amthor amthor 4096 2017-11-16 12:01 ./ +drwxr-xr-x 31 amthor amthor 4096 2017-11-07 12:42 ../ +-rw-rw-r-- 1 amthor vsbs 397032 2017-11-19 12:12 paper.pdf +-rw------- 1 amthor amthor 120064 2017-02-07 07:56 draft.tex +``` + +##### Autorisierungsmechanismen: ACL-Auswertung +Subjekte = Nutzermenge eines Linux-Systems... besteht aus Anzahl registrierter Nutzer +- jeder hat eindeutige UID (userID), z.B. integer- Zahl +- Dateien, Prozesse und andere Ressourcenwerden mit UID des Eigentümersversehen + - bei Dateien: Teil des I-Nodes + - bei Prozessen: Teil des PCB (vgl. Grundlagen ,,Betriebssysteme'') + - standardmäßiger Eigentümer: derjenige, eine Ressource erzeugt hat + +Nutzergruppen (groups) +- jeder Nutzer wird durch Eintrag in einer Systemdatei ( /etc/group ) einer oder mehreren Gruppen zugeordnet($\rightarrow$ ACL: ,, g '' Rechte) + +Superuser oder root... hat grundsätzlich uneingeschränkte Rechte. +- UID = 0 +- darf insbesondere alle Dateien im System lesen, schreiben, ausführen; unabhängig von ACL + +##### ACL-Implementierung +- ACLs: + - in welchen Kerneloperationen? + - welche Kernelschnittstellen (Rechte prüfen, ändern)? + - welche Datenstrukturen, wo gespeichert? +- acm und ACLs: + - Vorteile der Listenimplementierung? + - Nachteile ggü. zentral implementierter Matrix? (DAC vs. MAC, Administration, Analyse ...) +- $\rightarrow$ Übung 2 + +##### Nutzerrechte $\rightarrow$ Prozessrechte +bisher: Linux-Sicherheitspolitik formuliert Nutzerrechte an Dateien (verteilt gespeichert in ACLs) + +Durchsetzung: basiert auf Prozessrechten +- Annahme: Prozesse laufen mit UID des Nutzers, welcher sie gestartet hat und repräsentieren Nutzerintention und Nutzerberechtigungen i.S.d. Sicherheitspolitik +- technisch bedeutet dies: ein Nutzer beauftragt einen anderen Prozess, sich zu dublizieren( fork() ) und das gewünschte Programm auszuführen ( exec*() ) +- Vererbungsprinzip: ![](Assets/AdvancedOperatingSystems-acl-vererbungsprinzip.png) + +##### Autorisierungsmechanismen: Set-UID +konsequente Rechtevererbung: +- Nutzer können im Rahmen der DAC-Politik ACLs manipulieren +- Nutzer können (i.A.) jedoch keine Prozess-UIDs manipulieren +- $\rightarrow$ und genau so sollte es gem. Unix-Sicherheitspolitik auch sein! + +Hintergrund: +- Unix-Philosophie ,, everythingisa file '': BS-Ressourcen wie Sockets, IPC-Instanzen, E/A-Gerätehandler als Datei repräsentiert $\rightarrow$ identische Schutzmechanismen zum regulären Dateisystem +- somit: Autorisierungsmechanismen zur Begrenzung des Zugriffs auf solche Geräte nutzbar (Bsp.: Zugriffe verschiedener Prozesse auf einem Drucker müssen koordiniert, ggf. eingeschränkt werden) +- dazu muss + - _root_ bzw. zweckgebundener Nutzer Eigentümer des Druckers sein + - ACL als `rw- --- ---` gesetzt sein + +Folge: +- Nutzerprozesse könnten z.B. nicht drucken ... + +Lösung: Mechanismus zur Rechtedelegation +- implementiert durch ein weiteres ,,Recht'' in ACL: SUID-Bit (,, setUID'' ) +- Programmausführung modifiziert Kindprozess, so dass UID des Programmeigentümers (im Bsp.: root ) seine Rechte bestimmt +- Technik: eine von UID abweichende Prozess-Metainformation ($\rightarrow$ PCB) effektive UID (eUID) wird tatsächlich zur Autorisierung genutzt +- `-rws rws r-x 1 root root 2 2011-10-01 16:00 print` + +Strategie für sicherheitskritische Linux-Programme +- Eigentümer: root +- SUID-Bit: gesetzt +- per eUID delegiert root seine Rechte an genau solche Kindprozesse, die SUID-Programme ausführen +- Folge: Nutzerprozesse können Systemprogramme (und nur diese) ohne permanente root - Rechte ausführen + +Weiteres Beispiel: passwd +- ermöglicht Nutzern Ändern des (eigenen) Anmeldepassworts +- Schreibzugriff auf /etc/shadow (Password-Hashes) erforderlich ... Schutz der Integrität anderer Nutzerpasswörter? +- Lösung: `-rws rws r-x 1 root root 1 2005-01-20 10:00 passwd$ +- passwd - Programm (und nur dieses!) wird mit root-Rechten ausgeführt ()... und passwd schreibt ja nur unseren eigenen Passwort-Hash) + +##### Beispiel passwd +- Problem: privilegierter Zugriff durch unprivilegierte Anwendung + - ![](Assets/AdvancedOperatingSystems-passwd-problem.png) +- Standard Linux Lösung: + - ![](Assets/AdvancedOperatingSystems-passwd-lösung.png) + +### Modern: SELinux +- Ursprung + - Anfang 2000er Jahre: sicherheitsfokussiertes Betriebssystemprojekt für US-amerikanische NSA [LoSm01] + - Implementierung des (eigentlich)μKernel-Architekturkonzepts Flask + - heute: Open Source, Teil des mainline Linux Kernels +- Klassische UNIXoide: Sicherheitspolitik fest im Kernel implementiert + - I-Nodes, PCBs, ACLs, UID, GID, SUID, ... +- Idee SELinux: Sicherheitspolitikals eigene BS-Abstraktion + - zentrale Datenstruktur für Regeln, die erlaubte Zugriffe auf ein SELinux-System definiert + - erlaubt Modifikation und Anpassung an verschiedene Sicherheitsanforderungen $\rightarrow$ NFE Adaptivität ... + +##### SELinux-Sicherheitsmechanismen +BS-Komponenten +- Auswertung der Sicherheitspolitik: Security- Server , implementiert als Linux-Kernelmodul(Technik: LSM, Linux Security Module ); $\rightarrow$ entscheidet über alle Zugriffe auf alle Objekte +- Durchsetzung der Sicherheitspolitik : LSM Hooks (generische Anfrage-Schnittstellen in allen BS-Funktionen) +- Administration der Sicherheitspolitik: geschrieben in Textform, muss zur Laufzeit in Security Server installiert werden + +![Schematisch: Security Server und Sicherheitspolitik](Assets/AdvancedOperatingSystems-selinux-security-server.png) + +![Schematisch: Installation der Sicherheitspolitik](Assets/AdvancedOperatingSystems-selinux-sicherheitspolitik-installieren.png) + +##### SELinux-Sicherheitspolitik +Repräsentation der Sicherheitspolitik: +- physisch: in spezieller Datei, die alle Regeln enthält (in maschinenlesbarer Binärdarstellung), die der Kernel durchsetzen muss +- diese Datei wird aus Menge von Quelldateien in einer Spezifikationssprache für SELinux-Sicherheitspolitiken kompiliert +- diese ermöglicht anforderungsspezifische SELinux-Politiken: können (und müssen) sich von einem SELinux-System zum anderen wesentlich unterscheiden +- Politik wird während des Boot-Vorgangs in Kernel geladen + +##### Politiksemantik +Regeln einer SELinux-Sicherheitspolitiken, Semantische Konzepte(Auswahl): +- Type Enforcement (TE) +- Typisierung von + - Subjekten: Prozesse + - Objekten der Klassen: Dateien, Sockets, EA-Geräteschnittstellen, ... +- Rechte delegation durch Retypisierung(vgl. Unix-SUID!) +- ![](Assets/AdvancedOperatingSystems-selinux-retypisierung.png) + +##### Autorisierungsinformationen +Security Context: Respräsentiert SELinux-Autorisierungsinformationen für jedes Objekt: +```bash +$ ps -Z +cox:doctor_r:shell_t:s0-s0:c0.c255 4056 pts/2 00:00:00 bash +$ ls -Z /etc/shadow +system_u:object_r:shadow_t:s0 /etc/shadow +``` +- Semantik: + - Prozess bash läuft (momentan) mit Typ `shell_t` + - Datei shadow hat (momentan) den Typen `shadow_t`. + + +##### Autorisierungsregeln +... werden systemweit festgelegt in dessen Sicherheitspolitik ($\rightarrow$ MAC): + +Access Vector Rules +- definieren Autorisierungsregeln basierend auf Subjek-/Objekttypen +- Zugriffe müssen explizit gewährt werden ( default-deny ) + ```bash + allow shell_t passwd_exec_t : file { execute }; + allow passwd_t shadow_t : file { read write }; + ``` +- Semantik: Erlaube( ''allow'' ) ... + - jedem Prozess mit Typ `shell_t` + - ausführenden Zugriff (benötigt die Berechtigung `{execute}`), + - auf Dateien (also Objekte der Klassefile) + - mit Typ `passwd_exec_t`. + +##### Autorisierungsmechanismen: passwd Revisited +Klassischer Anwendungsfall für SELinux-TE: Passwort ändern + +Lösung: Retypisierung bei Ausführung +- Prozess wechselt in einen aufgabenspezifischen Typ `passwd_t` +- $\rightarrow$ massiv verringertes Missbrauchspotenzial! +- ![](Assets/AdvancedOperatingSystems-passwd-lösung2.png) + +##### SELinux: weitere Politiksemantiken +- hier nur gezeigt: Überblick über TE +- außerdem relevant für SELinux-Politiken (und deren Administration...): + - Einschränkung von erlaubten Typtransitionen (Welches Programm darf mit welchem Typ ausgeführt werden?) + - weitere Abstraktionsschicht: rollenbasierte Regeln (RBAC) + - $\rightarrow$ Schutz gegen nicht vertrauenswürdige Nutzer (vs. nvw. Software) +- Ergebnis: + - ✓ extrem feingranulare, anwendungsspezifische Sicherheitspolitik zur Vermeidung von privilege escalation Angriffen + - ✓ obligatorische Durchsetzung ($\rightarrow$ MAC, zusätzlich zu Standard-Unix-DAC) + - O Softwareentwicklung: Legacy-Linux-Anwendungen laufen ohne Einschränkung, jedoch + - ✗ Politikentwicklung und -administrationkomplex! + +##### Weitere Informationen zu SELinux +$\rightarrow$ MAC-Mechanismen ala SELinux sind heutzutage in vielerlei Software bereits zu finden: +- Datenbanksoftware (SEPostgreSQL) +- Betriebssysteme für mobile Geräte (FlaskDroid) +- sehr wahrscheinlich: zukünftige, sicherheitsorientierte BS... + +## Isolationsmechanismen +- bekannt: Isolationsmechanismen für robuste Betriebssysteme + - strukturierte Programmierung + - Adressraumisolation +- nun: Isolationsmechanismen für sichere Betriebssysteme + - all die obigen... + - kryptografische Hardwareunterstützung: Intel SGX Enclaves + - sprachbasiert: + - streng typisierte Sprachen und _managed code_ : Microsoft Singularity [HLAA05] + - speichersichere Sprachen (Rust) + Adressraumisolation (μKernel): [RedoxOS](https://www.redox-os.org/) + - isolierte Laufzeitumgebungen: Virtualisierung (Kap. 6) + +##### Intel SGX +- SGX: Software Guard Extensions [CoDe16] +- Ziel: Schutz von sicherheitskritischen Anwendungen durch vollständige, hardwarebasierte Isolation +- $\rightarrow$ strenggenommen kein BS-Mechanismus: Anwendungen müssen dem BS nicht mehr vertrauen! (AR-Schutz, Wechsel von Privilegierungsebenen, ...) +- Annahmen/Voraussetzungen: + 1. sämtliche Software nicht vertrauenswürdig (potenziell durch Angreifer kontrolliert) + 2. Kommunikation mit dem angegriffenen System nicht vertrauenswürdig (weder vertraulich noch verbindlich) + 3. kryptografische Algorithmen (Verschlüsselung und Signierung) sind vertrauenswürdig, also nicht für den Angreifer zu brechen + 4. Ziel der Isolation: Vertraulichkeit, Integrität und Authentizität(nicht Verfügbarkeit) von Anwendungen (Code) und den durch sie verarbeiteten Informationen + +##### Enclaves +- Idee: geschützter Speicherbereich für Teilmenge der Seiten (Code und Daten) einer Task: Enclave Page Cache (EPC) +- Prozessor (und nur dieser) ver-und entschlüsselt EPC-Seiten +- ![](Assets/AdvancedOperatingSystems-SGX-enclaves.png) +- Enclaves: Erzeugung + - Erzeugen: App. $\rightarrow$ Syscall $\rightarrow$ BS-Instruktion an CPU (ECREATE) + - Seiten hinzufügen: App. $\rightarrow$ Syscall $\rightarrow$ BS-Instruktion an CPU (EADD) + - Metainformationen für jede hinzugefügte Seite als Teil der EPC-Datenstruktur (u.a.: Enklave - ID, Zugriffsrechte, vAR-Adresse) + - Initialisieren: App. $\rightarrow$ Syscall $\rightarrow$ BS-Instruktion an CPU (EINIT) + - finalisiert gesamten Speicherinhalt für diese Enclave + - CPU erzeugt Hashwert = eindeutige Signatur des Enclave - Speicherinhalts + - falls BS bis zu diesem Punkt gegen Integrität der Anwendung verstoßen hat: durch Vergleich mit von dritter Seite generiertem Hashwert feststellbar! +- Enclave - Zustandsmodell (vereinfacht) : + - ![](Assets/AdvancedOperatingSystems-SGX-enclaves-model.png) +- Zugriff: App. $\rightarrow$ CPU-Instruktionen in User Mode (EENTER, EEXIT) + - CPU erfordert, dass EPC-Seiten in vARder zugreifenden Task + - ![](Assets/AdvancedOperatingSystems-SGX-enlaves-zugriff.png) + +##### SGX: Licht und Schatten +- Einführung 2015 in Skylake - Mikroarchitektur +- seither in allen Modellen verbaut, jedoch nicht immer aktiviert +- Nutzer bislang: Demos und Forschungsprojekte, Unterstützung durch einige Cloud-Anbieter, (noch) keine größeren Märkte erschlossen +- Konzept hardwarebasierter Isolation ... + - ✓ liefert erstmals die Möglichkeit zur Durchsetzung von Sicherheitspolitiken auf Anwendungsebene + - O setzt Vertrauen in korrekte (und nicht böswillige) Hardwarevoraus + - O Dokumentation und Entwicklerunterstützung (im Ausbau ...) + - ✗ schützt mittels Enclaves einzelne Anwendungen, aber nicht das System + - ✗ steckt hinsichtlich praktischer Eigenschaften noch in den Anfängen (vgl. μKernel...): + - Performanz [WeAK18] + - Speicherkapazität(max. Größe EPC: 128 MiB, davon nur 93 MiBnutzbar) + - $\rightarrow$ komplementäre NFE: Speichereffizienz! + +## Sicherheitsarchitekturen +Sicherheitsarchitektur... ist die Softwarearchitektur (Platzierung, Struktur und Interaktion) der Sicherheitsmechanismen eines IT-Systems. + +- Voraussetzung zum Verstehen jeder Sicherheitsarchitektur: + - Verstehen des Referenzmonitorprinzips + - frühe Forschungen zu Betriebssystemsicherheit in 1970er-1980er Jahren durch US-Verteidigungsministerium + - Schlüsselveröffentlichung: Anderson-Report(1972)[Ande72] + - $\rightarrow$ fundamentalen Eigenschaften zur Charakterisierung von Sicherheitsarchitekturen +- Begriffe des Referenzmonitorprinzips kennen wir schon: + - Abgrenzung passiver Ressourcen (in Form einzelner Objekte, z.B. Dateien) + - von Subjekten (aktiven Elementen, z.B. laufenden Programmen, Prozessen) durch Betriebssystem + +### Referenzmonitorprinzip +- Idee: + - $\rightarrow$ sämtliche Autorisierungsentscheidungen durch einen zentralen (abstrakten) Mechanismus = Referenzmonitor + - Bewertet jeden Zugriffsversuch eines Subjekts auf Objekt durch Anwendung einer Sicherheitspolitik (security policy) + - $\rightarrow$ vgl. SELinux + - somit: Architekturbeschreibung, wie Zugriffe auf Ressourcen (z.B. Dateien) auf solche Zugriffe, die Sicherheitspolitik erlaubt, eingeschränkt werden +- Autorisierungsentscheidungen + - basieren auf sicherheitsrelevanten Eigenschaften jedes Subjekts und jedes Objekts + - einige Beispiele kennen wir schon: + - Nutzname, Unix-Gruppe + - Prozess-ID, INode-Nummer + - SELinux-Typ +- Architekturkomponenten in a nutshell: + - ![nach [MaMC06], S.6](Assets/AdvancedOperatingSystems-Referenzmonitorprinzip.png) + +Definierende Eigenschaften: Referenzmonitor ist eine Architekturkomponenten, die +- (RM 1) bei sämtlichen Subjekt/Objekt-Interaktionen involviert sind + - $\rightarrow$ Unumgehbarkeit ( total mediation ) +- (RM 2) geschützt sind vor unautorisierter Manipulation + - $\rightarrow$ Manipulationssicherheit ( tamperproofness ) +- (RM 3) hinreichend klein und wohlstrukturiert sind, um formalen Analysemethoden zugänglich zu sein + - $\rightarrow$ Verifizierbarkeit ( verifyability ) + +##### Referenzmonitor in Betriebssystemen +Nahezu alle Betriebssysteme implementieren irgendeine Form eines Referenzmonitors [Jaeg11] und können über Begriffe, wie + - Subjekte + - Objekte + - Regeln einer Sicherheitspolitik +charakterisiert sowie auf + - Unumgehbarkeit + - Manipulationssicherheit + - Verifizierbarkeit +ihrer Sicherheitsarchitektur hin untersucht werden + +Beispiel: Standard- Linux +- Subjekte (generell Prozesse) + - haben reale (und effektive) Nutzer-Identifikatoren (UIDs) +- Objekte (verschiedene Systemressourcen, genutzt für Speicherung, Kommunikation: Dateien, Directories, Sockets, SharedMemory usw.) + - haben ACLs (,,rwxrw----'') +- Regeln der Sicherheitspolitik, die durch den Referenzmonitor (hier Kernel) unterstützt werden + - hart codiert, starr +- Sicherheitsattribute, die durch diese Regeln zur Prüfung genutzt werden (z.B. Zugriffsmodi) + - Objekten zugeordnet + - modifizierbar + +Man beurteile die Politikimplementierung in dieser Architektur bzgl.: + - Unumgehbarkeit + - Manipulationssicherheit + - Verifizierbarkeit + +##### Referenzmonitorimplementierung: Flask +( Flask - Architekturmodell) + +![Abb. nach \[Spen07\] S. 139, Bild 11.1](Assets/AdvancedOperatingSystems-referenzmonitor-flask.png) + +##### SELinux-Architektur: Security Server +- Security Server: Laufzeitumgebung für Politik in Schutzdomäne des Kerns +- Objektmanager: implementiert in allen BS-Dienstenmittels,, Linux Security Module Framework '' + - jedes Subsystemvon SELinux , das zuständig für + 1. Erzeugung neuer Objekte + 2. Zugriff auf existierende Objekte + - Beispiele: + 1. Prozess-Verwaltung (behandelte Objekte: hauptsächlich Prozesse) + 2. Dateisystem (behandelte Objekte: hauptsächlich Dateien) + 3. Networking/Socket-Subsystem (behandelte Objekte: [verschiedene Typen von] Sockets) + 4. u.a. + +SELinux-Architektur: Objektklassen +- Objektmanager zur Verwaltung verschiedener Objektklassen +- spiegeln Diversität und Komplexität von Linux BS-Abtraktionen wider: + - Dateisysteme: file, dir, fd, filesystem, ... + - Netzwerk: netif, socket, tcp_socket, udp_socket, ... + - IPC: msgq, sem, shm, ... + - Sonstige: process, system, ... + - ... + +Dateisystem als Objektmanager +- Durch Analyse von Linux - Dateisystem und zugehöriger API wurden zu überwachenden Objektklassen identifiziert: + - ergibt sich unmittelbar aus Linux-API: + - Dateien + - Verzeichnisse + - Pipes + - feingranularere Objektklassen für durch Dateien repräsentierte Objekte (Unix-Prinzip: ,,everythingisa file''!): + - reguläre Dateien + - symbolische Links + - zeichenorientierte Geräte + - blockorientierte Geräte + - FIFOs + - Unix-Domain Sockets (lokale Sockets) +- Permissions (Zugriffsrechte) + - für jede Objektklasse: Menge an Permissions definiert, um Zugriffe auf Objekte dieser Klasse zu kontrollieren + - Permissions: abgeleitet aus Dienstleistungen, die Linux-Dateisystem anbietet + - $\rightarrow$ Objektklassen gruppieren verschiedene Arten von Zugriffsoperationen auf verschiende Arten von Objekten + - z.B. Permissions für alle ,,Datei''-Objektklassen (Auswahl ...): read, write, append, create, execute, unlink + - für ,,Verzeichnis''-Objektklasse: add_name, remove_name, reparant, search, rmdir + +### Trusted Computing Base (TCB) +Begriff zur Bewertung von Referenzmonitorarchitekturen: TCB ( Trusted Computing Base ) +- = die Hard-und Softwarefunktionen eines IT-Systems, die notwendig und hinreichend sind, um alle Sicherheitsregeln durchzusetzen. +- besteht üblicherweise aus + 1. Laufzeitumgebung der Hardware(nicht E/A-Geräte) + 2. verschiedenen Komponenten des Betriebssystem-Kernels + 3. Benutzerprogrammen mit sicherheitsrelevanten Rechten (bei Standard-UNIX/Linux-Systemen: diejenigen mit root-Rechten) +- Betriebssystemfunktionen, die Teil der TCB sein müssen, beinhalten Teile + - des Prozessmanagements + - des Speichermanagements + - des Dateimanagements + - des E/A-Managements + - alle Referenzmonitorfunktionen + +# Echtzeitfähigkeit +## Motivation +Echtzeitbegriff: Was ist ein Echtzeitsystem? +> Any system in which the time at which output is produced is significant. This is usually because the input corresponds to some movement in the physical world, and the output has to relate to that same movement. The lag from input time to output time must be sufficiently small for acceptable timeliness. (The Oxford DictionaryofComputing) + +> A real-time system is any information processing activity or system which has to respond to externally generated input stimuli within a finite and specified period. [Young 1982] + +> A real-time system is a system that is required to react to stimuli from the environment (including the passage of physical time) within time intervals dictated by the environment. [Randall et.al. 1995] + + +Spektrum von Echtzeitsystemen: +1. Regelungssysteme: z.B. eingebettete Systeme (exakter: Steuerungs-, Regelungs-u. Überwachungssysteme = ,,SRÜ''-Systeme) +2. Endanwender-Rechnersysteme: z.B. Multimediasysteme +3. Lebewesen: Menschen, Tiere + +Beispiel Regelungssystem: ,,Fly-by-Wire''-Fluglage-Regelungssystem (Schema) +1. Flugzeugbewegung +2. Sensoren + Einstellmöglichkeiten des Piloten +3. Echtzeit-Datenverarbeitung (durch Echtzeit-Rechnersystem) +4. Aktoren setzen Berechnung um +5. Einstellung von Regelflächen +6. Aerodynamik und Flug Mechanik führt zu Flugzeugbewegung (1.) + +Beispiel Überwachungssysteme +- Luftraumüberwachung: + - Ortsfeste Radarstation + - Mobile Radarstation + - Tiefflieger-Erfassungsradar + - Flugplatzradar Netzfunkstellen + - Zentrale +- Umweltüberwachung: Stickstoffdioxidkonzentration über Europa +- Vorgeburtliche Gesundheitsüberwachung: Herzschlagsüberwachungssystem für Mutter und Kind + +Beispiel Multimediasystem +- zeitabhängige Datenwiedergabe +- Bildwiedergabe bei Mediendatenströmen +- Durchführung der Schritte durch Multimedia-Task binnen $t_{i+1} - t_i$ +- Frist für Rendering in Multimedia-Tasks: festgelegt durch periodische Bildrate (24~48 fps $\rightarrow$ 1/24 ... 1/48 s) +- $\rightarrow$ Berücksichtigung bei Scheduling, Interruptbehandlung, Speicherverwaltung, ... erforderlich! + +Zwischenfazit [Buttazzo97] +- Murphy‘s General Law: If something can go wrong, it will got wrong. +- Murphy‘s Constant: Damage to an object is proportional to its value. +- Johnson‘s First Law: If a system stops working, it will do it at the worst possible time. +- Sodd‘sSecond Law: Sooner or later, the worst possible combination of circumstances will happen. + +Realisierung von Echtzeiteigenschaften: komplex und fragil! + +## Terminologie +bevor wir uns über Echtzeit-Betriebssystemen unterhalten: +1. Wie ist die Eigenschaft Echtzeit definiert? +2. Was sind (rechnerbasierte) Echtzeitsysteme? +3. Wie können Echtzeitanwendungen beschrieben werden? +4. Welche grundsätzlichen Typen von Echtzeitprozessen gibt es/wodurch werden diese charakterisiert? + +Antwortzeit: +- Alle Definitionen -die zitierten u. andere - betrachten eine ,,responsetime'' (Antwortzeit, Reaktionszeit) als das Zeitintervall, das ein System braucht, um (irgend)eine Ausgabe als Reaktion auf (irgend)eine Eingabe zu erzeugen. + +Frist +- Bei Echtzeitsystemen ist genau dieses $\Delta t$ kritisch, d.h. je nach Art des Systems darf dieses auf keinen Fall zu groß werden. +- Genauer spezifizierbar wird dies durch Einführung einer Frist (deadline, due time) $d$, die angibt bis zu welchem Zeitpunkt spätestmöglich die Reaktion erfolgt sein muss, bzw. wie groß das Intervall $\Delta t$ maximal sein darf. + +Echtzeitfähigkeit und Korrektheit +- Wird genau dieses maximale Zeitintervall in die Spezifikation eines Systems einbezogen, bedeutet dies, dass ein Echtzeitsystem nur dann korrekt arbeitet, wenn seine Reaktion bis zur spezifizierten Frist erfolgt. +- Die Frist trennt also korrektes von inkorrektem Verhalten des Systems. + +![](Assets/AdvancedOperatingSystems-echtzeitfähigkeit.png) + +Harte und weiche Echtzeitsysteme +- Praktische Anwendungen erfordern oft Unterscheidung in harte und weiche Echtzeitsysteme: + - hartes Echtzeitsystem: keine Frist darf jemals überschritten werden (sonst: katastrophale Konsequenzen) + - weiches Echtzeitsystem: maßvolles (im spezifizierten Maß) Überschreiten von Fristen tolerierbar + +## Charakteristika von Echtzeit-Prozessen +- reale Echtzeitanwendungen beinhalten periodische oder aperiodische Prozesse (oder Mischung aus beiden) +- typische Unterscheidung: + - Periodische Prozesse + - zeitgesteuert (typisch: periodische Sensorauswertung) + - oft: kritische Aktivitäten $\rightarrow$ harte Fristen + - Aperiodische Prozesse + - ereignisgesteuert + - Abhängig von Anwendung: harte oder weiche Fristen, ggf. sogar Nicht-Echtzeit + +### Periodische Prozesse +- bei Echtzeit-Anwendungen: häufigster Fall +- typisch für: + 1. periodische Analyse von Sensor-Daten (z.B. Umweltüberwachung) + 2. Aktionsplanung (z.B. automatisierte Montage) + 3. Erzeugung oder Verarbeitung einzelner Dateneinheiten eines multimedialen Datenstroms + 4. ... +- Prozessaktivierung + - ereignisgesteuert oder zeitgesteuert + - Prozesse, die Eingangsdaten verarbeiten: meist ereignisgesteuert, z.B. wenn neues Datenpaket eingetroffen + - Prozesse, die Ausgangsdaten erzeugen: meist zeitgesteuert, z.B. Ansteuerung von Roboteraktoren + +Periodische Prozesse +- Fristen: + - hart oder weich (anwendungsabhängig) + - innerhalb einer Anwendung sind sowohl Prozesse mit harten oder weichen Fristen möglich + - Frist: spätestens am Ende der aktuellen Periode, möglich auch frühere Frist + - ![](Assets/AdvancedOperatingSystems-echtzeit-periodisch-frist.png) +- Modellierung: + - unendliche Folge identischer Aktivierungen: Instanzen, aktiviert mit konstanter Rate (Periode) + - ![](Assets/AdvancedOperatingSystems-echtzeit-periodisch-modellierung.png) +- Aufgaben des Betriebssystems: + - WennalleSpezifikationeneingehaltenwerden-muss Betriebssystem garantieren, dass + 1. zeitgesteuerte periodische Prozesse: mit ihrer spezifizierten Rate aktiviert werden und ihre Frist einhalten können + 2. ereignisgesteuerte periodische Prozesse: ihre Frist einhalten können + +### Aperiodische Prozesse +- typisch für + - unregelmäßig auftretende Ereignisse, z.B.: + - Überfahren der Spurgrenzen, Unterschreiten des Sicherheitsabstands $\rightarrow$ Reaktion des Fahrassistenzsystems + - Nutzereingaben in Multimediasystemen ($\rightarrow$ Spielkonsole) +- Prozessaktivierung + - ereignisgesteuert +- Fristen + - oft weich(aber anwendungsabhängig) +- Aufgabendes Betriebssystems + - bei Einhaltung der Prozessspezifikationen muss Betriebssystem auch hier für Einhaltung der Fristen sorgen +- Modellierung + - bestehen ebenfalls aus (maximal unendlicher) Folge identischer Aktivierungen (Instanzen); aber: Aktivierungszeitpunkte nicht regelmäßig (möglich: nur genau eine Aktivierung) + - ![](Assets/AdvancedOperatingSystems-echtzeit-aperiodisch-modellierung.png) + +### Parameter von Echtzeit-Prozessen +- ![nach (Buttazzo97) , Bild 2.4, S. 27](Assets/AdvancedOperatingSystems-echtzeit-parameter-instanz.png) +- $a_i$: Ankunftszeitpunkt (arrival time); auch r ... request time/release time + - Zeitpunkt, zu dem ein Prozess ablauffähig wird +- $s_i$: Startzeitpunkt (start time) + - Zeitpunkt, zu dem ein Prozess mit der Ausführung beginnt +- $f_i$: Beendigungszeitpunkt (finishing time) + - Zeitpunkt, an dem ein Prozess seine Ausführung beendet +- $d_i$: Frist (deadline, due time) + - Zeitpunkt, zu dem ein Prozess seine Ausführung spätestens beenden sollte +- $C_i$: Bearbeitungszeit(bedarf) (computation time) + - Zeitquantum, das Prozessor zur vollständigen Bearbeitung der aktuellen Instanz benötigt (Unterbrechungen nicht eingerechnet) +- ![](Assets/AdvancedOperatingSystems-echtzeit-parameter-instanz2.png) +- $L_i$: Unpünktlichkeit (lateness): $L_i= f_i - d_i$ + - Zeitbetrag, um den ein Prozess früher oder später als seine Frist beendet wird (wenn Prozess vor seiner Frist beendet, hat $L_i$ negativen Wert) +- $E_i$: Verspätung (exceeding time, tardiness): $E_i= max(0, L_i)$ + - Zeitbetrag, den ein Prozess noch nach seiner Frist aktiv ist +- ![](Assets/AdvancedOperatingSystems-echtzeit-parameter-instanz3.png) +- $X_i$: Spielraum (Laxity, Slacktime): $X_i = d_i - a_i - C_i$ + - maximales Zeitquantum, um das Ausführung eines Prozesses verzögert werden kann, damit dieser noch bis zu seiner Frist beendet werden kann ($f_i=d_i$) +- außerdem: + - criticality: Parameter zur Beschreibung der Konsequenzen einer Fristüberschreitung (typischerweise ,,hart'' oder ,,weich'') + - $V_i$ ...Wert (value): Parameter zum Ausdruck der relativen Wichtigkeit eines Prozesses bezogen auf andere Prozesse der gleichen Anwendung + +## Echtzeitfähige Betriebssysteme +- Hauptfragestellungen + 1. Was muss BS zu tun, um Echtzeitprozesse zu ermöglichen? Welche Teilprobleme müssen beachtet werden? + 2. Welche Mechanismen müssen hierfür anders als bei nicht-echtzeitfähigen Betriebssystemen implementiert werden, und wie? +- Grundlegender Gedanke + - Abgeleitet aus den Aufgaben eines Betriebssystems sind folgende Fragestellungenvon Interesse: + 1. Wie müssen die Ressourcen verwaltet werden? ($\rightarrow$ CPU, Speicher, E/A, ...) + 2. Sind neue Abstraktionen, Paradigmen (Herangehensweisen) und entsprechende Komponenten erforderlich (oder günstig)? +- Prozess-Metainformationen + 1. Frist + 2. Periodendauer + 3. abgeleitet davon: Spielraum, Unpünktlichkeit, Verspätung, ... + 4. im Zusammenhang damit: Prioritätsumkehr, Überlast +- Ressourcen-Management + - Wie müssen Ressourcen verwaltet werden, damit Fristen eingehalten werden können? + +Wir betrachten i.F. +1. Algorithmen, die Rechnersysteme echtzeitfähig machen -einschließlich des Betriebssystems: + - grundlegende Algorithmen zum Echtzeitscheduling + - Besonderheiten der Interruptbehandlung + - Besonderheiten der Speicherverwaltung +2. Probleme, die behandelt werden müssen, um Echtzeitfähigkeit nicht zu be- oder verhindern: + - Prioritätsumkehr + - Überlast + - Kommunikation-und Synchronisationsprobleme + +### Echtzeitscheduling +- Scheduling: + - Schedulingvon Prozessen/Threads als wichtigster Einflussfaktor auf Zeitverhalten des Gesamtsystems +- Echtzeit-Scheduling: + - benötigt: Scheduling-Algorithmen, die Scheduling unter Berücksichtigung der ( unterschiedlichen ) Fristen der Prozesse durchführen können +- Fundamentale Algorithmen: + - wichtigste Strategien: + 1. Ratenmonotones Scheduling (RM) + 2. Earliest Deadline First (EDF) + - beide schon 1973 von Liu & Layland ausführlich diskutiert [Liu&Layland73] + +Annahmen der Scheduling-Strategien +- A1: Alle Instanzen eines periodischen Prozesses $t_i$ treten regelmäßig und mit konstanter Rate auf (= werden aktiviert ). Das Zeitintervall $T_i$ zwischen zwei aufeinanderfolgenden Aktivierungen heißt Periode des Prozesses. +- A2: Alle Instanzen eines periodischen Prozesses $t_i$ haben den gleichen Worst-Case-Rechenzeitbedarf $C_i$. +- A3: Alle Instanzen eines periodischen Prozesses $t_i$ haben die gleiche relative Frist $D_i$, welche gleich der Periodendauer $T_i$ ist. +- A4: Alle Prozessesind kausal unabhängig voneinander (d.h. keine Vorrang- und Betriebsmittel-Restriktionen) +- A5: Kein Prozess kann sich selbst suspendieren, z.B. bei E/A-Operationen. +- A6: Alle Prozesse werden mit ihrer Aktivierung sofort rechenbereit ( release time = arrival time ). +- A7: Jeglicher Betriebssystem-Overhead (Kontextwechsel, Scheduler-Rechenzeit) wird vernachlässigt. + +A5-7 sind weitere Annahmen des Scheduling Modells + +Ratenmonotones Scheduling (RM) +- Voraussetzung: + - periodisches Bereitwerden der Prozesse/Threads, d.h. periodische Prozesse bzw. Threads +- Strategie RM: + - Prozess (Thread) mit höchster Ankunftsrate bekommt höchste statische Priorität (Kriterium: Wie oft pro Zeiteinheit wird Prozess bereit?) + - Scheduling-Zeitpunkt: nur einmal zu Beginn (bzw. wenn neuer periodischer Prozess auftritt) + - präemptiver Algorithmus +- ![Darstellung nach (Inf-Handbuch97) Bild 3 S.740](Assets/AdvancedOperatingSystems-echtzeit-scheduling-rm.png) + - Zuteilung eines Prozessors nach RM + - $t_1, t_2$: Anforderungen von Prozessorzeit durch zwei periodische Prozesse + - darunter: Prozessorzuteilung nach RM +- Optimalität von RM + - Unter allen Verfahren mit festen (statischen)Prioritäten ist RM optimaler Algorithmus in dem Sinne, dass kein anderes Verfahren dieser Klasse eine Prozessmenge einplanen kann, die nicht auch von RM geplant werden kann. [Liu&Layland73] +- Prozessor-Auslastungsfaktor + - Bei gegebener Menge von n periodischen Prozessen gilt: $U=\sum_{i=1}^n \frac{C_i}{T_i}$ + - mit $\frac{C_i}{T_i}$ Anteil an Prozessorzeit für jeden periodischen Prozess $t_i$ + - und $U$ Summe der Prozessorzeit zur Ausführung der gesamten Prozessmenge (,,utilization factor'') +- Prozessorlast + - $U$ ist folglich Maß für die durch Prozessmenge verursachte Last am Prozessor $\rightarrow$ Auslastungsfaktor +- Planbarkeitsanalyse einer Prozessmenge + - im allgemeinen Fall kann RM einen Prozessor nicht zu 100% auslasten + - von besonderem Interesse: kleinste obere Grenze des Auslastungsfaktors $U_{lub}$ (lub: ,,least upper bound'') +- Beispiel für $n=2$ + - ![](Assets/AdvancedOperatingSystems-echtzeit-scheduling-rm2.png) + - Obere Grenze des Prozessor-Auslastungsfaktors für zwei periodische Prozesse als Funktion des Verhältnisses ihrer Perioden. + - (Abb. nach [Buttazzo97] Bild 4.7, S. 90) +- Obere Auslastungsgrenze bei RM + - nach [Buttazzo97] (S. 89-91) erhält man bei n Prozessen für RM: $U_{lub}=n(2^{\frac{1}{n}}-1)$ + - für $n\rightarrow\infty$ konvergiert $U_{lub}$ zu $ln\ 2 \approx 0,6931...$ + - Wird genannter Wert nicht überschritten, sind beliebige Prozessmengen planbar. + - (Herleitung siehe [Buttazzo97] , Kap. 4.3.3) + +### Earliest Deadline First (EDF) +- Voraussetzung: + - kann sowohl periodische als auch aperiodische Prozesse planen +- Optimalität: + - EDF in Klasse der Schedulingverfahren mit dynamischen Prioritäten: optimaler Algorithmus [Liu&Layland73] +- Strategie EDF: + - Zu jedem Zeitpunkt erhält Prozess mit frühester Frist höchste dynamische Priorität + - Scheduling-Zeitpunkt: Bereitwerden eines (beliebigen) Prozesses + - präemptiver Algorithmus (keine Verdrängung bei gleichen Prioritäten) +- Beispiel + - ![Darstellung nach (Inf-Handbuch97) Bild 3 S.740](Assets/AdvancedOperatingSystems-echtzeit-scheduling-edf.png) + - Zuteilung eines Prozessors nach EDF + - $t_1, t_2$: Anforderungen nach Prozessorzeit durch zwei periodische Prozesse + - darunter: Prozessorzuteilung nach EDF +- Planbarkeitsanalyse: + - Mit den Regeln $A1 ... A7$ ergibt sich für die obere Schranke des Prozessorauslastungsfaktors: $U_{lub}= 1\rightarrow$ Auslastung bis 100% möglich! + - Eine Menge periodischer Prozesse ist demnach mit EDF planbar genau dann wenn: $U=\sum_{i=1}^n \frac{C_i}{T_i}\leq 1$ (Prozessor natürlich nicht mehr als 100% auslastbar) +- Beweis: Obere Auslastungsgrenze bei EDF + - Behauptung: Jede Menge von n periodischen Tasks ist mit EDF planbar $\Leftrightarrow$: $U=\sum_{i=1}^n \frac{C_i}{T_i}\leq 1$ + - $\Leftarrow$: $U>1$ übersteigt die verfügbare Prozessorzeit; folglich kann niemals eine Prozessmenge mit dieser (oder höherer) Gesamtauslastung planbar sein. + - $\Rightarrow$: Beweis durch Widerspruch. Annahme: $U\leq 1$ und die Prozessmenge ist nicht planbar. Dies führt zu einem Schedule mit Fristverletzung zu einem Zeitpunkt $t_2$, z.B.: + - ![](Assets/AdvancedOperatingSystems-echtzeit-scheduling-edf2.png) + - Beobachtungen an diesem Schedule: + - $exists$ ein längstes, kontinuierliches Rechenintervall $[t_1,t_2]$, in welchem nur Prozessinstanzen mit Fristen $\leq t_2$ rechnen + - die Gesamtrechenzeit $C_{bad}$ aller Prozesse in $[t_1,t_2]$ muss die verfügbare Prozessorzeit übersteigen: $C_{bad} > t_2-t_1$ (sonst: keine Fristverletzung an $t_2$) + - Anwesenheit in $[t_1,t_2]$ leitet sich davon ab, ob (genauer: wie oft) die Periode eines Prozesses in $t_2-t_1$ passt: $t_i$ in $[t_1,t_2]\Leftrightarrow\lfloor\frac{t_2-t_1}{T_i}\rfloor >0$ + - Damit ist $C_{bad}$ die Summe der Rechenzeiten aller Prozessinstanzen, die garantiert in $[t_1,t_2]$ sind, mithin: $C_{bad}=\sum_{i=1}^n \lfloor\frac{t_2-t_1}{T_i}\rfloor C_i$ + - Im Beispiel: $t_1... t_3$ in $[t_1,t_2]$, folglich: $C_{bad}= 2 C_1 + 1 C_2 + 1 C_3$ + - Zu zeigen: Beobachtung $C_{bad}> t_2-t_1$ widerspricht Annahme $U\leq 1$. + - Es gilt $\sum_{i=1}^n \lfloor\frac{t_2-t_1}{T_i}\rfloor C_i\leq\sum_{i=1}^n\frac{t_2-t_1}{T_i}C_i$ wegen Abrundung. + - Mit $U=\sum_{i=1}^n\frac{C_i}{T_i}$ folgt daraus $C_{bad}\leq(t_2-t_1)U$ + - $C_{bad}>t_2-t_1$ entspricht also $(t_2-t_1)U>t_2-t_1$ und somit $U>1$. Widerspruch zur Annahme! + +### Vergleich: EDF vs. RM +![(Abb. nach (Inf-Handbuch97) , Bild 3, S. 740)](Assets/AdvancedOperatingSystems-echtzeit-edf-vs-rm.png) + +Zuteilung eines Prozessors nach EDF (dynamisch) bzw. RM (statisch) $t_1,t_2$: Anforderungen nach Prozessorzeit durch zwei periodische Prozesse darunter: Prozessorzuteilung nach EDF bzw. RM +- gut erkennbar: deutliche Unterschiede bei Scheduling mit statischem (RM) vs. dynamischem Algorithmus (EDF). + +Vergleich: Anzahl Prozesswechsel +- Häufigkeit von Prozesswechseln im Beispiel: + - RM: 16 + - EDF: 12 +- Ursache: dynamische Prioritätenvergabe führt dazu, dass Instanz II von $t_2$ die gleiche Priorität wie Instanz A von $t_1$ hat (usw.) $\rightarrow$ keine unnötige Verdrängung + +Vergleich: 100% Prozessorauslastung +- EDF: erzeugt auch bei Prozessorauslastung bis 100% (immer) korrekte Schedules +- RM: kann das im allgemeinen Fall nicht +- Bedeutung von 100% Prozessorauslastung in der Praxis: Überwiegend müssen Systeme mit harten Echtzeitanforderungen auch weiche Echtzeit- sowie Nicht-Echtzeit-Prozesse unterstützen. Daher: Belegungslücken am Prozessor für die letzteren beiden nutzbar. + +Vergleich: Implementierung +- RM + - statisch: jeweils eine Warteschlange pro Priorität: + - Einfügen und Entfernen von Tasks: $O(1)$ + - ![](Assets/AdvancedOperatingSystems-echtzeit-scheduling-rm-statisch.png) +- EDF + - dynamisch: balancierter Binärbaum zur Sortierung nach Prioritäten: + - Einfügen und Entfernen von Tasks: $O(log\ n)$ + - ![](Assets/AdvancedOperatingSystems-echtzeit-scheduling-edf-dynamisch.png) + +Scheduling in Multimedia-Anwendungen +- Konkretisierung des Betrachtungswinkels + - RM und EDF wurden entwickelt insbesondere für Echtzeit-Regelsysteme $\rightarrow$ ohne Berücksichtigung von Multimediasystemen + - Multimediasysteme $\rightarrow$ andere Probleme, schwächere Annahmen: spezialisierte Scheduling-Algorithmen + - gehen meist auch von EDF und/oder RM als Grundlage aus +- Betrachteter Algorithmus: + - Beispielfür spezialisierten Scheduling-Algorithmus: + - RC-Algorithmus - entwickelt an University of Texas + - Anpassung von EDF an Charakteristika von Multimedia-Anwendungen + +Prozesstypen in Multimedia-Anwendungen +1. Echte Multimedia-Prozesse + - periodische Prozesse: weiche Fristen + 1. pünktliche periodische Prozesse mit konstantem Prozessorzeitbedarf $C$ für jede Instanz (unkomprimierte Audio- und Videodaten) + 2. pünktliche periodische Prozesse mit unterschiedlichem $C$ einzelner Instanzen (komprimierte Audio- und Videodaten) + 3. unpünktliche periodische Prozesse: + - verspätete Prozesse + - verfrühte Prozesse + - aperiodische-Prozesse aus Multimedia-Anwendungen: weiche Fristen +2. Prozesse nebenläufiger Nicht-Multimedia-Anwendungen + - interaktive Prozesse : keine Fristen , aber: keine zu langen Antwortzeiten Ansatz (z.B.): maximal tolerierbare Verzögerung + - Hintergrund-Prozesse : zeitunkritisch, keine Fristen, aber : dürfen nicht verhungern + +Multimediaanwendungen sind ein typisches Beispiel für mögliche Abweichungen der Lastpezifikation $(T_i,C_i)$ eines Echtzeitprozesses! + +Problem: Abweichungen von Lastspezifikation +- gibt Prozessor nicht frei +- verspätete periodische Prozesse + +### RC Algorithmus +- Ziel + - spezifikationstreue Prozesse nicht bestrafen durch Fristüberschreitung aufgrund abweichender Prozesse +- Idee + - grundsätzlich: Schedulingnach frühester Fristaufsteigend (= EDF) $\rightarrow$ für eine vollständig spezifikationstreue Prozessmenge verhält sich RC wie reines EDF + - Frist einer Instanz wird dynamisch angepasst:basierend auf derjenigen Periode, in der sie eigentlich sein sollte lt. Spezifikation der Prozessornutzung ($U_i$, hier: ,,Rate''): $U_i=\frac{C_i}{T_i}$ + - Bsp.: $U_i =\frac{20}{40}=\frac{1}{2}$ ($t_B$ hat spezifizierte Aktivitätsrate von $0,5$ pro Periode) + +#### RC Algorithmus: Strategie +- Variablen + - $a_i$: Ankunftszeit der zuletzt bereitgewordenen Instanz von $t_i$ + - $t_i^{virt}$: virtuelle Zeit in aktueller Periode, die $t_i$ bereits verbraucht hat + - $c_i^{virt}$: Netto-Rechenzeit, die $t_i$ in aktueller Periode bereits verbraucht hat + - $d_i$: dynamische Frist von $t_i$, nach der sich dessen Priorität berechnet (EDF) +- Strategie + - für eine bereite (lauffähige) Instanz von $t_i$: adaptiere dynamisch $d_i$ basierend auf $t_i^{virt}$ + - für eine bereit gewordene (neu angekommene oder zuvor blockierte) Instanzvon $t_i$: aktualisiere $t_i^{virt}$ auf akt. Systemzeit $(t)\rightarrow$ etwaiger ''Zeitkredit'' verfällt + +#### RC Algorithmus: Berechnung von $t_i^{virt}$ +Beispiel: Situation bei $t=20ms$ +![](Assets/AdvancedOperatingSystems-rc-ti-berechnen-1.png) + +Da $t_B$ aber noch weiteren Rechenbedarf hat: Situation bei $t=30 ms$ +![](Assets/AdvancedOperatingSystems-rc-ti-berechnen-2.png) + +#### RC Algorithmus: Adaptionsfunktion +Für Prozess ti zu jedem Scheduling-Zeitpunkt: +```cpp +RC (t_i) { + if (t_i. status wurde auf BEREIT gesetzt) { + t_i^virt := max( t_i^virt , t ); //kein Zeitkredit -> kein ,,Nachholen'' von verpassten/ungenutzten Perioden + } else { + c_i^virt := Gesamtprozessorzeit seit letztem Aufruf RC(t_i); + t_i^virt := t_i^virt + c_i^virt / U_i ; //Zeitwert, bis zu dem t_i Rechenzeit gemäß seiner Rate U_i erhalten hat + } + if (t_i. status != BLOCKIERT) { + finde k, so dass gilt: + a_i + (k - 1) * T_i <= t_i^virt < a_i + k * T_i ; // finde diejenige (aktuelle oder zukünftige) Periode, in der t_i^virt liegt + d_i := a_i + k * T_i ; // setze d_i auf deren Periodenende + } +} +``` + +#### RC Algorithmus: Scheduling +Zeitpunkte, zu denen der Scheduler aktiv wird: +1. aktuell laufender Prozess $t_i$ blockiert: + - $RC(t_i)$ +2. Prozesse $t_i..._j$ werden bereit: + - $for\ x\in[i,j]: RC(t_x)$ +3. periodischer ,,clock tick'' (SchedulingInterrupt): + - $t_i$ := aktuell ausgeführter Prozess + - $RC(t_i)$ + +anschließendes Scheduling (präemptiv) = EDF: +```cpp +SCHED := {t_i |t_i.status == BEREIT ⋀ d_i minimal }; // bereite(r) Prozess(e) mit nächster Frist +if (∃ t_j : t_j.status == LAUFEND) ⋀ ( d_j ≤ d_i ) + do nothing; // ggf. laufenden Prozess bevorzugen +else + preempt(rnd_member( SCHED )); // sonst: irgendein Prozess mit nächster Frist verdrängt den laufenden +``` + +#### Umgang mit abweichenden Prozessen unter RC +![Abb. nach (Yau+96) , Bild 4, S. 4](Assets/AdvancedOperatingSystems-rc-abweichende-prozesse.png) + +#### Resultat +> Garantie: Prozesse, die sich entsprechend ihrer Spezifikation verhalten, erhalten bis zum Ende jeder spezifizierten Periode ihren spezifizierten Anteil an Prozessorzeit. + +Auswirkung auf verschiedene Prozesstypen: +- ,,pünktliche'' Prozesse: Einhaltung der Frist in jeder Periode garantiert (unabhängig von Verhalten anderer Prozesse) +- ,,verspätete'' Prozesse: nur aktuelle Periode betrachtet, Nachholen ,,ausgelassener Perioden'' nicht möglich +- ,,gierige'' Prozesse: Prozessorentzug, sobald andere lauffähige Prozesse frühere Fristen aufweisen +- nicht-periodische Hintergrundprozesse: pro ,,Periode'' wird spezifizierte Prozessorrate garantiert (z.B. kleine Raten bei großen ,,Periodendauern'' wählen.) + +### Umgang mit gemischten Prozessmengen +- Hintergrund-Scheduling: + - Prinzip: ![Abb. nach (Buttazzo97) , Bild 5.2, S.111](Assets/AdvancedOperatingSystems-gemischte-prozessmenge.png) + - rechenbereite Prozesse auf 2 Warteschlangen aufgeteilt (einfache Variante eines Mehr-Ebenen-Scheduling ) + - Warteschlange 1: + - alle periodischen Prozesse + - mit höchster Priorität mittels RM oder EDF bedient + - Warteschlange 2: + - alle aperiodischen Prozesse + - nur bedient, wenn keine wartenden Prozesse in Warteschlange 1 + +#### Hintergrund-Scheduling: Vor- und Nachteile +- Hauptvorteil: + - einfache Implementierung +- Nachteile: + - Antwortzeit **aperiodischer Prozesse** kann zu lang werden (insbesondere bei hoher aperiodischer Last) $\rightarrow$ Verhungern möglich! + - geeignet nur für relativ zeitunkritische aperiodische Prozesse +- Beispiel: Hintergrund-Scheduling mit RM + - ![Abb. nach (Buttazzo97) , Bild 5.1, S.111](Assets/AdvancedOperatingSystems-hintergrund-scheduling.png) + +#### Optimierung: Server-Prozess +- Scheduling mit Server-Prozessen: + - Prinzip: periodisch aktivierter Prozess benutzt zur Ausführung aperiodischer Prozessoranforderungen + - Beschreibung Server-Prozess: durch Parameter äquivalent zu wirklichem periodischen Prozess: + - Periodendauer $T_S$ + - ,,Prozessorzeitbedarf'' $C_S$; jetzt Kapazitätdes Server-Prozesses + - Arbeitsweise Server-Prozess: + - geplant mit gleichem Scheduling-Algorithmus wie periodische Prozesse + - zum Aktivierungszeitpunkt vorliegende aperiodische Anforderungen bedient bis zur Kapazität des Servers + - keine aperiodischen Anforderungen: Server suspendiert sich bis Beginn der nächsten Periode (Schedule wird ohne ihn weitergeführt $\rightarrow$ Prozessorzeit für periodische Prozesse) + - Kapazitätin jeder Server-Periode neu ''aufgeladen'' + +#### Beispiel: Server-Prozess mit RM +![Abb. nach (Buttazzo97) , Bild 5.3, S. 112](Assets/AdvancedOperatingSystems-rm-server-prozess.png) + +#### Optimierung: Slack-Stealing +- Prinzip: Es existiert passiver Prozess ,,slack stealer'' (kein periodischer Server) + - versucht so viel Zeit wie möglich für aperiodische Anforderungen zu sammeln + - realisiert durch ,,slackstealing''(= Spielraum-Stehlen) bei periodischen Prozessen + - letztere auf Zeit-Achse so weit nach hinten geschoben, dass Frist und Beendigungszeitpunkt zusammenfallen + - Sinnvoll, da normalerweise Beenden periodischer Prozesse vor ihrer Frist keinerlei Vorteile bringt +- Resultat: Verbesserung der Antwortzeiten für aperiodische Anforderungen +- ![](Assets/AdvancedOperatingSystems-slack-stealing.png) + +### Prioritätsumkehr +> Mechanismen zur Synchronisation und Koordination sind häufige Ursachen für kausale Abhängigkeiten zwischen Prozessen! + +#### Problem +- Prinzip _kritischer Abschnitt_ (Grundlagen BS): + - Sperrmechanismen stellen wechselseitigen Ausschluss bei der Benutzung exklusiver Betriebsmittel durch nebenläufige Prozesse sicher + - Benutzung von exklusiven sowie nichtentziehbaren Betriebsmitteln: kritischer Abschnitt + - Folge: Wenn ein Prozess einen kritischen Abschnitt betreten hat, darf er aus diesem nicht verdrängt werden (durch anderen Prozess, der dasselbe Betriebsmittel nutzen will) +- Konflikt: kritische Abschnitte vs. Echtzeit-Prioritäten + - Falls ein weiterer Prozess mit höherer Priorität ablauffähig wird und im gleichen kritischen Abschnitt arbeiten will, muss er warten bis niederpriorisierter Prozess kritischen Abschnitt verlassen hat + - (zeitweise) Prioritätsumkehr möglich! d.h. aus einer (Teil-) Menge von Prozessen muss derjenige mit höchster Priorität auf solche mit niedrigerer Priorität warten + +#### Ursache der Prioritätsumkehr +- ![Abb. nach (Buttazzo97) , Bild 7.3, S. 183](Assets/AdvancedOperatingSystems-prioritätsumkehr-ursache.png) +- Prioritätsumkehr bei Blockierung an nichtentziehbarem, exklusivem Betriebsmittel +- $\rightarrow$ unvermeidlich + +#### Folgen der Prioritätsumkehr +- Kritisch bei zusätzlichen Prozessen mittlerer Priorität +- ![Abb. nach (Buttazzo97) , Bild 7.4, S.184](Assets/AdvancedOperatingSystems-prioritätsumkehr-folgen.png) +- Lösung: Priority Inheritance Protocol (PIP) + +#### Lösung: Prioritätsvererbung +- ![Abb. nach [Buttazzo97] , Bild 7.6, S.188] +- ePrio ... effektive Priorität + +### Überlast +- Definition: kritische Situation - bei der die benötigte Menge an Prozessorzeit die Kapazität des vorhandenen Prozessors übersteigt $(U>1)$ + - Folge: nicht alle Prozesse können Fristen einhalten +- Hauptrisiko: kritische Prozesse können Fristen nicht einhalten $\rightarrow$ Gefährdung funktionaler und anderer nichtfkt. Eigenschaften ($\rightarrow$ harte Fristen!) +- Stichwort: ,,graceful degradation'' (,,würdevolle'' Verschlechterung) statt unkontrollierbarer Situation $\rightarrow$ Wahrung von Determinismus + +#### Wichtigkeit eines Prozesses +- Minimallösung: (lebenswichtig für Echtzeit-System) + - Unterscheidung zwischen Zeitbeschränkungen (Fristen) und tatsächlicher Wichtigkeit eines Prozesses für System +- Allgemein gilt: + - Wichtigkeit eines Prozesses ist unabhängig von seiner Periodendauer und irgendwelchen Fristen + - z.B. kann ein Prozess trotz späterer Frist viel wichtiger als anderer mit früherer Frist sein. + - Beispiel: Bei chemischem Prozess könnte Temperaturauswertung jede 10s wichtiger sein als Aktualisierung graphischer Darstellung an Nutzerkonsole jeweils nach 5s + +#### Umgang mit Überlast: alltägliche Analogien +1. Weglassen weniger wichtiger Aktionen + - ohne Frühstück aus dem Haus... + - kein Zähneputzen ... + - Wichtung vom Problem bzw. Aktivitätsträgern (hier: Personen) abhängig! +2. Verkürzen von Aktivitäten + - Katzenwäsche... +3. Kombinieren + - kein Frühstück + Katzenwäsche + ungekämmt + +#### Wichtung von Prozessen +Behandlung: +- zusätzlicher Parameter V (Wert) für jeden Prozess/Thread einer Anwendung +- spezifiziert relative Wichtigkeit eines Prozesses (od. Thread) im Verhältnis zu anderen Prozessen (Threads) der gleichen Anwendung +- bei Scheduling: V stellt zusätzliche Randbedingung (primär: Priorität aufgrund von Frist, sekundär: Wichtigkeit) + +#### Obligatorischer und optionaler Prozessanteil +- Aufteilung der Gesamtberechnung $(C_{ges})$ eines Prozesses in zwei Phasen +- einfache Möglichkeit der Nutzung des Konzepts des anpassbaren Prozessorzeitbedarfs +- Prinzip: + - Bearbeitungszeitbedarf eines Prozesses zerlegt in + 1. obligatorischer Teil (Pflichtteil, $C_{ob}$): muss unbedingt u. immer ausgeführt werden $\rightarrow$ liefert bedingt akzeptables Ergebnis + 2. optionaler Teil $(C_{opt})$: nur bei ausreichender Prozessorkapazität ausgeführt $\rightarrow$ verbessert durch obligatorischen Teil erzieltes Ergebnis + - Prinzip in unterschiedlicher Weise verfeinerbar +- ![](Assets/AdvancedOperatingSystems-obligatorisch-optionaler-prozessanteil.png) + +### Echtzeit-Interruptbehandlung +1. Fristüberschreitung durch ungeeignete Interruptbearbeitung + - ![](Assets/AdvancedOperatingSystems-interruptbehandlung-fristüberschreitung.png) +2. Lösung für Echtzeitsysteme ohne Fristüberschreitung + - Interrupt wird zunächst nur registriert (deterministischer Zeitaufwand) + - tatsächliche Bearbeitung der Interruptroutine muss durch Scheduler eingeplant werden $\rightarrow$ Pop-up Thread + - ![](Assets/AdvancedOperatingSystems-interruptbehandlung-lösung.png) + +### Echtzeit-Speicherverwaltung +- Prinzip: + - Hauptanliegen: auch hier Fristen einhalten + - wie bei Interrupt-Bearbeitung und Prioritätsumkehr: unkontrollierbare Verzögerungen der Prozessbearbeitung (= zeitlicher Nichtdeterminismus) vermeiden! +- Ressourcenzuordnung, deswegen: + 1. keine Ressourcen-Zuordnung ,,on-demand'' (d.h. in dem Moment, wo sie benötigt werden) sondern ,,Pre-Allokation'' (= Vorab-Zuordnung) + 2. keine dynamische Ressourcenzuordnung (z.B. Hauptspeicher), sondern Zuordnung maximal benötigter Menge bei Pre-Allokation ($\rightarrow$ BS mit ausschließlich statischer Hauptspeicherallokation: TinyOS) + +#### Hauptspeicherverwaltung +- bei Anwendung existierender Paging-Systeme + - durch unkontrolliertes Ein-/Auslagern ,,zeitkritischer'' Seiten (-inhalte): unkontrollierbare Zeitverzögerungen möglich! + - Technik hier: ,,Festnageln'' von Seiten im Speicher (Pinning, Memory Locking) + +#### Sekundärspeicherverwaltung +- Beispiel 1: FCFS Festplattenscheduling + - Anforderungsreihenfolge = 98, 183, 37, 122, 14, 124, 65, 67 + - Zuletzt gelesener Block: 53 + - ![Abb. nach (Silberschatz+91) , S. 347](Assets/AdvancedOperatingSystems-sekundärspeicherverwaltung-fcfs.png) +- Beispiel 2: EDF Festplattenscheduling + - Anforderungsreihenfolge $t_1 = 98, 37, 124, 65$ + - Anforderungsreihenfolge $t_2 = 183, 122, 14, 67$ + - Zuletzt gelesener Block: 53 + | | $a_i$ | $d_i$ | + | ----- | ----- | ----- | + | $t_1$ | 0 | 3 | + | $t_2$ | 0 | 9 | + - ![Abb. nach (Silberschatz+91) , S. 347](Assets/AdvancedOperatingSystems-sekundärspeicherverwaltung-edf.png) + +- Primärziel: Wahrung der Echtzeitgarantien + - naheliegend: EA-Schedulingnach Fristen $\Rightarrow$ EDF (wie Prozessor) + - für Zugriffsreihenfolge auf Datenblöcke: lediglich deren Fristen maßgebend (weitere Regeln existieren nicht!) +- Resultat bei HDDs: + - ineffiziente Bewegungen der Lese-/Schreibköpfe -ähnlich FCFS + - nichtdeterministische Positionierzeiten + - geringer Durchsatz +- Fazit: + - Echtzeit-Festplattenscheduling $\rightarrow$ Kompromiss zwischen Zeitbeschränkungen und Effizienz +- bekannte Lösungen: + 1. Modifikation von EDF + 2. Kombination von EDF mit anderen Zugriffsstrategien + +$\rightarrow$ realisierte Strategien: + 1. SCAN-EDF (SCAN: Kopfbewegung nur in eine Richtung bis Mitte-/Randzylinder; EDF über alle angefragten Blöcke _in dieser Richtung_ ) + 2. Group Sweeping_ (SCAN mit nach Fristen gruppenweiser Bedienung) + 3. Mischstrategien +- Vereinfachung: + - o.g. Algorithmen i.d.R. zylinderorientiert $\rightarrow$ berücksichtigen bei Optimierung nur Positionierzeiten (Grund: Positionierzeit meist ≫Latenzzeit) + - ![Abb. nach (Deitel90) , Bild 12.2, S. 362](Assets/AdvancedOperatingSystems-sekundärspeicherverwaltung-festplatte.png) + +### Kommunikation und Synchronisation +- zeitlichen Nichtdeterminismus vermeiden: + 1. Interprozess-Kommunikation + - Minimierung blockierender Kommunikationsoperationen + - indirekte Kommunikation $\rightarrow$ CAB zum Geschwindigkeitsausgleich + - keine FIFO-Ordnungen (nach Fristen priorisieren) + - CAB ... Cyclic Asynchronous Buffer: ![Clark89](Assets/AdvancedOperatingSystems-kommunikation-cab.png) + 2. Synchronisation + - keine FIFO-Ordnungen, z.B. bei Semaphor-Warteschlangen (vgl. o.) + +#### Cyclic Asynchronous Buffer (CAB) +Kommunikation zwischen 1 Sender und n Empfängern: +- nach erstem Schreibzugriff: garantiert niemals undefinierte Wartezeiten +durch Blockierung von Sender/Empfänger +- Lesen/Überschreiben in zyklischer Reihenfolge: + - ![](Assets/AdvancedOperatingSystems-kommunikation-zyklisch-cab.png) +- Implementierung: + - MRW: Most-Recently-Written; Zeiger auf jüngstes, durch Sender vollständig geschriebenes Element + - LRW: Least-Recently-Written; Zeiger auf ältestes durch Sender geschriebenes Element + - Garantien: + - sowohl _MRW_ als auch _LRW_ können ausschließlich durch Sender manipuliert werden $\rightarrow$ keine inkonsistenten Zeiger durch konkurrierende Schreibzugriffe! + - sowohl _MRW_ als auch _LRW_ zeigen niemals auf ein Element, das gerade geschrieben wird $\rightarrow$ keine inkonsistenten Inhalte durch konkurrierende Schreib-/Lesezugriffe! + - Regeln für Sender: + - muss **nach** jedem Schreiben _MRW_ auf geschriebenes Element setzen + - muss **bevor** _LRW_ geschrieben wird _LRW_ inkrementieren + - Regel für Empfänger: muss immer nach Lesen von _MRW_ als nächstes _LRW_ anstelle des Listennachbarn lesen +- Sender-Regeln: + - anschaulich, ohne aktiven Empfänger + - ![](Assets/AdvancedOperatingSystems-cab-sender-regel.png) +- Empfänger-Regel: + - anschaulich, ohne aktiven Sender + - ![](Assets/AdvancedOperatingSystems-cab-empfänger.png) + +Sonderfall 1: Empfänger schneller als Sender + - nach Zugriff auf MRW muss auf Lesesequenz bei LRW fortgesetzt werden $\rightarrow$ transparenter Umgang mit nicht-vollem Puffer + - Abschwächung der Ordnungsgarantien:Empfänger weiß nur, dass Aktualität der Daten zwischen LRW und MRW liegt + - Empfänger (nach min. einem geschriebenen Element) niemals durch leeren Puffer blockiert + - ![](Assets/AdvancedOperatingSystems-cab-sonderfall-1.png) + +Sonderfall 2: Sender schneller als Empfänger + - Schreiben in Puffer grundsätzlich in Reihenfolge der Elemente $\rightarrow$ keine blockierenden Puffergrenzen $\rightarrow$ niemals Blockierung des Senders + - keine Vollständigkeitsgarantien:Empfänger kann nicht sicher sein, eine temporal stetige Sequenz zu lesen + - $\rightarrow$ Szenarien, in denen Empfänger sowieso nur an aktuellsten Daten interessiert (z.B. Sensorwerte) + - ![](Assets/AdvancedOperatingSystems-cab-sonderfall-2.png) + +Konkurrierende Zugriffe: +- ... sind durch Empfänger immer unschädlich (da lesend) +- ... müssen vom Sender nach Inkrementieren von LRW nicht-blockierend erkannt werden (klassisches Semaphormodell ungeeignet) +- schnellerer Sender überspringtein gesperrtes Element durch erneutes Inkrementieren von LRW , muss MRW trotzdem nachziehen +- ![](Assets/AdvancedOperatingSystems-cab-konkurrierende-zugriffe.png) + + +## Architekturen und Beispiel-Betriebssysteme +- Architekturprinzipien: + - müssen Echtzeitmechanismen unterstützen; ermöglicht entsprechende Strategien zur Entwicklungs-oder Laufzeit (CPU-Scheduler, EA-Scheduler, IPC ...) + - müssen funktional geringe Komplexität aufweisen $\rightarrow$ theoretische und praktische Beherrschung von Nichtdeterminismus + - Theoretisch: Modellierung und Analyse (vgl. Annahmen für Scheduling-Planbarkeitsanalyse) + - Praktisch: Implementierung (vgl. RC-Scheduler, Prioritätsvererbung) +- Konsequenzen: + - Architekturen für komplementäre NFE: + - Sparsamkeit $\rightarrow$ hardwarespezifische Kernelimplementierung + - Adaptivität $\rightarrow$ μKernel, Exokernel + - zu vermeiden: + - starke Hardwareabstraktion $\rightarrow$ Virtualisierungsarchitekturen + - Kommunikation und Synchronisationskosten $\rightarrow$ verteilte BS + - Hardwareunabhängigkeit und Portabilität $\rightarrow$ vgl. Mach + +Auswahl: Beispiel-Betriebssysteme +- wir kennen schon: + - funktional kleine Kernelimplementierung: TinyOS + - hardwarespezifischer μKernel: L4-Abkömmlinge + - Mischung aus beidem: RIOT + - Kommerziell bedeutender μKernel: QNX Neutrino +- weitere Vertreter: + - hardwarespezifische Makrokernel: VRTX, VxWorks + - μKernel: DRYOS, DROPS + - ,,Exokernel'' ...? + +VRTX (Versatile Real-Time Executive) +- Entwickler: + - Hunter & Ready +- Eckdaten: + - Makrokernel + - war erstes kommerzielles Echtzeitbetriebssystem für eingebettete Systeme + - heutige Bedeutung eher historisch + - Nachfolger (1993 bis heute): Nucleus RTOS (Siemens) +- Anwendung: + - Eingebettete Systeme in Automobilen(Brems-und ABS-Controller) + - Mobiltelefone + - Geldautomaten +- Einsatzgebiete + - spektakulär: im Hubble-Weltraumteleskop + +VxWorks +- Entwickler: + - Wind River Systems (USA) +- Eckdaten: + - modularer Makrokernel + - Konkurrenzprodukt zu VRTX + - Erfolgsfaktor: POSIX-konforme API + - ähnlich QNX: ,,skalierbarer'' Kernel,zuschneidbarauf Anwendungsdomäne ($\rightarrow$ Adaptivitätsansatz) +- Anwendung: + - eingebettete Systeme: + - industrielle Robotersteuerung + - Luft-und Raumfahrt + - Unterhaltungselektronik +- Einsatzgebiete + - Deep-Impact-Mission zur Untersuchung des Kometen Temple 1 + - NASA Mars Rover + - SpaceX Dragon + +DRYOS® +- Entwickler: Canon Inc. +- Eckdaten: + - Mikrokernel(Größe: 16 kB) + - Echtzeit-Middleware (Gerätetreiber $\rightarrow$ Objektive) + - Anwendungen: AE-und AF-Steuerung/-Automatik, GUI, Bildbearbeitung, RAW-Konverter, ... + - POSIX-kompatible Prozessverwaltung +- ![Abb.: http://www.canon.com/technology/canon_tech/explanation/dryos.html, Jul. 2016](Assets/AdvancedOperatingSystems-dryos.png) + +DROPS (Dresden Real-Time Operating System) +- Entwickler: TU Dresden, Lehrstuhl Betriebssysteme +- Eckdaten: Multi-Server-Architektur auf Basis eines L4-Mikrokerns +- ![Abb. nach (Hamann+97) , S.289](Assets/AdvancedOperatingSystems-drops.png) + + +# Adaptivität +## Motivation +- als unmittelbar geforderte NFE: + - eingebettete Systeme + - Systeme in garstiger Umwelt (Meeresgrund, Arktis, Weltraum, ...) + - Unterstützung von Cloud-Computing-Anwendungen + - Unterstützung von Legacy-Anwendungen +- Beobachtung: genau diese Anwendungsdomänen fordern typischerweise auch andere wesentliche NFE (s.bisherige Vorlesung ...) +- $\rightarrow$ Adaptivität als komplementäre NFE zur Förderung von + - Robustheit: funktionale Adaptivitätdes BS reduziert Kernelkomplexität ($\rightarrow$ kleiner, nicht adaptiver μKernel) + - Sicherheit: wie Robustheit:TCB-Größe $\rightarrow$ Verifizierbarkeit, außerdem: adaptive Reaktion auf Bedrohungen + - Echtzeitfähigkeit: adaptive Scheduling-Strategie (vgl. RC), adapt. Überlastbehandlung, adapt. Interruptbehandlungs-und Pinning-Strategien + - Performanz: Last-und Hardwareadaptivität + - Erweiterbarkeit: adaptive BS liefern oft hinreichende Voraussetzungen der einfachen Erweiterbarkeit von Abstraktionen, Schnittstellen, Hardware-Multiplexing-und -Schutzmechanismen ( Flexibility ) + - Wartbarkeit: Anpassung des BS an Anwendungen, nicht umgekehrt + - Sparsamkeit: Lastadaptivitätvon CPUs, adaptive Auswahl von Datenstrukturen und Kodierungsverfahren + +## Adaptivitätsbegriff +- Adaptability: ,,see Flexibility. '' [Marciniak94] +- Flexibility: + - ,,The ease with which a system or a component can be modified for use in applications or environments other than those for which it was specifically designed.'' (IEEE) + - für uns: entspricht Erweiterbarkeit +- Adaptivität: (unsere Arbeitsdefinition) + - Die Fähigkeit eines Systems, sich an ein breites Spektrum verschiedener Anforderungen anpassen zu lassen. + - = ... so gebaut zu sein, dass ein breites Spektrum verschiedener nicht funktionaler Eigenschaften unterstützt wird. + - letztere: komplementär zur allgemeinen NFE Adaptivität + +## Roadmap +- in diesem Kapitel: gleichzeitig Mechanismen und Architekturkonzepte +- Adaptivität jeweils anhand komplementärer Eigenschaften dargestellt: + - Exokernel: { Adaptivität } ∪ { Performanz, Echtzeitfähigkeit,Wartbarkeit, Sparsamkeit } + - Virtualisierung: { Adaptivität } ∪ { Wartbarkeit, Sicherheit, Robustheit } + - Container: { Adaptivität } ∪ { Wartbarkeit, Portabilität, Sparsamkeit } +- Beispielsysteme: + - Exokernel-Betriebssysteme: Aegis/ExOS, Nemesis, MirageOS + - Virtualisierung: Vmware, VirtualBox, Xen + - Containersoftware: Docker + +## Exokernelarchitektur +- Grundfunktion von Betriebssystemen + - physische Hardware darstellen als abstrahierte Hardware mit komfortableren Schnittstellen + - ![](Assets/AdvancedOperatingSystems-exokernelarchitekturen.png) + - Schnittstelle zu Anwendungen (API) : bietet dabei exakt die gleichen Abstraktionen der Hardware für alle Anwendungen an, z.B. + - **Prozesse:** gleiches Zustandsmodell, gleiches Threadmodell + - **Dateien:** gleiche Namensraumabstraktion + - **Adressräume:** gleiche Speicherverwaltung (VMM, Seitengröße, Paging) + - **Interprozesskommunikation:** gleiche Mechanismen für alle Anwendungsprozesse +- Problem: + - Implementierungsspielraumfür Anwendungen wird begrenzt: + 1. Vorteile domänenspezifischer Optimierungender Hardwarebenutzung können nicht ausgeschöpft werden $\rightarrow$ **Performanz, Sparsamkeit** + 2. die Implementierung existierender Abstraktionen kann bei veränderten Anforderungen nicht an Anwendungen angepasst werden $\rightarrow$ **Wartbarkeit** + 3. Hardwarespezifikationen, insbesondere des Zeitverhaltens (E/A, Netzwerk etc.), werden von Effekten des BS-Management überlagert $\rightarrow$ **Echtzeitfähigkeit** +- Idee von Exokernel-Architekturen: + - ![](Assets/AdvancedOperatingSystems-exokernel-architektur.png) + - ![Abb. nach (Engler98) , Abb. 1-1, S.12](Assets/AdvancedOperatingSystems-exokernel-beispiel.png) + +### Exokernelmechanismen +- Designprinzip von Exokernelmechanismen: + - Trennung von Schutz und Abstraktion der Ressourcen + - Ressourcen-Schutz und -Multiplexing: verbleibt beim Betriebssystemkernel(dem Exokernel) + - Ressourcen-Abstraktion (und deren Management): zentrale Aufgabe der Library-Betriebssysteme + - $\rightarrow$ autonome Management-Strategien durch in Anwendungen importierte Funktionalität + - Resultat: + 1. systemweit(durch jeweiliges BS vorgegebene) starre Hardware-Abstraktionen vermieden + 2. anwendungsdomänenspezifische Abstraktionen sehr einfach realisierbar + 3. (Wieder-) Verwendung eigener und fremder Managementfunktionalität wesentlich erleichtert $\rightarrow$ komplementäre NFEn! (Performanz, EZ-Fähigkeit, Sparsamkeit, ...) +- Funktion des Exokernels: + - Prinzip: definiert Low-level-Schnittstelle + - ,,low-level'' = so hardwarenah wie möglich, bspw. die logische Schnittstelle eines elektronischen Schaltkreises/ICs ($\rightarrow$ Gerätetreiber $\subseteq$ Library-BS!) + - Bsp.: der Exokernelmuss den Hauptspeicher schützen, aber nicht verstehen, wie dieser verwaltet wird $\rightarrow$ Adressierung ermöglichen ohne Informationen über Seiten, Segmente, Paging-Attribute, ... + - Library-Betriebssysteme: implementieren darauf jeweils geeignete anwendungsnahe Abstraktionen + - Bsp.: Adressraumsemantik, Seitentabellenlayout und -verwaltung, Paging-und Locking-Verfahren, ... + - Anwendungsprogrammierer: wählen geeignete Library-Betriebssysteme bzw. schreiben ihre eigenen Exokernelmechanismen +- prinzipielle Exokernelmechanismen am Beispiel Aegis/ExOS [Engler+95] + - Der Exokernel... + - _implementiert:_ Multiplexing der Hardware-Ressourcen + - _exportiert:_ geschützte Hardware-Ressourcen +- minimal: drei Arten von Mechanismen + 1. Secure Binding: erlaubt geschützte Verwendung von Hardware-Ressourcen durch Anwendungen, Behandlung von Ereignissen + 2. Visible ResourceRevocation: beteiligt Anwendungen am Entzug von Ressourcen mittels (kooperativen) Ressourcen-Entzugsprotokolls + 3. Abort-Protokoll: erlaubt ExokernelBeendigung von Ressourcenzuordnungen bei unkooperativen Applikationen + +### Secure Binding +- Schutzmechanismus, der Autorisierung ($\rightarrow$ Library-BS)zur Benutzung einer Ressource von tatsächlicher Benutzung ($\rightarrow$ Exokernel) trennt +- implementiert für den Exokernelerforderliches Zuordnungswissenvon (HW-)Ressource zu Mangement-Code (der im Library-BS implementiert ist) +- $\rightarrow$ ''Binding'' in Aegis implementiert als Unix-Hardlinkauf Metadatenstruktur zu einem Gerät im Kernelspeicher ( ,,remember: everythingisa file...'' ) +- Zur Implementierung benötigt: + - Hardware-Unterstützung zur effizienten Rechteprüfung (insbes. HW-Caching) + - Software-Caching von Autorisierungsentscheidungen im Kernel (bei Nutzung durch verschiedene Library-BS) + - Downloadingvon Applikationscode in Kernel zur effizienten Durchsetzung (quasi: User-Space-Implementierung von Systemaufrufcode) +- einfach ausgedrückt: ,,Secure Binding'' erlaubt einem ExokernelSchutz von Ressourcen, ohne deren Semantik verstehen zu müssen. + +### Visible Resource Revocation +- monolithische Betriebssysteme: entziehen Ressourcen ,,unsichtbar'' (invisible), d.h. transparent für Anwendungen + - Vorteil: im allgemeinen geringere Latenzzeiten, einfacheres und komfortableres Programmiermodell + - Nachteil: Anwendungen(hier: die eingebetteten Library-BS) erhalten keine Kenntnis über Entzug,bspw. aufgrund von Ressourcenknappheit etc. + - $\rightarrow$ erforderliches Wissen für Management-Strategien! +- Exokernel-Betriebssysteme: entziehen(überwiegend) Ressourcen ,,sichtbar''$\rightarrow$ Dialog zwischen Exokernel und Library-BS + - Vorteil: effizientes Management durch Library-BS möglich (z.B. Prozessor: nur tatsächlich benötigte Register werden bei Entzug gespeichert) + - Nachteil : Performanz bei sehr häufigem Entzug, Verwaltungs-und Fehlerbehandlungsstrategien zwischen verschiedenen Library-BS müssen korrekt und untereinander kompatibelsein... + - $\rightarrow$ Abort - Protokoll notwendig, falls dies nicht gegeben ist + +### Abort - Protokoll +- Ressourcenentzug bei unkooperativen Library-Betriebssystemen ( Konflikt mit Anforderung durch andere Anwendung/deren Library-BS: Verweigerung der Rückgabe, zu späte Rückgabe, ...) +- notwendig aufgrund von Visible Ressource Revocation +- Dialog: + - Exokernel: ,,Bitte Seitenrahmen x freigeben.'' + - Library-BS: ,,...'' + - Exokernel: ,,Seitenrahmen x innerhalb von 50 μs freigeben!'' + - Library-BS: ,,...'' + - Exokernel: (führt Abort-Protokoll aus) + - Library-BS: X (,,Abort'' in diesem Bsp. = Anwendungsprozess terminieren) +- In der Praxis: + - harte Echtzeit-Fristen (,, innerhalb von 50 μs'' ) in den wenigsten Anwendungen berücksichtigt + - $\rightarrow$ Abort = lediglich Widerruf aller Secure Bindings der jeweiligen Ressource für die unkooperativeAnwendung, nicht deren Terminierung (= unsichtbarerRessourcenentzug) + - $\rightarrow$ anschließend: Informieren des entsprechenden Library-BS + - ermöglicht sinnvolle Reaktion des Library-BS (in Library-BS wird ,,Repossession''-Exceptionausgelöst, so dass auf Entzug geeignet reagiert werden kann) + - bei zustandsbehafteten Ressourcen ($\rightarrow$ CPU): Exokernelkann diesen Zustand auf Hintergrundspeicher sichern $\rightarrow$ Management-Informationen zum Aufräumen durch Library-BS + +### Exokernelperformanz +- Was macht Exokern-Architekturen adaptiv(er)? + - Abstraktionen und Mechanismen des Betriebssystems können den Erfordernissen der Anwendungen angepasst werden + - (erwünschtes) Ergebnis: beträchtliche Performanzsteigerungen (vgl. komplementäre Ziel-NFE: Performanz, Echtzeitfähigkeit, Wartbarkeit, Sparsamkeit ) + +Performanzstudien +1. Aegis mit Library-BS ExOS (MIT: Dawson Engler, Frans Kaashoek) +2. Xok mit Library-BS ExOS (MIT) +3. Nemesis (Pegasus-Projekt, EU) +4. XOmB (U Pittsburgh) +5. ... + +Aegis/ExOSals erweiterte Machbarkeitsstudie [Engler+95] +1. machbar: sehr effiziente Exokerne + - Grundlage: begrenzte Anzahl einfacher Systemaufrufe (Größenordnung ~10) und Kernel-interne Primitiven (,,Pseudo-Maschinenanweisungen''), die enthalten sein müssen +2. machbar: sicheres Hardware-Multiplexing auf niedriger Abstraktionsebene (,,low-level'') mit geringem Overhead +3. traditionelle Abstraktionen (VMM, IPC) auf Anwendungsebene effizient implementierbar $\rightarrow$ einfache Erweiterbarkeit, Spezialisierbarkeitbzw. Ersetzbarkeit dieser Abstraktionen +4. für Anwendungen: hochspezialisierte Implementierungen von Abstraktionen generierbar, die genau auf Funktionalität und Performanz-Anforderungen dieser Anwendung zugeschnitten +5. geschützte Kontrollflussübergabe: als IPC-Primitive im Aegis-Kernel, 7-mal schnellerals damals beste Implementierung (vgl. [Liedtke95], Kap. 3) +6. Ausnahmebehandlung bei Aegis: 5-mal schneller als bei damals bester Implementierung +7. durch Aegis möglich: Flexibilität von ExOS, die mit Mikrokernel-Systemen nicht erreichbar ist: + - Bsp. VMM: auf Anwendungsebene implementiert, wo diese sehr einfach mit DSM-Systemen u. Garbage-Kollektoren verknüpfbar +8. Aegis erlaubt Anwendungen Konstruktion effizienter IPC-Primitiven (∆ μKernel: nicht vertrauenswürdige Anwendungen könnenkeinerlei spezialisierte IPC-Primitiven nutzen, geschweige denn selbst implementieren) + +Xok/ExOS +- praktische Weiterentwicklung von Aegis: Xok +- für x86-Hardware implementiert +- Kernel-Aufgaben (wie gehabt): Multiplexing von Festplatte, Speicher, Netzwerkschnittstellen, ... +- Standard Library-BS (wie bei Aegis): ExOS + - ,,Unix as a Library'' + - Plattform für unmodifizierte Unix-Anwendungen (csh, perl, gcc, telnet, ftp, ...) +- z.B. Library-BS zum Dateisystem-Management: C-FFS + - hochperformant (im Vergleich mit Makrokernel-Dateisystem-Management) + - Abstraktionen und Operationen auf Exokernel-Basis (u.a.): Inodes, Verzeichnisse, physische Dateirelokation($\rightarrow$ zusammenhängendes Lesen) + - Secure Bindings für Metadaten-Modifikation +- Forschungsziele: + - Aegis: Proof-of-Concept + - XOK: Proof-of-Feasibility (Performanz) +- ![Abb.: (Engler+96)](Assets/AdvancedOperatingSystems-exos.png) + +Zwischenfazit: Exokernelarchitektur +- Ziele: + - Performanz, Sparsamkeit: bei genauer Kenntnis der Hardware ermöglicht deren direkte BenutzungAnwendungsentwicklern Effizienzoptimierung + - Wartbarkeit: Hardwareabstraktionen sollen flexibel an Anwendungsdomänen anpassbar sein, ohne das BS modifizieren/wechseln zu müssen + - Echtzeitfähigkeit: Zeitverhaltendes Gesamtsystems durch direkte Steuerung der Hardware weitestgehend durch (Echtzeit-) Anwendungen kontrollierbar +- Idee: + - User-Space:anwendungsspezifische Hardwareabstraktionen im User-Space implementiert + - Kernel-Space:nur Multiplexing und Schutz der HW-Schnittstellen + - in der Praxis: kooperativer Ressourcenentzug zwischen Kernel, Lib. OS +- Ergebnisse: + - hochperformanteHardwarebenutzung durch spezialisierte Anwendungen + - funktional kleiner Exokernel($\rightarrow$ Sparsamkeit, Korrektheit des Kernelcodes ) + - flexible Nutzung problemgerechterHW-Abstraktionen ( readymade Lib. OS) + - keine Isolation von Anwendungen ($\rightarrow$ Parallelisierbarkeit: teuer und mit schwachen Garantien; $\rightarrow$ Robustheit und Sicherheit der Anwendungen: nicht umsetzbar) + +## Virtualisierung +- Ziele (zur Erinnerung): + - Adaptivität + - Wartbarkeit, Sicherheit, Robustheit + - $\rightarrow$ auf gleicher Hardware mehrere unterschiedliche Betriebssysteme ausführbar machen +- Idee: ![](Assets/AdvancedOperatingSystems-virtualisierung-idee.png) + +Ziele von Virtualisierung +- Adaptivität: ( ähnlich wie bei Exokernen) + - können viele unterschiedliche Betriebssysteme - mit jeweils unterschiedlichen Eigenschaften ausgeführt werden damit können: Gruppen von Anwendungen auf ähnliche Weise jeweils unterschiedliche Abstraktionen etc. zur Verfügung gestellt werden +- Wartbarkeit: + - Anwendungen - die sonst nicht gemeinsam auf gleicher Maschine lauffähig - auf einer phyischenMaschine ausführbar + - ökonomische Vorteile: Cloud-Computing, Wartbarkeit von Legacy-Anwendungen +- Sicherheit: + - Isolation von Anwendungs-und Kernelcode durch getrennte Adressräume (wie z.B. bei Mikrokern-Architekturen) + - somit möglich: + 1. Einschränkung der Fehlerausbreitung $\rightarrow$ angreifbare Schwachstellen + 2. Überwachung der Kommunikation zwischen Teilsystemen + - darüber hinaus: Sandboxing (vollständig von logischer Ablaufumgebung isolierte Software, typischerweise Anwendungen $\rightarrow$ siehe z.B. Cloud-Computing) +- Robustheit: + - siehe Sicherheit! + +Architekturvarianten - drei unterschiedliche Prinzipien: +1. Typ-1 - Hypervisor ( früher: VMM - ,,Virtual MachineMonitor'' ) +2. Typ-2 - Hypervisor +3. Paravirtualisierung + +### Typ-1 - Hypervisor +- ![](Assets/AdvancedOperatingSystems-virtualisierung-hypervisor-1.png) +- Idee des Typ- 1 - Hypervisors: + - Kategorien traditioneller funktionaler Eigenschaften von BS: + 1. Multiplexing & Schutz der Hardware (ermöglicht Multiprozess-Betrieb) + 2. abstrahierte Maschine** mit ,,angenehmerer'' Schnittstelle als die reine Hardware (z.B. Dateien, Sockets, Prozesse, ...) +- Typ- 1 - Hypervisor trennt beide Kategorien: + - läuft wie ein Betriebssystem unmittelbar über der Hardware + - bewirkt Multiplexing der Hardware, liefert aber keine erweiterte Maschine** an Anwendungsschicht $\rightarrow$ ,,Multi-Betriebssystem-Betrieb'' +- Bietet mehrmals die unmittelbare Hardware-Schnittstelle an, wobei jede Instanz eine virtuelle Maschine jeweils mit den unveränderten Hardware-Eigenschaften darstellt (Kernel u. User Mode, Ein-/Ausgaben usw.). +- Ursprünge: Time-Sharing an Großrechnern + - Standard-BS auf IBM-Großrechner System/360: OS/360 + - reines Stapelverarbeitungs-Betriebssystem (1960er Jahre) + - Nutzer (insbes. Entwickler) strebten interaktive Arbeitsweise an eigenem Terminal an $\rightarrow$ timesharing (MIT, 1962: CTSS) + - IBM zog nach: CP/CMS, später VM/370 $\rightarrow$ z/VM + - CP: Control Program $\rightarrow$ Typ- 1 - Hypervisor + - CMS: ConversationalMonitor System $\rightarrow$ Gast-BS + - CP lief auf ,,blanker'' Hardware (Begriff geprägt: ,,bare metal hypervisor'' ) + - lieferte Menge virtueller Kopiender System/360-Hardware an eigentliches Timesharing-System + - je eines solche Kopie pro Nutzer $\rightarrow$ unterschiedliche BS lauffähig (da jede virtuelle Maschine exakte Kopie der Hardware) + - in der Praxis: sehr leichtgewichtiges, schnelles Einzelnutzer-BS als Gast $\rightarrow$ CMS (heute wäre das wenig mehr als ein Terminal-Emulator...) +- heute: Forderungen nach Virtualisierung von Betriebssystemen + - seit 1980er: universeller Einsatz des PC für Einzelplatz- und Serveranwendungen $\rightarrow$ veränderte Anforderungen an Virtualisierung + - Wartbarkeit: vor allem ökonomische Gründe: + 1. Anwendungsentwicklung und -bereitstellung: verschiedene Anwendungen in Unternehmen, bisher auf verschiedenen Rechnern mit mehreren (oft verschiedenen) BS, auf einem Rechner entwickeln und betreiben (Lizenzkosten!) + 2. Administration: einfache Sicherung, Migration virtueller Maschinen + 3. Legacy-Software + - später: Sicherheit, Robustheit $\rightarrow$ Cloud-Computing-Anwendungen +- ideal hierfür: Typ- 1 - Hypervisor + - ✓ Gast-BS angenehm wartbar + - ✓ Softwarekosten beherrschbar + - ✓ Anwendungen isolierbar + +Hardware-Voraussetzungen +- Voraussetzungen zum Einsatz von Typ-1-HV + - Ziel: Nutzung von Virtualisierung auf PC-Hardware + - systematische Untersuchung der Virtualisierbarkeit von Prozessoren bereits 1974 durch Popek & Goldberg [Popek&Goldberg74] + - Ergebnis: + - Gast-BS (welches aus Sicht der CPU im User Mode - also unprivilegiert läuft) muss sicher sein können, dass privilegierte Instruktionen (Maschinencode im Kernel) ausgeführt werden + - dies geht nur, wenn tatsächlich der HV diese Instruktionen ausführt! + - dies geht nur, wenn CPU bei jeder solchen Instruktion im Nutzermodus Kontextwechsel zum HV ausführen, welcher Instruktion emuliert! +- virtualisierbare Prozessoren bis ca. 2006: + - ✓ IBM-Architekturen(bekannt: PowerPC, bis 2006 Apple-Standard) + - ✗ Intel x86-Architekturen (386, Pentium, teilweise Core i) + +Privilegierte Instruktionen **ohne** Hypervisor +- kennen wir schon: Instruktion für Systemaufrufe +1. User Mode: Anwendung bereitet Befehl und Parameter vor +2. User Mode: Privilegierte Instruktion (syscall/Trap - Interrupt) $\rightarrow$ CPU veranlasst Kontext-und Privilegierungswechsel, Ziel: BS-Kernel +3. Kernel Mode: BS-Dispatcher (Einsprungpunkt für Kernel-Kontrollfluss) behandelt Befehl und Parameter, ruft weitere privilegierte Instruktionen auf (z.B. EA-Code) +- ![](Assets/AdvancedOperatingSystems-instruction-ohne-hypervisor.png) + +Privilegierte Instruktionen mit Typ- 1 - Hypervisor(1) +- zum Vergleich: Instruktion für Systemaufrufe des Gast-BS +1. User Mode: Anwendung bereitet Befehl und Parameter vor +2. User Mode: Trap $\rightarrow$ Kontext-und Privilegierungswechsel, Ziel: Typ-1-HV +3. Kernel Mode: HV-Dispatcher ruft Dispatcher im Gast-BS auf +4. User Mode: BS-Dispatcher behandelt Befehl und Parameter, ruft weitere privilegierte Instruktionenauf (z.B. EA-Code) $\rightarrow$ Kontext-und Privilegierungswechsel, Ziel: Typ-1-HV +5. Kernel Mode: HV führt privilegierte Instruktionen anstelle des Gast-BS aus +- ![](Assets/AdvancedOperatingSystems-instruction-mit-typ1-hv.png) + +Sensible und privilegierte Instruktionen: Beobachtungen an verschiedenen Maschinenbefehlssätzen: [Popek&Goldberg74] +- $\exists$ Menge an Maschinenbefehlen, die nur im Kernel Mode ausgeführt werden dürfen (Befehle zur Realisierung von E/A, Manipulation der MMU, ...) + - $\rightarrow$ sensible Instruktionen +- $\exists$ Menge an Maschinenbefehlen, die Wechsel des Privilegierungsmodus auslösen (x86: Trap ), wenn sie im User Mode ausgeführt werden + - $\rightarrow$ privilegierte Instruktionen +- Prozessor ist virtualisierbarfalls (notw. Bed.): sensible Instruktionen $\subseteq$ privilegierte Instruktionen +- Folge: jeder Maschinenbefehl, der im Nutzermodus nicht erlaubt ist, muss einen Privilegierungswechsel auslösen (z.B. Trap generieren) +- kritische Instruktionen = sensible Instruktionen \ privilegierte Instruktionen + - Befehle, welche diese Bedingung verletzen $\rightarrow$ Existenz im Befehlssatz führt zu nicht-virtualisierbarem Prozessor +- Beispiele für sensible Instruktionen bei Intel x86: + - hlt: Befehlsabarbeitung bis zum nächsten Interrupt stoppen + - invlpg: TLB-Eintrag für Seite invalidieren + - lidt: IDT (interrupt descriptor table) neu laden + - mov auf Steuerregistern + - ... +- Beispiel: Privilegierte Prozessorinstruktionen + - Bsp.: write - Systemaufruf + - Anwendungsprogramm schreibt String in Puffer eines Ausgabegeräts ohne Nutzung der libc Standard-Bibliothek: + `asm ( "int $0x80" ); /* interrupt 80 (trap) */` + - Interrupt-Instruktion veranlasst Prozessor zum Kontextwechsel: Kernelcode im privilegierten Modus ausführen + +Vergleich: Privilegierte vs. sensible Instruktionen +- ![](Assets/AdvancedOperatingSystems-instruction-priv-vs-sensible.png) + +Folgen für Virtualisierung +- privilegierte Instruktionen bei virtualisierbaren Prozessoren +- bei Ausführung einer privilegierten Instruktion in virtueller Maschine: immer Kontrollflussübergabe an im Kernel-Modus laufende Systemsoftware - hier Typ-1-HV +- HV kann (anhand des virtuellen Privilegierungsmodus) feststellen: + 1. ob sensible Anweisung durch Gast-BS + 2. oder durch Nutzerprogramm (Systemaufruf!) ausgelöst +- Folgen: + 1. privilegierte Instruktionen des Gast-Betriebssystems werden ausgeführt $\rightarrow$ ,,trap-and-emulate'' + 2. Einsprung in Betriebssystem, hier also Einsprung in Gast-Betriebssystem $\rightarrow$ Upcall durch HV +- privilegierte Instruktionen bei nicht virtualisierbaren Prozessoren + - solche Instruktionen typischerweise ignoriert! + +Intel-Architektur ab 386 +- dominant im PC-und Universalrechnersegment ab 1980er +- keine Unterstützung für Virtualisierung ... +- kritische Instruktionen im User Mode werden von CPU ignoriert +- außerdem: in Pentium-Familie konnte Kernel-Code explizit feststellen, ob er im Kernel- oder Nutzermodus läuft $\rightarrow$ Gast-BS trifft (implementierungsabhängig) evtl. fatal fehlerhafte Entscheidungen +- Diese Architekturprobleme (bekannt seit 1974) wurden 20 Jahre lang im Sinne von Rückwärtskompatibilität auf Nachfolgeprozessoren übertragen ... + - erste virtualisierungsfähige Intel-Prozessorenfamilie (s. [Adams2006] ): VT, VT-x® (2005) + - dito für AMD: SVM, AMD-V® (auch 2005) + +Forschungsarbeit 1990er Jahre +- verschiedene akademische Projekte zur Virtualisierung bisher nicht virtualisierbarer Prozessoren +- erstes und vermutlich bekanntestes: DISCO- Projekt der University of Stanford +- Resultat: letztlich VMware (heute kommerziell) und Typ-2-Hypervisors... + +### Typ-2-Hypervisor +![](Assets/AdvancedOperatingSystems-typ-2-hypervisor.png) + +Virtualisierung ohne Hardwareunterstützung: +- keine Möglichkeit, trap-and-emulate zu nutzen +- keine Möglichkeit, um + 1. korrekt (bei sensiblen Instruktionen im Gast-Kernel) den Privilegierungsmodus zu wechseln + 2. den korrekten Code im HV auszuführen + +Übersetzungsstrategie in Software: +- vollständige Übersetzung des Maschinencodes, der in VM ausgeführt wird, in Maschinencode, der im HV ausgeführt wird +- praktische Forderung: HV sollte selbst abstrahierte HW-Schnittstelle zur Ausführung des (komplexen!) Übersetzungscodes zur Verfügung haben (z.B. Nutzung von Gerätetreibern) +- $\rightarrow$ Typ-2-HV als Kompromiss: + - korrekte Ausführung von virtualisierter Software auf virtualisierter HW + - beherrschbare Komplexität der Implementierung + +aus Nutzersicht +- läuft als gewöhnlicher Nutzer-Prozess auf Host-Betriebssystem (z.B. Windows oder Linux) +- VMware bedienbarwie physischer Rechner (bspw. erwartet Bootmedium in virtueller Repräsentation eines physischen Laufwerks) +- persistente Daten des Gast-BS auf virtuellem Speichermedium ( tatsächlich: Image-Datei aus Sicht des Host-Betriebssystems) + +Mechanismus: Code-Inspektion +- Bei Ausführung eines Binärprogramms in der virtuellen Maschine (egal ob Bootloader, Gast-BS-Kernel, Anwendungsprogramm): zunächst inspiziert Typ-2-HV den Code nach Basisblöcken + - Basisblock: Befehlsfolge, die mit privilegierten Befehlen oder solchen Befehlen abgeschlossen ist, die den Kontrollfluss ändern (sichtbar an Manipulation des Programm-Zählers eip), z.B. jmp, call, ret. +- Basisblöcke werden nach sensiblen Instruktionen abgesucht +- diese werden jeweils durchAufruf einer HV-Prozedur ersetzt, die jeweilige Instruktion behandelt +- gleiche Verfahrensweise mit letzter Instruktion eines Basis-Blocks + +Mechanismus: Binary Translation (Binärcodeübersetzung) +- modifizierter Basisblock: wird innerhalbdes HVin Cachegespeichert und ausgeführt +- Basisblock ohne sensible Instruktionen: läuft unter Typ-2-HV exakt so schnell wie unmittelbar auf Hardware (weil er auch tatsächlich unmittelbar auf der Hardware läuft, nur eben im HV-Kontext) +- sensible Instruktionen: nach dargestellter Methode abgefangen und emuliert $\rightarrow$ dabei hilft jetzt das Host-BS (z.B. durch eigene Systemaufrufe, Gerätetreiberschnittstellen) + +Mechanismus: Caching von Basisblöcken +- HV nutzt zwei parallel arbeitende Module (Host-BS-Threads!): + - Translator: Code-Inspektion, Binary Translation + - Dispatcher: Basisblock-Ausführung +- zusätzliche Datenstruktur: Basisblock-Cache +- Dispatcher: sucht Basisblock mit jeweils nächster auszuführender Befehlsadresse im Cache; falls miss $\rightarrow$ suspendieren (zugunsten Translator) +- Translator: schreibt Basisblöcke in Basisblock-Cache +- Annahme: irgendwann ist Großteil des Programms im Cache, dieses läuft dann mit nahezu Original-Geschwindigkeit (theoretisch) + +Performanzmessungen +- zeigen gemischtes Bild: Typ2-HV keinesfalls so schlecht, wie einst erwartet wurde +- qualitativer Vergleich mit virtualisierbarer Hardware (Typ1-Hypervisor): +- ,,trap-and-emulate,,: erzeugt Vielzahl von Traps $\rightarrow$ Kontextwechsel zwischen jeweiliger VM und HV +- insbesondere bei Vielzahl an VMs sehr teuer: CPU-Caches, TLBs, Heuristiken zur spekulativen Ausführung werden verschmutzt +- wenn andererseits sensible Instruktionen durch Aufruf von VMware-Prozeduren innerhalb des ausführenden Programms ersetzt: keine Kontextwechsel-Overheads + +Studie: (von Vmware) [Adams&Agesen06] +- last-und anwendungsabhängig kann Softwarelösung sogar Hardwarelösung übertreffen +- Folge: viele moderne Typ1-HV benutzen aus Performanzgründen ebenfalls Binary Translation + +### Paravirtualisierung +Funktionsprinzip +- ... unterscheidet sich prinzipiell von Typ-1/2-Hypervisor +- wesentlich: Quellcode des Gast-Betriebssystems modifiziert +- sensible Instruktionen: durch Hypervisor-Calls ersetzt +- Folge: Gast-Betriebssystem arbeitet jetzt vollständig wie Nutzerprogramm, welches Systemaufrufe zum Betriebssystem (hier dem Hypervisor) ausführt +- dazu: + - Hypervisor: muss geeignetes Interface definieren (HV-Calls) + - $\rightarrow$ Menge von Prozedur-Aufrufen zur Benutzung durch Gast-Betriebssystem + - bilden eine HV-API als Schnittstelle für Gast-Betriebssysteme (nicht für Nutzerprogramme!) +- mehr dazu: Xen + +Verwandtschaft mit Mikrokernel-Architekturen +- Geht man vom Typ-1-HV noch einen Schritt weiter ... + - und entfernt alle sensiblen Instruktionen aus Gast-Betriebssystem ... + - und ersetzt diese durch Hypervisor-Aufrufe, um Systemdienste wie E/A zu benutzen, ... + - hat man praktisch den Hypervisor in Mikrokernel transformiert. +- ... und genau das wird auch schon gemacht: $L^4$Linux (TU Dresden) + - Basis: stringente $L^4\mu$ Kernel-Implementierung (Typ-1-HV-artiger Funktionsumfang) + - Anwendungslaufzeitumgebung: paravirtualisierter Linux-Kernel als Serverprozess + - Ziele: Isolation (Sicherheit, Robustheit), Echtzeitfähigkeit durch direktere HW-Interaktion (vergleichbar Exokernel-Ziel) + +Zwischenfazit Virtualisierung +- Ziele: Adaptivität komplementär zu... + - Wartbarkeit : ökonomischer Betrieb von Cloud-und Legacy-Anwendungen ohne dedizierte Hardware + - Sicherheit : sicherheitskritische Anwendungen können vollständig von nichtvertrauenswürdigen Anwendungen (und untereinander) isoliert werden + - Robustheit : Fehler in VMs (= Anwendungsdomänen) können nicht andere VMs beeinträchtigen +- Idee: drei gängige Prinzipien: + - Typ-1-HV: unmittelbares HW-Multiplexing, trap-and-emulate + - Typ-2-HV: HW-Multiplexing auf Basis eines Host-OS, binarytranslation + - Paravirtualisierung: Typ-1-HV für angepasstes Gast-OS, kein trap-and-emulate nötig $\rightarrow$ HV ähnelt $\mu$Kern +- Ergebnisse: + - ✓ VMs mit individuell anpassbarer Laufzeitumgebung + - ✓ isolierteVMs + - ✓ kontrollierbare VM-Interaktion (untereinander und mit HW) + - ✗ keine hardwarespezifischen Optimierungen aus VM heraus möglich $\rightarrow$ Performanz, Echtzeitfähigkeit, Sparsamkeit! + +## Container +Ziele: +- Adaptivität , im Dienste von ... +- ... Wartbarkeit: einfachen Entwicklung, Installation, Rekonfiguration durch Kapselung von + - Anwendungsprogrammen + - + durch sie benutzte Bibliotheken + - + Instanzen bestimmter BS-Ressourcen +- ... Portabilität: Betrieb von Anwendungen, die lediglich von einem bestimmten BS-Kernel abhängig sind (nämlich ein solcher, der Container unterstützt); insbesondere hinsichtlich: + - Abhängigkeitskonflikten (Anwendungen und Bibliotheken) + - fehlenden Abhängigkeiten (Anwendungen und Bibliotheken) + - Versions-und Namenskonflikten +- ... Sparsamkeit: problemgerechtes ,,Packen,, von Anwendungen in Container $\rightarrow$ Reduktion an Overhead: selten (oder gar nicht) genutzter Code, Speicherbedarf, Hardware, ... + +Idee: +- private Sichten (Container) bilden = private User-Space-Instanzen für +verschiedene Anwendungsprogramme +- Kontrolle dieser Container i.S.v. Multiplexing, Unabhängigkeit und API: BS-Kernel +- somit keine Form der BS-Virtualisierung, eher: ,,User-Space-Virtualisierung,, + +![](Assets/AdvancedOperatingSystems-container.png) + +Anwendungsfälle für Container +- Anwendungsentwicklung: + - konfliktfreies Entwickeln und Testen unterschiedlicher Software, für unterschiedliche Zielkonfigurationen BS-User-Space +- Anwendungsbetrieb und -administration: + - Entschärfung von ,,dependency hell,, + - einfache Migration, einfaches Backup von Anwendungen ohne den (bei Virtualisierungsimages als Ballast auftretenden) BS-Kernel + - einfache Verteilung generischer Container für bestimmte Aufgaben + - = Kombinationen von Anwendungen +- Anwendungsisolation? $\rightarrow$ Docker + +Zwischenfazit: Container +- Ziele: Adaptivität komplementär zu... + - Wartbarkeit : Vermeidung von Administrationskosten für Laufzeitumgebung von Anwendungen + - Portabilität : Vereinfachung von Abhängigkeitsverwaltung + - Sparsamkeit : Optimierung der Speicher-und Verwaltungskosten für Laufzeitumgebung von Anwendungen +- Idee: + - unabhängige User-Space-Instanz für jeden einzelnen Container + - Aufgaben des Kernels: Unterstützung der Containersoftware bei Multiplexing und Herstellung der Unabhängigkeitdieser Instanzen +- Ergebnisse: + - ✓ vereinfachte Anwendungsentwicklung + - ✓ vereinfachter Anwendungsbetrieb + - ✗ Infrastruktur nötig über (lokale) Containersoftware hinaus, um Containern zweckgerecht bereitzustellen und zu warten + - ✗ keine vollständige Isolationmöglich + +Beispielsysteme (Auswahl) +- Virtualisierung: VMware, VirtualBox +- Paravirtualisierung: Xen +- Exokernel: Nemesis, MirageOS, RustyHermit +- Container: Docker, LupineLinux + +### Hypervisor +#### VMware +- " ... ist Unternehmenin PaloAlto, Kalifornien (USA) +- gegründet 1998 von 5 Informatikern +- stellt verschiedene Virtualisierungs-Softwareprodukte her: + 1. VMware Workstation + - war erstes Produkt von VMware (1999) + - mehrere unabhängige Instanzen von x86- bzw. x86-64-Betriebssystemen auf einer Hardware betreibbar + 2. VMware Fusion: ähnliches Produkt für Intel Mac-Plattformen + 3. VMware Player: (eingestellte) Freeware für nichtkommerziellen Gebrauch + 4. VMware Server (eingestellte Freeware, ehem. GSX Server) + 5. VMware vSphere (ESXi) + - Produkte 1 ... 3: für Desktop-Systeme + - Produkte 4 ... 5: für Server-Systeme + - Produkte 1 ... 4: Typ-2-Hypervisor +- bei VMware-Installation: spezielle vm- Treiber in Host-Betriebssystem eingefügt +- diese ermöglichen: direkten Hardware-Zugriff +- durch Laden der Treiber: entsteht ,,Virtualisierungsschicht'' (VMware-Sprechweise) + +- ![Host Guest Architektur](Assets/AdvancedOperatingSystems-vmware-host-guest-architecture.png) +- ![Bare Metal Architektur](Assets/AdvancedOperatingSystems-vmware-bare-metal.png) + - Typ1- Hypervisor- Architektur + - Anwendung nur bei VMware ESXi +- ![](Assets/AdvancedOperatingSystems-vmware-paravirtualisierung.png) + - Entsprechende Produkte in Vorbereitung + +#### VirtualBox +- Virtualisierungs-Software für x86- bzw. x86-64-Betriebssysteme für Industrie und ,,Hausgebrauch'' (ursprünglich: Innotek , dann Sun , jetzt Oracle ) +- frei verfügbare professionelle Lösung, als Open Source Software unter GNU General Public License(GPL) version 2. ... +- (gegenwärtig) lauffähig auf Windows, Linux, Macintosh und Solaris Hosts +- unterstützt große Anzahl von Gast-Betriebssystemen: Windows (NT 4.0, 2000, XP, Server 2003, Vista, Windows 7), DOS/Windows 3.x, Linux (2.4 and 2.6), Solaris and OpenSolaris , OS/2 , and OpenBSD u.a. +- reiner Typ-2-Hypervisor + +### Paravirutalisierung: Xen +- entstanden als Forschungsprojekt der University of Cambridge (UK), dann XenSource Inc., danach Citrix, jetzt: Linux Foundation (,,self-governing'') +- frei verfügbar als Open Source Software unter GNU General Public License (GPL) +- lauffähig auf Prozessoren der Typen x86, x86-64, PowerPC, ARM, MIPS +- unterstützt große Anzahl von Gast-Betriebssystemen: FreeBSD, GNU/Hurd/Mach, Linux, MINIX, NetBSD, Netware, OpenSolaris, OZONE, Plan 9 +- ,,Built for the cloud before it was called cloud.'' (Russel Pavlicek, Citrix) +- bekannt für Paravirtualisierung +- unterstützt heute auch andere Virtualisierungs-Prinzipien + +Xen : Architektur +- Gast-BSe laufen in Xen Domänen (,,$dom_i$'', analog $VM_i$) +- es existiert genau eine, obligatorische, vertrauenswürdige Domäne: $dom_0$ +- Aufgaben (Details umseitig): + - Bereitstellen und Verwalten der virtualisierten Hardware für andere Domänen (Hypervisor-API, Scheduling-Politiken für Hardware-Multiplexing) + - Hardwareverwaltung/-kommunikation für paravirtualisierte Gast-BSe (Gerätetreiber) + - Interaktionskontrolle (Sicherheitspolitiken) +- $dom_0$ im Detail: ein separates, hochkritisch administriertes, vertrauenswürdiges BS mit eben solchen Anwendungen (bzw. Kernelmodulen) zur Verwaltung des gesamten virtualisierten Systems + - es existieren hierfür spezialisierte Variantenvon Linux, BSD, GNU Hurd + - ![](Assets/AdvancedOperatingSystems-Xen-architektur.png) + +Xen : Sicherheit +- Sicherheitsmechanismusin Xen: Xen Security Modules (XSM) +- illustriert, wie (Para-) Typ-1-Virtualisierung von BS die NFE Sicherheit unterstützt +- PDP: Teil des vertrauenswürdigen BS in $dom_0$, PEPs: XSMs im Hypervisor +- Beispiel: Zugriff auf Hardware + - Sicherheitspolitik-Integration, Administration, Auswertung: $dom_0$ + - ![](Assets/AdvancedOperatingSystems-Xen-sicherheit.png) +- Beispiel: Inter-Domänen-Kommunikation + - Interaktionskontrolle (Aufgaben wie oben): $dom_0$ + - Beispiel: [VisorFlow](https://www.flyn.org/projects/VisorFlow/) + - selber XSM kontrolliert Kommunikation für zwei Domänen + +### Exokernel +Nemesis +- Betriebssystemaus EU-Verbundprojekt ,,Pegasus,, zur Realisierung eines verteilten multimediafähigen Systems (1. Version: 1994/95) +- Entwurfsprinzipien: + 1. Anwendungen: sollen Freiheit haben, Betriebsmittel in für sie geeignetster Weise zu nutzen (= Exokernel-Prinzip) + 2. Realisierung als sog. vertikal strukturiertes Betriebssystem: + - weitaus meiste Betriebssystem-Funktionalität innerhalb der Anwendungen ausgeführt (= Exokernel-Prinzip) + - Echtzeitanforderungen durch Multimedia $\rightarrow$ Vermeidung von Client-Server-Kommunikationsmodell wegen schlecht beherrschbarer zeitlicher Verzögerungen (neu) +- ![Reed+97](Assets/AdvancedOperatingSystems-Nemesis-struktur.png) + +MirageOS + Xen +- Spezialfall: Exokernel als paravirtualisiertes BS auf Xen +- Ziele : Wartbarkeit (Herkunft: Virtualisierungsarchitekturen ...) + - ökonomischer HW-Einsatz + - Unterstützung einfacher Anwendungsentwicklung + - nicht explizit: Unterstützung von Legacy-Anwendungen! +- Idee: ,,Unikernel'' $\rightarrow$ eine Anwendung, eine API, ein Kernel +- umfangreiche Dokumentation, Tutorials, ... $\rightarrow$ [ausprobieren](https://mirage.io/wiki/learning) +- Unikernel - Idee + - Architekturprinzip: ![](Assets/AdvancedOperatingSystems-unikernel-architektur.png) + - in MirageOS: ![](Assets/AdvancedOperatingSystems-mirageOs-architektur.png) +- Ergebnis: Kombination von Vorteilen zweier Welten + - Virtualisierungs vorteile: Sicherheit, Robustheit ($\rightarrow$ Xen - Prinzip genau einer vertrauenswürdigen, isolierten Domäne $dom_0$) + - Exokernelvorteile: Wartbarkeit, Sparsamkeit + - nicht: Exokernelvorteil der hardwarenahen Anwendungsentwicklung... ($\rightarrow$ Performanz und Echzeitfähigkeit ) + +### Container: Docker +- Idee: Container für einfache Wartbarkeit von Linux-Anwendungsprogrammen ... + - ... entwickeln + - ... testen + - ... konfigurieren + - ... portieren $\rightarrow$ Portabilität +- Besonderheit: Container können - unabhängig von ihrem Einsatzzweck - wie Software-Repositories benutzt, verwaltet, aktualisiert, verteilt ... werden +- Management von Containers: Docker Client $\rightarrow$ leichtgewichtiger Ansatz zur Nutzung der Wartbarkeitsvorteile von Virtualisierung +- Forsetzung unter der OCI (Open Container Initiative) + - ,,Docker does a nice job [...] for a focused purpose, namely the lightweight packaging and deployment of applications.'' (Dirk Merkel, Linux Journal) +- Implementierung der Containertechnik basierend auf Linux-Kernelfunktionen: + - Linux Containers (LXC): BS-Unterstützung für Containermanagement + - cgroups: Accounting/Beschränkung der Ressourcenzuordnung + - union mounting: Funktion zur logischen Reorganisation hierarchischer Dateisysteme +- ![](Assets/AdvancedOperatingSystems-docker.png) + +# Performanz und Parallelität +## Motivation +- Performanz: Wer hätte gern einen schnell(er)en Rechner...? +- Wer braucht schnelle Rechner: + - Hochleistungsrechnen, HPC (,,high performancecomputing'') + - wissenschaftliches Rechnen(z.B. Modellsimulation natürlicher Prozesse, Radioteleskop-Datenverarbeitung) + - Datenvisualisierung(z.B. Analysen großer Netzwerke) + - Datenorganisation-und speicherung(z.B. Kundendatenverarbeitung zur Personalisierung von Werbeaktivitäten, Bürgerdatenverarbeitung zur Personalisierung von Geheimdienstaktivitäten) + - nicht disjunkt dazu: kommerzielle Anwendungen + - ,,Big Data'': Dienstleistungen für Kunden, die o. g. Probleme auf gigantischen Eingabedatenmengen zu lösen haben (Software wie Apache Hadoop ) + - Wettervorhersage + - anspruchsvolle Multimedia- Anwendungen + - Animationsfilme + - VR-Rendering + +## Performanzbegriff +- Performance: The degree to which a system or component accomplishes its designated functions within given constraints, such as speed, accuracy, or memory usage. (IEEE) +- Performanz im engeren Sinne dieses Kapitels: Minimierung der für korrekte Funktion (= Lösung eines Berechnungsproblems) zur Verfügung stehenden Zeit. +- oder technischer: Maximierung der Anzahl pro Zeiteinheit abgeschlossener Berechnungen. + +## Roadmap +- Grundlegende Erkenntnis: Performanz geht nicht (mehr) ohne Parallelität $\rightarrow$ Hochleistungsrechnen = hochparalleles Rechnen +- daher in diesem Kapitel: Anforderungen hochparallelen Rechnens an ... + - Hardware: Prozessorarchitekturen + - Systemsoftware: Betriebssystemmechanismen + - Anwendungssoftware: Parallelisierbarkeitvon Problemen +- BS-Architekturen anhand von Beispielsystemen: + - Multikernel: Barrelfish + - verteilte Betriebssysteme + +## Hardware-Voraussetzungen +- Entwicklungstendenzen der Rechnerhardware: + - Multicore-Prozessoren: seit ca. 2006 (in größerem Umfang) + - Warum neues Paradigma für Prozessoren? bei CPU-Taktfrequenz ≫4 GHz: z.Zt. physikalische Grenze, u.a. nicht mehr sinnvoll handhabbare Abwärme + - Damit weiterhin: + 1. Anzahl der Kerne wächst nicht linear + 2. Taktfrequenz wächst asymptotisch, nimmt nur noch marginal zu + +## Performanz durch Parallelisierung ... +Folgerungen +1. weitere Performanz-Steigerung von Anwendungen: primär durch Parallelität (aggressiverer) Multi-Threaded-Anwendungen +2. erforderlich: Betriebssystem-Unterstützung $\rightarrow$ Scheduling, Sychronisation +3. weiterhin erforderlich: Formulierungsmöglichkeiten (Sprachen), Compiler, verteilte Algorithmen ... $\rightarrow$ hier nicht im Fokus + +## ... auf Prozessorebene +Vorteile von Multicore-Prozessoren +1. möglich wird: **Parallelarbeit auf Chip-Ebene** $\rightarrow$ Vermeidung der Plagen paralleler verteilter Systeme +2. bei geeigneter Architektur: Erkenntnisse und Software aus Gebiet verteilter Systeme als Grundlage verwendbar +3. durch gemeinsame Caches (architekturabhängig): schnellere Kommunikation (speicherbasiert), billigere Migration von Aktivitäten kann möglich sein +4. höhere Energieeffizienz: mehr Rechenleistung pro Chipfläche, geringere elektrische Leistungsaufnahme $\rightarrow$ weniger Gesamtabwärme, z.T. einzelne Kerne abschaltbar (vgl. Sparsamkeit , mobile Geräte) +5. Baugröße: geringeres physisches Volumen + +Nachteile von Multicore-Prozessoren +1. durch gemeinsam genutzte Caches und Busstrukturen: Engpässe (Bottlenecks) möglich +2. zur Vermeidung thermischer Zerstörungen: Lastausgleich zwingend erforderlich! (Ziel: ausgeglichene Lastverteilung auf einzelnen Kernen) +3. zum optimalen Einsatz zwingend erforderlich: + 1. Entwicklung Hardwarearchitektur + 2. zusätzlich: Entwicklung geeigneter Systemsoftware + 3. zusätzlich: Entwicklung geeigneter Anwendungssoftware + +### Multicore-Prozessoren +- Sprechweise in der Literatur gelegentlich unübersichtlich... +- daher: Terminologie und Abkürzungen: + - MC ...multicore(processor) + - CMP ...chip-level multiprocessing, hochintegrierte Bauweise für ,,MC'' + - SMC ...symmetric multicore $\rightarrow$ SMP ... symmetric multi-processing + - AMC ...asymmetric (auch: heterogeneous ) multicore $\rightarrow$ AMP ... asymmetric multi-processing + - UP ...uni-processing , Synonym zu singlecore(SC) oder uniprocessor + +Architekturen von Multicore-Prozessoren +- A. Netzwerkbasiertes Design + - Prozessorkerne des Chips u. ihre lokalen Speicher (oder Caches): durch Netzwerkstruktur verbunden + - damit: größte Ähnlichkeit zu traditionellen verteilten Systemen + - Verwendung: bei Vielzahl von Prozessorkernen (Skalierbarkeit!) + - Beispiel: Intel Teraflop-Forschungsprozessor Polaris (80 Kerne als 8x10-Gitter) + - ![](Assets/AdvancedOperatingSystems-multicore-prozessoren.png) +- B. Hierarchisches Design + - mehrere Prozessor-Kerne teilen sich mehrere baumartig angeordnete Caches + - meistens: + - jeder Prozessorkern hat eigenen L1-Cache + - L2-Cache, Zugriff auf (externen) Hauptspeicher u. Großteil der Busse aber geteilt + - Verwendung: typischerweise Serverkonfigurationen + - Beispiele: + - IBM Power + - Intel Core 2, Core i + - Sun UltraSPARCT1 (Niagara) + - ![](Assets/AdvancedOperatingSystems-multicore-prozessoren-2.png) +- C. Pipeline-Design + - Daten durch mehrere Prozessor-Kerne schrittweise verarbeitet + - durch letzten Prozessor: Ablage im Speichersystem + - Verwendung: + - Graphikchips + - (hochspezialisierte) Netzwerkprozessoren + - Beispiele: Prozessoren X10 u. X11 von Xelerator zur Verarbeitung von Netzwerkpaketen in Hochleistungsroutern (X11: bis zu 800 Pipeline-Prozessorkerne) + - ![](Assets/AdvancedOperatingSystems-multicore-prozessoren-3.png) + +Symmetrische u. asymmetrische Multicore-Prozessoren +- symmetrische Multicore-Prozessoren (SMC) + - alle Kerne identisch, d.h. gleiche Architektur und gleiche Fähigkeiten + - Beispiele: + - Intel Core 2 Duo + - Intel Core 2 Quad + - ParallaxPropeller +- asymmetrische MC-Prozessoren (AMC) + - Multicore-Architektur, jedoch mit Kernen unterschiedlicher Architektur und/oder unterschiedlichen Fähigkeiten + - Beispiel: Kilocore: + - 1 Allzweck-Prozessor (PowerPC) + - + 256 od. 1024 Datenverarbeitungsprozessoren + +### Superskalare Prozessoren +- Bekannt aus Rechnerarchitektur: Pipelining + - parallele Abarbeitung von Teilen eines Maschinenbefehls in Pipeline-Stufen + - ermöglicht durch verschiedene Funktionseinheiten eines Prozessors für verschiedene Stufen: + - Control Unit (CU) + - ArithmeticLogicUnit (ALU) + - Float Point Unit (FPU) + - Memory Management Unit (MMU) + - Cache + - sowie mehrere Pipeline-Register +- superskalare Prozessoren: solche, bei denen zur Bearbeitung einer Pipeling-Stufe erforderlichen Funktionseinheiten n-fach vorliegen +- Ziel: + - Skalarprozessor (mit Pipelining): 1 Befehl pro Takt (vollständig) bearbeitet + - Superskalarprozessor: bis zu n Befehle pro Taktbearbeitet +- Verbereitung heute: universell (bis hin zu allen Desktop-Prozessorfamilien) + +## Parallelisierung in Betriebssystemen +- Basis für alle Parallelarbeit aus BS-Sicht: Multithreading +- wir erinnern uns ...: + - Kernel-Level-Threads (KLTs): BS implementiert Threads $\rightarrow$ Scheduler kann mehrere Threads nebenläufig planen $\rightarrow$ Parallelität möglich + - User-Level-Threads (ULTs): Anwendung implementiert Threads $\rightarrow$ keine Parallelität möglich! +- grundlegend für echt paralleles Multithreading: + - parallelisierungsfähige Hardware + - kausal unabhängige Threads + - passendes (und korrekt eingesetztes!) Programmiermodell, insbesondere Synchronisation! + - $\rightarrow$ Programmierer + Compiler + +Vorläufiges Fazit: +- BS-Abstraktionen müssen Parallelität unterstützen (Abstraktion nebenläufiger Aktivitäten: KLTs) +- BS muss Synchronisationsmechanismen implementieren + +### Synchronisations- und Sperrmechanismen +- Synchronisationsmechanismen zur Nutzung + - ... durch Anwendungen $\rightarrow$ Teil der API + - ... durch den Kernel (z.B. Implementierung Prozessmanagement, E/A, ...) +- Aufgabe: Verhinderung konkurrierender Zugriffe auf logische oder physische Ressourcen + - Vermeidung von raceconditions + - Herstellung einer korrekten Ordnung entsprechend Kommunikationssemantik (z.B. ,,Schreiben vor Lesen'') +- (alt-) bekanntes Bsp.: Reader-Writer-Problem + +Erinnerung: Reader-Writer-Problem +- Begriffe: (bekannt) + - wechselseitiger Ausschluss ( mutual exclusion) + - kritischer Abschnitt (critical section) +- Synchronisationsprobleme: + - Wie verhindern wir ein write in vollen Puffer? + - Wie verhindern wir ein read aus leerem Puffer? + - Wie verhindern wir, dass auf ein Element während des read durch ein gleichzeitiges write zugegriffen wird? (Oder umgekehrt?) + +Sperrmechanismen ( Locks ) +- Wechselseitiger Ausschluss ... + - ... ist in nebenläufigen Systemen zwingend erforderlich + - ... ist in echt parallelen Systemen allgegenwärtig + - ... skaliert äußerst unfreundlich mit Code-Komplexität $\rightarrow$ (monolithischer) Kernel-Code! +- Mechanismen in Betriebssystemen: Locks +- Arten von Locks am Beispiel Linux: + - Big Kernel Lock (BKL) + - historisch (1996-2011): lockkernel(); ... unlockkernel(); + - ineffizient durch massiv gestiegene Komplexität des Kernels + - atomic-Operationen + - Spinlocks + - Semaphore (Spezialform: Reader/Writer Locks) + +atomic* +- Bausteine der komplexeren Sperrmechanismen: + - Granularität: einzelne Integer- (oder sogar Bit-) Operation + - Performanz: mittels Assembler implementiert, nutzt Atomaritäts garantiender CPU ( TSL - Anweisungen: ,,test-set-lock'' ) +- Benutzung: + ```cpp + atomic_t x; + atomic_set(&x, 42); + int y = atomic_read(&x); + ``` + - `atomic_*` Geschmacksrichtungen: read, set, add, sub, inc, dec u. a. + - keine explizite Lock-Datenstruktur $\rightarrow$ Deadlocks durch Mehrfachsperrung syntaktisch unmöglich + - definierte Länge des kritischen Abschnitts (genau diese eine Operation) $\rightarrow$ unnötiges Sperren sehr preiswert + +Spinlock +- Lockingfür längere kritische Abschnitte: + - wechselseitiger Ausschluss durch aktives Warten + - Granularität: einfach-exklusive Ausführung von Code, der ... + - ... nicht blockiert + - ... (vorhersehbar) kurze Zeit den kritischen Abschnitt nutzt + - Performanz: keine Scheduler-Aktivierung, keine sperrbedingten Kontextwechsel (alle wartenden Threads bleiben ablaufbereit!) +- Benutzung: +``` +DEFINE_SPINLOCK(the_lock); +spin_lock(&the_lock); +... // critical section +spin_unlock(&the_lock); +``` + - explizite Lock-Datenstruktur $\rightarrow$ Deadlocks durch Mehrfachsperrung oder multiple Locks möglich + - variable Länge des kritischen Abschnitts $\rightarrow$ unnötiges Sperren sehr teuer! (aktives Warten verschwendet Prozessorzeit) + +Semaphor +- Lockingfür komplexere kritische Abschnitte: + - wechselseitiger Ausschluss durch suspendieren von Threads + - Granularität: n - exklusive Ausführung von (nahezu) beliebigem Code, über längere oder unbekannt lange (aber endliche) kritische Abschnitte + - Performanz: nutzt Scheduler(Suspendierung und Reaktivierung wartender Threads), verursacht potenziell Kontextwechsel, implementiert Warteschlange +- Benutzung: +``` +struct semaphore the_semaphor; +sema_init(&the_semaphor, n); // Zählsemaphor mit n Plätzen +if (down_interruptible(&the_semaphor)) +{ // unterbrechbares Warten... } +... // critical section +up(&the_semaphor); +``` + - mehrfach nutzbare krit. Abschnitte möglich ($\rightarrow$ begrenzt teilbare Ressourcen) + - explizite Reaktion auf Signale während des Wartens möglich + - Deadlocks möglich, unnötiges Sperren teuer + +R/W-Lock +- Reader/Writer Locks: Spezialformen von Spinlocksund binären Semaphoren ( n = 1) + - Steigerung der Locking-Granularität $\rightarrow$ Optimierung des Parallelitätsgrades + - Idee: sperrende Threads nach Zugriffssemantik auf kritischen Abschnitt in zwei Gruppen unterteilt: + - _Reader:_ nur lesende Zugriffe auf Variablen + - _Writer:_ mindestens ein schreibender Zugriff auf Variablen + - R/W-Spinlock/Semaphor muss explizit als _Reader_ oder _Writer_ gesperrt werden + - Performanz: analog Spinlock/Semaphor +- Benutzung analog Spinlock/Semaphor, z.B.: + ``` + DEFINE_RWLOCK(the_lock); + read_lock(&the_lock); + ... // read-only critical section + read_unlock(&the_lock); + ``` + +Fazit: Locks im Linux-Kernel +- Locking-Overhead: Sperrkosten bei korrekter Benutzung +- Lock-Granularität (ebenfalls bei korrekter Benutzung): + - mögliche Länge des kritischen Abschnitts + - Granularität der selektiven Blockierung (z.B. nur Leser , nur Schreiber ) + - ![](Assets/AdvancedOperatingSystems-locks-in-linux.png) +- Locking-Sicherheit: Risiken und Nebenwirkungen hinsichtlich ... + - fehlerhaften Sperrens (Auftreten von Synchronisationsfehlern) + - Deadlocks + - unnötigen Sperrens (Parallelität ad absurdum ...) + +### Lastangleichung und Lastausgleich +- Probleme bei ungleicher Auslastung von Multicore-Prozessoren: +1. Performanzeinbußen + - stark belastete Prozessorkerne müssen Multiplexing zwischen mehr Threadsausführen als schwach belastete + - dadurch: Verlängerungder Gesamtbearbeitungsdauer +2. Akkumulation der Wärmeabgabe + - bedingt durch bauliche Gegebenheiten (Miniaturisierung, CMP) + - Kontrolle erforderlich zur Vermeidung thermischer Probleme (bis zu Zerstörung der Hardware) +- Lösung: Angleichung der Last auf einzelnen Prozessorkernen + +#### Lastangleichung +- Verfahren zur Lastangleichung + - statische Verfahren: einmalige Zuordnung von Threads + - Korrekturen möglich nur durch geeignete Verteilung neuer Threads + - Wirksamkeit der Korrekturen: relativ gering + - dynamische Verfahren: Optimierung der Zielfunktion zur Laufzeit + - Zuordnungsentscheidungen dynamisch anpassbar + - Korrekturpotentialzur Laufzeitdurch Zuweisung eines anderen Prozessorkerns an einen Thread ( Migration ) + - aber: algorithmisch komplexer, höhere Laufzeitkosten +- verbreitete Praxis in Universalbetriebssystemen: dynamische + +#### Dynamische Lastangleichung +- Anpassungsgründe zur Laufzeit + - Veränderte Lastsituation: Beenden von Threads + - Verändertes Verhaltens einzelner Threads: z.B. Änderung des Parallelitätsgrads, vormals E/A-Thread wird prozessorintensiv, etc. +- Zuordnungsentscheidungen + - auf Grundlage von a-priori - Informationen über Prozessverhalten + - durch Messungen tatsächlichen Verhaltens $\rightarrow$ Übergang von Steuerung zu Regelung +- Kosten von Thread-Migration + - zusätzliche Thread-bzw. Kontextwechsel + - kalte Caches + - $\rightarrow$ Migrationskosten gegen Nutzen aufwiegen + +grundlegende Strategien: +1. Lastausgleich (loadbalancing oder loadleveling) + - Ziel: gleichmäßige Verteilung der Last auf alle Prozessorkerne +2. Lastverteilung (loadsharing) + - verwendet schwächere Kriterien + - nur extreme Lastunterschiede zwischen einzelnen Prozessorkernen ausgeglichen(typisch: Ausgleich zwischen leerlaufenden bzw. überlasteten Kernen) + +- Anmerkungen +1. Lastausgleich: verwendet strengere Kriterien, die auch bei nicht leerlaufenden und überlasteten Kernen greifen +2. 100%tiger Lastausgleich nicht möglich (2 Threads auf 3 CPUs etc.) + + +#### Lastverteilung beim Linux-Scheduler +globale Entscheidungen +1. anfängliche Lastverteilung auf Prozessorkerne + grobbzgl. Ausgewogenheit +2. dynamische Lastverteilung auf Prozessorkerne durch + 1. loadbalancing-Strategie + 2. idlebalancing-Strategie + +#### Verteilungsstrategien +- ,,load balancing'' - Strategie + - für jeden Kern nach Zeitscheibenprinzip (z.B. 200 ms) aktiviert: + - ,,Thread-Stehlen'' vom am meisten ausgelasteten Kern + - aber: bestimmte Threads werden (vorerst) nicht migriert + 1. solche, die nicht auf allen Kernen lauffähig + 2. die mit noch ,,heißem Cache'' + - erzwungene Thread-Migration (unabhängig von heißen Caches), wenn ,,loadbalancing'' mehrmals fehlgeschlagen +- ,,idle balancing'' - Strategie + - von jedem Kern aktiviert, bevor er in Leerlauf geht: + - Versuch einer ,,Arbeitsbeschaffung'' + - mögliche Realisierung: gleichfalls als ,,Thread-Stehlen'' vom am meisten ausgelasteten Kern + +#### Heuristische Lastverteilung +- in der Praxis: Heuristiken werden genutzt ... + - ... für alle Entscheidungen bzgl. + - loadbalancing (,,Migrieren oder nicht?'') + - threadselection (,,Welchen Threads von anderem Prozessor migrieren?'') + - time-slicing (,,Zeitscheibenlänge für loadbalancing?'') + - ... unter Berücksichtigung von + - Systemlast + - erwarteter Systemperformanz + - bisherigem Thread-Verhalten +- Bewertung + - Heuristiken verwenden Minimum an Informationen zur Realisierung schneller Entscheidungen $\rightarrow$ Performanz der Lastverteilung + - Tradeoff: höhere Performanz für aktuelle Last durch teurere Heuristiken (Berücksichtigung von mehr Informationen)? + +## Grenzen der Parallelisierbarkeit +(oder: warum nicht jedes Performanzproblemdurch zusätzliche Hardware gelöst wird) + +- Parallelarbeit aus Anwendungssicht: Welchen Performanzgewinn bringt die Parallelisierung? +- naiv: + - 1 Prozessor $\rightarrow$ Bearbeitungszeit t + - n Prozessoren $\rightarrow$ Bearbeitungszeit t/n +- Leistungsmaß für den Performanzgewinn: Speedup $S(n)=\frac{T(1)}{T(n)}$, $T(n)$ bearbeitungszeit bei n Prozessoren + +Amdahls Gesetz: ,,Auch hochgradig parallele Programme weisen gewisse Teile strenger Datenabhängigkeit auf - die nur sequenziell ausgeführt werden können -und daher den erzielbaren Speed-up grundsätzlich limitieren.'' + +Jedes Programm besteht aus einem nur sequenziell ausführbaren und einem parallelisierbaren Anteil: $T(1)=T_s + T_p$ + +mit als sequenziellem Anteil (z.B. $\rightarrow$ 10% sequenzieller Anteil): Effizienz $f=\frac{T_s}{T_s+T_p}$ wobei $0\leq f \leq 1$ + +Damit ergibt sich im günstigsten Fall für Bearbeitungszeit bei Prozessoren: $T(n)=f*T(1)+ (1-f)\frac{T(1)}{n}$ + +Speedup nach Amdahl: $S(n)=\frac{T(1)}{T(n)}=\frac{1}{f+\frac{1-f}{n}}$ + +Praktische Konsequenz aus Amdahls Gesetz: +- mögliche Beschleunigung bei Parallelisierung einer Anwendung i.A. durch die Eigenschaften der Anwendungselbst begrenzt (sequenzieller Anteil) +- Erhöhung der Prozessorenanzahlüber bestimmtes Maß hinaus bringt nur noch minimalen Performanzgewinn + +Annahme bisher: +- parallelisierbarer Anteil auf beliebige Anzahl Prozessoren parallelisierbar +- genauere Problembeschreibung möglich durch Parallelitätsprofil: maximaler Parallelitätsgrad einer Anwendung in Abhängigkeit von der Zeit +- Für ein bestimmtes Problem bringt ab einer Maximalzahl ($p_{max}$) jede weitere Erhöhung der Prozessoren-Anzahl keinen weiteren Gewinn, da die Parallelisierbarkeitdes Problems begrenzt ist. + +#### Einfluss von Kommunikation und Synchronisation +- Threads eines Prozesses müssen kommunizieren (Daten austauschen), spätestens nach ihrer Beendigung +- hierzu i.A. auch Synchronisation (Koordination) erforderlich +- Resultat: Prozessoren nicht gesamte Zeit für Berechnungen nutzbar + +### Overhead durch Kommunikation und Synchronisation +aus Erfahrungen und theoretischen Überlegungen: +Zeitaufwand für Kommunikation und Synchronisation zwischen Prozessen (bzw. Threads) einer Anwendung auf verschiedenen Prozessoren: +- streng monoton wachsende Funktion der Prozessoren-Anzahl n (d.h. Funktion nicht nach oben beschränkt) +- praktische Konsequenz von Kommunikation und Synchronisation: + - zu viele Prozessoren für eine Anwendung bedeutet + - keine Geschwindigkeitssteigerung + - sogar Erhöhung der Gesamtbearbeitungszeit $T_{\sum}$ + - $\rightarrow$ fallender Speedup +- Für minimale Bearbeitungsdauer gibt es eine optimale Anzahl Prozessoren + +#### Leistungsmaß Effizienz +Effizienz des Speedups $E(n)=\frac{S(n)}{n}$ +- Normierung des Speedupauf CPU-Anzahl entspricht Wirkungsgrad der eingesetzten Prozessoren +- Idealfall: $S(n)=n\Rightarrow E(n)=\frac{S(n)}{n}=1$ + +#### Optimale Prozessorenanzahl +$T(n)$ Gesamtbearbeitungszeit +- Im Bereich des Minimums: sehr flacher Verlauf +- (geringe) Änderung der Prozessoren-Anzahl in diesem Bereich: kaum Auswirkungen auf Rechenzeit (im steilen, fallenden Bereich hat Prozessorenanzahl jedoch gewaltige Auswirkungen auf Rechenzeit) + +$E(n)$ Effizienz (Auslastung der Prozessoren) +- verringert sich stetig mit zunehmender Prozessoren-Anzahl +- Konflikt zwischen Kostenminimierung (= Minimierung der Ausführungszeit bzw. Maximierung des Speed-up) und Nutzenmaximierung (= Maximierung der Effizienz) +- $\rightarrow$ Kompromissbereich + + +Nutzen($E(n)$)-Kosten($T(n)$)-Quotienten maximieren: $\mu(n)=\frac{E(n)}{T(n)} T(1)=S(n)*E(n)=\frac{S(n)^2}{n}$ + +1. Effizienz maximieren: $n_{opt}=n^*_E = 1$ unsinnig +2. Speedup maximieren = Ausführungszeit minimieren: $n_{opt}=n^*_S$ Individuell für jedes Programm +3. Nutzen-Kosten-Funktion maximieren: $n_{opt}=n^*_{\mu}$ individuell für jedes Programm + +## Beispiel-Betriebssysteme +- Auswahl: Betriebssysteme, die mit Fokus auf Hochparallelität entworfen wurden +- Konsequenzen für BS-Architekturen: + - Parallelität durch Abstraktion von Multicore-Architekturen: Multikernel + - Parallelität durch netzwerkbasierteMulticore-Architekturen: Verteilte Betriebssysteme + +### Multikernel: Barrelfish +In a nutshell: +- seit ca. 2009 entwickeltes, experimentelles Forschungs-Betriebssystem (open source) +- Untersuchungen zur Struktur künftiger heterogener Multicore-Systeme +- gegenwärtig in Entwicklung an ETH Zürich + - in Zusammenarbeit mit Microsoft +- Forschungsfragen + 1. Betriebssystemarchitektur + - Trend stetig wachsender Anzahl Prozessorkerne $\rightarrow$ Skalierbarkeit des Betriebssystems zur Maximierung von + Parallelität? + - zunehmende Menge an Varianten der Hardware-Architektur, betreffend z.B. + - Speicherhierarchien + - Verbindungsstrukturen + - Befehlssatz + - E/A-Konfiguration + - $\rightarrow$ Unterstützung zunehmend heterogener Hardware-Vielfalt (insbesondere noch zu erwartender Multicore-Prozessoren)? + 2. Wissensdarstellung + - Betriebssystem und Anwendungen Informationen über aktuelle Architektur zur Laufzeit liefern + - $\rightarrow$ Informationen zur Adaptivitätdes BS an Last und Hardware zur Maximierung von Parallelität? +- Betriebssystem-Architektur für heterogene Multicore-Rechner + - Idee: Betriebssystem wird strukturiert ... + - als verteiltes System von Kernen, + - die über Botschaften kommunizieren (Inter-Core-Kommunikation) und + - keinen gemeinsamen Speicher besitzen. + - Entwurfsprinzipien: + 1. alle Inter-Core-Kommunikation explizit realisiert d.h. keine implizite Kommunikation z.B. über verteilte Speichermodelle wie DSM (Distributed SharedMemory), Botschaften zum Cache-Abgleich etc. + 2. Betriebssystem-Struktur ist Hardware-neutral + 3. Zustandsinformationen als repliziert (nicht als verteilt)betrachtet $\rightarrow$ schwächere Synchronisationsanforderungen! +- Ziele dieser Entwurfsprinzipien + 1. Verbesserte Performanz auf Grundlage des Entwurfs als verteiltes System + 2. Natürliche Unterstützung für Hardware-Inhomogenitäten + 3. Größere Modularität + 4. Wiederverwendbarkeit von Algorithmen, die für verteilte Systeme entwickelt wurden +- Implementierung: auf jedem Prozessorkern Betriebssystem-Instanz aus CPU-''Treiber'' und Monitor-Prozess + +CPU Driver +- Aufgabe: Umsetzung von Strategien zur Ressourcenverwaltung, z.B. + - Durchsetzung von Zugriffssteuerungsentscheidungen + - Zeitscheiben-Multiplexing von Threads + - Vermittlung von Hardware-Zugriffendes Kernels (MMU, Clockusw.) + - Ereignisbehandlung +- Implementierung: + - hardwarespezifisch + - vollständig ereignisgesteuert, single-threaded, nicht-präemptiv + - läuft im privilegierten Modus (Kernel-Modus) + - ist absolut lokal auf jedem Prozessor-Kern (gesamte Inter-Core-Kommunikation durch die Monitore realisiert) + - ist vergleichsweise klein, so dass er im Lokalspeicher des Prozessorkerns untergebracht werden kann $\rightarrow$ Wartbarkeit, Robustheit, Korrektheit + +Monitor +- Wichtige Angaben + - läuft im Nutzer-Modus + - Quellcode fast vollständig prozessorunabhängig +- Monitore auf allen Prozessorkernen: koordinieren gemeinsam systemweite Zustandsinformationen + - auf allen Prozessor-Kernen replizierte Datenstrukturen: mittels Abstimmungsprotokollkonsistent gehalten (z.B. Speicherzuweisungstabellen u. Adressraum-Abbildungen) + - $\rightarrow$ implementiert Konsensalgorithmenfür verteilte Systeme +- Monitore: enthalten die meisten wesentlichen Mechanismen und Strategien, die in monolithischem Betriebssystem-Kernel (bzw. $\mu$Kernel-Serverprozessen) zu finden sind + +### Verteilte Betriebssysteme +- hier nur Einblick in ein breites Themenfeld +- Grundidee: Ortstransparenz + - FE des Betriebssystems: + - abstrahieren ... + - multiplexen ... + - schützen ... + - hierzu: lokaler BS-Kernel kommuniziert mit über Netzwerk verbundenen, physisch verteilten anderen Kernels (desselben BS) + - Anwendungssicht auf (nun verteilte) Hardware-Ressourcen identisch zu Sicht auf lokale Hardware $\rightarrow$ Ortstransparenz +- Zwei Beispiele: + - Amoeba: Forschungsbetriebssystem, Python-Urplattform + - Plan 9 fom Bell Labs: everything is a file + +#### Amoeba +Architektur: +- verteiltes System aus drei (nicht zwingend disjunkten)Arten von Knoten: + - Workstation (GUI/Terminalprozess, Benutzerinteraktion) + - Pool Processor (nicht-interaktive Berechnungen) + - Servers(File ~, Directory ~, Networking ~, ...) +- Betriebssystem: $\mu$Kernel (identisch auf allen Knoten) + Serverprozesse (dedizierte Knoten, s.o.: Servers ) +- $\rightarrow$ Vertreter einer verteilten μKernel-Implementierung +- Kommunikation: + - LAN (Ethernet) + - RPCs (Remote ProcedureCalls) + - $\rightarrow$ realisieren ortstransparenten Zugriff auf sämtliche BS-Abstraktionen (Amoeba: objects ) + +#### Plan 9 +- verteiltes BS der Bell Labs (heute: Open Source Projekt) +- Besonderheit: Semantik der Zugriffe auf verteilte BS-Abstraktionen + - ortstransparent (s. Amoeba) + - mit ressourcenunabhängig identischen Operationen - deren spezifische Funktionalität wird für die Anwendung transparent implementiert $\rightarrow$ Konzept ,,everything is a file''... bis heute in unixoiden BS und Linux! +- Beispiele: + - Tastatureingabenwerden aus (Pseudo-) ,,Datei'' gelesen + - Textausgabenwerden in ,,Datei'' geschrieben -aus dieser wiederum lesen Terminalanwendungen + - all dies wird logisch organisiert durch private Namensräume + - $\rightarrow$ Konzept hierarchischer Dateisysteme + +# Zusammenfassung +## Funktionale und nichtfunktionale Eigenschaften +- Funktionale Eigenschaften: beschreiben, was ein (Software)-Produkt tun soll +- Nichtfunktionale Eigenschaften: beschreiben, wie funktionale Eigenschaften realisiert werden, also welche sonstigen Eigenschaftendas Produkt haben soll ... unterteilbar in: + 1. Laufzeiteigenschaften (zur Laufzeit sichtbar) + 2. Evolutionseigenschaften (beim Betrieb sichtbar: Erweiterung, Wartung, Test usw.) + +Roadmap (... von Betriebssystemen) +- Sparsamkeit und Effizienz +- Robustheit und Verfügbarkeit +- Sicherheit +- Echtzeitfähigkeit +- Adaptivität +- Performanzund Parallelität + +## Sparsamkeit und Effizienz +- Sparsamkeit: Die Eigenschaft eines Systems, seine Funktion mit minimalem Ressourcenverbrauch auszuüben. +- Effizienz: Der Grad, zu welchem ein System oder eine seiner Komponenten seine Funktion mit minimalem Ressourcenverbrauch ausübt. $\rightarrow$ Ausnutzungsgrad begrenzter Ressourcen +- Die jeweils betrachtete(n) Ressource(n) muss /(müssen) dabei spezifiziert sein! +- sinnvolle Möglichkeiten bei Betriebssystemen: + 1. Sparsamer Umgang mit Energie , z.B. energieeffizientes Scheduling + 2. Sparsamer Umgang mit Speicherplatz (Speichereffizienz) + 3. Sparsamer Umgang mit Prozessorzeit + 4. ... + +Sparsamkeit mit Energie +- Sparsamkeit mit Energie als heute extrem wichtigen Ressource, mit nochmals gesteigerter Bedeutung bei mobilen bzw. vollständig autonomen Geräten Maßnahmen: +1. Hardware-Ebene: momentan nicht oder nicht mit maximaler Leistung benötigte Ressourcen in energiesparenden Modus bringen: abschalten, Standby, Betrieb mit verringertem Energieverbrauch ( abwägen gegen verminderte Leistung). (Geeignete Hardware wurde/wird ggf. erst entwickelt) +2. Software-Ebene: neue Komponenten entwickeln, die in der Lage sein müssen: + - Bedingungenzu erkennen, unter denen ein energiesparender Modus möglich ist; + - Steuerungs-Algorithmen für Hardwarebetrieb so zu gestalten, dass Hardware-Ressourcen möglichst lange in einem energiesparenden Modus betrieben werden. + - Energie-Verwaltungsstrategien: energieeffizientes Scheduling zur Vermeidung von Unfairness und Prioritätsumkehr + - Beispiele: energieeffizientes Magnetfestplatten-Prefetching, energiebewusstes RR-Scheduling + +Sparsamkeit mit Speicherplatz +- Betrachtet: Sparsamkeit mit Speicherplatz mit besonderer Wichtigkeit für physisch beschränkte, eingebettete und autonome Geräte +- Maßnahmen Hauptspeicherauslastung: + 1. Algorithmus und Strategie z.B.: + - Speicherplatz sparende Algorithmen zur Realisierung gleicher Strategien + 2. Speicherverwaltung von Betriebssystemen: + - physische vs. virtuelle Speicherverwaltung + - speichereffiziente Ressourcenverwaltung + - Speicherbedarfdes Kernels + - direkte Speicherverwaltungskosten +- Maßnahmen Hintergrundspeicherauslastung: + 1. Speicherbedarf des Betriebssystem-Images + 2. dynamische SharedLibraries + 3. VMM-Auslagerungsbereich + 4. Modularität und Adaptivität des Betriebssystem-Images +- Nicht betrachtet: Sparsamkeit mit Prozessorzeit $\rightarrow$ 99% Überschneidung mit NFE Performanz + +## Robustheit und Verfügbarkeit +- Robustheit: Zuverlässigkeit unter Anwesenheit externer Ausfälle +- fault, aktiviert $\rightarrow$ error, breitet sich aus $\rightarrow$ failure + +Robustheit +- Erhöhung der Robustheit durch Isolation: + - Maßnahmen zur Verhinderung der Fehlerausbreitung: + 1. Adressraumisolation: Mikrokernarchitekturen, + 2. kryptografische HW-Unterstützung: Intel SGX und + 3. Virtualisierungsarchitekturen +- Erhöhung der Robustheit durch Behandlung von Ausfällen: Micro-Reboots + +Vorbedingung für Robustheit: Korrektheit +- Korrektheit: Eigenschaft eines Systems sich gemäß seiner Spezifikation zu verhalten (unter der Annahme, dass bei dieser keine Fehler gemacht wurden). +- Maßnahmen (nur angesprochen): +1. diverse Software-Tests: + - können nur Fehler aufspüren, aber keine Fehlerfreiheit garantieren! +2. Verifizierung: + - Durch umfangreichen mathematischen Apparat wird Korrektheit der Software bewiesen. + - Aufgrund der Komplexität ist Größe verifizierbarer Systeme (bisher?) begrenzt. + - Betriebssystem-Beispiel: verifizierter Mikrokern seL + +Verfügbarkeit +- Verfügbarkeit: Der Anteil an Laufzeit eines Systems, in dem dieses seine spezifizierte Leistung erbringt. +- angesprochen: Hochverfügbare Systeme +- Maßnahmen zur Erhöhung der Verfügbarkeit: + 1. Robustheitsmaßnahmen + 2. Redundanz + 3. Redundanz + 4. Redundanz + 5. Ausfallmanagement + +## Sicherheit +- Sicherheit (IT-Security): Schutz eines Systems gegen Schäden durch zielgerichtete Angriffe, insbesondere in Bezug auf die Informationen, die es speichert, verarbeitet und kommuniziert. +- Sicherheitsziele: + 1. Vertraulichkeit (Confidentiality) + 2. Integrität (Integrity) + 3. Verfügbarkeit (Availability) + 4. Authentizität (Authenticity) + 5. Verbindlichkeit (Non-repudiability) + +Security Engineering +- Sicherheitsziele $\rightarrow$ Sicherheitspolitik $\rightarrow$ Sicherheitsarchitektur $\rightarrow$ Sicherheitsmechanismen +- Sicherheitspolitik: Regeln zum Erreichen eines Sicherheitsziels. + - hierzu formale Sicherheitsmodelle: + - IBAC, TE, MLS + - DAC, MAC +- Sicherheitsmechanismen: Implementierung der Durchsetzung einer Sicherheitspolitik. + - Zugriffssteuerungslisten(ACLs) + - SELinux +- Sicherheitsarchitektur: Platzierung, Struktur und Interaktion von Sicherheitsmechanismen. + - wesentlich: Referenzmonitorprinzipien + - RM1: Unumgehbarkeit $\rightarrow$ vollständiges Finden aller Schnittstellen + - RM2: Manipulationssicherheit $\rightarrow$ Sicherheit einerSicherheitspolitik selbst + - RM3: Verifizierbarkeit $\rightarrow$ wohlstrukturierte und per Designkleine TCBs + +## Echtzeitfähigkeit +- Echtzeitfähigkeit: Fähigkeit eines Systems auf eine Eingabe innerhalb eines spezifizierten Zeitintervalls eine korrekte Reaktion hervorzubringen. +- Maximum dieses relativen Zeitintervalls: Frist d +1. echtzeitfähige Scheduling-Algorithmen für Prozessoren + - zentral: garantierte Einhaltung von Fristen + - wichtige Probleme: Prioritätsumkehr, Überlast, kausale Abhängigkeit +2. echtzeitfähige Interrupt-Behandlung + - zweiteilig:asynchron registrieren, geplant bearbeiten +3. echtzeitfähige Speicherverwaltung + - Primärspeicherverwaltung, VMM (Pinning) + - Sekundärspeicherverwaltung, Festplattenscheduling + +## Adaptivität +- Adaptivität: Eigenschaft eines Systems, so gebaut zu sein, dass es ein gegebenes (breites) Spektrum nichtfunktionaler Eigenschaften unterstützt. +- Beobachtung: Adaptivität i.d.R. als komplementär und synergetisch zu anderen NFE: + - Sparsamkeit + - Robustheit + - Sicherheit + - Echzeitfähigkeit + - Performanz + - Wartbarkeit und Portierbarkeit + +Adaptive Systemarchitekturen +- Zielstellungen: + - Exokernel: { Adaptivität } ∪ { Performanz, Echtzeitfähigkeit, Wartbarkeit, Sparsamkeit } + - Virtualisierung: { Adaptivität } ∪ { Wartbarkeit, Sicherheit, Robustheit } + - Container: { Adaptivität } ∪ { Wartbarkeit, Portabilität, Sparsamkeit } + +## Performanz und Parallelität +- Performanz (wie hier besprochen): Eigenschaft eines Systems, die für korrekte Funktion (= Berechnung) benötigte Zeit zu minimieren. +- hier betrachtet: Kurze Antwort-und Reaktionszeiten + 1. vor allen Dingen: Parallelisierung auf Betriebssystemebene zur weiteren Steigerung der Performanz/Ausnutzung von Multicore-Prozessoren(da Steigerung der Prozessortaktfrequenz kaum noch möglich) + 2. weiterhin: Parallelisierung auf Anwendungsebene zur Verringerung der Antwortzeiten von Anwendungen und Grenzen der Parallelisierbarkeit(für Anwendungen auf einem Multicore-Betriebssystem). + +Mechanismen, Architekturen, Grenzen der Parallelisierung +- Hardware: + - Multicore-Prozessoren + - Superskalarität +- Betriebssystem: + - Multithreading(KLTs) und Scheduling + - Synchronisation und Kommunikation + - Lastangleichung +- Anwendung(sprogrammierer): + - Parallelisierbarkeiteines Problems + - optimaler Prozessoreneinsatz, Effizienz + +## Synergetische und konträre Eigenschaften +- Normalerweise: + - Eine nichtfunktionale Eigenschaft bei IT-Systemen meist nicht ausreichend + - Beispiel: Was nützt ein Echtzeit-Betriebssystem - z.B. innerhalb einer Flugzeugsteuerung - wenn es nicht auch verlässlich arbeitet? +- In diesem Zusammenhang interessant: + - Welche nichtfunktionalen Eigenschaften mit Maßnahmen erreichbar, die in gleiche Richtung zielen, bei welchen wirken Maßnahmen eher gegenläufig? + - Erstere sollen synergetische, die zweiten konträre (also in Widerspruch zueinander stehende) nichtfunktionale Eigenschaften genannt werden. + - Zusammenhang nicht immer eindeutig und offensichtlich, wie z.B. bei: ,,Sicherheit kostet Zeit.'' (d.h. Performanz und Sicherheit sind nichtsynergetische Eigenschaften) + +## Notwendige NFE-Paarungen +- Motivation: Anwendungen (damit auch Betriebssysteme) für bestimmte Einsatzgebiete brauchen oft mehrere nichtfunktionale Eigenschaften gleichzeitig - unabhängig davon, ob sich diese synergetisch oder nichtsynergetisch zueinander verhalten. +- Beispiele: + - Echtzeit und Verlässlichkeit: ,,SRÜ''-Systeme an potentiell gefährlichen Einsatzgebieten (Atomkraftwerk, Flugzeugsteuerung, Hinderniserkennung an Fahrzeugen, ...) + - Echtzeit und Sparsamkeit: Teil der eingebetteten Systeme + - Robustheit und Sparsamkeit: unter entsprechenden Umweltbedingungen eingesetzte autonome Systeme, z.B. smart-dust-Systeme + + +Überblick: NFE und Architekturkonzepte + +| | Makrokernel | Mikrokernel | Exokernel | Virtualisierung | Multikernel | +| ----------------- | ----------- | ----------- | --------- | --------------- | ----------- | +| Energieeffizienz | | | (✓) | ✗ | ✗ | +| Speichereffizienz | ✗ | (✓) | (✓) | | ✗ | +| Robustheit | ✗ | ✓ | ✗ | ✓ | | +| Verfügbarkeit | ✗ | (✓) | | (✓) | (✓) | +| Korrektheit | ✗ | ✓ | ✗ | ✗ | (✓) | +| Sicherheit | ✗ | ✓ | ✗ | ✓ | | +| Echtzeitfähigkeit | (✓) | (✓) | ✓ | ✗ | ✗ | +| Adaptivität | ✗ | (✓) | ✓ | ✓ | (✓) | +| Wartbarkeit | ✓ | | ✓ | ✓ | | +| Performanz | (✓) | ✗ | ✓ | ✗ | ✓ | + +- ✓ ... Zieleigenschaft +- ( ✓ ) ... synergetische Eigenschaft +- ✗ ... konträre Eigenschaft +- Leere Zellen: keine pauschale Aussage möglich. + +Fazit: Breites und offenes Forschungsfeld $\rightarrow$ werden Sie aktiv! + +# Prüfungsschwerpunkte +- Basiswissen: Allgemeines zu NFEn, NFE-Ziele (Anwendungsbsp.), Probleme und deren Lösungskonzepte (Strategien, Mechanismen, Architekturen)! + - zu jeder NFE: Konzepte und Strategien der Mechanismen (Idee), relevante System-Architekturen (Idee, Vor-und Nachteile) + - z.B.: Warum Sicherheit? Wo? Welche BS-Probleme sind zur Herstellung von Sicherheitseigenschaften zu lösen? Durch welche Konzepte (z.B. Zugriffssteuerungsmechanismen, Referenzmonitor-Arch.) ist dies möglich? +- Basiswissen plus (= für gute Noten): + - Mechanismen: prinzipieller Ablauf von Algorithmen, praktische Eigenheiten/Implementierungsprobleme + - Beispiel-BSe(Idee, ggf. deren Aufbau) + - Vergleichende Bewertung synergetischer und konträrer NFE anhand ihrer jeweils relevanten Mechanismen und Architekturen (Stoffquerschnitt) +- Tipp: Übungsstoff zu 90% aus diesen beiden Schwerpunktklassen +- Spezialwissen (= für supergute Noten): + - Sparsamkeit: Implementierung energiebewusstes RR + - Robustheit: Details zur L4-Abstraktion von hierarchischen Adressräumen + - Sicherheit: TCBs, ACL-Implementierung, HRU- und BLP Sicherheitsmodelle, SELinux: grundlegende Politiksemantik + - Echtzeit: RC Algorithmus über die ,,Idee'' hinausgehend , Strategien zur Sekundärspeicherverwaltung, Formeln fur $U_{lub}$ + - Adaptivität: Details zur ExOS, XoK + - Performanz: BKLs in $\mu$Kernels, Formeln zur Parallelisierbarkeit +- Zusatzwissen (= für‘s Leben, nicht für die Prüfung): + - Sparsamkeit: Hardware-Maßnahmen, Details zu DPM und DVS + - Robustheit: Verfügbarkeitsklassen in Zahlen + - Sicherheit: Syntax zur Definition der SELinux-Politik, Benutzung von SGX-Enclaves + - Echtzeit: Beweis: Obere Auslastungsgrenze bei EDF + - Adaptivität: Assembler-Beispiel zur sensiblen Instruktionen + - Performanz: Berechnung des Optimums der Beschleunigungseffizienz, Plan 9 + + +# Literatur +- NFE in Betriebssystemen + - Eeles, Peter; Cripps, Peter: The Process of Software Architecting +- Funktionale Eigenschaften eines Betriebssystem + - Tanebaum, Andrews; Bos, Herbert: Modern Operating Systems + - Tanebaum, Andrews; Woodhull, Alberts: Operating Systems Design and Implementation + - Stallings, William: Operating Systems: Internals and Design Principles +- Energieeffizienz + - GUPTA, RAJESHK.; IRANI, SANDY; SHUKLA, SANDEEPK.; SHUKLA, SANDEEPK.: Formal Methods for Dynamic Power Management + - RANGANATHAN, PARTHASARATHY: Recipe for efficiency: principles of power-aware computing + - SIMUNIC, TAJANA; BENINI, LUCA; GLYNN, PETER; DEMICHELI, GIOVANNI: Dynamic Power Management for Portable Systems +- Effiziente Hauptspeicherverwaltung + - DINIZ, BRUNO; GUEDES, DORGIVAL; MEIRA, WAGNER, JR.; BIANCHINI, RICARDO: Limiting the Power Consumption of Main Memory +- Traditionelles Festplatten-Prefetching + - CAO, PEI; FELTEN, EDWARDW.; KARLIN, ANNAR.; LI, KAI: A Study ofIntegrated Prefetching and Caching Strategies +- Effizienter Betrieb von Festplatten + - PAPATHANASIOU, ATHANASIOSE.; SCOTT, MICHAELL.: Energy Efficient Prefetching and Caching +- Energieeffizientes Scheduling + - KLEE, CHRISTOPH: Design and Analysis of Energy-Aware Scheduling Policies +- Energieeffiziente Betriebssysteme + - LANG, CLEMENS: Components for Energy-Efficient Operating Systems + - YAN, LE; ZHONG, LIN; JHA, NIRAJK.: Towards a Responsive, Yet Power-efficient, Operating System: A Holistic Approach + - YAN, LE; ZHONG, LIN; JHA, NIRAJK.: User-perceived Latency Driven Voltage Scaling for Interactive Applications +- Eingebettete Systeme + - MANLEY, JOHNH.: Embedded Systems, MARCINIAK, J. J.(Hrsg.) +- TinyOS + - KELLNER, SIMON; BELLOSA, FRANK: Energy Accounting Support in TinyOS + - KELLNER, SIMON: Flexible Online Energy Accounting in TinyOS +- Verlässlichkeitsbegriff, Fehlermodell: + - [ALRL04] AVIŽIENIS, ALGIRDAS; LAPRIE, JEAN-CLAUDE; RANDELL, BRIAN; LANDWEHR, CARL: Basic Concepts and Taxonomy of Dependable and Secure Computing. In: IEEE Trans. Dependable Secur. Comput. https://doi.org/10.1109/TDSC.2004.2 + - [AvLR04] AVIŽIENIS, ALGIRDAS; LAPRIE, JEAN-CLAUDE; RANDELL, BRIAN: Dependability and Its Threats: A Taxonomy. In: JACQUART, R.(Hrsg.): Building theInformation Society , IFIP International Federation for Information Processing : Springer US, 2004, https://doi.org/10.1007/978 +- DeepSpace 1 Remote Debugging: + - GARRET, RON: Lispingat JPL. URL http://www.flownet.com/gat/jpl-lisp.html +- Kernelarchitekturdesign und Mikrokernelprinzip: + - [Heis19] HEISER, GERNOT: COMP9242 Advanced Operating Systems. Lecture Slides UNSW Australia, 2019. Courtesy of Gernot Heiser, UNSW. https://www.cse.unsw.edu.au/~cs9242/19/lectures.shtml + - [TaBo15] TANENBAUM, ANDREWS; WOODHULL, ALBERTS: Operating Systems Design and Implementation. 3. Aufl. UpperSaddleRiver, NJ, USA: Prentice-Hall, Inc., 2005 +- Mikrokerneldesign, L4: + - [Lied95] LIEDTKE, JOCHEN: On μ-Kernel Construction. In: Operating Systems Review. Special issue for the Fifteenth ACM Symposium on Operating System Principles Bd. 29 (1995), https://doi.org/10.1145/224056.224075 +- MINIX: + - HERDER, JORRITN.; BOS, HERBERT; GRAS, BEN; HOMBURG, PHILIP; TANENBAUM, ANDREWS.: MINIX 3: A Highly Reliable, Self-repairing Operating System. In: ACM SIGOPS Operating Systems Review https://doi.org/10.1145/1151374.1151391 + - TANENBAUM, ANDREWS. APPUSWAMY, RAJA; BOS, HERBERTJ. ; CAVALLARO, LORENZO; GIUFFRIDA, CRISTIANO; HRUBY, TOMAS; HERDER, JORRIT; VANDERKOUWE, ERIK; U.A.: MINIX 3: Status Report and Current Research. In: login: The USENIX Magazine Bd. 35 (2010) https://www.usenix.org/publications/login/june- 2010 + - [TaWo05] TANENBAUM, ANDREWS; WOODHULL, ALBERTS: Operating Systems Design and Implementation. 3. Aufl. UpperSaddleRiver, NJ, USA: Prentice-Hall, Inc. +- Sicherheitsbedrohungen: + - [Stal18] STALLINGS, WILLIAM: Operating Systems: Internals and Design Principles. Pearson, 2018 +- Sicherheitsmodelle: + - [Amth16] AMTHOR, PETER: The Entity LabelingPattern for Modeling Operating Systems Access Control. In: OBAIDAT, S. M.; LORENZ, P.(Hrsg.): E-Business and Telecommunications: 12th International Joint Conference, ICETE 2015, Colmar, France, http://dx.doi.org/10.1007/978-3-319-30222-5_13 + - [BeLa76] BELL, D. ELLIOTT; LAPADULA, LEONARDJ.: Secure Computer System: Unified Exposition and MulticsInterpretation (Technical Report Nr. AD-A023 588): MITRE, 1976 + - [Biba77] BIBA, KENNETHJ.: IntegrityConsiderationsforSecure Computer Systems (Technical Report Nr. ESD-TR-76-372). Bedford, Massachusetts: MITRE, 1977 http://seclab.cs.ucdavis.edu/projects/history/papers/biba75.pdf (digitalisierte Fassung von 1975) + - [HaRU76] HARRISON, MICHAELA.; RUZZO, WALTERL.; ULLMAN, JEFFREYD.: Protectionin Operating Systems. In: Communications oftheACM Bd. 19 (1976), Nr.8, S. 461 - 471 http://doi.acm.org/10.1145/360303.360333 +- SELinux: + - [LoSm01] LOSCOCCO, PETERA.; SMALLEY, STEPHEND.: Integrating Flexible Support for Security Policies into the Linux Operating System. In: COLE, C.(Hrsg.): Proceedings of the FREENIX Track: 2001 USENIX Annual Technical Conference. Berkeley, CA, USA: USENIX Association + - [MaMC06] MAYER, FRANK; MACMILLAN, KARL; CAPLAN, DAVID: SELinux by Example: Using Security Enhanced Linux (Prentice Hall Open Source Software Development Series). UpperSaddle River, NJ, USA: PrenticeHall PTR, 2006 + - [Spen07] SPENNEBERG, RALF: SELinux & AppArmor: Mandatory Access Control für Linux einsetzen und verwalten. 1. Aufl. München: Addison-Wesley Verlag, 2007 +- Microsoft Singularity: + - [HLAA05] HUNT, GALEN; LARUS, JAMES; ABADI, MARTIN; AIKEN, MARK; BARHAM, PAUL; FÄHNDRICH, MANUEL; HAWBLITZEL, CHRIS; HODSON, ORION; U.A.: An Overview of the Singularity Project (Nr. MSR-TR-2005-135): Microsoft Research, Redmond, 2005 http://research.microsoft.com/pubs/52716/tr-2005-135.pdf +- Intel SGX: + - [CoDe16] COSTAN, VICTOR; DEVADAS, SRINIVAS: Intel SGX Explained , 2016. Published: Cryptology ePrintArchive, Report 2016/086 https://eprint.iacr.org/2016/086.pdf + - [WeAK18] WEICHBRODT, NICO; AUBLIN, PIERRE-LOUIS; KAPITZA, RÜDIGER: Sgx-perf: A Performance Analysis Tool forIntel SGX Enclaves. In: Proceedingsofthe19th International Middleware Conference , Middleware ’18. New York, NY, USA: ACM, 2018. Rennes, France, S. 201 - 213 http://doi.acm.org/10.1145/3274808.3274824 +Referenzmonitor: + - [Ande72] ANDERSON, JAMESP.: Computer Security Technology Planning Study (Nr. ESD-TR-73-51). HanscomAFB, Bedford, MA, USA: Air Force Electronic Systems Division, 1972 + - [Jaeg11] JAEGER, TRENT: Reference Monitor. In: VANTILBORG, H. C. A.; JAJODIA, S.(Hrsg.): Encyclopedia of Cryptography and Security. Boston, MA: Springer US, 2011, S. 1038 - 1040 http://www.cse.psu.edu/~trj1/cse543-s15/docs/refmon.pdf +- [Buttazzo97], [Buttazzo2000] Giorgio C. Buttazzo: Hard Real-Time Computing Systems - Predictable Scheduling Algorithms and Applications, Kluwer Academic Publishers Boston / Dordrecht / London, 1997 +- [Burns+89] Alan Burns, Andy Wellings: Real-Time Systems andProgrammingLanguages, Addison-Wesley, 3rd edition 2001 +- [Liu&Layland73] C. L. Liu, James W. Layland: Scheduling Algorithms for Multiprogramming in a Hard-Real-Time Environment, Journal of the ACM, Vol. 20, Nr. 1 (Januar 1973) +- [Quade+2012] Jürgen Quade, Michael Mächtel: Moderne Realzeitsysteme kompakt -Eine Einführung mit Embedded Linux, dpunkt.verlag, 2012 +- [Liu2000] Jane W. S. Liu: Real-Time Systems, PrenticeHall 2000 +- [Clark89] Dayton Clark: HIC: An Operating System for Hierarchies of Servo Loops, Proceedings of the 1989 International Conference on Robotics and Automation +- [Deitel90] Harvey M. Deitel: Operating Systems, Addison-Wesley, 1990 +- [Goyal+96] PawanGoyal, XingangGuo, HarrickM. Vin: A HierarchicalCPU Scheduler forMultimedia Operating Systems, OSDI (ACM-Konferenz ,,Operating System Design andImplementation'') 1996 +- [Hamann+97] Claude-Joachim Hamann u.a. [http://os.inf.tu-dresden.de/drops/doc.html](http://os.inf.tu-dresden.de/drops/doc.html) +- [Sha+90] L. Sha, R. Rajkumar, J. P. Lehoczky: Priority Inheritance Protocols: An Approach to Real-Time Synchronization, IEEE Transactions on Computers, September 1990 +- [Inf-Handbuch97] Peter Rechenberg, Gustav Pomberger (Hrsg.): Informatik-Handbuch, Carl-Hanser-Verlag München Wien, 1997 +- [Schiebe+92] Michael Schiebe (Hrsg.): Real-time Systems -Engineering andApplications, Kluwer Academic Publishers 1992 +- [Silberschatz+91] Abraham Silberschatz, James L. Peterson, Peter B. Galvin: Operating Systems Concepts(3rd edition), Addison-Wesley Publishing Company, 1991 +- [Steinmetz95] Ralf Steinmetz: Analyzing the Multimedia Operating System, IEEE Multimedia, Vol. 2, Nr. 1 (Spring 1995) +- [Wörn+2005] Heinz Wörn, Uwe Brinkschulte: Echtzeitsysteme - Grundlagen, Funktionsweisen, Anwendungen, Springer-Verlag Berlin Heidelberg 2005 +- [Yau+96] David K. Y. Yau, Simon S. Lam: Adaptive Rate-Controlled Scheduling for Multimedia Applications, Proceedings of the 4th ACM International Multimedia Conference 1996 +- Container: + - [Merkel14] Dirk Merkel: Docker: Lightweight Linux Containers for Consistent Development and Deployment, Linux Journal, No. 239 (Mar 2014). +- Adaptivitätsbegriff: + - [Marciniak94] John J. Marciniak (Hrsg.): Encyclopedia of Software Engineering, Vol. 1, John Wiley& Sons, 1994 +- Exokernel: + - [Engler+95] Dawson R. Engler, M. Frans Kaashoek, James O‘TooleJr.: Exokernel: An Operating System Architecture for Application-Level Resource Management, 15th ACM Symposium on Operating System Principles(SOSP), 1995 + - [Engler98] Dawson R. Engler: The Exokernel Operating System Architecture, Ph.D. Thesis, Massachusetts Institute ofTechnology, 1998 + - [Engler+97] M. Frans Kaashoek, Dawson R. Engler, Gregory R. Ganger, Héctor M. Briceño, Russell Hunt, David Mazieres, Thomas Pinckney, Robert Grimm, John Jannotti, Kenneth Mackenzie: Application Performance and Flexibility of Exokernel Systems, 16th ACM Symposium on Operating System Principles(SOSP), 1997 + - [Engler+96] Dawson R. Engler, M. Frans Kaashoek, Gregory R. Ganger, Héctor M. Briceño, Russell Hunt, David Mazieres, Thomas Pinckney, John Jannotti: Exokernels (Präsentation, online verfügbar unter: https://pdos.csail.mit.edu/exo/exo-slides/sld001.htm) +- Nemesis: + - [Reed+97] Dickon Reed, Robin Fairbairns (Hrsg.): Nemesis, The Kernel - Overview, Technischer Bericht, 1997, (verfügbar unter: http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.57.512) +- MirageOS: + - [Scott+13] Anil Madhavapeddy, David J. Scott: Unikernels: Rise of the Virtual Library Operating System, ACM Queue -Distributed Computing, Vol. 11, No. 11 (Nov 2013), https://dl.acm.org/citation.cfm?id=2566628 +- Virtualisierung: + - [Popek&Goldberg74] Gerald J. Popek, Robert P. Goldberg: Formal Requirements for Virtualizable Third Generation Architectures, Communications of the ACM, Vol. 17, No.7, 1974 + - [Adams&Agesen06] Keith Adams, Ole Agesen: A Comparison of Software and Hardware Techniques for x86 Virtualization, 12th Int. Conf. on Architectural Support for Programming Languages and Operating, Systems(ASPLOS XII), 2006 + - [Agesen+12] Ole Agesen,Jim Mattson,Radu Rugina, Jeffrey Sheldon: Software Techniques for Avoiding Hardware Virtualization Exits, 2012 USENIX Annual Technical Conference (USENIX ATC '12), 2012 +- Parallelisierbarkeit: + - [Heiss94] Hans-Ulrich Heiss: Prozessorzuteilung in Parallelrechnern, B.I. Wissenschaftsverlag: Mannheim, Leipzig, Wien, Zürich, 1994, ISBN: 3-411-17061-1 + - [Keckler+2009] Stephen W. Keckler: Multicore Processors and Systems, Springer Science+BusinessMedia, LLC 2009, ISBN 978-1-4419-0263-4 +- Barrelfish: + - [Baumann+2009b] Andrew Baumann et al.: The Multikernel: A newOS architecture for scalable multicoresystems, Proceedings ACM SOSP (Symposium on Operating System Principles) 2009 +- Amoeba: + - [Tanenbaum+91] AndrewS. Tanenbaum, M. Frans Kaashoek, Robbertvan Renesse, Henri E. Bal: The Amoeba Distributed Operating System - A Status Report Elsevier Computer Communications, Vol. 14, No.6, 1991, S. 324 - 335 \ No newline at end of file diff --git a/Assets/ASK_Diamantengadget.png b/Assets/ASK_Diamantengadget.png new file mode 100644 index 0000000..54f37b4 Binary files /dev/null and b/Assets/ASK_Diamantengadget.png differ diff --git a/Assets/ASK_Dreieckfaerbung1.png b/Assets/ASK_Dreieckfaerbung1.png new file mode 100644 index 0000000..8c25144 Binary files /dev/null and b/Assets/ASK_Dreieckfaerbung1.png differ diff --git a/Assets/ASK_Dreieckfaerbung2.png b/Assets/ASK_Dreieckfaerbung2.png new file mode 100644 index 0000000..12c9ca4 Binary files /dev/null and b/Assets/ASK_Dreieckfaerbung2.png differ diff --git a/Assets/ASK_Dreieckfaerbung3.png b/Assets/ASK_Dreieckfaerbung3.png new file mode 100644 index 0000000..5be5f59 Binary files /dev/null and b/Assets/ASK_Dreieckfaerbung3.png differ diff --git a/Assets/ASK_Dreieckfaerbung4.png b/Assets/ASK_Dreieckfaerbung4.png new file mode 100644 index 0000000..e103499 Binary files /dev/null and b/Assets/ASK_Dreieckfaerbung4.png differ diff --git a/Assets/ASK_HamiltonkreisKanten.png b/Assets/ASK_HamiltonkreisKanten.png new file mode 100644 index 0000000..ecd70e8 Binary files /dev/null and b/Assets/ASK_HamiltonkreisKanten.png differ diff --git a/Assets/ASK_Hamiltonkreise.png b/Assets/ASK_Hamiltonkreise.png new file mode 100644 index 0000000..0f3c6e4 Binary files /dev/null and b/Assets/ASK_Hamiltonkreise.png differ diff --git a/Assets/ASK_cyk-Algorithmus.png b/Assets/ASK_cyk-Algorithmus.png new file mode 100644 index 0000000..68977a1 Binary files /dev/null and b/Assets/ASK_cyk-Algorithmus.png differ diff --git a/Assets/ASK_uebung/u01-01.png b/Assets/ASK_uebung/u01-01.png new file mode 100644 index 0000000..e36fc27 Binary files /dev/null and b/Assets/ASK_uebung/u01-01.png differ diff --git a/Assets/ASK_uebung/u02-01.png b/Assets/ASK_uebung/u02-01.png new file mode 100644 index 0000000..26cb871 Binary files /dev/null and b/Assets/ASK_uebung/u02-01.png differ diff --git a/Assets/ASK_uebung/u02-02.png b/Assets/ASK_uebung/u02-02.png new file mode 100644 index 0000000..8ec0c4f Binary files /dev/null and b/Assets/ASK_uebung/u02-02.png differ diff --git a/Assets/ASK_uebung/u03-01.png b/Assets/ASK_uebung/u03-01.png new file mode 100644 index 0000000..2be2b95 Binary files /dev/null and b/Assets/ASK_uebung/u03-01.png differ diff --git a/Assets/ASK_uebung/u04_01.png b/Assets/ASK_uebung/u04_01.png new file mode 100644 index 0000000..be57f57 Binary files /dev/null and b/Assets/ASK_uebung/u04_01.png differ diff --git a/Assets/ASK_uebung/u06_01.png b/Assets/ASK_uebung/u06_01.png new file mode 100644 index 0000000..df82c43 Binary files /dev/null and b/Assets/ASK_uebung/u06_01.png differ diff --git a/Assets/ASK_uebung/u06_02.png b/Assets/ASK_uebung/u06_02.png new file mode 100644 index 0000000..23f4527 Binary files /dev/null and b/Assets/ASK_uebung/u06_02.png differ diff --git a/Assets/ASK_uebung/u06_03.png b/Assets/ASK_uebung/u06_03.png new file mode 100644 index 0000000..280e0c1 Binary files /dev/null and b/Assets/ASK_uebung/u06_03.png differ diff --git a/Assets/Advanced-Operating-Systems-systemaufrufkosten.png b/Assets/Advanced-Operating-Systems-systemaufrufkosten.png new file mode 100644 index 0000000..5f29251 Binary files /dev/null and b/Assets/Advanced-Operating-Systems-systemaufrufkosten.png differ diff --git a/Assets/AdvancedOperatingSystems-L4-second-g.png b/Assets/AdvancedOperatingSystems-L4-second-g.png new file mode 100644 index 0000000..e4c1d2b Binary files /dev/null and b/Assets/AdvancedOperatingSystems-L4-second-g.png differ diff --git a/Assets/AdvancedOperatingSystems-Nemesis-struktur.png b/Assets/AdvancedOperatingSystems-Nemesis-struktur.png new file mode 100644 index 0000000..c0ea2fa Binary files /dev/null and b/Assets/AdvancedOperatingSystems-Nemesis-struktur.png differ diff --git a/Assets/AdvancedOperatingSystems-Referenzmonitorprinzip.png b/Assets/AdvancedOperatingSystems-Referenzmonitorprinzip.png new file mode 100644 index 0000000..191e6e7 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-Referenzmonitorprinzip.png differ diff --git a/Assets/AdvancedOperatingSystems-SGX-enclaves-model.png b/Assets/AdvancedOperatingSystems-SGX-enclaves-model.png new file mode 100644 index 0000000..1c6b43b Binary files /dev/null and b/Assets/AdvancedOperatingSystems-SGX-enclaves-model.png differ diff --git a/Assets/AdvancedOperatingSystems-SGX-enclaves.png b/Assets/AdvancedOperatingSystems-SGX-enclaves.png new file mode 100644 index 0000000..05e7461 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-SGX-enclaves.png differ diff --git a/Assets/AdvancedOperatingSystems-SGX-enlaves-zugriff.png b/Assets/AdvancedOperatingSystems-SGX-enlaves-zugriff.png new file mode 100644 index 0000000..105a891 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-SGX-enlaves-zugriff.png differ diff --git a/Assets/AdvancedOperatingSystems-Xen-architektur.png b/Assets/AdvancedOperatingSystems-Xen-architektur.png new file mode 100644 index 0000000..e4b4cb0 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-Xen-architektur.png differ diff --git a/Assets/AdvancedOperatingSystems-Xen-sicherheit.png b/Assets/AdvancedOperatingSystems-Xen-sicherheit.png new file mode 100644 index 0000000..267d8ea Binary files /dev/null and b/Assets/AdvancedOperatingSystems-Xen-sicherheit.png differ diff --git a/Assets/AdvancedOperatingSystems-acl-vererbungsprinzip.png b/Assets/AdvancedOperatingSystems-acl-vererbungsprinzip.png new file mode 100644 index 0000000..c11a0d3 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-acl-vererbungsprinzip.png differ diff --git a/Assets/AdvancedOperatingSystems-adressraumhierarchie.png b/Assets/AdvancedOperatingSystems-adressraumhierarchie.png new file mode 100644 index 0000000..7052f72 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-adressraumhierarchie.png differ diff --git a/Assets/AdvancedOperatingSystems-cab-empfänger.png b/Assets/AdvancedOperatingSystems-cab-empfänger.png new file mode 100644 index 0000000..3f8357f Binary files /dev/null and b/Assets/AdvancedOperatingSystems-cab-empfänger.png differ diff --git a/Assets/AdvancedOperatingSystems-cab-konkurrierende-zugriffe.png b/Assets/AdvancedOperatingSystems-cab-konkurrierende-zugriffe.png new file mode 100644 index 0000000..3e6f819 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-cab-konkurrierende-zugriffe.png differ diff --git a/Assets/AdvancedOperatingSystems-cab-sender-regel.png b/Assets/AdvancedOperatingSystems-cab-sender-regel.png new file mode 100644 index 0000000..756ad0b Binary files /dev/null and b/Assets/AdvancedOperatingSystems-cab-sender-regel.png differ diff --git a/Assets/AdvancedOperatingSystems-cab-sonderfall-1.png b/Assets/AdvancedOperatingSystems-cab-sonderfall-1.png new file mode 100644 index 0000000..e0515c8 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-cab-sonderfall-1.png differ diff --git a/Assets/AdvancedOperatingSystems-cab-sonderfall-2.png b/Assets/AdvancedOperatingSystems-cab-sonderfall-2.png new file mode 100644 index 0000000..d90de49 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-cab-sonderfall-2.png differ diff --git a/Assets/AdvancedOperatingSystems-container.png b/Assets/AdvancedOperatingSystems-container.png new file mode 100644 index 0000000..2aa9417 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-container.png differ diff --git a/Assets/AdvancedOperatingSystems-dac-zugriffsmatrix.png b/Assets/AdvancedOperatingSystems-dac-zugriffsmatrix.png new file mode 100644 index 0000000..d3a0a9b Binary files /dev/null and b/Assets/AdvancedOperatingSystems-dac-zugriffsmatrix.png differ diff --git a/Assets/AdvancedOperatingSystems-dateisystem-serverausfall.png b/Assets/AdvancedOperatingSystems-dateisystem-serverausfall.png new file mode 100644 index 0000000..eb67dd6 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-dateisystem-serverausfall.png differ diff --git a/Assets/AdvancedOperatingSystems-docker.png b/Assets/AdvancedOperatingSystems-docker.png new file mode 100644 index 0000000..c53f25f Binary files /dev/null and b/Assets/AdvancedOperatingSystems-docker.png differ diff --git a/Assets/AdvancedOperatingSystems-drops.png b/Assets/AdvancedOperatingSystems-drops.png new file mode 100644 index 0000000..5d33ff6 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-drops.png differ diff --git a/Assets/AdvancedOperatingSystems-dryos.png b/Assets/AdvancedOperatingSystems-dryos.png new file mode 100644 index 0000000..d402ed7 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-dryos.png differ diff --git a/Assets/AdvancedOperatingSystems-echtzeit-aperiodisch-modellierung.png b/Assets/AdvancedOperatingSystems-echtzeit-aperiodisch-modellierung.png new file mode 100644 index 0000000..5e5a6e9 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-echtzeit-aperiodisch-modellierung.png differ diff --git a/Assets/AdvancedOperatingSystems-echtzeit-edf-vs-rm.png b/Assets/AdvancedOperatingSystems-echtzeit-edf-vs-rm.png new file mode 100644 index 0000000..8e80080 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-echtzeit-edf-vs-rm.png differ diff --git a/Assets/AdvancedOperatingSystems-echtzeit-parameter-instanz.png b/Assets/AdvancedOperatingSystems-echtzeit-parameter-instanz.png new file mode 100644 index 0000000..c1a0c8f Binary files /dev/null and b/Assets/AdvancedOperatingSystems-echtzeit-parameter-instanz.png differ diff --git a/Assets/AdvancedOperatingSystems-echtzeit-parameter-instanz2.png b/Assets/AdvancedOperatingSystems-echtzeit-parameter-instanz2.png new file mode 100644 index 0000000..280ad43 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-echtzeit-parameter-instanz2.png differ diff --git a/Assets/AdvancedOperatingSystems-echtzeit-parameter-instanz3.png b/Assets/AdvancedOperatingSystems-echtzeit-parameter-instanz3.png new file mode 100644 index 0000000..3fa6a19 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-echtzeit-parameter-instanz3.png differ diff --git a/Assets/AdvancedOperatingSystems-echtzeit-periodisch-frist.png b/Assets/AdvancedOperatingSystems-echtzeit-periodisch-frist.png new file mode 100644 index 0000000..1a04087 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-echtzeit-periodisch-frist.png differ diff --git a/Assets/AdvancedOperatingSystems-echtzeit-periodisch-modellierung.png b/Assets/AdvancedOperatingSystems-echtzeit-periodisch-modellierung.png new file mode 100644 index 0000000..89bb0ec Binary files /dev/null and b/Assets/AdvancedOperatingSystems-echtzeit-periodisch-modellierung.png differ diff --git a/Assets/AdvancedOperatingSystems-echtzeit-scheduling-edf-dynamisch.png b/Assets/AdvancedOperatingSystems-echtzeit-scheduling-edf-dynamisch.png new file mode 100644 index 0000000..dfc8bd0 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-echtzeit-scheduling-edf-dynamisch.png differ diff --git a/Assets/AdvancedOperatingSystems-echtzeit-scheduling-edf.png b/Assets/AdvancedOperatingSystems-echtzeit-scheduling-edf.png new file mode 100644 index 0000000..7d2c579 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-echtzeit-scheduling-edf.png differ diff --git a/Assets/AdvancedOperatingSystems-echtzeit-scheduling-edf2.png b/Assets/AdvancedOperatingSystems-echtzeit-scheduling-edf2.png new file mode 100644 index 0000000..1c3b875 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-echtzeit-scheduling-edf2.png differ diff --git a/Assets/AdvancedOperatingSystems-echtzeit-scheduling-rm-statisch.png b/Assets/AdvancedOperatingSystems-echtzeit-scheduling-rm-statisch.png new file mode 100644 index 0000000..353c14b Binary files /dev/null and b/Assets/AdvancedOperatingSystems-echtzeit-scheduling-rm-statisch.png differ diff --git a/Assets/AdvancedOperatingSystems-echtzeit-scheduling-rm.png b/Assets/AdvancedOperatingSystems-echtzeit-scheduling-rm.png new file mode 100644 index 0000000..e6442f3 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-echtzeit-scheduling-rm.png differ diff --git a/Assets/AdvancedOperatingSystems-echtzeit-scheduling-rm2.png b/Assets/AdvancedOperatingSystems-echtzeit-scheduling-rm2.png new file mode 100644 index 0000000..5606bfc Binary files /dev/null and b/Assets/AdvancedOperatingSystems-echtzeit-scheduling-rm2.png differ diff --git a/Assets/AdvancedOperatingSystems-echtzeitfähigkeit.png b/Assets/AdvancedOperatingSystems-echtzeitfähigkeit.png new file mode 100644 index 0000000..c0576a6 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-echtzeitfähigkeit.png differ diff --git a/Assets/AdvancedOperatingSystems-edf-prioritätsumkehr.png b/Assets/AdvancedOperatingSystems-edf-prioritätsumkehr.png new file mode 100644 index 0000000..f1be188 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-edf-prioritätsumkehr.png differ diff --git a/Assets/AdvancedOperatingSystems-energiebewisstes-rr-2.png b/Assets/AdvancedOperatingSystems-energiebewisstes-rr-2.png new file mode 100644 index 0000000..b819e53 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-energiebewisstes-rr-2.png differ diff --git a/Assets/AdvancedOperatingSystems-energiebewusstes-rr-reaktivität.png b/Assets/AdvancedOperatingSystems-energiebewusstes-rr-reaktivität.png new file mode 100644 index 0000000..857b5ab Binary files /dev/null and b/Assets/AdvancedOperatingSystems-energiebewusstes-rr-reaktivität.png differ diff --git a/Assets/AdvancedOperatingSystems-energiebewusstes-rr.png b/Assets/AdvancedOperatingSystems-energiebewusstes-rr.png new file mode 100644 index 0000000..4cc56db Binary files /dev/null and b/Assets/AdvancedOperatingSystems-energiebewusstes-rr.png differ diff --git a/Assets/AdvancedOperatingSystems-energiezustände-festplatte.png b/Assets/AdvancedOperatingSystems-energiezustände-festplatte.png new file mode 100644 index 0000000..891b53d Binary files /dev/null and b/Assets/AdvancedOperatingSystems-energiezustände-festplatte.png differ diff --git a/Assets/AdvancedOperatingSystems-ethernet-treiberausfall.png b/Assets/AdvancedOperatingSystems-ethernet-treiberausfall.png new file mode 100644 index 0000000..a8fbbb9 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-ethernet-treiberausfall.png differ diff --git a/Assets/AdvancedOperatingSystems-exokernel-architektur.png b/Assets/AdvancedOperatingSystems-exokernel-architektur.png new file mode 100644 index 0000000..bc2727c Binary files /dev/null and b/Assets/AdvancedOperatingSystems-exokernel-architektur.png differ diff --git a/Assets/AdvancedOperatingSystems-exokernel-beispiel.png b/Assets/AdvancedOperatingSystems-exokernel-beispiel.png new file mode 100644 index 0000000..cbbf031 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-exokernel-beispiel.png differ diff --git a/Assets/AdvancedOperatingSystems-exokernelarchitekturen.png b/Assets/AdvancedOperatingSystems-exokernelarchitekturen.png new file mode 100644 index 0000000..448a346 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-exokernelarchitekturen.png differ diff --git a/Assets/AdvancedOperatingSystems-exos.png b/Assets/AdvancedOperatingSystems-exos.png new file mode 100644 index 0000000..0dadb8e Binary files /dev/null and b/Assets/AdvancedOperatingSystems-exos.png differ diff --git a/Assets/AdvancedOperatingSystems-externe-fragmentierung.png b/Assets/AdvancedOperatingSystems-externe-fragmentierung.png new file mode 100644 index 0000000..b36f562 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-externe-fragmentierung.png differ diff --git a/Assets/AdvancedOperatingSystems-fehler.png b/Assets/AdvancedOperatingSystems-fehler.png new file mode 100644 index 0000000..96868fa Binary files /dev/null and b/Assets/AdvancedOperatingSystems-fehler.png differ diff --git a/Assets/AdvancedOperatingSystems-gemischte-prozessmenge.png b/Assets/AdvancedOperatingSystems-gemischte-prozessmenge.png new file mode 100644 index 0000000..9007470 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-gemischte-prozessmenge.png differ diff --git a/Assets/AdvancedOperatingSystems-hintergrund-scheduling.png b/Assets/AdvancedOperatingSystems-hintergrund-scheduling.png new file mode 100644 index 0000000..782190d Binary files /dev/null and b/Assets/AdvancedOperatingSystems-hintergrund-scheduling.png differ diff --git a/Assets/AdvancedOperatingSystems-instruction-mit-typ1-hv.png b/Assets/AdvancedOperatingSystems-instruction-mit-typ1-hv.png new file mode 100644 index 0000000..4269f20 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-instruction-mit-typ1-hv.png differ diff --git a/Assets/AdvancedOperatingSystems-instruction-ohne-hypervisor.png b/Assets/AdvancedOperatingSystems-instruction-ohne-hypervisor.png new file mode 100644 index 0000000..aa44d3a Binary files /dev/null and b/Assets/AdvancedOperatingSystems-instruction-ohne-hypervisor.png differ diff --git a/Assets/AdvancedOperatingSystems-instruction-priv-vs-sensible.png b/Assets/AdvancedOperatingSystems-instruction-priv-vs-sensible.png new file mode 100644 index 0000000..6f463e8 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-instruction-priv-vs-sensible.png differ diff --git a/Assets/AdvancedOperatingSystems-interne-fragmentierung.png b/Assets/AdvancedOperatingSystems-interne-fragmentierung.png new file mode 100644 index 0000000..4dd072b Binary files /dev/null and b/Assets/AdvancedOperatingSystems-interne-fragmentierung.png differ diff --git a/Assets/AdvancedOperatingSystems-interruptbehandlung-fristüberschreitung.png b/Assets/AdvancedOperatingSystems-interruptbehandlung-fristüberschreitung.png new file mode 100644 index 0000000..ea3eeb7 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-interruptbehandlung-fristüberschreitung.png differ diff --git a/Assets/AdvancedOperatingSystems-interruptbehandlung-lösung.png b/Assets/AdvancedOperatingSystems-interruptbehandlung-lösung.png new file mode 100644 index 0000000..aa94b54 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-interruptbehandlung-lösung.png differ diff --git a/Assets/AdvancedOperatingSystems-kommunikation-cab.png b/Assets/AdvancedOperatingSystems-kommunikation-cab.png new file mode 100644 index 0000000..3e201e8 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-kommunikation-cab.png differ diff --git a/Assets/AdvancedOperatingSystems-kommunikation-zyklisch-cab.png b/Assets/AdvancedOperatingSystems-kommunikation-zyklisch-cab.png new file mode 100644 index 0000000..09ee0e7 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-kommunikation-zyklisch-cab.png differ diff --git a/Assets/AdvancedOperatingSystems-l4-family.png b/Assets/AdvancedOperatingSystems-l4-family.png new file mode 100644 index 0000000..ef3aad0 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-l4-family.png differ diff --git a/Assets/AdvancedOperatingSystems-l4-first-g.png b/Assets/AdvancedOperatingSystems-l4-first-g.png new file mode 100644 index 0000000..4d311aa Binary files /dev/null and b/Assets/AdvancedOperatingSystems-l4-first-g.png differ diff --git a/Assets/AdvancedOperatingSystems-l4-ipc-performance.png b/Assets/AdvancedOperatingSystems-l4-ipc-performance.png new file mode 100644 index 0000000..aba7a30 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-l4-ipc-performance.png differ diff --git a/Assets/AdvancedOperatingSystems-l4-third-g.png b/Assets/AdvancedOperatingSystems-l4-third-g.png new file mode 100644 index 0000000..98deaa9 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-l4-third-g.png differ diff --git a/Assets/AdvancedOperatingSystems-locks-in-linux.png b/Assets/AdvancedOperatingSystems-locks-in-linux.png new file mode 100644 index 0000000..c63d59e Binary files /dev/null and b/Assets/AdvancedOperatingSystems-locks-in-linux.png differ diff --git a/Assets/AdvancedOperatingSystems-mach-architektur.png b/Assets/AdvancedOperatingSystems-mach-architektur.png new file mode 100644 index 0000000..268c960 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-mach-architektur.png differ diff --git a/Assets/AdvancedOperatingSystems-mach-server.png b/Assets/AdvancedOperatingSystems-mach-server.png new file mode 100644 index 0000000..3b6c31c Binary files /dev/null and b/Assets/AdvancedOperatingSystems-mach-server.png differ diff --git a/Assets/AdvancedOperatingSystems-mach-systemaufruf.png b/Assets/AdvancedOperatingSystems-mach-systemaufruf.png new file mode 100644 index 0000000..90d35a4 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-mach-systemaufruf.png differ diff --git a/Assets/AdvancedOperatingSystems-makrokernel.png b/Assets/AdvancedOperatingSystems-makrokernel.png new file mode 100644 index 0000000..c058b01 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-makrokernel.png differ diff --git a/Assets/AdvancedOperatingSystems-makrokernelarchitektur.png b/Assets/AdvancedOperatingSystems-makrokernelarchitektur.png new file mode 100644 index 0000000..958cabc Binary files /dev/null and b/Assets/AdvancedOperatingSystems-makrokernelarchitektur.png differ diff --git a/Assets/AdvancedOperatingSystems-mikrokernel.png b/Assets/AdvancedOperatingSystems-mikrokernel.png new file mode 100644 index 0000000..1e35a48 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-mikrokernel.png differ diff --git a/Assets/AdvancedOperatingSystems-minix-architektur-bs.png b/Assets/AdvancedOperatingSystems-minix-architektur-bs.png new file mode 100644 index 0000000..d09af7b Binary files /dev/null and b/Assets/AdvancedOperatingSystems-minix-architektur-bs.png differ diff --git a/Assets/AdvancedOperatingSystems-minix-architektur.png b/Assets/AdvancedOperatingSystems-minix-architektur.png new file mode 100644 index 0000000..95a378b Binary files /dev/null and b/Assets/AdvancedOperatingSystems-minix-architektur.png differ diff --git a/Assets/AdvancedOperatingSystems-minix-reincarnation-server.png b/Assets/AdvancedOperatingSystems-minix-reincarnation-server.png new file mode 100644 index 0000000..213a324 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-minix-reincarnation-server.png differ diff --git a/Assets/AdvancedOperatingSystems-mirageOs-architektur.png b/Assets/AdvancedOperatingSystems-mirageOs-architektur.png new file mode 100644 index 0000000..ffbc4a2 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-mirageOs-architektur.png differ diff --git a/Assets/AdvancedOperatingSystems-modularer-makrokernel-2.png b/Assets/AdvancedOperatingSystems-modularer-makrokernel-2.png new file mode 100644 index 0000000..0cab0e4 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-modularer-makrokernel-2.png differ diff --git a/Assets/AdvancedOperatingSystems-modularer-makrokernel.png b/Assets/AdvancedOperatingSystems-modularer-makrokernel.png new file mode 100644 index 0000000..324464e Binary files /dev/null and b/Assets/AdvancedOperatingSystems-modularer-makrokernel.png differ diff --git a/Assets/AdvancedOperatingSystems-multicore-prozessoren-2.png b/Assets/AdvancedOperatingSystems-multicore-prozessoren-2.png new file mode 100644 index 0000000..51aa605 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-multicore-prozessoren-2.png differ diff --git a/Assets/AdvancedOperatingSystems-multicore-prozessoren-3.png b/Assets/AdvancedOperatingSystems-multicore-prozessoren-3.png new file mode 100644 index 0000000..a19b291 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-multicore-prozessoren-3.png differ diff --git a/Assets/AdvancedOperatingSystems-multicore-prozessoren.png b/Assets/AdvancedOperatingSystems-multicore-prozessoren.png new file mode 100644 index 0000000..f5d14df Binary files /dev/null and b/Assets/AdvancedOperatingSystems-multicore-prozessoren.png differ diff --git a/Assets/AdvancedOperatingSystems-obligatorisch-optionaler-prozessanteil.png b/Assets/AdvancedOperatingSystems-obligatorisch-optionaler-prozessanteil.png new file mode 100644 index 0000000..d4d0374 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-obligatorisch-optionaler-prozessanteil.png differ diff --git a/Assets/AdvancedOperatingSystems-optimale-prozessoranzahl.png b/Assets/AdvancedOperatingSystems-optimale-prozessoranzahl.png new file mode 100644 index 0000000..ef8292a Binary files /dev/null and b/Assets/AdvancedOperatingSystems-optimale-prozessoranzahl.png differ diff --git a/Assets/AdvancedOperatingSystems-passwd-lösung.png b/Assets/AdvancedOperatingSystems-passwd-lösung.png new file mode 100644 index 0000000..0f039ed Binary files /dev/null and b/Assets/AdvancedOperatingSystems-passwd-lösung.png differ diff --git a/Assets/AdvancedOperatingSystems-passwd-lösung2.png b/Assets/AdvancedOperatingSystems-passwd-lösung2.png new file mode 100644 index 0000000..361b4a5 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-passwd-lösung2.png differ diff --git a/Assets/AdvancedOperatingSystems-passwd-problem.png b/Assets/AdvancedOperatingSystems-passwd-problem.png new file mode 100644 index 0000000..9c959bb Binary files /dev/null and b/Assets/AdvancedOperatingSystems-passwd-problem.png differ diff --git a/Assets/AdvancedOperatingSystems-prioritätsumkehr-folgen.png b/Assets/AdvancedOperatingSystems-prioritätsumkehr-folgen.png new file mode 100644 index 0000000..7ec27d1 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-prioritätsumkehr-folgen.png differ diff --git a/Assets/AdvancedOperatingSystems-prioritätsumkehr-ursache.png b/Assets/AdvancedOperatingSystems-prioritätsumkehr-ursache.png new file mode 100644 index 0000000..99cf668 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-prioritätsumkehr-ursache.png differ diff --git a/Assets/AdvancedOperatingSystems-prioritätsumkehr.png b/Assets/AdvancedOperatingSystems-prioritätsumkehr.png new file mode 100644 index 0000000..2ac0fc5 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-prioritätsumkehr.png differ diff --git a/Assets/AdvancedOperatingSystems-private-virtuelle-adressräume.png b/Assets/AdvancedOperatingSystems-private-virtuelle-adressräume.png new file mode 100644 index 0000000..f943e09 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-private-virtuelle-adressräume.png differ diff --git a/Assets/AdvancedOperatingSystems-rc-abweichende-prozesse.png b/Assets/AdvancedOperatingSystems-rc-abweichende-prozesse.png new file mode 100644 index 0000000..cb3fc78 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-rc-abweichende-prozesse.png differ diff --git a/Assets/AdvancedOperatingSystems-rc-ti-berechnen-1.png b/Assets/AdvancedOperatingSystems-rc-ti-berechnen-1.png new file mode 100644 index 0000000..e75dc80 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-rc-ti-berechnen-1.png differ diff --git a/Assets/AdvancedOperatingSystems-rc-ti-berechnen-2.png b/Assets/AdvancedOperatingSystems-rc-ti-berechnen-2.png new file mode 100644 index 0000000..af38c38 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-rc-ti-berechnen-2.png differ diff --git a/Assets/AdvancedOperatingSystems-referenzmonitor-flask.png b/Assets/AdvancedOperatingSystems-referenzmonitor-flask.png new file mode 100644 index 0000000..2e4e16a Binary files /dev/null and b/Assets/AdvancedOperatingSystems-referenzmonitor-flask.png differ diff --git a/Assets/AdvancedOperatingSystems-rm-server-prozess.png b/Assets/AdvancedOperatingSystems-rm-server-prozess.png new file mode 100644 index 0000000..b6577be Binary files /dev/null and b/Assets/AdvancedOperatingSystems-rm-server-prozess.png differ diff --git a/Assets/AdvancedOperatingSystems-round-robin-unfair.png b/Assets/AdvancedOperatingSystems-round-robin-unfair.png new file mode 100644 index 0000000..b85631c Binary files /dev/null and b/Assets/AdvancedOperatingSystems-round-robin-unfair.png differ diff --git a/Assets/AdvancedOperatingSystems-sekundärspeicherverwaltung-edf.png b/Assets/AdvancedOperatingSystems-sekundärspeicherverwaltung-edf.png new file mode 100644 index 0000000..cb8fcf6 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-sekundärspeicherverwaltung-edf.png differ diff --git a/Assets/AdvancedOperatingSystems-sekundärspeicherverwaltung-fcfs.png b/Assets/AdvancedOperatingSystems-sekundärspeicherverwaltung-fcfs.png new file mode 100644 index 0000000..06ba0a9 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-sekundärspeicherverwaltung-fcfs.png differ diff --git a/Assets/AdvancedOperatingSystems-sekundärspeicherverwaltung-festplatte.png b/Assets/AdvancedOperatingSystems-sekundärspeicherverwaltung-festplatte.png new file mode 100644 index 0000000..bdbab1b Binary files /dev/null and b/Assets/AdvancedOperatingSystems-sekundärspeicherverwaltung-festplatte.png differ diff --git a/Assets/AdvancedOperatingSystems-selinux-retypisierung.png b/Assets/AdvancedOperatingSystems-selinux-retypisierung.png new file mode 100644 index 0000000..021d31a Binary files /dev/null and b/Assets/AdvancedOperatingSystems-selinux-retypisierung.png differ diff --git a/Assets/AdvancedOperatingSystems-selinux-security-server.png b/Assets/AdvancedOperatingSystems-selinux-security-server.png new file mode 100644 index 0000000..41965b5 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-selinux-security-server.png differ diff --git a/Assets/AdvancedOperatingSystems-selinux-sicherheitspolitik-installieren.png b/Assets/AdvancedOperatingSystems-selinux-sicherheitspolitik-installieren.png new file mode 100644 index 0000000..3de06e0 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-selinux-sicherheitspolitik-installieren.png differ diff --git a/Assets/AdvancedOperatingSystems-sicherheit-taxonomie.png b/Assets/AdvancedOperatingSystems-sicherheit-taxonomie.png new file mode 100644 index 0000000..3b9e25a Binary files /dev/null and b/Assets/AdvancedOperatingSystems-sicherheit-taxonomie.png differ diff --git a/Assets/AdvancedOperatingSystems-slack-stealing.png b/Assets/AdvancedOperatingSystems-slack-stealing.png new file mode 100644 index 0000000..f4a043a Binary files /dev/null and b/Assets/AdvancedOperatingSystems-slack-stealing.png differ diff --git a/Assets/AdvancedOperatingSystems-speicherverwaltung.png b/Assets/AdvancedOperatingSystems-speicherverwaltung.png new file mode 100644 index 0000000..0cdf9cc Binary files /dev/null and b/Assets/AdvancedOperatingSystems-speicherverwaltung.png differ diff --git a/Assets/AdvancedOperatingSystems-treiber-kernel-fehler.png b/Assets/AdvancedOperatingSystems-treiber-kernel-fehler.png new file mode 100644 index 0000000..15fc526 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-treiber-kernel-fehler.png differ diff --git a/Assets/AdvancedOperatingSystems-treiber-kernel.png b/Assets/AdvancedOperatingSystems-treiber-kernel.png new file mode 100644 index 0000000..decd115 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-treiber-kernel.png differ diff --git a/Assets/AdvancedOperatingSystems-typ-2-hypervisor.png b/Assets/AdvancedOperatingSystems-typ-2-hypervisor.png new file mode 100644 index 0000000..61442cd Binary files /dev/null and b/Assets/AdvancedOperatingSystems-typ-2-hypervisor.png differ diff --git a/Assets/AdvancedOperatingSystems-unikernel-architektur.png b/Assets/AdvancedOperatingSystems-unikernel-architektur.png new file mode 100644 index 0000000..b194e12 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-unikernel-architektur.png differ diff --git a/Assets/AdvancedOperatingSystems-verfügbarkeit-laufzeit.png b/Assets/AdvancedOperatingSystems-verfügbarkeit-laufzeit.png new file mode 100644 index 0000000..63d93db Binary files /dev/null and b/Assets/AdvancedOperatingSystems-verfügbarkeit-laufzeit.png differ diff --git a/Assets/AdvancedOperatingSystems-virtualisierung-hypervisor-1.png b/Assets/AdvancedOperatingSystems-virtualisierung-hypervisor-1.png new file mode 100644 index 0000000..9cb5f24 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-virtualisierung-hypervisor-1.png differ diff --git a/Assets/AdvancedOperatingSystems-virtualisierung-idee.png b/Assets/AdvancedOperatingSystems-virtualisierung-idee.png new file mode 100644 index 0000000..91af158 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-virtualisierung-idee.png differ diff --git a/Assets/AdvancedOperatingSystems-virtuelle-kernel-adressräume.png b/Assets/AdvancedOperatingSystems-virtuelle-kernel-adressräume.png new file mode 100644 index 0000000..e5e1c8f Binary files /dev/null and b/Assets/AdvancedOperatingSystems-virtuelle-kernel-adressräume.png differ diff --git a/Assets/AdvancedOperatingSystems-virtuelle-vs-physische-adresse.png b/Assets/AdvancedOperatingSystems-virtuelle-vs-physische-adresse.png new file mode 100644 index 0000000..fd21471 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-virtuelle-vs-physische-adresse.png differ diff --git a/Assets/AdvancedOperatingSystems-vmware-bare-metal.png b/Assets/AdvancedOperatingSystems-vmware-bare-metal.png new file mode 100644 index 0000000..1bcbcf0 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-vmware-bare-metal.png differ diff --git a/Assets/AdvancedOperatingSystems-vmware-host-guest-architecture.png b/Assets/AdvancedOperatingSystems-vmware-host-guest-architecture.png new file mode 100644 index 0000000..91cfaf5 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-vmware-host-guest-architecture.png differ diff --git a/Assets/AdvancedOperatingSystems-vmware-paravirtualisierung.png b/Assets/AdvancedOperatingSystems-vmware-paravirtualisierung.png new file mode 100644 index 0000000..a465c44 Binary files /dev/null and b/Assets/AdvancedOperatingSystems-vmware-paravirtualisierung.png differ diff --git a/Assets/Betriebssysteme_Adressräume.png b/Assets/Betriebssysteme_Adressräume.png new file mode 100644 index 0000000..038a8a9 Binary files /dev/null and b/Assets/Betriebssysteme_Adressräume.png differ diff --git a/Assets/Betriebssysteme_Architekturen.png b/Assets/Betriebssysteme_Architekturen.png new file mode 100644 index 0000000..a7e9114 Binary files /dev/null and b/Assets/Betriebssysteme_Architekturen.png differ diff --git a/Assets/Betriebssysteme_PCI_Bridge.png b/Assets/Betriebssysteme_PCI_Bridge.png new file mode 100644 index 0000000..3fadc67 Binary files /dev/null and b/Assets/Betriebssysteme_PCI_Bridge.png differ diff --git a/Assets/Betriebssysteme_PCI_Bridge2.png b/Assets/Betriebssysteme_PCI_Bridge2.png new file mode 100644 index 0000000..5e0cb91 Binary files /dev/null and b/Assets/Betriebssysteme_PCI_Bridge2.png differ diff --git a/Assets/Betriebssysteme_Seitenabbildungstabellen.png b/Assets/Betriebssysteme_Seitenabbildungstabellen.png new file mode 100644 index 0000000..ee9b92b Binary files /dev/null and b/Assets/Betriebssysteme_Seitenabbildungstabellen.png differ diff --git a/Assets/Betriebssysteme_Seitentabelleneinträge.png b/Assets/Betriebssysteme_Seitentabelleneinträge.png new file mode 100644 index 0000000..7da1084 Binary files /dev/null and b/Assets/Betriebssysteme_Seitentabelleneinträge.png differ diff --git a/Assets/Betriebssysteme_Uebersicht.png b/Assets/Betriebssysteme_Uebersicht.png new file mode 100644 index 0000000..8ab7a38 Binary files /dev/null and b/Assets/Betriebssysteme_Uebersicht.png differ diff --git a/Assets/Betriebssysteme_Zustandsmodell.png b/Assets/Betriebssysteme_Zustandsmodell.png new file mode 100644 index 0000000..39026a7 Binary files /dev/null and b/Assets/Betriebssysteme_Zustandsmodell.png differ diff --git a/Assets/Betriebssysteme_i-Node.png b/Assets/Betriebssysteme_i-Node.png new file mode 100644 index 0000000..47aa3d9 Binary files /dev/null and b/Assets/Betriebssysteme_i-Node.png differ diff --git a/Assets/Betriebssysteme_uebung/u2-anlage/u2-a1-anlage/Makefile b/Assets/Betriebssysteme_uebung/u2-anlage/u2-a1-anlage/Makefile new file mode 100644 index 0000000..58ccc7f --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u2-anlage/u2-a1-anlage/Makefile @@ -0,0 +1,16 @@ +all: p1 p2 p3 p4 + +p1: + cc -o p1 p1.c + +p2: + cc -o p2 p2.c + +p3: + cc -o p3 p3.c + +p4: + cc -o p4 p4.c + +clean: + rm -f p1 p2 p3 p4 diff --git a/Assets/Betriebssysteme_uebung/u2-anlage/u2-a1-anlage/p1.c b/Assets/Betriebssysteme_uebung/u2-anlage/u2-a1-anlage/p1.c new file mode 100644 index 0000000..364c15a --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u2-anlage/u2-a1-anlage/p1.c @@ -0,0 +1,11 @@ +#include +#include + +int main() +{ + printf("%d: code before forking - executed once only\n", getpid()); + + fork(); + + printf("%d: code after forking - executed by each process\n", getpid()); +} diff --git a/Assets/Betriebssysteme_uebung/u2-anlage/u2-a1-anlage/p2.c b/Assets/Betriebssysteme_uebung/u2-anlage/u2-a1-anlage/p2.c new file mode 100644 index 0000000..4bd4937 --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u2-anlage/u2-a1-anlage/p2.c @@ -0,0 +1,20 @@ +#include +#include +#include +#include + +int main() +{ + if (fork() == 0) + { // child proc + printf("%d: child created by parent %d; executing 'p4'...\n", getpid(), getppid()); + execl("p4", "p4", NULL); + printf("system call execl(): no success\n"); + } + else + { // parent proc + printf("%d: parent process\n", getpid()); + } + + wait(NULL); +} diff --git a/Assets/Betriebssysteme_uebung/u2-anlage/u2-a1-anlage/p3.c b/Assets/Betriebssysteme_uebung/u2-anlage/u2-a1-anlage/p3.c new file mode 100644 index 0000000..44f129d --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u2-anlage/u2-a1-anlage/p3.c @@ -0,0 +1,22 @@ +#include +#include +#include +#include + +int main() +{ + if (fork() == 0) + { // child proc + printf("%d: child created by parent %d; executing 'p4'...\n", getpid(), getppid()); + execl("p4", "p4", NULL); + } + else + { // parent proc + printf("%d: parent process\n", getpid()); + } + + fork(); + printf("%d: terminating\n", getpid()); + + wait(NULL); +} diff --git a/Assets/Betriebssysteme_uebung/u2-anlage/u2-a1-anlage/p4.c b/Assets/Betriebssysteme_uebung/u2-anlage/u2-a1-anlage/p4.c new file mode 100644 index 0000000..60737e5 --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u2-anlage/u2-a1-anlage/p4.c @@ -0,0 +1,7 @@ +#include +#include + +int main() +{ + printf("%d: p4 running\n", getpid()); +} diff --git a/Assets/Betriebssysteme_uebung/u2-anlage/u2-a2-anlage/Makefile b/Assets/Betriebssysteme_uebung/u2-anlage/u2-a2-anlage/Makefile new file mode 100644 index 0000000..c046b39 --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u2-anlage/u2-a2-anlage/Makefile @@ -0,0 +1,13 @@ +all: p5 p6 p7 + +p5: + gcc -o p5 p5.c + +p6: + gcc -o p6 p6.c + +p7: + gcc -o p7 p7.c + +clean: + rm -f p5 p6 p7 diff --git a/Assets/Betriebssysteme_uebung/u2-anlage/u2-a2-anlage/p5.c b/Assets/Betriebssysteme_uebung/u2-anlage/u2-a2-anlage/p5.c new file mode 100644 index 0000000..1da7cab --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u2-anlage/u2-a2-anlage/p5.c @@ -0,0 +1,23 @@ +#include +#include +#include +#include + +int main() +{ + int pid; + + pid = fork(); + + if (pid == 0) + { // child proc looping endlessly + printf("%d: child ...\n", getpid()); + for(;10;); + } + else + { // parent proc + printf("%d: parent; child pid: %d \n", getpid(), pid); + wait(NULL); // for child termination + printf("%d: parent after wait ... terminating\n", getpid()); + } +} diff --git a/Assets/Betriebssysteme_uebung/u2-anlage/u2-a2-anlage/p6.c b/Assets/Betriebssysteme_uebung/u2-anlage/u2-a2-anlage/p6.c new file mode 100644 index 0000000..9592f77 --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u2-anlage/u2-a2-anlage/p6.c @@ -0,0 +1,7 @@ +#include + +int main() +{ + printf("p6: calling getchar()\n"); + getchar(); +} diff --git a/Assets/Betriebssysteme_uebung/u2-anlage/u2-a2-anlage/p7.c b/Assets/Betriebssysteme_uebung/u2-anlage/u2-a2-anlage/p7.c new file mode 100644 index 0000000..70080bd --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u2-anlage/u2-a2-anlage/p7.c @@ -0,0 +1,8 @@ +#include +#include + +int main() +{ + printf("p7: calling sleep()\n"); + sleep(100); +} diff --git a/Assets/Betriebssysteme_uebung/u2-anlage/u2-a3-anlage-ELF-vs1-2.pdf b/Assets/Betriebssysteme_uebung/u2-anlage/u2-a3-anlage-ELF-vs1-2.pdf new file mode 100644 index 0000000..78711dc Binary files /dev/null and b/Assets/Betriebssysteme_uebung/u2-anlage/u2-a3-anlage-ELF-vs1-2.pdf differ diff --git a/Assets/Betriebssysteme_uebung/u3_a1.png b/Assets/Betriebssysteme_uebung/u3_a1.png new file mode 100644 index 0000000..482e4cf Binary files /dev/null and b/Assets/Betriebssysteme_uebung/u3_a1.png differ diff --git a/Assets/Betriebssysteme_uebung/u4_a1.png b/Assets/Betriebssysteme_uebung/u4_a1.png new file mode 100644 index 0000000..bd60a45 Binary files /dev/null and b/Assets/Betriebssysteme_uebung/u4_a1.png differ diff --git a/Assets/Betriebssysteme_uebung/u5-a1-anlage/Makefile b/Assets/Betriebssysteme_uebung/u5-a1-anlage/Makefile new file mode 100644 index 0000000..93c0705 --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u5-a1-anlage/Makefile @@ -0,0 +1,10 @@ +all: client server + +client: + gcc -o msgclient msgclient.c + +server: + gcc -o msgserver msgserver.c + +clean: + rm -f msgclient msgserver diff --git a/Assets/Betriebssysteme_uebung/u5-a1-anlage/msgclient.c b/Assets/Betriebssysteme_uebung/u5-a1-anlage/msgclient.c new file mode 100644 index 0000000..2a64bd1 --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u5-a1-anlage/msgclient.c @@ -0,0 +1,68 @@ +/* + * Interprozesskommunikation über Message Queues - msgclient.c + * + * Funktionsweise: Der Client schickt eine Losung an einen Server. Falls die + * Losung die vom Server erwartete war, gibt letzterer dem Client sein + * Geheimnis preis. + */ + +#include +#include +#include +#include +#include + +#define MSGSIZE 100 +key_t key = 1337; +int msgflg = 0666; + +// Typdefinition für Message Queue (muss explizit geschehen, da noch nicht +// vorhanden) +struct message { + long msgType; + char msgText[MSGSIZE]; +}; + +// char CODEWORD[] = ""; +char CODEWORD[] = "Losung"; + +int main() { + struct message msg_snd; + struct message msg_rcv; + + // Verbinden mit Message-Queue des Servers + printf("Client: Verbinde mich mit Message Queue.\n"); + int id_q = msgget(key, msgflg); + + if (id_q >= 0) { + printf(" OK.\n\n"); + } + + // Absenden des Codeworts + printf("Client: Sende Codewort an den Server.\n"); + msg_snd.msgType = 5; + strcpy(msg_snd.msgText, CODEWORD); + + int result_snd = msgsnd(id_q, &msg_snd, MSGSIZE, 0); + + if (result_snd >= 0) { + printf(" OK.\n\n"); + } + + // Empfangen der Antwort + printf("Client: Warte auf Geheimnis.\n"); + + // Abholen des Geheimnisses aus der Message-Queue + int result_rcv = msgrcv(id_q, &msg_rcv, MSGSIZE, 6, 0); + + if (result_rcv >= 0) { + printf(" Geheimnis erhalten.\n\n"); + } + + // Ausgabe des Geheimnisses + printf("Client: Das Geheimnis lautet: '%s'.\n\n", msg_rcv.msgText); + + printf("Client: Ende.\n"); + + return 0; +} diff --git a/Assets/Betriebssysteme_uebung/u5-a1-anlage/msgserver.c b/Assets/Betriebssysteme_uebung/u5-a1-anlage/msgserver.c new file mode 100644 index 0000000..a7a1543 --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u5-a1-anlage/msgserver.c @@ -0,0 +1,76 @@ +/* + * Interprozesskommunikation über Message Queues - msgcserver.c + * + * Funktionsweise: Der Server erzeugt eine Message Queue und erwartet über diese + * die Losung eines Client. Falls die Losung mit der vom Server erwarteten + * übereinstimmt, teilt der Server dem Client sein Geheimnis mit. + */ + +#include +#include +#include +#include +#include +#include + +#define MSGSIZE 100 + +#define SECRET "GGG ..." +key_t key = 1337; +int msgflg = IPC_CREAT | 0666; // Vergibt lese und schreibrechte an alle Nutzer, user group others +struct message { + long msgType; + char msgText[MSGSIZE]; +}; + +int main() { + struct message msg_rcv; + struct message msg_snd; + + // Erzeugen einer Message Queue + printf("Server: Erzeuge Message Queue.\n"); + int id_q = msgget(key, msgflg); + + if (id_q >= 0) { + printf(" OK.\n\n"); + } + + // Losung empfangen + printf("Server: Warte auf Losung.\n"); + int result_rcv = msgrcv(id_q, &msg_rcv, MSGSIZE, 5, 0); // hier war + + if (result_rcv >= 0) { + printf(" Losung empfangen.\n\n"); + } + + // Vergleich + if (strncmp(msg_rcv.msgText, "Losung", strlen("Losung")) == 0) { + printf("Server: Losung ist korrekt. Sende jetzt das Geheimnis.\n"); + + // Senden des Geheimnisses + msg_snd.msgType = 5; + strcpy(msg_snd.msgText, SECRET); + + int result_snd = msgsnd(id_q, &msg_snd, MSGSIZE, 0); + + if (result_snd >= 0) { + printf(" OK.\n\n"); + } + } + else { + printf("Server: Das war falsch.\n"); + } + + sleep(1); + + int result_ctl = msgctl(id_q, IPC_RMID, 0); + + if (result_ctl >= 0) { + printf("Server: Message Queue gelöscht. Ende.\n\n"); + return 0; // alles OK + } + else { + printf("Server: Message Queue löschen fehlgeschlagen. Ende.\n\n"); + return 10; // Fehler + } +} diff --git a/Assets/Betriebssysteme_uebung/u5-a2-anlage/Makefile b/Assets/Betriebssysteme_uebung/u5-a2-anlage/Makefile new file mode 100644 index 0000000..87cb6d0 --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u5-a2-anlage/Makefile @@ -0,0 +1,10 @@ +all: client server + +client: + gcc -o shmclient shmclient.c + +server: + gcc -o shmserver shmserver.c + +clean: + rm -f shmclient shmserver diff --git a/Assets/Betriebssysteme_uebung/u5-a2-anlage/shmclient.c b/Assets/Betriebssysteme_uebung/u5-a2-anlage/shmclient.c new file mode 100644 index 0000000..26203c9 --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u5-a2-anlage/shmclient.c @@ -0,0 +1,76 @@ +/* + * Interprozesskommunikation über Shared Memory - shmclient.c + * + * Funktionsweise: Das Programm kommuniziert mit einem Server mittels Shared + * Memory und fragt mit einem Passwortsatz nach einem Geheimnis. Der Server + * hinterlegt die Antwort ebenfalls im Shared-Memory-Bereich. Dabei müssen beide + * Kommunikationspartner jeweils mit Semaphoren den Ablauf ihrer Kommunikation + * steuern. + */ + +#include +#include +#include +#include +#include + +#define SHMSIZE 256 +#define CODEWORD "Losung" + +// statisch vereinbarte Schlüssel +const int shmKey = 1337; // Schlüssel zum Benutzen des Shared Memory +const int readSemaphoreKey = 100; // Schlüssel zum Benutzen der Semaphore +const int writeSemaphoreKey = 101; // Schlüssel zum Benutzen der Semaphore + +const int textLen = 128; + +int main(int arc, char** argv) { + // dynamisch vergebene ID's + // Benutzung der Semaphore und des Shared Memory vorbereiten + int shmID = shmget(shmKey, 2 * textLen, 0); + int readSemID = semget(readSemaphoreKey, 1, 0666); + int writeSemID = semget(writeSemaphoreKey, 1, 0666); + + // Anhängen des Shared-Memory-Segments + printf("Client: Hänge Shared-Memory-Segment an.\n\n"); + + char *shm_ptr; + shm_ptr = shmat(shmID, 0, 0); + + char *shm_ptr_alt; + shm_ptr_alt = shm_ptr; + + // Absenden der Losung + printf("Client: Sende meine Losung.\n\n"); + + for (int i = 0; i <= strlen(CODEWORD); i++) { + *shm_ptr++ = CODEWORD[i]; + } + + *shm_ptr = '\0'; + + // Signal an den Server, dass die Daten jetzt lesbar sind + struct sembuf semaphoreOperation; + semaphoreOperation.sem_num = 0; + semaphoreOperation.sem_op = 1; + semaphoreOperation.sem_flg = SEM_UNDO; + semop(writeSemID, &semaphoreOperation, 1); + + // Warten auf die Antwort (das Signal vom Server) + semaphoreOperation.sem_num = 0; + semaphoreOperation.sem_op = -1; + semaphoreOperation.sem_flg = SEM_UNDO; + semop(readSemID, &semaphoreOperation, 1); + + // Abolen des Geheimnisses und direkte Ausgabe + char *sbuf; + sbuf = shmat(shmID,0,0); + printf("Client: Das Geheimnis lautet: '%s'.\n\n", sbuf); + + printf("Client: Ende.\n\n"); + + // Ausblenden des Shared Memory + shmdt(&shmID); + + return 0; +} diff --git a/Assets/Betriebssysteme_uebung/u5-a2-anlage/shmserver.c b/Assets/Betriebssysteme_uebung/u5-a2-anlage/shmserver.c new file mode 100644 index 0000000..0d781b7 --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u5-a2-anlage/shmserver.c @@ -0,0 +1,90 @@ +/* + * Interprozesskommunikation über Shared Memory - shmserver.c + * + * Funktionsweise: Das Programm kommuniziert mit einem Server mittels Shared + * Memory und fragt mit einem Passwortsatz nach einem Geheimnis. Der Server + * hinterlegt die Antwort ebenfalls im Shared-Memory-Bereich. Dabei müssen beide + * Kommunikationspartner jeweils mit Semaphoren den Ablauf ihrer Kommunikation + * steuern. + */ + +#include +#include +#include +#include +#include +#include + +// SHM +#define SHMKEY 1337 +#define SHMSIZE 256 + +// SEM +#define RSEMKEY 100 +#define SSEMKEY 101 + +#define SECRET "xxx..." +#define Losung "Losung" + +struct sembuf sb[1]; +int rsem_id, ssem_id; +char *sbuf; + + + +int main() { + // Erzeugen eines Shared-Memory-Segments + printf("Server: Erzeuge Shared-Memory-Segment.\n"); + int id_shm = shmget(SHMKEY, SHMSIZE, IPC_CREAT|0666); + + if (id_shm >= 0) { + printf(" OK.\n\n"); + } + + // Anhängen des Shared-Memory-Segments + printf("Server: Hänge Shared-Memory-Segment an.\n"); + sbuf = shmat(id_shm, 0, 0); + + if (sbuf >= 0) { + printf(" OK.\n\n"); + } + + // Erzeugen Semaphore + ssem_id = semget(SSEMKEY, 1, IPC_CREAT|0666); + rsem_id = semget(RSEMKEY, 1, IPC_CREAT|0666); + + semctl(ssem_id, 0, SETVAL, 0); + semctl(rsem_id, 0, SETVAL, 0); + + printf("Server: Warte auf Semaphor.\n\n"); + sb[0].sem_num = 0; + sb[0].sem_op = -1; + sb[0].sem_flg = SEM_UNDO; + semop(ssem_id, sb, 1); + + // Warten bis der Client geschrieben hat + // Synchronisation + printf("Server: Die Losung des Client lautet: '%s'.\n", sbuf); + + if (strncmp(sbuf, Losung, sizeof(Losung)) == 0 ) { + printf(" Das war richtig.\n\n"); + printf("Server: Schreibe das Geheimnis in den Shared Memory.\n\n"); + snprintf(sbuf, SHMSIZE, "%s", SECRET); + } + else { + printf(" Das war falsch.\n"); + snprintf(sbuf, 128, "Pech gehabt."); + } + + printf("Server: Signalisiere, dass Client nun lesen kann.\n\n"); + sb[0].sem_num = 0; + sb[0].sem_op = 1; + sb[0].sem_flg = SEM_UNDO; + semop(rsem_id, sb, 1); + + printf("Server: Ende.\n\n"); + + shmdt(&id_shm); + + return 0; +} diff --git a/Assets/Betriebssysteme_uebung/u5-a3-anlage/Makefile b/Assets/Betriebssysteme_uebung/u5-a3-anlage/Makefile new file mode 100644 index 0000000..bd78596 --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u5-a3-anlage/Makefile @@ -0,0 +1,10 @@ +all: client server + +client: + gcc -o pipeclient pipeclient.c + +server: + gcc -o pipeserver pipeserver.c + +clean: + rm -f pipeclient pipeserver diff --git a/Assets/Betriebssysteme_uebung/u5-a3-anlage/pipeclient.c b/Assets/Betriebssysteme_uebung/u5-a3-anlage/pipeclient.c new file mode 100644 index 0000000..ae98531 --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u5-a3-anlage/pipeclient.c @@ -0,0 +1,65 @@ +/* + * Interprozesskommunikation über Named Pipes (FIFOs) - pipeclient.c + * + * Funktionsweise: Dieses Client-Programm meldet sich über ein benanntes Pipe + * bei einem geeigneten Server und fragt mit einer Losung (Passwortsatz) nach + * einem Geheimnis. Der Server kontrolliert die Losung. Ist diese korrekt, + * antwortet der Server mit dem Geheimnis über die gleiche Pipe, welches auf + * geeignete Weise vom Client gelesen werden kann. + */ + +#include +#include +#include +#include +#include +#include + +//char CODEWORD[] = ""; +char CODEWORD[] = ""; +char buffer[8]; + +int main() { + // Öffnen der Named Pipe nur zum Schreiben + printf("Client: Öffne Pipe nur zum Schreiben.\n"); + int id_p = open("P1", O_WRONLY); // const char *path, int oflag … / returnt einen Filedeskriptor + + if (id_p >= 0) { + printf(" OK.\n\n"); + } + + // Absenden des Codeworts an Server + printf("Client: Übergebe Codewort an den Server.\n"); + int result_write = write(id_p, CODEWORD, strlen(CODEWORD)); + + if (result_write > 0) { + printf(" OK.\n\n"); + } + + close(id_p); + + // Empfangen der Antwort + printf("Client: Empfange Geheimnis.\n\n"); + + // Öffnen der Pipe zum Lesen + printf("Client: Öffne Pipe nur zum Lesen.\n"); + id_p = open("P1", O_RDONLY); + + if (id_p >= 0) { + printf(" OK.\n"); + } + + // Lesen des Geheimnisses aus der Pipe + int result_read = read(id_p, buffer, sizeof(buffer)); + + if (result_read > 0) { + printf(" Geheimnis erhalten.\n\n"); + } + + // Ausgabe des Geheimnisses + printf("Client: Das Geheimnis lautet: '%s'.\n\n", buffer); + + printf("Client: Ende.\n"); + + return 0; +} diff --git a/Assets/Betriebssysteme_uebung/u5-a3-anlage/pipeserver.c b/Assets/Betriebssysteme_uebung/u5-a3-anlage/pipeserver.c new file mode 100644 index 0000000..22c6c74 --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u5-a3-anlage/pipeserver.c @@ -0,0 +1,83 @@ +/* + * Interprozesskommunikation über Named Pipes (FIFOs) - pipeserver.c + * + * Funktionsweise: Dieses Server-Programm erwartet von seinem Client über ein + * von ihm angelegtes benanntes Pipe eine Losung (Passwortsatz). Nach + * (erfolgreicher) Überpruefung verrät der Server ein Geheimnis. Anschließend + * löscht er das Pipe wieder. + */ + +#include +#include +#include +#include +#include + +#include +#include +#include + +char buffer[30]; + +#define SECRET "xxx ..." + +int main() { + // Erzeugen der Named Pipe + printf("Server: Erzeuge Named Pipe (FIFO).\n"); + int rw = mkfifo("P1", 0666); // erstellt PIPE bei const char *pathname hier P1, mit mode mode_t mode = 0_RDWR /erlaubt lesen und schreiben + + if (rw >= 0) { + printf(" OK.\n\n"); + } + + // Öffnen der Pipe zum Lesen + printf("Server: Öffne Pipe zum Lesen.\n"); + int id_p = open("P1", O_RDONLY); + + if (id_p >= 0) { + printf(" OK.\n\n"); + } + + // Losung empfangen + printf("Server: Warte auf Losung.\n"); + int result_read = read(id_p, buffer, sizeof(buffer)); + + if (result_read > 0) { + printf(" Losung empfangen.\n\n"); + printf("Received: %s\n", buffer); + } + + // Vergleich + if (strncmp(buffer, "", strlen("")) == 0) { // int strncmp(const char *str1, const char *str2, size_t n) + printf("Server: Losung ist korrekt. Übergebe jetzt das Geheimnis.\n\n"); + + // Öffnen der Pipe zum Schreiben + printf("Server: Öffne dazu Pipe nur zum Schreiben.\n"); + close(id_p); + + id_p = open("P1", O_WRONLY); + + if (id_p >= 0) { + printf(" OK.\n"); + } + + // Übergeben des Geheimnisses + int result_write = write(id_p, SECRET, strlen(SECRET)); + + if (result_write > 0) { + printf(" OK.\n\n"); + } + } + else { + printf("Server: Das war falsch.\n"); + } + + sleep(5); + + // Vernichte Pipe + unlink("P1"); + + printf("Server: Ende.\n"); + + return 0; +} diff --git a/Assets/Betriebssysteme_uebung/u5_a5.png b/Assets/Betriebssysteme_uebung/u5_a5.png new file mode 100644 index 0000000..25a6723 Binary files /dev/null and b/Assets/Betriebssysteme_uebung/u5_a5.png differ diff --git a/Assets/Betriebssysteme_uebung/u6-a1-anlage/Makefile b/Assets/Betriebssysteme_uebung/u6-a1-anlage/Makefile new file mode 100644 index 0000000..ba5524b --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u6-a1-anlage/Makefile @@ -0,0 +1,7 @@ +all: syscall + +syscall: syscall.c + $(CC) -o syscall syscall.c + +clean: + rm -f syscall syscall diff --git a/Assets/Betriebssysteme_uebung/u6-a1-anlage/run.sh b/Assets/Betriebssysteme_uebung/u6-a1-anlage/run.sh new file mode 100644 index 0000000..0f1f4c9 --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u6-a1-anlage/run.sh @@ -0,0 +1,2 @@ +#!/bin/sh +make --silent ; ./syscall ; echo "[returned $?]" diff --git a/Assets/Betriebssysteme_uebung/u6-a1-anlage/syscall b/Assets/Betriebssysteme_uebung/u6-a1-anlage/syscall new file mode 100644 index 0000000..a398737 Binary files /dev/null and b/Assets/Betriebssysteme_uebung/u6-a1-anlage/syscall differ diff --git a/Assets/Betriebssysteme_uebung/u6-a1-anlage/syscall.c b/Assets/Betriebssysteme_uebung/u6-a1-anlage/syscall.c new file mode 100644 index 0000000..e240b9c --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u6-a1-anlage/syscall.c @@ -0,0 +1,105 @@ +/* syscall.c + * + * Call OS functions without using libc. The example `my_print` could be done in + * different flavors: + * + * **my_print_64:** + * Using the SYSCALL instruction (successor to SYSENTER). Should work for both + * IA-64 and AMD64 CPUs, can be ported to `my_print_trap` (see there). + * Register usage: + * + * - RAX: pass syscall number, hold return value from syscall execution + * - RDI: syscall argument 1 + * - RSI: syscall argument 2 + * - RDX: syscall argument 3 + * + * **my_print_trap:** + * Using the trap interrupt to switch to kernel mode. Slower, but + * architecturally neutral. Register usage: + * + * - EAX: pass syscall number, hold return value from syscall execution + * - EBX: syscall argument 1 + * - ECX: syscall argument 2 + * - EDX: syscall argument 3 + */ + +#include /* compile with -m32 for 32-bit syscall numbers, + without for 64-bit syscall numbers. */ +/* simple inline assembler (asm) requires global symbols */ +#define __NR_exit 60 +// text buffer pointer +char *my_print_text; +// text buffer length, print return value +int my_print_len, my_print_ret; +// write() syscall number +int call_write; +int exitnum; + +int my_print_64(char *text) { + my_print_text = text; + + /* strlen(my_print_text) manually */ + for (my_print_len = 0; my_print_text[my_print_len]; ++my_print_len); + + /* system call signature: + * ssize_t write(int fd, const void *buf, size_t count); + * + * write() system call number is defined by __NR_write + */ + call_write = __NR_write; + /* stdout is file descriptor no. 1 */ + asm("mov call_write, %rax"); /* arg 0 (rax): syscall number */ + asm("mov $1, %rdi"); /* arg 1 (rdi): file descriptor */ + asm("mov my_print_text, %rsi"); /* arg 2 (rsi): buffer */ + asm("mov my_print_len, %rdx"); /* arg 3 (rdx): length */ + asm("syscall"); /* SYSCALL instruction */ + asm("mov %rax, my_print_ret"); /* save return code (rax) */ + + return my_print_ret; +} + +int my_print_trap(char *text) { + /* system call signature: see my_print_64 */ + + /* TODO */ + + return 7; +} + +/* simple inline assembler (asm) requires global symbols */ + +// exit return value +int my_exit_status; + +void my_exit_64(int status) { + my_exit_status = status; + + /* system call signature: + * void exit(int status); + * + * exit() system call number is defined by __NR_exit + */ + + /* TODO */ + // Syscall + //exitnum = __NR_exit; + //asm("mov $60, %rax"); // verwende den exitnum / 60 Syscall + //asm("mov my_exit_status, %rdi"); //status = myexitstatus oder 0 + //asm("syscall"); + //TRAP + asm("mov $1, %eax"); + asm("mov my_exit_status, %ebx"); + asm("int $0x80"); + + + +} + +int main(void) { + my_print_64("Hello World!\n"); + + my_exit_64(42); + + /* never come here, if my_exit_64 works */ + return 6; +} diff --git a/Assets/Betriebssysteme_uebung/u6-a2-anlage/Makefile b/Assets/Betriebssysteme_uebung/u6-a2-anlage/Makefile new file mode 100644 index 0000000..55f8e54 --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u6-a2-anlage/Makefile @@ -0,0 +1,13 @@ +CFLAGS = -g + +all: daemon + +clean: + rm -f helpers.o daemon.o daemon + +helpers.o: helpers.c helpers.h + +daemon.o: daemon.c helpers.h + +daemon: daemon.o helpers.o + $(CC) -o daemon daemon.o helpers.o diff --git a/Assets/Betriebssysteme_uebung/u6-a2-anlage/daemon.c b/Assets/Betriebssysteme_uebung/u6-a2-anlage/daemon.c new file mode 100644 index 0000000..13a6247 --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u6-a2-anlage/daemon.c @@ -0,0 +1,54 @@ +#include +#include + +#include "helpers.h" + +void got_signal(int s) { + /* + * For demonstration purposes only! + * + * In real-world applications avoid the execution of complex + * tasks in signal handlers, this cries for race conditions and + * exploits. + * + * https://web.archive.org/web/20070204064240/http://www.bindview.com:80/ + % Services/Razor/Papers/2001/signals.cfm + */ + + static int count = 2; + + fprintf(stderr, "Caught Ctrl-C, press %i more time%s to really" + " quit.\n", count, count == 1 ? "" : "s"); + + if (count-- > 1) { + /* Catch subsequent SIGINTs */ + signal(SIGINT, got_signal); + } + else { + /* Don't catch SIGINT anymore */ + signal(SIGINT, SIG_DFL); + } +} + +int main(void) { + /* + * Initialization... + */ + void load_cfg(int x) // Wrapper um die inkompatibilität durch die fehlerhafte methodendeklaration zu beheben + { + load_config(); + } + load_config(); + signal(SIGHUP, load_cfg); + signal(SIGINT, got_signal); + signal(SIGKILL, SIG_IGN); // Unaufhaltsam, da SIGKILL sich ja eben genau nicht um das Programm kümmern soll, sondern einfach immer töten soll + signal(SIGTERM, SIG_IGN); // Aufhaltbar + + /* + * Do some work. + */ + + main_loop(); + + return 0; +} diff --git a/Assets/Betriebssysteme_uebung/u6-a2-anlage/daemon.o b/Assets/Betriebssysteme_uebung/u6-a2-anlage/daemon.o new file mode 100644 index 0000000..9d6b6b0 Binary files /dev/null and b/Assets/Betriebssysteme_uebung/u6-a2-anlage/daemon.o differ diff --git a/Assets/Betriebssysteme_uebung/u6-a2-anlage/helpers.c b/Assets/Betriebssysteme_uebung/u6-a2-anlage/helpers.c new file mode 100644 index 0000000..7397e5c --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u6-a2-anlage/helpers.c @@ -0,0 +1,103 @@ +/* + * This is just some code behind the curtain. + * You really don't need to touch this. + * + */ + +#include +#include +#include +#include +#include + +#include "helpers.h" + +int do_quit = 0; +int do_reload = 0; + +int load_config(void) { + static char firsttime_message[] = "Loading"; + static char subsequent_message[] = "Reloading"; + static char *message = firsttime_message; + + fprintf(stderr, "%s configuration... ", message); + fprintf(stderr, "done.\n"); + + message = subsequent_message; + do_reload = 0; + + return 1; +} + +int main_loop(void) { + fd_set rfds; + struct timeval tv; + int retval; + char buf[1024]; + ssize_t len; + +#if 0 + /* fork() to the background */ + if(fork()) return 0; +#endif + + fprintf(stderr, "I'm just a simple daemon, my PID is: %i\n", + getpid()); + + while (!do_quit) { + /* + * Let's just do our really simple job: + * Copy stdin to stdout (just another cat(1)). + */ + + if (do_reload) { + load_config(); + } + + /* Watch stdin (fd 0) to see when it has input. */ + FD_ZERO(&rfds); + FD_SET(0, &rfds); + + /* Wait up to five seconds. */ + tv.tv_sec = 5; + tv.tv_usec = 0; + + retval = select(1, &rfds, NULL, NULL, &tv); + /* Don't rely on the value of tv now! */ + + if (retval == -1) { + if (errno == EINTR) { + continue; + } + + perror("select()"); + continue; + } + + if (retval == 0) { + /* fprintf(stderr, "Timeout reached.\n"); */ + continue; + } + + if (!FD_ISSET(0, &rfds)) { + fprintf(stderr, "BUG: Empty read-set, this should" + " never happen. Never ever. Really! :-)\n"); + continue; + } + + len = read(0, buf, sizeof(buf) - 1); + if (len < 0) { + perror("read()"); + continue; + } + + buf[len] = 0; + printf("%s", buf); + + if (len == 0) { + do_quit = 1; + } + } + + return 1; +} diff --git a/Assets/Betriebssysteme_uebung/u6-a2-anlage/helpers.h b/Assets/Betriebssysteme_uebung/u6-a2-anlage/helpers.h new file mode 100644 index 0000000..5348d9b --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u6-a2-anlage/helpers.h @@ -0,0 +1,7 @@ +#ifndef _HELPERS_H +#define _HELPERS_H + +int load_config(void); /* load/reload our daemon's configuration */ +int main_loop(void); /* our daemon's main task */ + +#endif /* _HELPERS_H */ diff --git a/Assets/Betriebssysteme_uebung/u6-a2-anlage/helpers.o b/Assets/Betriebssysteme_uebung/u6-a2-anlage/helpers.o new file mode 100644 index 0000000..98df0fc Binary files /dev/null and b/Assets/Betriebssysteme_uebung/u6-a2-anlage/helpers.o differ diff --git a/Assets/Betriebssysteme_uebung/u6-a3-anlage/malloc.c b/Assets/Betriebssysteme_uebung/u6-a3-anlage/malloc.c new file mode 100644 index 0000000..9868f41 --- /dev/null +++ b/Assets/Betriebssysteme_uebung/u6-a3-anlage/malloc.c @@ -0,0 +1,19 @@ +#include +#include + +int main(void) { + int *p; + + p = malloc(sizeof(int)); + if(p != NULL) { + *p=99; + printf("Allokation erfolgreich ... \n"); + } + else { + printf("Kein virtueller RAM mehr verfügbar ...\n"); + return EXIT_FAILURE; + } + free(p); + printf("Speicher nun erfolgreich freigegeben "); + return EXIT_SUCCESS; +} diff --git a/Assets/Betriebssysteme_uebung/u6_a2.png b/Assets/Betriebssysteme_uebung/u6_a2.png new file mode 100644 index 0000000..ed4583f Binary files /dev/null and b/Assets/Betriebssysteme_uebung/u6_a2.png differ diff --git a/Assets/Betriebssysteme_uebung/u6_a21.png b/Assets/Betriebssysteme_uebung/u6_a21.png new file mode 100644 index 0000000..e89cce1 Binary files /dev/null and b/Assets/Betriebssysteme_uebung/u6_a21.png differ diff --git a/Assets/Bildverarbeitung-1d-faltung.png b/Assets/Bildverarbeitung-1d-faltung.png new file mode 100644 index 0000000..98f5f87 Binary files /dev/null and b/Assets/Bildverarbeitung-1d-faltung.png differ diff --git a/Assets/Bildverarbeitung-2d-dirac-stoß.png b/Assets/Bildverarbeitung-2d-dirac-stoß.png new file mode 100644 index 0000000..218427c Binary files /dev/null and b/Assets/Bildverarbeitung-2d-dirac-stoß.png differ diff --git a/Assets/Bildverarbeitung-2d-dreiecksgitter.png b/Assets/Bildverarbeitung-2d-dreiecksgitter.png new file mode 100644 index 0000000..36750ae Binary files /dev/null and b/Assets/Bildverarbeitung-2d-dreiecksgitter.png differ diff --git a/Assets/Bildverarbeitung-2d-hexagongitter.png b/Assets/Bildverarbeitung-2d-hexagongitter.png new file mode 100644 index 0000000..29f4065 Binary files /dev/null and b/Assets/Bildverarbeitung-2d-hexagongitter.png differ diff --git a/Assets/Bildverarbeitung-2d-quadratgitter.png b/Assets/Bildverarbeitung-2d-quadratgitter.png new file mode 100644 index 0000000..35a6e2e Binary files /dev/null and b/Assets/Bildverarbeitung-2d-quadratgitter.png differ diff --git a/Assets/Bildverarbeitung-2d-rechteck-skaliert.png b/Assets/Bildverarbeitung-2d-rechteck-skaliert.png new file mode 100644 index 0000000..a91c5a6 Binary files /dev/null and b/Assets/Bildverarbeitung-2d-rechteck-skaliert.png differ diff --git a/Assets/Bildverarbeitung-2d-rechteck.png b/Assets/Bildverarbeitung-2d-rechteck.png new file mode 100644 index 0000000..33c773c Binary files /dev/null and b/Assets/Bildverarbeitung-2d-rechteck.png differ diff --git a/Assets/Bildverarbeitung-4er-nachbarschaft.png b/Assets/Bildverarbeitung-4er-nachbarschaft.png new file mode 100644 index 0000000..b555553 Binary files /dev/null and b/Assets/Bildverarbeitung-4er-nachbarschaft.png differ diff --git a/Assets/Bildverarbeitung-8er-nachbarschaft.png b/Assets/Bildverarbeitung-8er-nachbarschaft.png new file mode 100644 index 0000000..60ea1e2 Binary files /dev/null and b/Assets/Bildverarbeitung-8er-nachbarschaft.png differ diff --git a/Assets/Bildverarbeitung-bildrepräsentation-falschfarben.png b/Assets/Bildverarbeitung-bildrepräsentation-falschfarben.png new file mode 100644 index 0000000..af769b8 Binary files /dev/null and b/Assets/Bildverarbeitung-bildrepräsentation-falschfarben.png differ diff --git a/Assets/Bildverarbeitung-bildrepräsentation-grauwert.png b/Assets/Bildverarbeitung-bildrepräsentation-grauwert.png new file mode 100644 index 0000000..edf6780 Binary files /dev/null and b/Assets/Bildverarbeitung-bildrepräsentation-grauwert.png differ diff --git a/Assets/Bildverarbeitung-bildrepräsentation-pixel.png b/Assets/Bildverarbeitung-bildrepräsentation-pixel.png new file mode 100644 index 0000000..d9eb28d Binary files /dev/null and b/Assets/Bildverarbeitung-bildrepräsentation-pixel.png differ diff --git a/Assets/Bildverarbeitung-digitalisierung-grauwertquantisierung.png b/Assets/Bildverarbeitung-digitalisierung-grauwertquantisierung.png new file mode 100644 index 0000000..44d204c Binary files /dev/null and b/Assets/Bildverarbeitung-digitalisierung-grauwertquantisierung.png differ diff --git a/Assets/Bildverarbeitung-digitalisierung-ortsvariablen.png b/Assets/Bildverarbeitung-digitalisierung-ortsvariablen.png new file mode 100644 index 0000000..889b6d6 Binary files /dev/null and b/Assets/Bildverarbeitung-digitalisierung-ortsvariablen.png differ diff --git a/Assets/Bildverarbeitung-digitalisierung-quantisierungsstufen.png b/Assets/Bildverarbeitung-digitalisierung-quantisierungsstufen.png new file mode 100644 index 0000000..9eba47b Binary files /dev/null and b/Assets/Bildverarbeitung-digitalisierung-quantisierungsstufen.png differ diff --git a/Assets/Bildverarbeitung-dirac-abtasteigenschaft.png b/Assets/Bildverarbeitung-dirac-abtasteigenschaft.png new file mode 100644 index 0000000..971eedc Binary files /dev/null and b/Assets/Bildverarbeitung-dirac-abtasteigenschaft.png differ diff --git a/Assets/Bildverarbeitung-euklidische-distanz.png b/Assets/Bildverarbeitung-euklidische-distanz.png new file mode 100644 index 0000000..c591316 Binary files /dev/null and b/Assets/Bildverarbeitung-euklidische-distanz.png differ diff --git a/Assets/Bildverarbeitung-fokussierungsunschärfe.png b/Assets/Bildverarbeitung-fokussierungsunschärfe.png new file mode 100644 index 0000000..0b08d2d Binary files /dev/null and b/Assets/Bildverarbeitung-fokussierungsunschärfe.png differ diff --git a/Assets/Bildverarbeitung-fokussierungsunschärfe2.png b/Assets/Bildverarbeitung-fokussierungsunschärfe2.png new file mode 100644 index 0000000..7e08d55 Binary files /dev/null and b/Assets/Bildverarbeitung-fokussierungsunschärfe2.png differ diff --git a/Assets/Bildverarbeitung-grauwertfunktion.png b/Assets/Bildverarbeitung-grauwertfunktion.png new file mode 100644 index 0000000..a89e894 Binary files /dev/null and b/Assets/Bildverarbeitung-grauwertfunktion.png differ diff --git a/Assets/Bildverarbeitung-manhatten-distanz.png b/Assets/Bildverarbeitung-manhatten-distanz.png new file mode 100644 index 0000000..84857a9 Binary files /dev/null and b/Assets/Bildverarbeitung-manhatten-distanz.png differ diff --git a/Assets/Bildverarbeitung-nachbarschaft-definition-4.png b/Assets/Bildverarbeitung-nachbarschaft-definition-4.png new file mode 100644 index 0000000..4fa3ba2 Binary files /dev/null and b/Assets/Bildverarbeitung-nachbarschaft-definition-4.png differ diff --git a/Assets/Bildverarbeitung-nachbarschaft-definition-8.png b/Assets/Bildverarbeitung-nachbarschaft-definition-8.png new file mode 100644 index 0000000..e44eeeb Binary files /dev/null and b/Assets/Bildverarbeitung-nachbarschaft-definition-8.png differ diff --git a/Assets/Bildverarbeitung-psf-bewegung.png b/Assets/Bildverarbeitung-psf-bewegung.png new file mode 100644 index 0000000..c5519b3 Binary files /dev/null and b/Assets/Bildverarbeitung-psf-bewegung.png differ diff --git a/Assets/Bildverarbeitung-rand-4-nachbarschaft.png b/Assets/Bildverarbeitung-rand-4-nachbarschaft.png new file mode 100644 index 0000000..6ed5570 Binary files /dev/null and b/Assets/Bildverarbeitung-rand-4-nachbarschaft.png differ diff --git a/Assets/Bildverarbeitung-rand-8-nachbarschaft.png b/Assets/Bildverarbeitung-rand-8-nachbarschaft.png new file mode 100644 index 0000000..a30acd4 Binary files /dev/null and b/Assets/Bildverarbeitung-rand-8-nachbarschaft.png differ diff --git a/Assets/Bildverarbeitung-schachbrett-distanz.png b/Assets/Bildverarbeitung-schachbrett-distanz.png new file mode 100644 index 0000000..b00a5c6 Binary files /dev/null and b/Assets/Bildverarbeitung-schachbrett-distanz.png differ diff --git a/Assets/Bildverarbeitung-verschobener-dirac-stoß.png b/Assets/Bildverarbeitung-verschobener-dirac-stoß.png new file mode 100644 index 0000000..f05073a Binary files /dev/null and b/Assets/Bildverarbeitung-verschobener-dirac-stoß.png differ diff --git a/Assets/Biosignalverarbeitung-AD289.png b/Assets/Biosignalverarbeitung-AD289.png new file mode 100644 index 0000000..8e822c3 Binary files /dev/null and b/Assets/Biosignalverarbeitung-AD289.png differ diff --git a/Assets/Biosignalverarbeitung-Dehnungsmessrosette.png b/Assets/Biosignalverarbeitung-Dehnungsmessrosette.png new file mode 100644 index 0000000..856402f Binary files /dev/null and b/Assets/Biosignalverarbeitung-Dehnungsmessrosette.png differ diff --git a/Assets/Biosignalverarbeitung-Delta-Sigma-Wandler.png b/Assets/Biosignalverarbeitung-Delta-Sigma-Wandler.png new file mode 100644 index 0000000..d825afb Binary files /dev/null and b/Assets/Biosignalverarbeitung-Delta-Sigma-Wandler.png differ diff --git a/Assets/Biosignalverarbeitung-Delta-Sigma-Wandlung-2.png b/Assets/Biosignalverarbeitung-Delta-Sigma-Wandlung-2.png new file mode 100644 index 0000000..351daf4 Binary files /dev/null and b/Assets/Biosignalverarbeitung-Delta-Sigma-Wandlung-2.png differ diff --git a/Assets/Biosignalverarbeitung-Delta-Sigma-Wandlung-3.png b/Assets/Biosignalverarbeitung-Delta-Sigma-Wandlung-3.png new file mode 100644 index 0000000..86a5c67 Binary files /dev/null and b/Assets/Biosignalverarbeitung-Delta-Sigma-Wandlung-3.png differ diff --git a/Assets/Biosignalverarbeitung-Delta-Sigma-Wandlung-4.png b/Assets/Biosignalverarbeitung-Delta-Sigma-Wandlung-4.png new file mode 100644 index 0000000..1bb8112 Binary files /dev/null and b/Assets/Biosignalverarbeitung-Delta-Sigma-Wandlung-4.png differ diff --git a/Assets/Biosignalverarbeitung-Delta-Sigma-Wandlung.png b/Assets/Biosignalverarbeitung-Delta-Sigma-Wandlung.png new file mode 100644 index 0000000..0eb601a Binary files /dev/null and b/Assets/Biosignalverarbeitung-Delta-Sigma-Wandlung.png differ diff --git a/Assets/Biosignalverarbeitung-Diff-und-Gleichtakt.png b/Assets/Biosignalverarbeitung-Diff-und-Gleichtakt.png new file mode 100644 index 0000000..c2f80e9 Binary files /dev/null and b/Assets/Biosignalverarbeitung-Diff-und-Gleichtakt.png differ diff --git a/Assets/Biosignalverarbeitung-Diff-und-Gleichtakt2.png b/Assets/Biosignalverarbeitung-Diff-und-Gleichtakt2.png new file mode 100644 index 0000000..8db7f84 Binary files /dev/null and b/Assets/Biosignalverarbeitung-Diff-und-Gleichtakt2.png differ diff --git a/Assets/Biosignalverarbeitung-Differenzverstärker-asymmetrisch.png b/Assets/Biosignalverarbeitung-Differenzverstärker-asymmetrisch.png new file mode 100644 index 0000000..6db23d7 Binary files /dev/null and b/Assets/Biosignalverarbeitung-Differenzverstärker-asymmetrisch.png differ diff --git a/Assets/Biosignalverarbeitung-Differenzverstärker-funktion.png b/Assets/Biosignalverarbeitung-Differenzverstärker-funktion.png new file mode 100644 index 0000000..7d9951c Binary files /dev/null and b/Assets/Biosignalverarbeitung-Differenzverstärker-funktion.png differ diff --git a/Assets/Biosignalverarbeitung-EKG-kontinuierlich-spektrum.png b/Assets/Biosignalverarbeitung-EKG-kontinuierlich-spektrum.png new file mode 100644 index 0000000..502db2a Binary files /dev/null and b/Assets/Biosignalverarbeitung-EKG-kontinuierlich-spektrum.png differ diff --git a/Assets/Biosignalverarbeitung-EKG-tasten-falten.png b/Assets/Biosignalverarbeitung-EKG-tasten-falten.png new file mode 100644 index 0000000..5102cd3 Binary files /dev/null and b/Assets/Biosignalverarbeitung-EKG-tasten-falten.png differ diff --git a/Assets/Biosignalverarbeitung-Einrampenverfahren.png b/Assets/Biosignalverarbeitung-Einrampenverfahren.png new file mode 100644 index 0000000..b0c351b Binary files /dev/null and b/Assets/Biosignalverarbeitung-Einrampenverfahren.png differ diff --git a/Assets/Biosignalverarbeitung-Filtertheorie.png b/Assets/Biosignalverarbeitung-Filtertheorie.png new file mode 100644 index 0000000..6023f55 Binary files /dev/null and b/Assets/Biosignalverarbeitung-Filtertheorie.png differ diff --git a/Assets/Biosignalverarbeitung-Filtertheorie2.png b/Assets/Biosignalverarbeitung-Filtertheorie2.png new file mode 100644 index 0000000..eeb50de Binary files /dev/null and b/Assets/Biosignalverarbeitung-Filtertheorie2.png differ diff --git a/Assets/Biosignalverarbeitung-Galvanische-trennung.png b/Assets/Biosignalverarbeitung-Galvanische-trennung.png new file mode 100644 index 0000000..3be2b10 Binary files /dev/null and b/Assets/Biosignalverarbeitung-Galvanische-trennung.png differ diff --git a/Assets/Biosignalverarbeitung-Gradiometer.png b/Assets/Biosignalverarbeitung-Gradiometer.png new file mode 100644 index 0000000..212a8d0 Binary files /dev/null and b/Assets/Biosignalverarbeitung-Gradiometer.png differ diff --git a/Assets/Biosignalverarbeitung-Isolationsverstäker.png b/Assets/Biosignalverarbeitung-Isolationsverstäker.png new file mode 100644 index 0000000..dd81dc1 Binary files /dev/null and b/Assets/Biosignalverarbeitung-Isolationsverstäker.png differ diff --git a/Assets/Biosignalverarbeitung-Linearität-arbeitsbereich.png b/Assets/Biosignalverarbeitung-Linearität-arbeitsbereich.png new file mode 100644 index 0000000..c98fdb9 Binary files /dev/null and b/Assets/Biosignalverarbeitung-Linearität-arbeitsbereich.png differ diff --git a/Assets/Biosignalverarbeitung-Mehrkanalsysteme.png b/Assets/Biosignalverarbeitung-Mehrkanalsysteme.png new file mode 100644 index 0000000..b9c19a2 Binary files /dev/null and b/Assets/Biosignalverarbeitung-Mehrkanalsysteme.png differ diff --git a/Assets/Biosignalverarbeitung-Mehrkanalsysteme2.png b/Assets/Biosignalverarbeitung-Mehrkanalsysteme2.png new file mode 100644 index 0000000..ded70c6 Binary files /dev/null and b/Assets/Biosignalverarbeitung-Mehrkanalsysteme2.png differ diff --git a/Assets/Biosignalverarbeitung-Mehrkanalsysteme3.png b/Assets/Biosignalverarbeitung-Mehrkanalsysteme3.png new file mode 100644 index 0000000..b0e1b0c Binary files /dev/null and b/Assets/Biosignalverarbeitung-Mehrkanalsysteme3.png differ diff --git a/Assets/Biosignalverarbeitung-Mehrkanalsysteme4.png b/Assets/Biosignalverarbeitung-Mehrkanalsysteme4.png new file mode 100644 index 0000000..bab1f43 Binary files /dev/null and b/Assets/Biosignalverarbeitung-Mehrkanalsysteme4.png differ diff --git a/Assets/Biosignalverarbeitung-Parallelwandler.png b/Assets/Biosignalverarbeitung-Parallelwandler.png new file mode 100644 index 0000000..db07beb Binary files /dev/null and b/Assets/Biosignalverarbeitung-Parallelwandler.png differ diff --git a/Assets/Biosignalverarbeitung-Pulsamplitudenmodulation.png b/Assets/Biosignalverarbeitung-Pulsamplitudenmodulation.png new file mode 100644 index 0000000..a699018 Binary files /dev/null and b/Assets/Biosignalverarbeitung-Pulsamplitudenmodulation.png differ diff --git a/Assets/Biosignalverarbeitung-Sukzessive-Approximation.png b/Assets/Biosignalverarbeitung-Sukzessive-Approximation.png new file mode 100644 index 0000000..3f3265a Binary files /dev/null and b/Assets/Biosignalverarbeitung-Sukzessive-Approximation.png differ diff --git a/Assets/Biosignalverarbeitung-Zweirampenverfahren.png b/Assets/Biosignalverarbeitung-Zweirampenverfahren.png new file mode 100644 index 0000000..b0123bc Binary files /dev/null and b/Assets/Biosignalverarbeitung-Zweirampenverfahren.png differ diff --git a/Assets/Biosignalverarbeitung-abtastung-kotelnikov.png b/Assets/Biosignalverarbeitung-abtastung-kotelnikov.png new file mode 100644 index 0000000..4fa89bf Binary files /dev/null and b/Assets/Biosignalverarbeitung-abtastung-kotelnikov.png differ diff --git a/Assets/Biosignalverarbeitung-abtastung-rekonstruktion.png b/Assets/Biosignalverarbeitung-abtastung-rekonstruktion.png new file mode 100644 index 0000000..c75adcf Binary files /dev/null and b/Assets/Biosignalverarbeitung-abtastung-rekonstruktion.png differ diff --git a/Assets/Biosignalverarbeitung-ad-tigersharcs.png b/Assets/Biosignalverarbeitung-ad-tigersharcs.png new file mode 100644 index 0000000..aeff112 Binary files /dev/null and b/Assets/Biosignalverarbeitung-ad-tigersharcs.png differ diff --git a/Assets/Biosignalverarbeitung-adaptiv-fir.png b/Assets/Biosignalverarbeitung-adaptiv-fir.png new file mode 100644 index 0000000..4d832cc Binary files /dev/null and b/Assets/Biosignalverarbeitung-adaptiv-fir.png differ diff --git a/Assets/Biosignalverarbeitung-adaptive-filter-match-filter.png b/Assets/Biosignalverarbeitung-adaptive-filter-match-filter.png new file mode 100644 index 0000000..88ed6f2 Binary files /dev/null and b/Assets/Biosignalverarbeitung-adaptive-filter-match-filter.png differ diff --git a/Assets/Biosignalverarbeitung-adaptiver-filter-adaption-anc.png b/Assets/Biosignalverarbeitung-adaptiver-filter-adaption-anc.png new file mode 100644 index 0000000..0b1410b Binary files /dev/null and b/Assets/Biosignalverarbeitung-adaptiver-filter-adaption-anc.png differ diff --git a/Assets/Biosignalverarbeitung-adaptiver-filter-aufbau.png b/Assets/Biosignalverarbeitung-adaptiver-filter-aufbau.png new file mode 100644 index 0000000..5a2aea0 Binary files /dev/null and b/Assets/Biosignalverarbeitung-adaptiver-filter-aufbau.png differ diff --git a/Assets/Biosignalverarbeitung-adaptiver-filter-ekg+netz.png b/Assets/Biosignalverarbeitung-adaptiver-filter-ekg+netz.png new file mode 100644 index 0000000..7f85283 Binary files /dev/null and b/Assets/Biosignalverarbeitung-adaptiver-filter-ekg+netz.png differ diff --git a/Assets/Biosignalverarbeitung-adaptiver-filter-ekg-abdominal.png b/Assets/Biosignalverarbeitung-adaptiver-filter-ekg-abdominal.png new file mode 100644 index 0000000..5465c70 Binary files /dev/null and b/Assets/Biosignalverarbeitung-adaptiver-filter-ekg-abdominal.png differ diff --git a/Assets/Biosignalverarbeitung-adaptiver-filter-ekg-mtchfit.png b/Assets/Biosignalverarbeitung-adaptiver-filter-ekg-mtchfit.png new file mode 100644 index 0000000..f21b80b Binary files /dev/null and b/Assets/Biosignalverarbeitung-adaptiver-filter-ekg-mtchfit.png differ diff --git a/Assets/Biosignalverarbeitung-adaptiver-filter-ekg-roh-weiß.png b/Assets/Biosignalverarbeitung-adaptiver-filter-ekg-roh-weiß.png new file mode 100644 index 0000000..2826dd6 Binary files /dev/null and b/Assets/Biosignalverarbeitung-adaptiver-filter-ekg-roh-weiß.png differ diff --git a/Assets/Biosignalverarbeitung-adaptiver-filter-noise-canceller.png b/Assets/Biosignalverarbeitung-adaptiver-filter-noise-canceller.png new file mode 100644 index 0000000..a7b6421 Binary files /dev/null and b/Assets/Biosignalverarbeitung-adaptiver-filter-noise-canceller.png differ diff --git a/Assets/Biosignalverarbeitung-adaptiver-filter-qrs.png b/Assets/Biosignalverarbeitung-adaptiver-filter-qrs.png new file mode 100644 index 0000000..1e9c22a Binary files /dev/null and b/Assets/Biosignalverarbeitung-adaptiver-filter-qrs.png differ diff --git a/Assets/Biosignalverarbeitung-adaptiver-filter-reale-aufnahme.png b/Assets/Biosignalverarbeitung-adaptiver-filter-reale-aufnahme.png new file mode 100644 index 0000000..2c3b202 Binary files /dev/null and b/Assets/Biosignalverarbeitung-adaptiver-filter-reale-aufnahme.png differ diff --git a/Assets/Biosignalverarbeitung-adaptiver-filter-stochastik.png b/Assets/Biosignalverarbeitung-adaptiver-filter-stochastik.png new file mode 100644 index 0000000..4655d13 Binary files /dev/null and b/Assets/Biosignalverarbeitung-adaptiver-filter-stochastik.png differ diff --git a/Assets/Biosignalverarbeitung-adaptiver-filter-zeitverlauf-anc.png b/Assets/Biosignalverarbeitung-adaptiver-filter-zeitverlauf-anc.png new file mode 100644 index 0000000..228990c Binary files /dev/null and b/Assets/Biosignalverarbeitung-adaptiver-filter-zeitverlauf-anc.png differ diff --git a/Assets/Biosignalverarbeitung-aktive-elektroden.png b/Assets/Biosignalverarbeitung-aktive-elektroden.png new file mode 100644 index 0000000..9bf71df Binary files /dev/null and b/Assets/Biosignalverarbeitung-aktive-elektroden.png differ diff --git a/Assets/Biosignalverarbeitung-aktive-filter-3.png b/Assets/Biosignalverarbeitung-aktive-filter-3.png new file mode 100644 index 0000000..a02aad2 Binary files /dev/null and b/Assets/Biosignalverarbeitung-aktive-filter-3.png differ diff --git a/Assets/Biosignalverarbeitung-aktive-filter-4.png b/Assets/Biosignalverarbeitung-aktive-filter-4.png new file mode 100644 index 0000000..61e1de0 Binary files /dev/null and b/Assets/Biosignalverarbeitung-aktive-filter-4.png differ diff --git a/Assets/Biosignalverarbeitung-aktive-filter.png b/Assets/Biosignalverarbeitung-aktive-filter.png new file mode 100644 index 0000000..194087d Binary files /dev/null and b/Assets/Biosignalverarbeitung-aktive-filter.png differ diff --git a/Assets/Biosignalverarbeitung-aktive-filter2.png b/Assets/Biosignalverarbeitung-aktive-filter2.png new file mode 100644 index 0000000..235a4e2 Binary files /dev/null and b/Assets/Biosignalverarbeitung-aktive-filter2.png differ diff --git a/Assets/Biosignalverarbeitung-amplitudenmodulation.png b/Assets/Biosignalverarbeitung-amplitudenmodulation.png new file mode 100644 index 0000000..0cb6874 Binary files /dev/null and b/Assets/Biosignalverarbeitung-amplitudenmodulation.png differ diff --git a/Assets/Biosignalverarbeitung-analoge-übertragung-2.png b/Assets/Biosignalverarbeitung-analoge-übertragung-2.png new file mode 100644 index 0000000..871dd4c Binary files /dev/null and b/Assets/Biosignalverarbeitung-analoge-übertragung-2.png differ diff --git a/Assets/Biosignalverarbeitung-analoge-übertragung-3.png b/Assets/Biosignalverarbeitung-analoge-übertragung-3.png new file mode 100644 index 0000000..4b47ecc Binary files /dev/null and b/Assets/Biosignalverarbeitung-analoge-übertragung-3.png differ diff --git a/Assets/Biosignalverarbeitung-analoge-übertragung-4.png b/Assets/Biosignalverarbeitung-analoge-übertragung-4.png new file mode 100644 index 0000000..875cbce Binary files /dev/null and b/Assets/Biosignalverarbeitung-analoge-übertragung-4.png differ diff --git a/Assets/Biosignalverarbeitung-analoge-übertragung.png b/Assets/Biosignalverarbeitung-analoge-übertragung.png new file mode 100644 index 0000000..e275b29 Binary files /dev/null and b/Assets/Biosignalverarbeitung-analoge-übertragung.png differ diff --git a/Assets/Biosignalverarbeitung-beispiel-film.png b/Assets/Biosignalverarbeitung-beispiel-film.png new file mode 100644 index 0000000..420553d Binary files /dev/null and b/Assets/Biosignalverarbeitung-beispiel-film.png differ diff --git a/Assets/Biosignalverarbeitung-breitbandige-Wandler.png b/Assets/Biosignalverarbeitung-breitbandige-Wandler.png new file mode 100644 index 0000000..dfda2ac Binary files /dev/null and b/Assets/Biosignalverarbeitung-breitbandige-Wandler.png differ diff --git a/Assets/Biosignalverarbeitung-cad-digitaler-filter.png b/Assets/Biosignalverarbeitung-cad-digitaler-filter.png new file mode 100644 index 0000000..a3446fb Binary files /dev/null and b/Assets/Biosignalverarbeitung-cad-digitaler-filter.png differ diff --git a/Assets/Biosignalverarbeitung-digitale-übertragung-1.png b/Assets/Biosignalverarbeitung-digitale-übertragung-1.png new file mode 100644 index 0000000..c989c08 Binary files /dev/null and b/Assets/Biosignalverarbeitung-digitale-übertragung-1.png differ diff --git a/Assets/Biosignalverarbeitung-digitale-übertragung-2.png b/Assets/Biosignalverarbeitung-digitale-übertragung-2.png new file mode 100644 index 0000000..a3a9a4c Binary files /dev/null and b/Assets/Biosignalverarbeitung-digitale-übertragung-2.png differ diff --git a/Assets/Biosignalverarbeitung-diskreter-integrator-mit-ov.png b/Assets/Biosignalverarbeitung-diskreter-integrator-mit-ov.png new file mode 100644 index 0000000..b93f914 Binary files /dev/null and b/Assets/Biosignalverarbeitung-diskreter-integrator-mit-ov.png differ diff --git a/Assets/Biosignalverarbeitung-eigenrauschen.png b/Assets/Biosignalverarbeitung-eigenrauschen.png new file mode 100644 index 0000000..4f1dbe3 Binary files /dev/null and b/Assets/Biosignalverarbeitung-eigenrauschen.png differ diff --git a/Assets/Biosignalverarbeitung-ekg-ableitung.jpg b/Assets/Biosignalverarbeitung-ekg-ableitung.jpg new file mode 100644 index 0000000..3391998 Binary files /dev/null and b/Assets/Biosignalverarbeitung-ekg-ableitung.jpg differ diff --git a/Assets/Biosignalverarbeitung-ekg-verlauf.jpg b/Assets/Biosignalverarbeitung-ekg-verlauf.jpg new file mode 100644 index 0000000..d5d3601 Binary files /dev/null and b/Assets/Biosignalverarbeitung-ekg-verlauf.jpg differ diff --git a/Assets/Biosignalverarbeitung-ekg-verzerrt.png b/Assets/Biosignalverarbeitung-ekg-verzerrt.png new file mode 100644 index 0000000..7376f10 Binary files /dev/null and b/Assets/Biosignalverarbeitung-ekg-verzerrt.png differ diff --git a/Assets/Biosignalverarbeitung-ekg-verzerrt2.png b/Assets/Biosignalverarbeitung-ekg-verzerrt2.png new file mode 100644 index 0000000..b397523 Binary files /dev/null and b/Assets/Biosignalverarbeitung-ekg-verzerrt2.png differ diff --git a/Assets/Biosignalverarbeitung-ekg.png b/Assets/Biosignalverarbeitung-ekg.png new file mode 100644 index 0000000..4edda10 Binary files /dev/null and b/Assets/Biosignalverarbeitung-ekg.png differ diff --git a/Assets/Biosignalverarbeitung-elektrochemische-grundlage.png b/Assets/Biosignalverarbeitung-elektrochemische-grundlage.png new file mode 100644 index 0000000..2997990 Binary files /dev/null and b/Assets/Biosignalverarbeitung-elektrochemische-grundlage.png differ diff --git a/Assets/Biosignalverarbeitung-elektrode-therapie.png b/Assets/Biosignalverarbeitung-elektrode-therapie.png new file mode 100644 index 0000000..2ac5112 Binary files /dev/null and b/Assets/Biosignalverarbeitung-elektrode-therapie.png differ diff --git a/Assets/Biosignalverarbeitung-elektroden.png b/Assets/Biosignalverarbeitung-elektroden.png new file mode 100644 index 0000000..6eff575 Binary files /dev/null and b/Assets/Biosignalverarbeitung-elektroden.png differ diff --git a/Assets/Biosignalverarbeitung-filterentwurf.png b/Assets/Biosignalverarbeitung-filterentwurf.png new file mode 100644 index 0000000..205c0f0 Binary files /dev/null and b/Assets/Biosignalverarbeitung-filterentwurf.png differ diff --git a/Assets/Biosignalverarbeitung-filterentwurf2.png b/Assets/Biosignalverarbeitung-filterentwurf2.png new file mode 100644 index 0000000..17f8de9 Binary files /dev/null and b/Assets/Biosignalverarbeitung-filterentwurf2.png differ diff --git a/Assets/Biosignalverarbeitung-fir-nichtrekursiv.png b/Assets/Biosignalverarbeitung-fir-nichtrekursiv.png new file mode 100644 index 0000000..8f6a51b Binary files /dev/null and b/Assets/Biosignalverarbeitung-fir-nichtrekursiv.png differ diff --git a/Assets/Biosignalverarbeitung-fir-realisierung-2.png b/Assets/Biosignalverarbeitung-fir-realisierung-2.png new file mode 100644 index 0000000..ef51e56 Binary files /dev/null and b/Assets/Biosignalverarbeitung-fir-realisierung-2.png differ diff --git a/Assets/Biosignalverarbeitung-fir-realisierung-3.png b/Assets/Biosignalverarbeitung-fir-realisierung-3.png new file mode 100644 index 0000000..eab1c50 Binary files /dev/null and b/Assets/Biosignalverarbeitung-fir-realisierung-3.png differ diff --git a/Assets/Biosignalverarbeitung-fir-realisierung-4.png b/Assets/Biosignalverarbeitung-fir-realisierung-4.png new file mode 100644 index 0000000..0c60535 Binary files /dev/null and b/Assets/Biosignalverarbeitung-fir-realisierung-4.png differ diff --git a/Assets/Biosignalverarbeitung-fir-realisierung-5.png b/Assets/Biosignalverarbeitung-fir-realisierung-5.png new file mode 100644 index 0000000..2dbdcfe Binary files /dev/null and b/Assets/Biosignalverarbeitung-fir-realisierung-5.png differ diff --git a/Assets/Biosignalverarbeitung-fir-realisierung-6.png b/Assets/Biosignalverarbeitung-fir-realisierung-6.png new file mode 100644 index 0000000..cb55fc1 Binary files /dev/null and b/Assets/Biosignalverarbeitung-fir-realisierung-6.png differ diff --git a/Assets/Biosignalverarbeitung-fir-realisierung.png b/Assets/Biosignalverarbeitung-fir-realisierung.png new file mode 100644 index 0000000..a900a85 Binary files /dev/null and b/Assets/Biosignalverarbeitung-fir-realisierung.png differ diff --git a/Assets/Biosignalverarbeitung-fir-tiefpass-2.png b/Assets/Biosignalverarbeitung-fir-tiefpass-2.png new file mode 100644 index 0000000..ec52cdb Binary files /dev/null and b/Assets/Biosignalverarbeitung-fir-tiefpass-2.png differ diff --git a/Assets/Biosignalverarbeitung-fir-tiefpass-3.png b/Assets/Biosignalverarbeitung-fir-tiefpass-3.png new file mode 100644 index 0000000..bf559de Binary files /dev/null and b/Assets/Biosignalverarbeitung-fir-tiefpass-3.png differ diff --git a/Assets/Biosignalverarbeitung-fir-tiefpass-4.png b/Assets/Biosignalverarbeitung-fir-tiefpass-4.png new file mode 100644 index 0000000..99159dd Binary files /dev/null and b/Assets/Biosignalverarbeitung-fir-tiefpass-4.png differ diff --git a/Assets/Biosignalverarbeitung-fir-tiefpass.png b/Assets/Biosignalverarbeitung-fir-tiefpass.png new file mode 100644 index 0000000..17f7570 Binary files /dev/null and b/Assets/Biosignalverarbeitung-fir-tiefpass.png differ diff --git a/Assets/Biosignalverarbeitung-folien-dms.png b/Assets/Biosignalverarbeitung-folien-dms.png new file mode 100644 index 0000000..f3fbcb4 Binary files /dev/null and b/Assets/Biosignalverarbeitung-folien-dms.png differ diff --git a/Assets/Biosignalverarbeitung-gehirn-eeg.png b/Assets/Biosignalverarbeitung-gehirn-eeg.png new file mode 100644 index 0000000..65740bf Binary files /dev/null and b/Assets/Biosignalverarbeitung-gehirn-eeg.png differ diff --git a/Assets/Biosignalverarbeitung-gehirn-ekg.png b/Assets/Biosignalverarbeitung-gehirn-ekg.png new file mode 100644 index 0000000..d22d788 Binary files /dev/null and b/Assets/Biosignalverarbeitung-gehirn-ekg.png differ diff --git a/Assets/Biosignalverarbeitung-gehirn.png b/Assets/Biosignalverarbeitung-gehirn.png new file mode 100644 index 0000000..a778337 Binary files /dev/null and b/Assets/Biosignalverarbeitung-gehirn.png differ diff --git a/Assets/Biosignalverarbeitung-gibbs-effekt.png b/Assets/Biosignalverarbeitung-gibbs-effekt.png new file mode 100644 index 0000000..65109ae Binary files /dev/null and b/Assets/Biosignalverarbeitung-gibbs-effekt.png differ diff --git a/Assets/Biosignalverarbeitung-gradiometer-2.png b/Assets/Biosignalverarbeitung-gradiometer-2.png new file mode 100644 index 0000000..364e01d Binary files /dev/null and b/Assets/Biosignalverarbeitung-gradiometer-2.png differ diff --git a/Assets/Biosignalverarbeitung-guarding-real.png b/Assets/Biosignalverarbeitung-guarding-real.png new file mode 100644 index 0000000..5efc0fd Binary files /dev/null and b/Assets/Biosignalverarbeitung-guarding-real.png differ diff --git a/Assets/Biosignalverarbeitung-guarding.png b/Assets/Biosignalverarbeitung-guarding.png new file mode 100644 index 0000000..1c957d5 Binary files /dev/null and b/Assets/Biosignalverarbeitung-guarding.png differ diff --git a/Assets/Biosignalverarbeitung-guarding2.png b/Assets/Biosignalverarbeitung-guarding2.png new file mode 100644 index 0000000..846b7b3 Binary files /dev/null and b/Assets/Biosignalverarbeitung-guarding2.png differ diff --git a/Assets/Biosignalverarbeitung-harvard.png b/Assets/Biosignalverarbeitung-harvard.png new file mode 100644 index 0000000..f7a34fd Binary files /dev/null and b/Assets/Biosignalverarbeitung-harvard.png differ diff --git a/Assets/Biosignalverarbeitung-herz-ekg.png b/Assets/Biosignalverarbeitung-herz-ekg.png new file mode 100644 index 0000000..080fddf Binary files /dev/null and b/Assets/Biosignalverarbeitung-herz-ekg.png differ diff --git a/Assets/Biosignalverarbeitung-hochpass-2.ordnung.png b/Assets/Biosignalverarbeitung-hochpass-2.ordnung.png new file mode 100644 index 0000000..c46f1b8 Binary files /dev/null and b/Assets/Biosignalverarbeitung-hochpass-2.ordnung.png differ diff --git a/Assets/Biosignalverarbeitung-hohe-gleichtaktunterdrückung.png b/Assets/Biosignalverarbeitung-hohe-gleichtaktunterdrückung.png new file mode 100644 index 0000000..9d4aa04 Binary files /dev/null and b/Assets/Biosignalverarbeitung-hohe-gleichtaktunterdrückung.png differ diff --git a/Assets/Biosignalverarbeitung-hoher-eingangswiderstand.png b/Assets/Biosignalverarbeitung-hoher-eingangswiderstand.png new file mode 100644 index 0000000..6f0ab76 Binary files /dev/null and b/Assets/Biosignalverarbeitung-hoher-eingangswiderstand.png differ diff --git a/Assets/Biosignalverarbeitung-iir-1.png b/Assets/Biosignalverarbeitung-iir-1.png new file mode 100644 index 0000000..0f06234 Binary files /dev/null and b/Assets/Biosignalverarbeitung-iir-1.png differ diff --git a/Assets/Biosignalverarbeitung-iir-2.png b/Assets/Biosignalverarbeitung-iir-2.png new file mode 100644 index 0000000..db91364 Binary files /dev/null and b/Assets/Biosignalverarbeitung-iir-2.png differ diff --git a/Assets/Biosignalverarbeitung-iir-3.png b/Assets/Biosignalverarbeitung-iir-3.png new file mode 100644 index 0000000..3f99ea1 Binary files /dev/null and b/Assets/Biosignalverarbeitung-iir-3.png differ diff --git a/Assets/Biosignalverarbeitung-iir-rekursiv-2.png b/Assets/Biosignalverarbeitung-iir-rekursiv-2.png new file mode 100644 index 0000000..0eaef5d Binary files /dev/null and b/Assets/Biosignalverarbeitung-iir-rekursiv-2.png differ diff --git a/Assets/Biosignalverarbeitung-iir-rekursiv.png b/Assets/Biosignalverarbeitung-iir-rekursiv.png new file mode 100644 index 0000000..54aff11 Binary files /dev/null and b/Assets/Biosignalverarbeitung-iir-rekursiv.png differ diff --git a/Assets/Biosignalverarbeitung-integrierter-integrator-mit-sc.png b/Assets/Biosignalverarbeitung-integrierter-integrator-mit-sc.png new file mode 100644 index 0000000..4843fd7 Binary files /dev/null and b/Assets/Biosignalverarbeitung-integrierter-integrator-mit-sc.png differ diff --git a/Assets/Biosignalverarbeitung-kontinuierliches-signal.png b/Assets/Biosignalverarbeitung-kontinuierliches-signal.png new file mode 100644 index 0000000..85abc41 Binary files /dev/null and b/Assets/Biosignalverarbeitung-kontinuierliches-signal.png differ diff --git a/Assets/Biosignalverarbeitung-linearer-phasenfrequenzgang.png b/Assets/Biosignalverarbeitung-linearer-phasenfrequenzgang.png new file mode 100644 index 0000000..0c8833c Binary files /dev/null and b/Assets/Biosignalverarbeitung-linearer-phasenfrequenzgang.png differ diff --git a/Assets/Biosignalverarbeitung-masse-messung.png b/Assets/Biosignalverarbeitung-masse-messung.png new file mode 100644 index 0000000..307fffa Binary files /dev/null and b/Assets/Biosignalverarbeitung-masse-messung.png differ diff --git a/Assets/Biosignalverarbeitung-massebezogen-brückenspannung.png b/Assets/Biosignalverarbeitung-massebezogen-brückenspannung.png new file mode 100644 index 0000000..1513c22 Binary files /dev/null and b/Assets/Biosignalverarbeitung-massebezogen-brückenspannung.png differ diff --git a/Assets/Biosignalverarbeitung-maxim7418.png b/Assets/Biosignalverarbeitung-maxim7418.png new file mode 100644 index 0000000..11c0300 Binary files /dev/null and b/Assets/Biosignalverarbeitung-maxim7418.png differ diff --git a/Assets/Biosignalverarbeitung-mehrstufiger-verstärker.png b/Assets/Biosignalverarbeitung-mehrstufiger-verstärker.png new file mode 100644 index 0000000..ddbb6fe Binary files /dev/null and b/Assets/Biosignalverarbeitung-mehrstufiger-verstärker.png differ diff --git a/Assets/Biosignalverarbeitung-messspannung-massebezogen.png b/Assets/Biosignalverarbeitung-messspannung-massebezogen.png new file mode 100644 index 0000000..c3d99ce Binary files /dev/null and b/Assets/Biosignalverarbeitung-messspannung-massebezogen.png differ diff --git a/Assets/Biosignalverarbeitung-netzfrequenz-bandsperre.png b/Assets/Biosignalverarbeitung-netzfrequenz-bandsperre.png new file mode 100644 index 0000000..b2eefb1 Binary files /dev/null and b/Assets/Biosignalverarbeitung-netzfrequenz-bandsperre.png differ diff --git a/Assets/Biosignalverarbeitung-netzunterdrückung.png b/Assets/Biosignalverarbeitung-netzunterdrückung.png new file mode 100644 index 0000000..248ffb3 Binary files /dev/null and b/Assets/Biosignalverarbeitung-netzunterdrückung.png differ diff --git a/Assets/Biosignalverarbeitung-pegelanpassung.png b/Assets/Biosignalverarbeitung-pegelanpassung.png new file mode 100644 index 0000000..cdcc58b Binary files /dev/null and b/Assets/Biosignalverarbeitung-pegelanpassung.png differ diff --git a/Assets/Biosignalverarbeitung-pneumotachograph.png b/Assets/Biosignalverarbeitung-pneumotachograph.png new file mode 100644 index 0000000..b12cc1d Binary files /dev/null and b/Assets/Biosignalverarbeitung-pneumotachograph.png differ diff --git a/Assets/Biosignalverarbeitung-pulsoxy-1.png b/Assets/Biosignalverarbeitung-pulsoxy-1.png new file mode 100644 index 0000000..b8e5049 Binary files /dev/null and b/Assets/Biosignalverarbeitung-pulsoxy-1.png differ diff --git a/Assets/Biosignalverarbeitung-pulsoxy-2.png b/Assets/Biosignalverarbeitung-pulsoxy-2.png new file mode 100644 index 0000000..b6837e0 Binary files /dev/null and b/Assets/Biosignalverarbeitung-pulsoxy-2.png differ diff --git a/Assets/Biosignalverarbeitung-pulsoxy-3.png b/Assets/Biosignalverarbeitung-pulsoxy-3.png new file mode 100644 index 0000000..4eac212 Binary files /dev/null and b/Assets/Biosignalverarbeitung-pulsoxy-3.png differ diff --git a/Assets/Biosignalverarbeitung-pulsoxy-4.png b/Assets/Biosignalverarbeitung-pulsoxy-4.png new file mode 100644 index 0000000..9203516 Binary files /dev/null and b/Assets/Biosignalverarbeitung-pulsoxy-4.png differ diff --git a/Assets/Biosignalverarbeitung-pulsoxy-5.png b/Assets/Biosignalverarbeitung-pulsoxy-5.png new file mode 100644 index 0000000..3bdd80a Binary files /dev/null and b/Assets/Biosignalverarbeitung-pulsoxy-5.png differ diff --git a/Assets/Biosignalverarbeitung-pulsoxy-6.png b/Assets/Biosignalverarbeitung-pulsoxy-6.png new file mode 100644 index 0000000..61879ad Binary files /dev/null and b/Assets/Biosignalverarbeitung-pulsoxy-6.png differ diff --git a/Assets/Biosignalverarbeitung-pulsoxy-7.png b/Assets/Biosignalverarbeitung-pulsoxy-7.png new file mode 100644 index 0000000..367f5de Binary files /dev/null and b/Assets/Biosignalverarbeitung-pulsoxy-7.png differ diff --git a/Assets/Biosignalverarbeitung-pulsoxy-8.png b/Assets/Biosignalverarbeitung-pulsoxy-8.png new file mode 100644 index 0000000..b677c1b Binary files /dev/null and b/Assets/Biosignalverarbeitung-pulsoxy-8.png differ diff --git a/Assets/Biosignalverarbeitung-rekonstruierter-sinus.png b/Assets/Biosignalverarbeitung-rekonstruierter-sinus.png new file mode 100644 index 0000000..976a175 Binary files /dev/null and b/Assets/Biosignalverarbeitung-rekonstruierter-sinus.png differ diff --git a/Assets/Biosignalverarbeitung-squid.png b/Assets/Biosignalverarbeitung-squid.png new file mode 100644 index 0000000..85a2fcc Binary files /dev/null and b/Assets/Biosignalverarbeitung-squid.png differ diff --git a/Assets/Biosignalverarbeitung-super-harvard.png b/Assets/Biosignalverarbeitung-super-harvard.png new file mode 100644 index 0000000..dc11158 Binary files /dev/null and b/Assets/Biosignalverarbeitung-super-harvard.png differ diff --git a/Assets/Biosignalverarbeitung-tiefpass-2.ordnung.png b/Assets/Biosignalverarbeitung-tiefpass-2.ordnung.png new file mode 100644 index 0000000..82e72f6 Binary files /dev/null and b/Assets/Biosignalverarbeitung-tiefpass-2.ordnung.png differ diff --git a/Assets/Biosignalverarbeitung-tiger-super-harvard.png b/Assets/Biosignalverarbeitung-tiger-super-harvard.png new file mode 100644 index 0000000..2b731ed Binary files /dev/null and b/Assets/Biosignalverarbeitung-tiger-super-harvard.png differ diff --git a/Assets/Biosignalverarbeitung-trendelimination.png b/Assets/Biosignalverarbeitung-trendelimination.png new file mode 100644 index 0000000..d8c8b8d Binary files /dev/null and b/Assets/Biosignalverarbeitung-trendelimination.png differ diff --git a/Assets/Biosignalverarbeitung-ultraschall-doppler-2.png b/Assets/Biosignalverarbeitung-ultraschall-doppler-2.png new file mode 100644 index 0000000..c0c6eb7 Binary files /dev/null and b/Assets/Biosignalverarbeitung-ultraschall-doppler-2.png differ diff --git a/Assets/Biosignalverarbeitung-ultraschall-doppler.png b/Assets/Biosignalverarbeitung-ultraschall-doppler.png new file mode 100644 index 0000000..570aff7 Binary files /dev/null and b/Assets/Biosignalverarbeitung-ultraschall-doppler.png differ diff --git a/Assets/Biosignalverarbeitung-ultraschall-geschwindigkeit.png b/Assets/Biosignalverarbeitung-ultraschall-geschwindigkeit.png new file mode 100644 index 0000000..95c1010 Binary files /dev/null and b/Assets/Biosignalverarbeitung-ultraschall-geschwindigkeit.png differ diff --git a/Assets/Biosignalverarbeitung-von-neumann.png b/Assets/Biosignalverarbeitung-von-neumann.png new file mode 100644 index 0000000..64e950f Binary files /dev/null and b/Assets/Biosignalverarbeitung-von-neumann.png differ diff --git a/Assets/Biosignalverarbeitung-wheatstone-brücke.png b/Assets/Biosignalverarbeitung-wheatstone-brücke.png new file mode 100644 index 0000000..2a4ac84 Binary files /dev/null and b/Assets/Biosignalverarbeitung-wheatstone-brücke.png differ diff --git a/Assets/Biosignalverarbeitung-zeitdiskretes-signal.png b/Assets/Biosignalverarbeitung-zeitdiskretes-signal.png new file mode 100644 index 0000000..3b37474 Binary files /dev/null and b/Assets/Biosignalverarbeitung-zeitdiskretes-signal.png differ diff --git a/Assets/Computergrafik-Renderpipeline-primitive.png b/Assets/Computergrafik-Renderpipeline-primitive.png new file mode 100644 index 0000000..3dc757f Binary files /dev/null and b/Assets/Computergrafik-Renderpipeline-primitive.png differ diff --git a/Assets/Computergrafik_Affines-Texturmapping.png b/Assets/Computergrafik_Affines-Texturmapping.png new file mode 100644 index 0000000..2498237 Binary files /dev/null and b/Assets/Computergrafik_Affines-Texturmapping.png differ diff --git a/Assets/Computergrafik_Antialiasing.png b/Assets/Computergrafik_Antialiasing.png new file mode 100644 index 0000000..ead6a18 Binary files /dev/null and b/Assets/Computergrafik_Antialiasing.png differ diff --git a/Assets/Computergrafik_Antialiasing_Nyquist.png b/Assets/Computergrafik_Antialiasing_Nyquist.png new file mode 100644 index 0000000..970e2cf Binary files /dev/null and b/Assets/Computergrafik_Antialiasing_Nyquist.png differ diff --git a/Assets/Computergrafik_Basisvektor_Linearkombination.png b/Assets/Computergrafik_Basisvektor_Linearkombination.png new file mode 100644 index 0000000..1f0f198 Binary files /dev/null and b/Assets/Computergrafik_Basisvektor_Linearkombination.png differ diff --git a/Assets/Computergrafik_Bildraster_skalieren.png b/Assets/Computergrafik_Bildraster_skalieren.png new file mode 100644 index 0000000..9151ef8 Binary files /dev/null and b/Assets/Computergrafik_Bildraster_skalieren.png differ diff --git a/Assets/Computergrafik_Bintrees.png b/Assets/Computergrafik_Bintrees.png new file mode 100644 index 0000000..b562ddd Binary files /dev/null and b/Assets/Computergrafik_Bintrees.png differ diff --git a/Assets/Computergrafik_Box-filter1.png b/Assets/Computergrafik_Box-filter1.png new file mode 100644 index 0000000..249afa3 Binary files /dev/null and b/Assets/Computergrafik_Box-filter1.png differ diff --git a/Assets/Computergrafik_Box-filter2.png b/Assets/Computergrafik_Box-filter2.png new file mode 100644 index 0000000..9516d49 Binary files /dev/null and b/Assets/Computergrafik_Box-filter2.png differ diff --git a/Assets/Computergrafik_Brechungseffekt.png b/Assets/Computergrafik_Brechungseffekt.png new file mode 100644 index 0000000..87846b0 Binary files /dev/null and b/Assets/Computergrafik_Brechungseffekt.png differ diff --git a/Assets/Computergrafik_Bumpmap.png b/Assets/Computergrafik_Bumpmap.png new file mode 100644 index 0000000..edaf106 Binary files /dev/null and b/Assets/Computergrafik_Bumpmap.png differ diff --git a/Assets/Computergrafik_CIE.png b/Assets/Computergrafik_CIE.png new file mode 100644 index 0000000..f6aeca1 Binary files /dev/null and b/Assets/Computergrafik_CIE.png differ diff --git a/Assets/Computergrafik_DCT.png b/Assets/Computergrafik_DCT.png new file mode 100644 index 0000000..1a8f703 Binary files /dev/null and b/Assets/Computergrafik_DCT.png differ diff --git a/Assets/Computergrafik_Depth-Sort-Algorithmus.png b/Assets/Computergrafik_Depth-Sort-Algorithmus.png new file mode 100644 index 0000000..5f97cf4 Binary files /dev/null and b/Assets/Computergrafik_Depth-Sort-Algorithmus.png differ diff --git a/Assets/Computergrafik_Diffuse_Reflexion.png b/Assets/Computergrafik_Diffuse_Reflexion.png new file mode 100644 index 0000000..50b7312 Binary files /dev/null and b/Assets/Computergrafik_Diffuse_Reflexion.png differ diff --git a/Assets/Computergrafik_Diffuse_Reflexion_2.png b/Assets/Computergrafik_Diffuse_Reflexion_2.png new file mode 100644 index 0000000..f996e4e Binary files /dev/null and b/Assets/Computergrafik_Diffuse_Reflexion_2.png differ diff --git a/Assets/Computergrafik_Diffuse_Reflexion_3.png b/Assets/Computergrafik_Diffuse_Reflexion_3.png new file mode 100644 index 0000000..afac617 Binary files /dev/null and b/Assets/Computergrafik_Diffuse_Reflexion_3.png differ diff --git a/Assets/Computergrafik_Environment-Map-Kugel.png b/Assets/Computergrafik_Environment-Map-Kugel.png new file mode 100644 index 0000000..196400b Binary files /dev/null and b/Assets/Computergrafik_Environment-Map-Kugel.png differ diff --git a/Assets/Computergrafik_Farbsättigung.png b/Assets/Computergrafik_Farbsättigung.png new file mode 100644 index 0000000..9f444ee Binary files /dev/null and b/Assets/Computergrafik_Farbsättigung.png differ diff --git a/Assets/Computergrafik_Farbton.png b/Assets/Computergrafik_Farbton.png new file mode 100644 index 0000000..6b84919 Binary files /dev/null and b/Assets/Computergrafik_Farbton.png differ diff --git a/Assets/Computergrafik_Flat-vs-Gouraud-Shading.png b/Assets/Computergrafik_Flat-vs-Gouraud-Shading.png new file mode 100644 index 0000000..64a6385 Binary files /dev/null and b/Assets/Computergrafik_Flat-vs-Gouraud-Shading.png differ diff --git a/Assets/Computergrafik_Fourier_Hochpass.png b/Assets/Computergrafik_Fourier_Hochpass.png new file mode 100644 index 0000000..a789c10 Binary files /dev/null and b/Assets/Computergrafik_Fourier_Hochpass.png differ diff --git a/Assets/Computergrafik_Fourier_Tiefpass.png b/Assets/Computergrafik_Fourier_Tiefpass.png new file mode 100644 index 0000000..5b56d0b Binary files /dev/null and b/Assets/Computergrafik_Fourier_Tiefpass.png differ diff --git a/Assets/Computergrafik_Frequenzraum_Signal.png b/Assets/Computergrafik_Frequenzraum_Signal.png new file mode 100644 index 0000000..e6f0504 Binary files /dev/null and b/Assets/Computergrafik_Frequenzraum_Signal.png differ diff --git a/Assets/Computergrafik_Frequenzraum_Transformation.png b/Assets/Computergrafik_Frequenzraum_Transformation.png new file mode 100644 index 0000000..23eaad4 Binary files /dev/null and b/Assets/Computergrafik_Frequenzraum_Transformation.png differ diff --git a/Assets/Computergrafik_Frequenzraum_diskretes_Bild.png b/Assets/Computergrafik_Frequenzraum_diskretes_Bild.png new file mode 100644 index 0000000..106e1e0 Binary files /dev/null and b/Assets/Computergrafik_Frequenzraum_diskretes_Bild.png differ diff --git a/Assets/Computergrafik_GPU-Performance.png b/Assets/Computergrafik_GPU-Performance.png new file mode 100644 index 0000000..c4ff71e Binary files /dev/null and b/Assets/Computergrafik_GPU-Performance.png differ diff --git a/Assets/Computergrafik_GPU_Hardware.png b/Assets/Computergrafik_GPU_Hardware.png new file mode 100644 index 0000000..9fe2de9 Binary files /dev/null and b/Assets/Computergrafik_GPU_Hardware.png differ diff --git a/Assets/Computergrafik_Gauss-filter1.png b/Assets/Computergrafik_Gauss-filter1.png new file mode 100644 index 0000000..5aad44a Binary files /dev/null and b/Assets/Computergrafik_Gauss-filter1.png differ diff --git a/Assets/Computergrafik_Gauss-filter2.png b/Assets/Computergrafik_Gauss-filter2.png new file mode 100644 index 0000000..4ce4999 Binary files /dev/null and b/Assets/Computergrafik_Gauss-filter2.png differ diff --git a/Assets/Computergrafik_Gourad-Shading.png b/Assets/Computergrafik_Gourad-Shading.png new file mode 100644 index 0000000..b2ba41b Binary files /dev/null and b/Assets/Computergrafik_Gourad-Shading.png differ diff --git a/Assets/Computergrafik_Gourad_Glanzlichter.png b/Assets/Computergrafik_Gourad_Glanzlichter.png new file mode 100644 index 0000000..c72a87c Binary files /dev/null and b/Assets/Computergrafik_Gourad_Glanzlichter.png differ diff --git a/Assets/Computergrafik_Grafik-Pipeline.png b/Assets/Computergrafik_Grafik-Pipeline.png new file mode 100644 index 0000000..db99b86 Binary files /dev/null and b/Assets/Computergrafik_Grafik-Pipeline.png differ diff --git a/Assets/Computergrafik_Helligkeitsstufen.png b/Assets/Computergrafik_Helligkeitsstufen.png new file mode 100644 index 0000000..76f39f3 Binary files /dev/null and b/Assets/Computergrafik_Helligkeitsstufen.png differ diff --git a/Assets/Computergrafik_KD-tree.png b/Assets/Computergrafik_KD-tree.png new file mode 100644 index 0000000..0752e84 Binary files /dev/null and b/Assets/Computergrafik_KD-tree.png differ diff --git a/Assets/Computergrafik_Kegel-filter1.png b/Assets/Computergrafik_Kegel-filter1.png new file mode 100644 index 0000000..7dbd119 Binary files /dev/null and b/Assets/Computergrafik_Kegel-filter1.png differ diff --git a/Assets/Computergrafik_Kegel-filter2.png b/Assets/Computergrafik_Kegel-filter2.png new file mode 100644 index 0000000..dfb7245 Binary files /dev/null and b/Assets/Computergrafik_Kegel-filter2.png differ diff --git a/Assets/Computergrafik_Mapping-Anti-Alising.png b/Assets/Computergrafik_Mapping-Anti-Alising.png new file mode 100644 index 0000000..70b0da3 Binary files /dev/null and b/Assets/Computergrafik_Mapping-Anti-Alising.png differ diff --git a/Assets/Computergrafik_Midpoint.png b/Assets/Computergrafik_Midpoint.png new file mode 100644 index 0000000..72d3dac Binary files /dev/null and b/Assets/Computergrafik_Midpoint.png differ diff --git a/Assets/Computergrafik_Mitchell-Netravali-Filter1.png b/Assets/Computergrafik_Mitchell-Netravali-Filter1.png new file mode 100644 index 0000000..aae50eb Binary files /dev/null and b/Assets/Computergrafik_Mitchell-Netravali-Filter1.png differ diff --git a/Assets/Computergrafik_Mitchell-Netravali-Filter2.png b/Assets/Computergrafik_Mitchell-Netravali-Filter2.png new file mode 100644 index 0000000..0a11242 Binary files /dev/null and b/Assets/Computergrafik_Mitchell-Netravali-Filter2.png differ diff --git a/Assets/Computergrafik_Perskeptivisches-Texture-Mapping.png b/Assets/Computergrafik_Perskeptivisches-Texture-Mapping.png new file mode 100644 index 0000000..92d3725 Binary files /dev/null and b/Assets/Computergrafik_Perskeptivisches-Texture-Mapping.png differ diff --git a/Assets/Computergrafik_Phong_Modell.png b/Assets/Computergrafik_Phong_Modell.png new file mode 100644 index 0000000..f0d6f86 Binary files /dev/null and b/Assets/Computergrafik_Phong_Modell.png differ diff --git a/Assets/Computergrafik_Photonmapping.png b/Assets/Computergrafik_Photonmapping.png new file mode 100644 index 0000000..0b8c75f Binary files /dev/null and b/Assets/Computergrafik_Photonmapping.png differ diff --git a/Assets/Computergrafik_Quadtree.png b/Assets/Computergrafik_Quadtree.png new file mode 100644 index 0000000..d7487bf Binary files /dev/null and b/Assets/Computergrafik_Quadtree.png differ diff --git a/Assets/Computergrafik_RGB-Farbraum.png b/Assets/Computergrafik_RGB-Farbraum.png new file mode 100644 index 0000000..6c7aefd Binary files /dev/null and b/Assets/Computergrafik_RGB-Farbraum.png differ diff --git a/Assets/Computergrafik_Radiosity.png b/Assets/Computergrafik_Radiosity.png new file mode 100644 index 0000000..b974e8e Binary files /dev/null and b/Assets/Computergrafik_Radiosity.png differ diff --git a/Assets/Computergrafik_Rendering_Equation.png b/Assets/Computergrafik_Rendering_Equation.png new file mode 100644 index 0000000..1b19ae7 Binary files /dev/null and b/Assets/Computergrafik_Rendering_Equation.png differ diff --git a/Assets/Computergrafik_RotatedGrids.png b/Assets/Computergrafik_RotatedGrids.png new file mode 100644 index 0000000..87cb9d6 Binary files /dev/null and b/Assets/Computergrafik_RotatedGrids.png differ diff --git a/Assets/Computergrafik_Rückwärtstransformation_Interpolation.png b/Assets/Computergrafik_Rückwärtstransformation_Interpolation.png new file mode 100644 index 0000000..4f8690a Binary files /dev/null and b/Assets/Computergrafik_Rückwärtstransformation_Interpolation.png differ diff --git a/Assets/Computergrafik_Rückwärtstransformation_Pixelkoordinaten.png b/Assets/Computergrafik_Rückwärtstransformation_Pixelkoordinaten.png new file mode 100644 index 0000000..83b4c6c Binary files /dev/null and b/Assets/Computergrafik_Rückwärtstransformation_Pixelkoordinaten.png differ diff --git a/Assets/Computergrafik_ShadowMap.png b/Assets/Computergrafik_ShadowMap.png new file mode 100644 index 0000000..5dc8d3b Binary files /dev/null and b/Assets/Computergrafik_ShadowMap.png differ diff --git a/Assets/Computergrafik_Sinc-filter1.png b/Assets/Computergrafik_Sinc-filter1.png new file mode 100644 index 0000000..dc90d02 Binary files /dev/null and b/Assets/Computergrafik_Sinc-filter1.png differ diff --git a/Assets/Computergrafik_Sinc-filter2.png b/Assets/Computergrafik_Sinc-filter2.png new file mode 100644 index 0000000..01021d9 Binary files /dev/null and b/Assets/Computergrafik_Sinc-filter2.png differ diff --git a/Assets/Computergrafik_Spekuläre_Reflexion.png b/Assets/Computergrafik_Spekuläre_Reflexion.png new file mode 100644 index 0000000..631351f Binary files /dev/null and b/Assets/Computergrafik_Spekuläre_Reflexion.png differ diff --git a/Assets/Computergrafik_Supersampling.png b/Assets/Computergrafik_Supersampling.png new file mode 100644 index 0000000..2493024 Binary files /dev/null and b/Assets/Computergrafik_Supersampling.png differ diff --git a/Assets/Computergrafik_Transformation_Basisvektoren.png b/Assets/Computergrafik_Transformation_Basisvektoren.png new file mode 100644 index 0000000..8d40943 Binary files /dev/null and b/Assets/Computergrafik_Transformation_Basisvektoren.png differ diff --git a/Assets/Computergrafik_Transparenz-Fehler.png b/Assets/Computergrafik_Transparenz-Fehler.png new file mode 100644 index 0000000..f97bb38 Binary files /dev/null and b/Assets/Computergrafik_Transparenz-Fehler.png differ diff --git a/Assets/Computergrafik_Z-buffer-verfahren.png b/Assets/Computergrafik_Z-buffer-verfahren.png new file mode 100644 index 0000000..8624990 Binary files /dev/null and b/Assets/Computergrafik_Z-buffer-verfahren.png differ diff --git a/Assets/Computergrafik_ambientes-licht.png b/Assets/Computergrafik_ambientes-licht.png new file mode 100644 index 0000000..0e2529a Binary files /dev/null and b/Assets/Computergrafik_ambientes-licht.png differ diff --git a/Assets/Computergrafik_diffus-gerichtete-reflexion.png b/Assets/Computergrafik_diffus-gerichtete-reflexion.png new file mode 100644 index 0000000..e522522 Binary files /dev/null and b/Assets/Computergrafik_diffus-gerichtete-reflexion.png differ diff --git a/Assets/Computergrafik_diffuse-reflexion.png b/Assets/Computergrafik_diffuse-reflexion.png new file mode 100644 index 0000000..6438f65 Binary files /dev/null and b/Assets/Computergrafik_diffuse-reflexion.png differ diff --git a/Assets/Computergrafik_paralleles-licht.png b/Assets/Computergrafik_paralleles-licht.png new file mode 100644 index 0000000..09c2493 Binary files /dev/null and b/Assets/Computergrafik_paralleles-licht.png differ diff --git a/Assets/Computergrafik_punkt-licht.png b/Assets/Computergrafik_punkt-licht.png new file mode 100644 index 0000000..3afe2d3 Binary files /dev/null and b/Assets/Computergrafik_punkt-licht.png differ diff --git a/Assets/Computergrafik_spekuläre-reflexion.png b/Assets/Computergrafik_spekuläre-reflexion.png new file mode 100644 index 0000000..ab38937 Binary files /dev/null and b/Assets/Computergrafik_spekuläre-reflexion.png differ diff --git a/Assets/Computergrafik_spot-licht.png b/Assets/Computergrafik_spot-licht.png new file mode 100644 index 0000000..fcdb2f9 Binary files /dev/null and b/Assets/Computergrafik_spot-licht.png differ diff --git a/Assets/ContentVerwaltungsmodelle-Schlüsselkontrolle.png b/Assets/ContentVerwaltungsmodelle-Schlüsselkontrolle.png new file mode 100644 index 0000000..757be23 Binary files /dev/null and b/Assets/ContentVerwaltungsmodelle-Schlüsselkontrolle.png differ diff --git a/Assets/ContentVerwertungsmodelle-Android-Architektur.jpg b/Assets/ContentVerwertungsmodelle-Android-Architektur.jpg new file mode 100644 index 0000000..09ff8ed Binary files /dev/null and b/Assets/ContentVerwertungsmodelle-Android-Architektur.jpg differ diff --git a/Assets/ContentVerwertungsmodelle-CEK-übertragung.png b/Assets/ContentVerwertungsmodelle-CEK-übertragung.png new file mode 100644 index 0000000..e92b5e3 Binary files /dev/null and b/Assets/ContentVerwertungsmodelle-CEK-übertragung.png differ diff --git a/Assets/ContentVerwertungsmodelle-DRM-Modell.png b/Assets/ContentVerwertungsmodelle-DRM-Modell.png new file mode 100644 index 0000000..06fd042 Binary files /dev/null and b/Assets/ContentVerwertungsmodelle-DRM-Modell.png differ diff --git a/Assets/ContentVerwertungsmodelle-Flutter.png b/Assets/ContentVerwertungsmodelle-Flutter.png new file mode 100644 index 0000000..737e260 Binary files /dev/null and b/Assets/ContentVerwertungsmodelle-Flutter.png differ diff --git a/Assets/ContentVerwertungsmodelle-android-studio.png b/Assets/ContentVerwertungsmodelle-android-studio.png new file mode 100644 index 0000000..264920d Binary files /dev/null and b/Assets/ContentVerwertungsmodelle-android-studio.png differ diff --git a/Assets/ContentVerwertungsmodelle-content.png b/Assets/ContentVerwertungsmodelle-content.png new file mode 100644 index 0000000..6f04f3a Binary files /dev/null and b/Assets/ContentVerwertungsmodelle-content.png differ diff --git a/Assets/ContentVerwertungsmodelle-krypto-hash.png b/Assets/ContentVerwertungsmodelle-krypto-hash.png new file mode 100644 index 0000000..a55dadb Binary files /dev/null and b/Assets/ContentVerwertungsmodelle-krypto-hash.png differ diff --git a/Assets/ContentVerwertungsmodelle-lizenz-digitale-signatur.png b/Assets/ContentVerwertungsmodelle-lizenz-digitale-signatur.png new file mode 100644 index 0000000..ac7a150 Binary files /dev/null and b/Assets/ContentVerwertungsmodelle-lizenz-digitale-signatur.png differ diff --git a/Assets/ContentVerwertungsmodelle-react-native.png b/Assets/ContentVerwertungsmodelle-react-native.png new file mode 100644 index 0000000..0613419 Binary files /dev/null and b/Assets/ContentVerwertungsmodelle-react-native.png differ diff --git a/Assets/ContentVerwertungsmodelle-sym-verschlüsselung-block.png b/Assets/ContentVerwertungsmodelle-sym-verschlüsselung-block.png new file mode 100644 index 0000000..675f97b Binary files /dev/null and b/Assets/ContentVerwertungsmodelle-sym-verschlüsselung-block.png differ diff --git a/Assets/ContentVerwertungsmodelle-sym-verschlüsselung-xor.png b/Assets/ContentVerwertungsmodelle-sym-verschlüsselung-xor.png new file mode 100644 index 0000000..a7922f2 Binary files /dev/null and b/Assets/ContentVerwertungsmodelle-sym-verschlüsselung-xor.png differ diff --git a/Assets/DB_ERD_01.png b/Assets/DB_ERD_01.png new file mode 100644 index 0000000..1dab9f0 Binary files /dev/null and b/Assets/DB_ERD_01.png differ diff --git a/Assets/DB_ERD_02.png b/Assets/DB_ERD_02.png new file mode 100644 index 0000000..05516ea Binary files /dev/null and b/Assets/DB_ERD_02.png differ diff --git a/Assets/DB_ERD_03-chen.png.png b/Assets/DB_ERD_03-chen.png.png new file mode 100644 index 0000000..5dd6cd0 Binary files /dev/null and b/Assets/DB_ERD_03-chen.png.png differ diff --git a/Assets/DB_ERD_04-chen.png.png b/Assets/DB_ERD_04-chen.png.png new file mode 100644 index 0000000..c118211 Binary files /dev/null and b/Assets/DB_ERD_04-chen.png.png differ diff --git a/Assets/DB_ERD_05-crow.png.png b/Assets/DB_ERD_05-crow.png.png new file mode 100644 index 0000000..f506efc Binary files /dev/null and b/Assets/DB_ERD_05-crow.png.png differ diff --git a/Assets/DB_ERD_06-crow.png.png b/Assets/DB_ERD_06-crow.png.png new file mode 100644 index 0000000..15b37a9 Binary files /dev/null and b/Assets/DB_ERD_06-crow.png.png differ diff --git a/Assets/DB_ERD_07-bachmann.png b/Assets/DB_ERD_07-bachmann.png new file mode 100644 index 0000000..f5ee49f Binary files /dev/null and b/Assets/DB_ERD_07-bachmann.png differ diff --git a/Assets/DB_ERD_08-bachmann.png b/Assets/DB_ERD_08-bachmann.png new file mode 100644 index 0000000..d0cb045 Binary files /dev/null and b/Assets/DB_ERD_08-bachmann.png differ diff --git a/Assets/DB_ERD_09-IDE1FX.png b/Assets/DB_ERD_09-IDE1FX.png new file mode 100644 index 0000000..ba06be0 Binary files /dev/null and b/Assets/DB_ERD_09-IDE1FX.png differ diff --git a/Assets/DB_ERD_10.png b/Assets/DB_ERD_10.png new file mode 100644 index 0000000..cde5e53 Binary files /dev/null and b/Assets/DB_ERD_10.png differ diff --git a/Assets/DB_tabelle_fragen-anfragenalgebren.png b/Assets/DB_tabelle_fragen-anfragenalgebren.png new file mode 100644 index 0000000..550f348 Binary files /dev/null and b/Assets/DB_tabelle_fragen-anfragenalgebren.png differ diff --git a/Assets/DB_tabelle_fragen-anfragenalgebren2.png b/Assets/DB_tabelle_fragen-anfragenalgebren2.png new file mode 100644 index 0000000..550f348 Binary files /dev/null and b/Assets/DB_tabelle_fragen-anfragenalgebren2.png differ diff --git a/Assets/DB_tabelle_fragen-anfragenalgebren3.png b/Assets/DB_tabelle_fragen-anfragenalgebren3.png new file mode 100644 index 0000000..162ff09 Binary files /dev/null and b/Assets/DB_tabelle_fragen-anfragenalgebren3.png differ diff --git a/Assets/DB_tabelle_fragen-anfragenalgebren4.png b/Assets/DB_tabelle_fragen-anfragenalgebren4.png new file mode 100644 index 0000000..f454dc9 Binary files /dev/null and b/Assets/DB_tabelle_fragen-anfragenalgebren4.png differ diff --git a/Assets/DB_tabelle_fragen-relationenalgebra.png b/Assets/DB_tabelle_fragen-relationenalgebra.png new file mode 100644 index 0000000..f7db407 Binary files /dev/null and b/Assets/DB_tabelle_fragen-relationenalgebra.png differ diff --git a/Assets/DB_tabelle_fragen-relationenalgebra2.png b/Assets/DB_tabelle_fragen-relationenalgebra2.png new file mode 100644 index 0000000..457ba13 Binary files /dev/null and b/Assets/DB_tabelle_fragen-relationenalgebra2.png differ diff --git a/Assets/DB_tabelle_fragen-äußere-verbunde.png b/Assets/DB_tabelle_fragen-äußere-verbunde.png new file mode 100644 index 0000000..d28e912 Binary files /dev/null and b/Assets/DB_tabelle_fragen-äußere-verbunde.png differ diff --git a/Assets/DBimpl-5-schichten-funktionen.png b/Assets/DBimpl-5-schichten-funktionen.png new file mode 100644 index 0000000..a3f2b08 Binary files /dev/null and b/Assets/DBimpl-5-schichten-funktionen.png differ diff --git a/Assets/DBimpl-5-schichten-objekte.png b/Assets/DBimpl-5-schichten-objekte.png new file mode 100644 index 0000000..9f2c65c Binary files /dev/null and b/Assets/DBimpl-5-schichten-objekte.png differ diff --git a/Assets/DBimpl-Baumverfahren.png b/Assets/DBimpl-Baumverfahren.png new file mode 100644 index 0000000..a9e2576 Binary files /dev/null and b/Assets/DBimpl-Baumverfahren.png differ diff --git a/Assets/DBimpl-DBL-to-arc.png b/Assets/DBimpl-DBL-to-arc.png new file mode 100644 index 0000000..be63a1f Binary files /dev/null and b/Assets/DBimpl-DBL-to-arc.png differ diff --git a/Assets/DBimpl-LSM-baum.png b/Assets/DBimpl-LSM-baum.png new file mode 100644 index 0000000..f37d3f9 Binary files /dev/null and b/Assets/DBimpl-LSM-baum.png differ diff --git a/Assets/DBimpl-PAX.png b/Assets/DBimpl-PAX.png new file mode 100644 index 0000000..0f1f29c Binary files /dev/null and b/Assets/DBimpl-PAX.png differ diff --git a/Assets/DBimpl-Raid-level-1.png b/Assets/DBimpl-Raid-level-1.png new file mode 100644 index 0000000..ad276dc Binary files /dev/null and b/Assets/DBimpl-Raid-level-1.png differ diff --git a/Assets/DBimpl-Raid-level-2.png b/Assets/DBimpl-Raid-level-2.png new file mode 100644 index 0000000..a455bb9 Binary files /dev/null and b/Assets/DBimpl-Raid-level-2.png differ diff --git a/Assets/DBimpl-SSD.png b/Assets/DBimpl-SSD.png new file mode 100644 index 0000000..8bf6af4 Binary files /dev/null and b/Assets/DBimpl-SSD.png differ diff --git a/Assets/DBimpl-Seitenersetzung-2.png b/Assets/DBimpl-Seitenersetzung-2.png new file mode 100644 index 0000000..40276aa Binary files /dev/null and b/Assets/DBimpl-Seitenersetzung-2.png differ diff --git a/Assets/DBimpl-Seitenersetzung.png b/Assets/DBimpl-Seitenersetzung.png new file mode 100644 index 0000000..13773c4 Binary files /dev/null and b/Assets/DBimpl-Seitenersetzung.png differ diff --git a/Assets/DBimpl-Transferrate.png b/Assets/DBimpl-Transferrate.png new file mode 100644 index 0000000..eabf5e3 Binary files /dev/null and b/Assets/DBimpl-Transferrate.png differ diff --git a/Assets/DBimpl-arc-bsp-1.png b/Assets/DBimpl-arc-bsp-1.png new file mode 100644 index 0000000..b68fb34 Binary files /dev/null and b/Assets/DBimpl-arc-bsp-1.png differ diff --git a/Assets/DBimpl-arc-bsp-2.png b/Assets/DBimpl-arc-bsp-2.png new file mode 100644 index 0000000..0e94cb6 Binary files /dev/null and b/Assets/DBimpl-arc-bsp-2.png differ diff --git a/Assets/DBimpl-arc-bsp-3.png b/Assets/DBimpl-arc-bsp-3.png new file mode 100644 index 0000000..e7f4451 Binary files /dev/null and b/Assets/DBimpl-arc-bsp-3.png differ diff --git a/Assets/DBimpl-arc-bsp-4.png b/Assets/DBimpl-arc-bsp-4.png new file mode 100644 index 0000000..0339078 Binary files /dev/null and b/Assets/DBimpl-arc-bsp-4.png differ diff --git a/Assets/DBimpl-arc-bsp-5.png b/Assets/DBimpl-arc-bsp-5.png new file mode 100644 index 0000000..cab4fec Binary files /dev/null and b/Assets/DBimpl-arc-bsp-5.png differ diff --git a/Assets/DBimpl-b+-baum-blattebenen.png b/Assets/DBimpl-b+-baum-blattebenen.png new file mode 100644 index 0000000..d6d341b Binary files /dev/null and b/Assets/DBimpl-b+-baum-blattebenen.png differ diff --git a/Assets/DBimpl-b+-baum-traversieren.png b/Assets/DBimpl-b+-baum-traversieren.png new file mode 100644 index 0000000..ed1b95e Binary files /dev/null and b/Assets/DBimpl-b+-baum-traversieren.png differ diff --git a/Assets/DBimpl-b-baum-beispiel-2.png b/Assets/DBimpl-b-baum-beispiel-2.png new file mode 100644 index 0000000..0b85188 Binary files /dev/null and b/Assets/DBimpl-b-baum-beispiel-2.png differ diff --git a/Assets/DBimpl-b-baum-beispiel-3.png b/Assets/DBimpl-b-baum-beispiel-3.png new file mode 100644 index 0000000..dc18f74 Binary files /dev/null and b/Assets/DBimpl-b-baum-beispiel-3.png differ diff --git a/Assets/DBimpl-b-baum-beispiel.png b/Assets/DBimpl-b-baum-beispiel.png new file mode 100644 index 0000000..b9bf2d7 Binary files /dev/null and b/Assets/DBimpl-b-baum-beispiel.png differ diff --git a/Assets/DBimpl-b-baum-lookup.png b/Assets/DBimpl-b-baum-lookup.png new file mode 100644 index 0000000..32bb387 Binary files /dev/null and b/Assets/DBimpl-b-baum-lookup.png differ diff --git a/Assets/DBimpl-beispiel-seitenwechsel.png b/Assets/DBimpl-beispiel-seitenwechsel.png new file mode 100644 index 0000000..df96acc Binary files /dev/null and b/Assets/DBimpl-beispiel-seitenwechsel.png differ diff --git a/Assets/DBimpl-bs-puffer.png b/Assets/DBimpl-bs-puffer.png new file mode 100644 index 0000000..d726148 Binary files /dev/null and b/Assets/DBimpl-bs-puffer.png differ diff --git a/Assets/DBimpl-bsp-partition.png b/Assets/DBimpl-bsp-partition.png new file mode 100644 index 0000000..a55e2cd Binary files /dev/null and b/Assets/DBimpl-bsp-partition.png differ diff --git a/Assets/DBimpl-csb-baum.png b/Assets/DBimpl-csb-baum.png new file mode 100644 index 0000000..6429d7c Binary files /dev/null and b/Assets/DBimpl-csb-baum.png differ diff --git a/Assets/DBimpl-dsm.png b/Assets/DBimpl-dsm.png new file mode 100644 index 0000000..095281e Binary files /dev/null and b/Assets/DBimpl-dsm.png differ diff --git a/Assets/DBimpl-ebenen.png b/Assets/DBimpl-ebenen.png new file mode 100644 index 0000000..fc1ae64 Binary files /dev/null and b/Assets/DBimpl-ebenen.png differ diff --git a/Assets/DBimpl-eckentransformation.png b/Assets/DBimpl-eckentransformation.png new file mode 100644 index 0000000..7875c8f Binary files /dev/null and b/Assets/DBimpl-eckentransformation.png differ diff --git a/Assets/DBimpl-erweiterbares-hashing-2.png b/Assets/DBimpl-erweiterbares-hashing-2.png new file mode 100644 index 0000000..f1cbb7d Binary files /dev/null and b/Assets/DBimpl-erweiterbares-hashing-2.png differ diff --git a/Assets/DBimpl-erweiterbares-hashing-3.png b/Assets/DBimpl-erweiterbares-hashing-3.png new file mode 100644 index 0000000..a5135a2 Binary files /dev/null and b/Assets/DBimpl-erweiterbares-hashing-3.png differ diff --git a/Assets/DBimpl-erweiterbares-hashing.png b/Assets/DBimpl-erweiterbares-hashing.png new file mode 100644 index 0000000..449fe89 Binary files /dev/null and b/Assets/DBimpl-erweiterbares-hashing.png differ diff --git a/Assets/DBimpl-full-table-scan-dsm.png b/Assets/DBimpl-full-table-scan-dsm.png new file mode 100644 index 0000000..d899ff7 Binary files /dev/null and b/Assets/DBimpl-full-table-scan-dsm.png differ diff --git a/Assets/DBimpl-grid-beispiel-1.png b/Assets/DBimpl-grid-beispiel-1.png new file mode 100644 index 0000000..63f7ab7 Binary files /dev/null and b/Assets/DBimpl-grid-beispiel-1.png differ diff --git a/Assets/DBimpl-grid-beispiel-5.png b/Assets/DBimpl-grid-beispiel-5.png new file mode 100644 index 0000000..2369745 Binary files /dev/null and b/Assets/DBimpl-grid-beispiel-5.png differ diff --git a/Assets/DBimpl-grid-beispiel-6.png b/Assets/DBimpl-grid-beispiel-6.png new file mode 100644 index 0000000..d19d28d Binary files /dev/null and b/Assets/DBimpl-grid-beispiel-6.png differ diff --git a/Assets/DBimpl-grid-files.png b/Assets/DBimpl-grid-files.png new file mode 100644 index 0000000..617a659 Binary files /dev/null and b/Assets/DBimpl-grid-files.png differ diff --git a/Assets/DBimpl-grid-start.png b/Assets/DBimpl-grid-start.png new file mode 100644 index 0000000..38f415f Binary files /dev/null and b/Assets/DBimpl-grid-start.png differ diff --git a/Assets/DBimpl-hashing-split.png b/Assets/DBimpl-hashing-split.png new file mode 100644 index 0000000..7216887 Binary files /dev/null and b/Assets/DBimpl-hashing-split.png differ diff --git a/Assets/DBimpl-indexsequentiell-2.png b/Assets/DBimpl-indexsequentiell-2.png new file mode 100644 index 0000000..3978824 Binary files /dev/null and b/Assets/DBimpl-indexsequentiell-2.png differ diff --git a/Assets/DBimpl-indexsequentiell-3.png b/Assets/DBimpl-indexsequentiell-3.png new file mode 100644 index 0000000..763f674 Binary files /dev/null and b/Assets/DBimpl-indexsequentiell-3.png differ diff --git a/Assets/DBimpl-indexsequentiell.png b/Assets/DBimpl-indexsequentiell.png new file mode 100644 index 0000000..2273be9 Binary files /dev/null and b/Assets/DBimpl-indexsequentiell.png differ diff --git a/Assets/DBimpl-invertierte-liste.png b/Assets/DBimpl-invertierte-liste.png new file mode 100644 index 0000000..a90dc79 Binary files /dev/null and b/Assets/DBimpl-invertierte-liste.png differ diff --git a/Assets/DBimpl-kdb-baum-brickwall.png b/Assets/DBimpl-kdb-baum-brickwall.png new file mode 100644 index 0000000..34f82db Binary files /dev/null and b/Assets/DBimpl-kdb-baum-brickwall.png differ diff --git a/Assets/DBimpl-lineares-hashen.png b/Assets/DBimpl-lineares-hashen.png new file mode 100644 index 0000000..6bf8164 Binary files /dev/null and b/Assets/DBimpl-lineares-hashen.png differ diff --git a/Assets/DBimpl-lineares-hashing-problem.png b/Assets/DBimpl-lineares-hashing-problem.png new file mode 100644 index 0000000..1059867 Binary files /dev/null and b/Assets/DBimpl-lineares-hashing-problem.png differ diff --git a/Assets/DBimpl-lock-contention.png b/Assets/DBimpl-lock-contention.png new file mode 100644 index 0000000..55fc2a7 Binary files /dev/null and b/Assets/DBimpl-lock-contention.png differ diff --git a/Assets/DBimpl-mdh-veranschaulichung.png b/Assets/DBimpl-mdh-veranschaulichung.png new file mode 100644 index 0000000..bb7e413 Binary files /dev/null and b/Assets/DBimpl-mdh-veranschaulichung.png differ diff --git a/Assets/DBimpl-mehrstufige-geom-bearbeitung.png b/Assets/DBimpl-mehrstufige-geom-bearbeitung.png new file mode 100644 index 0000000..1b3b000 Binary files /dev/null and b/Assets/DBimpl-mehrstufige-geom-bearbeitung.png differ diff --git a/Assets/DBimpl-mittentransformation.png b/Assets/DBimpl-mittentransformation.png new file mode 100644 index 0000000..80d7b51 Binary files /dev/null and b/Assets/DBimpl-mittentransformation.png differ diff --git a/Assets/DBimpl-nichtspannsätze.png b/Assets/DBimpl-nichtspannsätze.png new file mode 100644 index 0000000..f749d13 Binary files /dev/null and b/Assets/DBimpl-nichtspannsätze.png differ diff --git a/Assets/DBimpl-oracle-datensatz.png b/Assets/DBimpl-oracle-datensatz.png new file mode 100644 index 0000000..7034925 Binary files /dev/null and b/Assets/DBimpl-oracle-datensatz.png differ diff --git a/Assets/DBimpl-oracle-dbstruktur.png b/Assets/DBimpl-oracle-dbstruktur.png new file mode 100644 index 0000000..d2ad136 Binary files /dev/null and b/Assets/DBimpl-oracle-dbstruktur.png differ diff --git a/Assets/DBimpl-präfix-b-baum.png b/Assets/DBimpl-präfix-b-baum.png new file mode 100644 index 0000000..e2a0fba Binary files /dev/null and b/Assets/DBimpl-präfix-b-baum.png differ diff --git a/Assets/DBimpl-präfix-baum.png b/Assets/DBimpl-präfix-baum.png new file mode 100644 index 0000000..90bcfef Binary files /dev/null and b/Assets/DBimpl-präfix-baum.png differ diff --git a/Assets/DBimpl-pufferverwaltung.png b/Assets/DBimpl-pufferverwaltung.png new file mode 100644 index 0000000..de60c42 Binary files /dev/null and b/Assets/DBimpl-pufferverwaltung.png differ diff --git a/Assets/DBimpl-r+-baum-problem.png b/Assets/DBimpl-r+-baum-problem.png new file mode 100644 index 0000000..9137d2d Binary files /dev/null and b/Assets/DBimpl-r+-baum-problem.png differ diff --git a/Assets/DBimpl-r+-baum-struktur.png b/Assets/DBimpl-r+-baum-struktur.png new file mode 100644 index 0000000..cb48567 Binary files /dev/null and b/Assets/DBimpl-r+-baum-struktur.png differ diff --git a/Assets/DBimpl-r+-baum.png b/Assets/DBimpl-r+-baum.png new file mode 100644 index 0000000..7f18218 Binary files /dev/null and b/Assets/DBimpl-r+-baum.png differ diff --git a/Assets/DBimpl-r-baum-struktur.png b/Assets/DBimpl-r-baum-struktur.png new file mode 100644 index 0000000..21f134f Binary files /dev/null and b/Assets/DBimpl-r-baum-struktur.png differ diff --git a/Assets/DBimpl-r-baum-vergrößern.png b/Assets/DBimpl-r-baum-vergrößern.png new file mode 100644 index 0000000..37fb775 Binary files /dev/null and b/Assets/DBimpl-r-baum-vergrößern.png differ diff --git a/Assets/DBimpl-r-baum.png b/Assets/DBimpl-r-baum.png new file mode 100644 index 0000000..2241830 Binary files /dev/null and b/Assets/DBimpl-r-baum.png differ diff --git a/Assets/DBimpl-satztypen.png b/Assets/DBimpl-satztypen.png new file mode 100644 index 0000000..ccb1475 Binary files /dev/null and b/Assets/DBimpl-satztypen.png differ diff --git a/Assets/DBimpl-seitenersetzung-clock.png b/Assets/DBimpl-seitenersetzung-clock.png new file mode 100644 index 0000000..a40fb54 Binary files /dev/null and b/Assets/DBimpl-seitenersetzung-clock.png differ diff --git a/Assets/DBimpl-seitenersetzung-lru.png b/Assets/DBimpl-seitenersetzung-lru.png new file mode 100644 index 0000000..c21839b Binary files /dev/null and b/Assets/DBimpl-seitenersetzung-lru.png differ diff --git a/Assets/DBimpl-seitenorganisation.png b/Assets/DBimpl-seitenorganisation.png new file mode 100644 index 0000000..eb2cdaf Binary files /dev/null and b/Assets/DBimpl-seitenorganisation.png differ diff --git a/Assets/DBimpl-seitenwechsel-strategie.png b/Assets/DBimpl-seitenwechsel-strategie.png new file mode 100644 index 0000000..450684d Binary files /dev/null and b/Assets/DBimpl-seitenwechsel-strategie.png differ diff --git a/Assets/DBimpl-spaltenorientierte-db.png b/Assets/DBimpl-spaltenorientierte-db.png new file mode 100644 index 0000000..68122e0 Binary files /dev/null and b/Assets/DBimpl-spaltenorientierte-db.png differ diff --git a/Assets/DBimpl-spannsätze.png b/Assets/DBimpl-spannsätze.png new file mode 100644 index 0000000..d278675 Binary files /dev/null and b/Assets/DBimpl-spannsätze.png differ diff --git a/Assets/DBimpl-speicherhierarchie.png b/Assets/DBimpl-speicherhierarchie.png new file mode 100644 index 0000000..9fb818a Binary files /dev/null and b/Assets/DBimpl-speicherhierarchie.png differ diff --git a/Assets/DBimpl-speichertechniken-klassifikation.png b/Assets/DBimpl-speichertechniken-klassifikation.png new file mode 100644 index 0000000..d48b526 Binary files /dev/null and b/Assets/DBimpl-speichertechniken-klassifikation.png differ diff --git a/Assets/DBimpl-spiral-hashing-2.png b/Assets/DBimpl-spiral-hashing-2.png new file mode 100644 index 0000000..c778467 Binary files /dev/null and b/Assets/DBimpl-spiral-hashing-2.png differ diff --git a/Assets/DBimpl-spiral-hashing.png b/Assets/DBimpl-spiral-hashing.png new file mode 100644 index 0000000..7e49a35 Binary files /dev/null and b/Assets/DBimpl-spiral-hashing.png differ diff --git a/Assets/DBimpl-statische-verfahren.png b/Assets/DBimpl-statische-verfahren.png new file mode 100644 index 0000000..9358cbd Binary files /dev/null and b/Assets/DBimpl-statische-verfahren.png differ diff --git a/Assets/DBimpl-suchfenster.png b/Assets/DBimpl-suchfenster.png new file mode 100644 index 0000000..b3d2ce9 Binary files /dev/null and b/Assets/DBimpl-suchfenster.png differ diff --git a/Assets/DBimpl-tid-einstufig.png b/Assets/DBimpl-tid-einstufig.png new file mode 100644 index 0000000..8478ede Binary files /dev/null and b/Assets/DBimpl-tid-einstufig.png differ diff --git a/Assets/DBimpl-tid-zweistufig.png b/Assets/DBimpl-tid-zweistufig.png new file mode 100644 index 0000000..59f61bd Binary files /dev/null and b/Assets/DBimpl-tid-zweistufig.png differ diff --git a/Assets/DBimpl-trie.png b/Assets/DBimpl-trie.png new file mode 100644 index 0000000..9c87839 Binary files /dev/null and b/Assets/DBimpl-trie.png differ diff --git a/Assets/DBimpl-tries.png b/Assets/DBimpl-tries.png new file mode 100644 index 0000000..be7897e Binary files /dev/null and b/Assets/DBimpl-tries.png differ diff --git a/Assets/DBimpl-va-file.png b/Assets/DBimpl-va-file.png new file mode 100644 index 0000000..e148427 Binary files /dev/null and b/Assets/DBimpl-va-file.png differ diff --git a/Assets/DBimpl-variable-länge-1.png b/Assets/DBimpl-variable-länge-1.png new file mode 100644 index 0000000..ed1b147 Binary files /dev/null and b/Assets/DBimpl-variable-länge-1.png differ diff --git a/Assets/DBimpl-variable-länge-2.png b/Assets/DBimpl-variable-länge-2.png new file mode 100644 index 0000000..54207a9 Binary files /dev/null and b/Assets/DBimpl-variable-länge-2.png differ diff --git a/Assets/DBimpl-variable-länge-3.png b/Assets/DBimpl-variable-länge-3.png new file mode 100644 index 0000000..2d1dd4c Binary files /dev/null and b/Assets/DBimpl-variable-länge-3.png differ diff --git a/Assets/DBimpl-zugriff-klassifikation.png b/Assets/DBimpl-zugriff-klassifikation.png new file mode 100644 index 0000000..ff89745 Binary files /dev/null and b/Assets/DBimpl-zugriff-klassifikation.png differ diff --git a/Assets/Datenbanksysteme_Beziehungen.png b/Assets/Datenbanksysteme_Beziehungen.png new file mode 100644 index 0000000..7b3e8ef Binary files /dev/null and b/Assets/Datenbanksysteme_Beziehungen.png differ diff --git a/Assets/Datenbanksysteme_Fragen_Mengenoperationen.jpeg b/Assets/Datenbanksysteme_Fragen_Mengenoperationen.jpeg new file mode 100644 index 0000000..e8c2300 Binary files /dev/null and b/Assets/Datenbanksysteme_Fragen_Mengenoperationen.jpeg differ diff --git a/Assets/Datenbanksysteme_JDBC_Struktur.png b/Assets/Datenbanksysteme_JDBC_Struktur.png new file mode 100644 index 0000000..baddb33 Binary files /dev/null and b/Assets/Datenbanksysteme_JDBC_Struktur.png differ diff --git a/Assets/Datenbanksysteme_JDBC_Treiberkonzept.png b/Assets/Datenbanksysteme_JDBC_Treiberkonzept.png new file mode 100644 index 0000000..1dcf3b7 Binary files /dev/null and b/Assets/Datenbanksysteme_JDBC_Treiberkonzept.png differ diff --git a/Assets/Datenbanksysteme_ORM_Prinzip.png b/Assets/Datenbanksysteme_ORM_Prinzip.png new file mode 100644 index 0000000..862e677 Binary files /dev/null and b/Assets/Datenbanksysteme_ORM_Prinzip.png differ diff --git a/Assets/Datenbanksysteme_SQLJ_Prinzip.png b/Assets/Datenbanksysteme_SQLJ_Prinzip.png new file mode 100644 index 0000000..1dd7f99 Binary files /dev/null and b/Assets/Datenbanksysteme_SQLJ_Prinzip.png differ diff --git a/Assets/Datenbanksysteme_Tabellenbeispiel.png b/Assets/Datenbanksysteme_Tabellenbeispiel.png new file mode 100644 index 0000000..edad767 Binary files /dev/null and b/Assets/Datenbanksysteme_Tabellenbeispiel.png differ diff --git a/Assets/Dbimpl-adressierungstechniken.png b/Assets/Dbimpl-adressierungstechniken.png new file mode 100644 index 0000000..1939ab0 Binary files /dev/null and b/Assets/Dbimpl-adressierungstechniken.png differ diff --git a/Assets/Dbimpl-b+-baum-aufbau.png b/Assets/Dbimpl-b+-baum-aufbau.png new file mode 100644 index 0000000..ab60780 Binary files /dev/null and b/Assets/Dbimpl-b+-baum-aufbau.png differ diff --git a/Assets/Dbimpl-cluster-vs-nicht-cluster.png b/Assets/Dbimpl-cluster-vs-nicht-cluster.png new file mode 100644 index 0000000..54f3626 Binary files /dev/null and b/Assets/Dbimpl-cluster-vs-nicht-cluster.png differ diff --git a/Assets/Dbimpl-full-table-scan-nsm.png b/Assets/Dbimpl-full-table-scan-nsm.png new file mode 100644 index 0000000..84f9a44 Binary files /dev/null and b/Assets/Dbimpl-full-table-scan-nsm.png differ diff --git a/Assets/Dbimpl-grid-beispiel-2.png b/Assets/Dbimpl-grid-beispiel-2.png new file mode 100644 index 0000000..1b2db5e Binary files /dev/null and b/Assets/Dbimpl-grid-beispiel-2.png differ diff --git a/Assets/Dbimpl-grid-beispiel-3.png b/Assets/Dbimpl-grid-beispiel-3.png new file mode 100644 index 0000000..a62b9a1 Binary files /dev/null and b/Assets/Dbimpl-grid-beispiel-3.png differ diff --git a/Assets/Dbimpl-grid-beispiel-4.png b/Assets/Dbimpl-grid-beispiel-4.png new file mode 100644 index 0000000..096e54a Binary files /dev/null and b/Assets/Dbimpl-grid-beispiel-4.png differ diff --git a/Assets/Dbimpl-grid-file-degeneration.png b/Assets/Dbimpl-grid-file-degeneration.png new file mode 100644 index 0000000..a719562 Binary files /dev/null and b/Assets/Dbimpl-grid-file-degeneration.png differ diff --git a/Assets/Dbimpl-hashverfahren.png b/Assets/Dbimpl-hashverfahren.png new file mode 100644 index 0000000..8e24247 Binary files /dev/null and b/Assets/Dbimpl-hashverfahren.png differ diff --git a/Assets/Dbimpl-kdb-baum-beispiel.png b/Assets/Dbimpl-kdb-baum-beispiel.png new file mode 100644 index 0000000..4565f9d Binary files /dev/null and b/Assets/Dbimpl-kdb-baum-beispiel.png differ diff --git a/Assets/Dbimpl-mehr-attribut-b-baum.png b/Assets/Dbimpl-mehr-attribut-b-baum.png new file mode 100644 index 0000000..8a0a8df Binary files /dev/null and b/Assets/Dbimpl-mehr-attribut-b-baum.png differ diff --git a/Assets/Dbimpl-nichtsequentieller-index.png b/Assets/Dbimpl-nichtsequentieller-index.png new file mode 100644 index 0000000..c796444 Binary files /dev/null and b/Assets/Dbimpl-nichtsequentieller-index.png differ diff --git a/Assets/Dbimpl-oracle-blöcke.png b/Assets/Dbimpl-oracle-blöcke.png new file mode 100644 index 0000000..1683f20 Binary files /dev/null and b/Assets/Dbimpl-oracle-blöcke.png differ diff --git a/Assets/Dbimpl-r+-baum-problem-2.png b/Assets/Dbimpl-r+-baum-problem-2.png new file mode 100644 index 0000000..5217c86 Binary files /dev/null and b/Assets/Dbimpl-r+-baum-problem-2.png differ diff --git a/Assets/Dbimpl-trie-vs-patricia.png b/Assets/Dbimpl-trie-vs-patricia.png new file mode 100644 index 0000000..885c54d Binary files /dev/null and b/Assets/Dbimpl-trie-vs-patricia.png differ diff --git a/Assets/Dbimpl-tries-knoten.png b/Assets/Dbimpl-tries-knoten.png new file mode 100644 index 0000000..b23f1e1 Binary files /dev/null and b/Assets/Dbimpl-tries-knoten.png differ diff --git a/Assets/GudS-schaltung.png b/Assets/GudS-schaltung.png new file mode 100644 index 0000000..e3ce1a5 Binary files /dev/null and b/Assets/GudS-schaltung.png differ diff --git a/Assets/Kryptographie-teilbarkeitsbeziehung.png b/Assets/Kryptographie-teilbarkeitsbeziehung.png new file mode 100644 index 0000000..d4f3feb Binary files /dev/null and b/Assets/Kryptographie-teilbarkeitsbeziehung.png differ diff --git a/Assets/LaborBMT-15-03-32.png b/Assets/LaborBMT-15-03-32.png new file mode 100644 index 0000000..abd4651 Binary files /dev/null and b/Assets/LaborBMT-15-03-32.png differ diff --git a/Assets/LaborBMT-15-10-44.png b/Assets/LaborBMT-15-10-44.png new file mode 100644 index 0000000..d15148b Binary files /dev/null and b/Assets/LaborBMT-15-10-44.png differ diff --git a/Assets/LaborBMT-15-11-03.png b/Assets/LaborBMT-15-11-03.png new file mode 100644 index 0000000..42d2963 Binary files /dev/null and b/Assets/LaborBMT-15-11-03.png differ diff --git a/Assets/LaborBMT-15-20-37.png b/Assets/LaborBMT-15-20-37.png new file mode 100644 index 0000000..1e311f9 Binary files /dev/null and b/Assets/LaborBMT-15-20-37.png differ diff --git a/Assets/LaborBMT-15-27-08.png b/Assets/LaborBMT-15-27-08.png new file mode 100644 index 0000000..2ef080f Binary files /dev/null and b/Assets/LaborBMT-15-27-08.png differ diff --git a/Assets/LaborBMT-15-40-04.png b/Assets/LaborBMT-15-40-04.png new file mode 100644 index 0000000..258058b Binary files /dev/null and b/Assets/LaborBMT-15-40-04.png differ diff --git a/Assets/LaborBMT-15-42-26.png b/Assets/LaborBMT-15-42-26.png new file mode 100644 index 0000000..01db107 Binary files /dev/null and b/Assets/LaborBMT-15-42-26.png differ diff --git a/Assets/LaborBMT-15-50-45.png b/Assets/LaborBMT-15-50-45.png new file mode 100644 index 0000000..7b23600 Binary files /dev/null and b/Assets/LaborBMT-15-50-45.png differ diff --git a/Assets/LaborBMT-15-54-32.png b/Assets/LaborBMT-15-54-32.png new file mode 100644 index 0000000..e9640a3 Binary files /dev/null and b/Assets/LaborBMT-15-54-32.png differ diff --git a/Assets/LaborBMT-15-57-50.png b/Assets/LaborBMT-15-57-50.png new file mode 100644 index 0000000..45e9fc3 Binary files /dev/null and b/Assets/LaborBMT-15-57-50.png differ diff --git a/Assets/LaborBMT-16-14-54.png b/Assets/LaborBMT-16-14-54.png new file mode 100644 index 0000000..a9ca076 Binary files /dev/null and b/Assets/LaborBMT-16-14-54.png differ diff --git a/Assets/LaborBMT-16-32-42.png b/Assets/LaborBMT-16-32-42.png new file mode 100644 index 0000000..2847f1c Binary files /dev/null and b/Assets/LaborBMT-16-32-42.png differ diff --git a/Assets/LaborBMT-16-33-27.png b/Assets/LaborBMT-16-33-27.png new file mode 100644 index 0000000..25dad4c Binary files /dev/null and b/Assets/LaborBMT-16-33-27.png differ diff --git a/Assets/LaborBMT-16-35-29.png b/Assets/LaborBMT-16-35-29.png new file mode 100644 index 0000000..333d92a Binary files /dev/null and b/Assets/LaborBMT-16-35-29.png differ diff --git a/Assets/LaborBMT-16-59-32.png b/Assets/LaborBMT-16-59-32.png new file mode 100644 index 0000000..17cac7b Binary files /dev/null and b/Assets/LaborBMT-16-59-32.png differ diff --git a/Assets/LaborBMT-17-00-21.png b/Assets/LaborBMT-17-00-21.png new file mode 100644 index 0000000..3e71965 Binary files /dev/null and b/Assets/LaborBMT-17-00-21.png differ diff --git a/Assets/LaborBMT-17-09-35.png b/Assets/LaborBMT-17-09-35.png new file mode 100644 index 0000000..e1e4e3f Binary files /dev/null and b/Assets/LaborBMT-17-09-35.png differ diff --git a/Assets/LaborBMT-17-25-19.png b/Assets/LaborBMT-17-25-19.png new file mode 100644 index 0000000..e95e4cb Binary files /dev/null and b/Assets/LaborBMT-17-25-19.png differ diff --git a/Assets/LaborBMT-17-30-09.png b/Assets/LaborBMT-17-30-09.png new file mode 100644 index 0000000..15ad92c Binary files /dev/null and b/Assets/LaborBMT-17-30-09.png differ diff --git a/Assets/LaborBMT-Lagetyps.png b/Assets/LaborBMT-Lagetyps.png new file mode 100644 index 0000000..be81097 Binary files /dev/null and b/Assets/LaborBMT-Lagetyps.png differ diff --git a/Assets/Logik-Beweisbaum.png b/Assets/Logik-Beweisbaum.png new file mode 100644 index 0000000..2675187 Binary files /dev/null and b/Assets/Logik-Beweisbaum.png differ diff --git a/Assets/Logik-Deduktionsbeispiel.png b/Assets/Logik-Deduktionsbeispiel.png new file mode 100644 index 0000000..b9f7a5d Binary files /dev/null and b/Assets/Logik-Deduktionsbeispiel.png differ diff --git a/Assets/Logik-Disjunktionselimination.png b/Assets/Logik-Disjunktionselimination.png new file mode 100644 index 0000000..40904ef Binary files /dev/null and b/Assets/Logik-Disjunktionselimination.png differ diff --git a/Assets/Logik-Falsumeinführung.png b/Assets/Logik-Falsumeinführung.png new file mode 100644 index 0000000..61bc1bb Binary files /dev/null and b/Assets/Logik-Falsumeinführung.png differ diff --git a/Assets/Logik-Implikationseinführung.png b/Assets/Logik-Implikationseinführung.png new file mode 100644 index 0000000..871fe9e Binary files /dev/null and b/Assets/Logik-Implikationseinführung.png differ diff --git a/Assets/Logik-Implikationseleimination-beispiel.png b/Assets/Logik-Implikationseleimination-beispiel.png new file mode 100644 index 0000000..fa1fdd9 Binary files /dev/null and b/Assets/Logik-Implikationseleimination-beispiel.png differ diff --git a/Assets/Logik-Implikationselimination.png b/Assets/Logik-Implikationselimination.png new file mode 100644 index 0000000..ecf89ed Binary files /dev/null and b/Assets/Logik-Implikationselimination.png differ diff --git a/Assets/Logik-Konjunktionselimination.png b/Assets/Logik-Konjunktionselimination.png new file mode 100644 index 0000000..f7435bc Binary files /dev/null and b/Assets/Logik-Konjunktionselimination.png differ diff --git a/Assets/Logik-Negationseinführung.png b/Assets/Logik-Negationseinführung.png new file mode 100644 index 0000000..e3e2689 Binary files /dev/null and b/Assets/Logik-Negationseinführung.png differ diff --git a/Assets/Logik-Negationselimination.png b/Assets/Logik-Negationselimination.png new file mode 100644 index 0000000..a2fc291 Binary files /dev/null and b/Assets/Logik-Negationselimination.png differ diff --git a/Assets/Logik-ableitungsbaum-beispiel.png b/Assets/Logik-ableitungsbaum-beispiel.png new file mode 100644 index 0000000..0f34069 Binary files /dev/null and b/Assets/Logik-ableitungsbaum-beispiel.png differ diff --git a/Assets/Logik-beispiel-1.png b/Assets/Logik-beispiel-1.png new file mode 100644 index 0000000..c618249 Binary files /dev/null and b/Assets/Logik-beispiel-1.png differ diff --git a/Assets/Logik-beispiel-10.png b/Assets/Logik-beispiel-10.png new file mode 100644 index 0000000..b71c4f3 Binary files /dev/null and b/Assets/Logik-beispiel-10.png differ diff --git a/Assets/Logik-beispiel-11.png b/Assets/Logik-beispiel-11.png new file mode 100644 index 0000000..6c612b8 Binary files /dev/null and b/Assets/Logik-beispiel-11.png differ diff --git a/Assets/Logik-beispiel-2.png b/Assets/Logik-beispiel-2.png new file mode 100644 index 0000000..ef7bcbd Binary files /dev/null and b/Assets/Logik-beispiel-2.png differ diff --git a/Assets/Logik-beispiel-3.png b/Assets/Logik-beispiel-3.png new file mode 100644 index 0000000..eea2edb Binary files /dev/null and b/Assets/Logik-beispiel-3.png differ diff --git a/Assets/Logik-beispiel-4.png b/Assets/Logik-beispiel-4.png new file mode 100644 index 0000000..2d02427 Binary files /dev/null and b/Assets/Logik-beispiel-4.png differ diff --git a/Assets/Logik-beispiel-5.png b/Assets/Logik-beispiel-5.png new file mode 100644 index 0000000..692f68b Binary files /dev/null and b/Assets/Logik-beispiel-5.png differ diff --git a/Assets/Logik-beispiel-6.png b/Assets/Logik-beispiel-6.png new file mode 100644 index 0000000..54ea761 Binary files /dev/null and b/Assets/Logik-beispiel-6.png differ diff --git a/Assets/Logik-beispiel-7.png b/Assets/Logik-beispiel-7.png new file mode 100644 index 0000000..6c3e4f0 Binary files /dev/null and b/Assets/Logik-beispiel-7.png differ diff --git a/Assets/Logik-beispiel-8.png b/Assets/Logik-beispiel-8.png new file mode 100644 index 0000000..187172d Binary files /dev/null and b/Assets/Logik-beispiel-8.png differ diff --git a/Assets/Logik-beispiel-9.png b/Assets/Logik-beispiel-9.png new file mode 100644 index 0000000..6668cc3 Binary files /dev/null and b/Assets/Logik-beispiel-9.png differ diff --git a/Assets/Logik-beispiel-korrekheitssatz.png b/Assets/Logik-beispiel-korrekheitssatz.png new file mode 100644 index 0000000..2eb03c3 Binary files /dev/null and b/Assets/Logik-beispiel-korrekheitssatz.png differ diff --git a/Assets/Logik-deduktion-1.png b/Assets/Logik-deduktion-1.png new file mode 100644 index 0000000..59f919c Binary files /dev/null and b/Assets/Logik-deduktion-1.png differ diff --git a/Assets/Logik-deduktion-2.png b/Assets/Logik-deduktion-2.png new file mode 100644 index 0000000..1b989a4 Binary files /dev/null and b/Assets/Logik-deduktion-2.png differ diff --git a/Assets/Logik-deduktion-beispiel-2.png b/Assets/Logik-deduktion-beispiel-2.png new file mode 100644 index 0000000..d0c6b34 Binary files /dev/null and b/Assets/Logik-deduktion-beispiel-2.png differ diff --git a/Assets/Logik-deduktion-beispiel-3.png b/Assets/Logik-deduktion-beispiel-3.png new file mode 100644 index 0000000..91cac68 Binary files /dev/null and b/Assets/Logik-deduktion-beispiel-3.png differ diff --git a/Assets/Logik-deduktion-beispiel.png b/Assets/Logik-deduktion-beispiel.png new file mode 100644 index 0000000..e57ed9e Binary files /dev/null and b/Assets/Logik-deduktion-beispiel.png differ diff --git a/Assets/Logik-deduktion-konklusion.png b/Assets/Logik-deduktion-konklusion.png new file mode 100644 index 0000000..43c4b68 Binary files /dev/null and b/Assets/Logik-deduktion-konklusion.png differ diff --git a/Assets/Logik-deduktionsbaum.png b/Assets/Logik-deduktionsbaum.png new file mode 100644 index 0000000..dd7cc29 Binary files /dev/null and b/Assets/Logik-deduktionsbaum.png differ diff --git a/Assets/Logik-gleiches-für-gleiches-ausführlich.png b/Assets/Logik-gleiches-für-gleiches-ausführlich.png new file mode 100644 index 0000000..0ee5551 Binary files /dev/null and b/Assets/Logik-gleiches-für-gleiches-ausführlich.png differ diff --git a/Assets/Logik-gleiches-für-gleiches-kurz.png b/Assets/Logik-gleiches-für-gleiches-kurz.png new file mode 100644 index 0000000..08b7ac9 Binary files /dev/null and b/Assets/Logik-gleiches-für-gleiches-kurz.png differ diff --git a/Assets/Logik-konjunktionseinführung.png b/Assets/Logik-konjunktionseinführung.png new file mode 100644 index 0000000..69d71e9 Binary files /dev/null and b/Assets/Logik-konjunktionseinführung.png differ diff --git a/Assets/Logik-korrekheitssatz.png b/Assets/Logik-korrekheitssatz.png new file mode 100644 index 0000000..3da0823 Binary files /dev/null and b/Assets/Logik-korrekheitssatz.png differ diff --git a/Assets/Logik-lemma-v1-beweis.png b/Assets/Logik-lemma-v1-beweis.png new file mode 100644 index 0000000..a576daa Binary files /dev/null and b/Assets/Logik-lemma-v1-beweis.png differ diff --git a/Assets/Logik-logische-programmierung-einordnung.png b/Assets/Logik-logische-programmierung-einordnung.png new file mode 100644 index 0000000..99fc2ea Binary files /dev/null and b/Assets/Logik-logische-programmierung-einordnung.png differ diff --git a/Assets/Logik-parkettierung-1.png b/Assets/Logik-parkettierung-1.png new file mode 100644 index 0000000..a9e8bd9 Binary files /dev/null and b/Assets/Logik-parkettierung-1.png differ diff --git a/Assets/Logik-prolog-horn.png b/Assets/Logik-prolog-horn.png new file mode 100644 index 0000000..5ec20cc Binary files /dev/null and b/Assets/Logik-prolog-horn.png differ diff --git a/Assets/Logik-prolog-mit-unifikation.png b/Assets/Logik-prolog-mit-unifikation.png new file mode 100644 index 0000000..e4124be Binary files /dev/null and b/Assets/Logik-prolog-mit-unifikation.png differ diff --git a/Assets/Logik-prolog-ohne-unifikation.png b/Assets/Logik-prolog-ohne-unifikation.png new file mode 100644 index 0000000..3f642ab Binary files /dev/null and b/Assets/Logik-prolog-ohne-unifikation.png differ diff --git a/Assets/Logik-prädikate-suche-fail-2.png b/Assets/Logik-prädikate-suche-fail-2.png new file mode 100644 index 0000000..c7521ff Binary files /dev/null and b/Assets/Logik-prädikate-suche-fail-2.png differ diff --git a/Assets/Logik-prädikate-suche-fail.png b/Assets/Logik-prädikate-suche-fail.png new file mode 100644 index 0000000..1807bbe Binary files /dev/null and b/Assets/Logik-prädikate-suche-fail.png differ diff --git a/Assets/Logik-prädikate-suche.png b/Assets/Logik-prädikate-suche.png new file mode 100644 index 0000000..4821a3a Binary files /dev/null and b/Assets/Logik-prädikate-suche.png differ diff --git a/Assets/Logik-prädikatenlogik-graph.png b/Assets/Logik-prädikatenlogik-graph.png new file mode 100644 index 0000000..f058da7 Binary files /dev/null and b/Assets/Logik-prädikatenlogik-graph.png differ diff --git a/Assets/Logik-reductio-ad-absurdum.png b/Assets/Logik-reductio-ad-absurdum.png new file mode 100644 index 0000000..fdf4150 Binary files /dev/null and b/Assets/Logik-reductio-ad-absurdum.png differ diff --git a/Assets/Logik-reflexivität-kurz.png b/Assets/Logik-reflexivität-kurz.png new file mode 100644 index 0000000..ab9a127 Binary files /dev/null and b/Assets/Logik-reflexivität-kurz.png differ diff --git a/Assets/Logik-uebung6.png b/Assets/Logik-uebung6.png new file mode 100644 index 0000000..460e9d4 Binary files /dev/null and b/Assets/Logik-uebung6.png differ diff --git a/Assets/Logik-variableninterpretation-beispiel.png b/Assets/Logik-variableninterpretation-beispiel.png new file mode 100644 index 0000000..121dc85 Binary files /dev/null and b/Assets/Logik-variableninterpretation-beispiel.png differ diff --git a/Assets/Logik_allgemeinster-unifikator.png b/Assets/Logik_allgemeinster-unifikator.png new file mode 100644 index 0000000..0c17208 Binary files /dev/null and b/Assets/Logik_allgemeinster-unifikator.png differ diff --git a/Assets/MedizinischeInformatik_10-20.PNG b/Assets/MedizinischeInformatik_10-20.PNG new file mode 100644 index 0000000..4e53945 Binary files /dev/null and b/Assets/MedizinischeInformatik_10-20.PNG differ diff --git a/Assets/MedizinischeInformatik_Aktionspotential.svg b/Assets/MedizinischeInformatik_Aktionspotential.svg new file mode 100644 index 0000000..c579255 --- /dev/null +++ b/Assets/MedizinischeInformatik_Aktionspotential.svg @@ -0,0 +1,883 @@ + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Assets/MedizinischeInformatik_Anatomy_Heart_Latin_Tiesworks.jpg b/Assets/MedizinischeInformatik_Anatomy_Heart_Latin_Tiesworks.jpg new file mode 100644 index 0000000..ede04ee Binary files /dev/null and b/Assets/MedizinischeInformatik_Anatomy_Heart_Latin_Tiesworks.jpg differ diff --git a/Assets/MedizinischeInformatik_Defibrillator_Monitor_Closeup.jpg b/Assets/MedizinischeInformatik_Defibrillator_Monitor_Closeup.jpg new file mode 100644 index 0000000..91c17bc Binary files /dev/null and b/Assets/MedizinischeInformatik_Defibrillator_Monitor_Closeup.jpg differ diff --git a/Assets/MedizinischeInformatik_ECG_Principle_fast.gif b/Assets/MedizinischeInformatik_ECG_Principle_fast.gif new file mode 100644 index 0000000..38a3b88 Binary files /dev/null and b/Assets/MedizinischeInformatik_ECG_Principle_fast.gif differ diff --git a/Assets/MedizinischeInformatik_Gray_Surface-head.jpg b/Assets/MedizinischeInformatik_Gray_Surface-head.jpg new file mode 100644 index 0000000..1e62113 Binary files /dev/null and b/Assets/MedizinischeInformatik_Gray_Surface-head.jpg differ diff --git a/Assets/MedizinischeInformatik_International_10-20_system_for_EEG-MCN.png b/Assets/MedizinischeInformatik_International_10-20_system_for_EEG-MCN.png new file mode 100644 index 0000000..e49caf6 Binary files /dev/null and b/Assets/MedizinischeInformatik_International_10-20_system_for_EEG-MCN.png differ diff --git a/Assets/MedizinischeInformatik_Neuron_Hand-tuned.svg.png b/Assets/MedizinischeInformatik_Neuron_Hand-tuned.svg.png new file mode 100644 index 0000000..484e27a Binary files /dev/null and b/Assets/MedizinischeInformatik_Neuron_Hand-tuned.svg.png differ diff --git a/Assets/MedizinischeInformatik_Precordial_Leads_2.svg b/Assets/MedizinischeInformatik_Precordial_Leads_2.svg new file mode 100644 index 0000000..ead83d6 --- /dev/null +++ b/Assets/MedizinischeInformatik_Precordial_Leads_2.svg @@ -0,0 +1,816 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + V1 + + + + + V2 + + + + V4 + + + + V5 + + + + V6 + + + + V3 + + + + + + + + + diff --git a/Assets/NetworkSecurity-802.11-ad-hoc-architecture.png b/Assets/NetworkSecurity-802.11-ad-hoc-architecture.png new file mode 100644 index 0000000..0d06e4e Binary files /dev/null and b/Assets/NetworkSecurity-802.11-ad-hoc-architecture.png differ diff --git a/Assets/NetworkSecurity-802.11-network-architecture.png b/Assets/NetworkSecurity-802.11-network-architecture.png new file mode 100644 index 0000000..89061af Binary files /dev/null and b/Assets/NetworkSecurity-802.11-network-architecture.png differ diff --git a/Assets/NetworkSecurity-802.11-wep-decryption.png b/Assets/NetworkSecurity-802.11-wep-decryption.png new file mode 100644 index 0000000..3e3fcf2 Binary files /dev/null and b/Assets/NetworkSecurity-802.11-wep-decryption.png differ diff --git a/Assets/NetworkSecurity-802.11-wep-encryption.png b/Assets/NetworkSecurity-802.11-wep-encryption.png new file mode 100644 index 0000000..7b44eff Binary files /dev/null and b/Assets/NetworkSecurity-802.11-wep-encryption.png differ diff --git a/Assets/NetworkSecurity-AH-inbound-processing-1.png b/Assets/NetworkSecurity-AH-inbound-processing-1.png new file mode 100644 index 0000000..54379c4 Binary files /dev/null and b/Assets/NetworkSecurity-AH-inbound-processing-1.png differ diff --git a/Assets/NetworkSecurity-AH-inbound-processing-2.png b/Assets/NetworkSecurity-AH-inbound-processing-2.png new file mode 100644 index 0000000..2b35e3a Binary files /dev/null and b/Assets/NetworkSecurity-AH-inbound-processing-2.png differ diff --git a/Assets/NetworkSecurity-AH-outbound-processing.png b/Assets/NetworkSecurity-AH-outbound-processing.png new file mode 100644 index 0000000..ab7d11c Binary files /dev/null and b/Assets/NetworkSecurity-AH-outbound-processing.png differ diff --git a/Assets/NetworkSecurity-AH-prepare-header.png b/Assets/NetworkSecurity-AH-prepare-header.png new file mode 100644 index 0000000..121a4ab Binary files /dev/null and b/Assets/NetworkSecurity-AH-prepare-header.png differ diff --git a/Assets/NetworkSecurity-Authentication-relation-in-inter-networks.png b/Assets/NetworkSecurity-Authentication-relation-in-inter-networks.png new file mode 100644 index 0000000..be389bb Binary files /dev/null and b/Assets/NetworkSecurity-Authentication-relation-in-inter-networks.png differ diff --git a/Assets/NetworkSecurity-CBC-mac.png b/Assets/NetworkSecurity-CBC-mac.png new file mode 100644 index 0000000..f09d691 Binary files /dev/null and b/Assets/NetworkSecurity-CBC-mac.png differ diff --git a/Assets/NetworkSecurity-DMVPN.png b/Assets/NetworkSecurity-DMVPN.png new file mode 100644 index 0000000..87755f6 Binary files /dev/null and b/Assets/NetworkSecurity-DMVPN.png differ diff --git a/Assets/NetworkSecurity-ESP-inbound-processing-2.png b/Assets/NetworkSecurity-ESP-inbound-processing-2.png new file mode 100644 index 0000000..ab34548 Binary files /dev/null and b/Assets/NetworkSecurity-ESP-inbound-processing-2.png differ diff --git a/Assets/NetworkSecurity-ESP-inbound-processing.png b/Assets/NetworkSecurity-ESP-inbound-processing.png new file mode 100644 index 0000000..2b7a737 Binary files /dev/null and b/Assets/NetworkSecurity-ESP-inbound-processing.png differ diff --git a/Assets/NetworkSecurity-ESP-prepare-header.png b/Assets/NetworkSecurity-ESP-prepare-header.png new file mode 100644 index 0000000..6de20fe Binary files /dev/null and b/Assets/NetworkSecurity-ESP-prepare-header.png differ diff --git a/Assets/NetworkSecurity-ESP-processing.png b/Assets/NetworkSecurity-ESP-processing.png new file mode 100644 index 0000000..51584e9 Binary files /dev/null and b/Assets/NetworkSecurity-ESP-processing.png differ diff --git a/Assets/NetworkSecurity-ESP.png b/Assets/NetworkSecurity-ESP.png new file mode 100644 index 0000000..1f57885 Binary files /dev/null and b/Assets/NetworkSecurity-ESP.png differ diff --git a/Assets/NetworkSecurity-GET.png b/Assets/NetworkSecurity-GET.png new file mode 100644 index 0000000..ad76da5 Binary files /dev/null and b/Assets/NetworkSecurity-GET.png differ diff --git a/Assets/NetworkSecurity-IKE-aggressive-mode.png b/Assets/NetworkSecurity-IKE-aggressive-mode.png new file mode 100644 index 0000000..67a9f08 Binary files /dev/null and b/Assets/NetworkSecurity-IKE-aggressive-mode.png differ diff --git a/Assets/NetworkSecurity-IKE-exchange-payload-signature.png b/Assets/NetworkSecurity-IKE-exchange-payload-signature.png new file mode 100644 index 0000000..840ffa0 Binary files /dev/null and b/Assets/NetworkSecurity-IKE-exchange-payload-signature.png differ diff --git a/Assets/NetworkSecurity-IKE-exchange-payloads.png b/Assets/NetworkSecurity-IKE-exchange-payloads.png new file mode 100644 index 0000000..e9549f4 Binary files /dev/null and b/Assets/NetworkSecurity-IKE-exchange-payloads.png differ diff --git a/Assets/NetworkSecurity-IKE-exchange-public-key-2.png b/Assets/NetworkSecurity-IKE-exchange-public-key-2.png new file mode 100644 index 0000000..f25a6ff Binary files /dev/null and b/Assets/NetworkSecurity-IKE-exchange-public-key-2.png differ diff --git a/Assets/NetworkSecurity-IKE-exchange-public-key.png b/Assets/NetworkSecurity-IKE-exchange-public-key.png new file mode 100644 index 0000000..5fb375a Binary files /dev/null and b/Assets/NetworkSecurity-IKE-exchange-public-key.png differ diff --git a/Assets/NetworkSecurity-IKE-quick-mode.png b/Assets/NetworkSecurity-IKE-quick-mode.png new file mode 100644 index 0000000..1c5e0e9 Binary files /dev/null and b/Assets/NetworkSecurity-IKE-quick-mode.png differ diff --git a/Assets/NetworkSecurity-IKEv2-exchange-procedure.png b/Assets/NetworkSecurity-IKEv2-exchange-procedure.png new file mode 100644 index 0000000..9ce3db9 Binary files /dev/null and b/Assets/NetworkSecurity-IKEv2-exchange-procedure.png differ diff --git a/Assets/NetworkSecurity-IPsec-standardization.png b/Assets/NetworkSecurity-IPsec-standardization.png new file mode 100644 index 0000000..ebff72d Binary files /dev/null and b/Assets/NetworkSecurity-IPsec-standardization.png differ diff --git a/Assets/NetworkSecurity-ISAKMP-format.png b/Assets/NetworkSecurity-ISAKMP-format.png new file mode 100644 index 0000000..c620df1 Binary files /dev/null and b/Assets/NetworkSecurity-ISAKMP-format.png differ diff --git a/Assets/NetworkSecurity-ISAKMP-payload-types.png b/Assets/NetworkSecurity-ISAKMP-payload-types.png new file mode 100644 index 0000000..2ae6c29 Binary files /dev/null and b/Assets/NetworkSecurity-ISAKMP-payload-types.png differ diff --git a/Assets/NetworkSecurity-ISAKMP-payload.png b/Assets/NetworkSecurity-ISAKMP-payload.png new file mode 100644 index 0000000..6075beb Binary files /dev/null and b/Assets/NetworkSecurity-ISAKMP-payload.png differ diff --git a/Assets/NetworkSecurity-ISAKMP-proposal-payload.png b/Assets/NetworkSecurity-ISAKMP-proposal-payload.png new file mode 100644 index 0000000..c5ddb4c Binary files /dev/null and b/Assets/NetworkSecurity-ISAKMP-proposal-payload.png differ diff --git a/Assets/NetworkSecurity-ISAKMP-security-payload.png b/Assets/NetworkSecurity-ISAKMP-security-payload.png new file mode 100644 index 0000000..39b278e Binary files /dev/null and b/Assets/NetworkSecurity-ISAKMP-security-payload.png differ diff --git a/Assets/NetworkSecurity-ISAKMP-transform-payload.png b/Assets/NetworkSecurity-ISAKMP-transform-payload.png new file mode 100644 index 0000000..a21460d Binary files /dev/null and b/Assets/NetworkSecurity-ISAKMP-transform-payload.png differ diff --git a/Assets/NetworkSecurity-Kerberos.png b/Assets/NetworkSecurity-Kerberos.png new file mode 100644 index 0000000..875a5d6 Binary files /dev/null and b/Assets/NetworkSecurity-Kerberos.png differ diff --git a/Assets/NetworkSecurity-Layer-relationship.png b/Assets/NetworkSecurity-Layer-relationship.png new file mode 100644 index 0000000..bc86b4f Binary files /dev/null and b/Assets/NetworkSecurity-Layer-relationship.png differ diff --git a/Assets/NetworkSecurity-NAT-BEET-mode.png b/Assets/NetworkSecurity-NAT-BEET-mode.png new file mode 100644 index 0000000..8527a7c Binary files /dev/null and b/Assets/NetworkSecurity-NAT-BEET-mode.png differ diff --git a/Assets/NetworkSecurity-NAT-encap-ESP.png b/Assets/NetworkSecurity-NAT-encap-ESP.png new file mode 100644 index 0000000..98c3617 Binary files /dev/null and b/Assets/NetworkSecurity-NAT-encap-ESP.png differ diff --git a/Assets/NetworkSecurity-NAT-example.png b/Assets/NetworkSecurity-NAT-example.png new file mode 100644 index 0000000..8598e24 Binary files /dev/null and b/Assets/NetworkSecurity-NAT-example.png differ diff --git a/Assets/NetworkSecurity-PPTP-Packet-Construction-at-Client.png b/Assets/NetworkSecurity-PPTP-Packet-Construction-at-Client.png new file mode 100644 index 0000000..5ce0654 Binary files /dev/null and b/Assets/NetworkSecurity-PPTP-Packet-Construction-at-Client.png differ diff --git a/Assets/NetworkSecurity-PPTP-Tunneling-Protocol.png b/Assets/NetworkSecurity-PPTP-Tunneling-Protocol.png new file mode 100644 index 0000000..bf048fc Binary files /dev/null and b/Assets/NetworkSecurity-PPTP-Tunneling-Protocol.png differ diff --git a/Assets/NetworkSecurity-PPTP-Tunneling-Protocol2.png b/Assets/NetworkSecurity-PPTP-Tunneling-Protocol2.png new file mode 100644 index 0000000..530bd8b Binary files /dev/null and b/Assets/NetworkSecurity-PPTP-Tunneling-Protocol2.png differ diff --git a/Assets/NetworkSecurity-Point-to-Point-CHAP1.png b/Assets/NetworkSecurity-Point-to-Point-CHAP1.png new file mode 100644 index 0000000..5bbfb48 Binary files /dev/null and b/Assets/NetworkSecurity-Point-to-Point-CHAP1.png differ diff --git a/Assets/NetworkSecurity-Point-to-Point-CHAP2.png b/Assets/NetworkSecurity-Point-to-Point-CHAP2.png new file mode 100644 index 0000000..3d75939 Binary files /dev/null and b/Assets/NetworkSecurity-Point-to-Point-CHAP2.png differ diff --git a/Assets/NetworkSecurity-Point-to-Point-DESE.png b/Assets/NetworkSecurity-Point-to-Point-DESE.png new file mode 100644 index 0000000..9bc216c Binary files /dev/null and b/Assets/NetworkSecurity-Point-to-Point-DESE.png differ diff --git a/Assets/NetworkSecurity-Point-to-Point-DESE2.png b/Assets/NetworkSecurity-Point-to-Point-DESE2.png new file mode 100644 index 0000000..fc1f57e Binary files /dev/null and b/Assets/NetworkSecurity-Point-to-Point-DESE2.png differ diff --git a/Assets/NetworkSecurity-Point-to-Point-LCP.png b/Assets/NetworkSecurity-Point-to-Point-LCP.png new file mode 100644 index 0000000..e855801 Binary files /dev/null and b/Assets/NetworkSecurity-Point-to-Point-LCP.png differ diff --git a/Assets/NetworkSecurity-Point-to-Point-format.png b/Assets/NetworkSecurity-Point-to-Point-format.png new file mode 100644 index 0000000..c323102 Binary files /dev/null and b/Assets/NetworkSecurity-Point-to-Point-format.png differ diff --git a/Assets/NetworkSecurity-Point-to-Point.png b/Assets/NetworkSecurity-Point-to-Point.png new file mode 100644 index 0000000..d6f9fbe Binary files /dev/null and b/Assets/NetworkSecurity-Point-to-Point.png differ diff --git a/Assets/NetworkSecurity-SOLID-topology-control.png b/Assets/NetworkSecurity-SOLID-topology-control.png new file mode 100644 index 0000000..496cbc7 Binary files /dev/null and b/Assets/NetworkSecurity-SOLID-topology-control.png differ diff --git a/Assets/NetworkSecurity-SOLID-topology.png b/Assets/NetworkSecurity-SOLID-topology.png new file mode 100644 index 0000000..657d69d Binary files /dev/null and b/Assets/NetworkSecurity-SOLID-topology.png differ diff --git a/Assets/NetworkSecurity-SSL-record-protocol.png b/Assets/NetworkSecurity-SSL-record-protocol.png new file mode 100644 index 0000000..662cccd Binary files /dev/null and b/Assets/NetworkSecurity-SSL-record-protocol.png differ diff --git a/Assets/NetworkSecurity-Security-service-dim-1.png b/Assets/NetworkSecurity-Security-service-dim-1.png new file mode 100644 index 0000000..dc6696d Binary files /dev/null and b/Assets/NetworkSecurity-Security-service-dim-1.png differ diff --git a/Assets/NetworkSecurity-Security-service-dim-2.png b/Assets/NetworkSecurity-Security-service-dim-2.png new file mode 100644 index 0000000..806ce09 Binary files /dev/null and b/Assets/NetworkSecurity-Security-service-dim-2.png differ diff --git a/Assets/NetworkSecurity-TED.png b/Assets/NetworkSecurity-TED.png new file mode 100644 index 0000000..30ba2b2 Binary files /dev/null and b/Assets/NetworkSecurity-TED.png differ diff --git a/Assets/NetworkSecurity-aes-ccmp-frame-format.png b/Assets/NetworkSecurity-aes-ccmp-frame-format.png new file mode 100644 index 0000000..1bac5bb Binary files /dev/null and b/Assets/NetworkSecurity-aes-ccmp-frame-format.png differ diff --git a/Assets/NetworkSecurity-authentication-header-2.png b/Assets/NetworkSecurity-authentication-header-2.png new file mode 100644 index 0000000..bc0a3a4 Binary files /dev/null and b/Assets/NetworkSecurity-authentication-header-2.png differ diff --git a/Assets/NetworkSecurity-authentication-header.png b/Assets/NetworkSecurity-authentication-header.png new file mode 100644 index 0000000..e599306 Binary files /dev/null and b/Assets/NetworkSecurity-authentication-header.png differ diff --git a/Assets/NetworkSecurity-cipher-block-chaining-mode.png b/Assets/NetworkSecurity-cipher-block-chaining-mode.png new file mode 100644 index 0000000..c63ad07 Binary files /dev/null and b/Assets/NetworkSecurity-cipher-block-chaining-mode.png differ diff --git a/Assets/NetworkSecurity-communication-endpoints.png b/Assets/NetworkSecurity-communication-endpoints.png new file mode 100644 index 0000000..27e0096 Binary files /dev/null and b/Assets/NetworkSecurity-communication-endpoints.png differ diff --git a/Assets/NetworkSecurity-communication-nesting-2.png b/Assets/NetworkSecurity-communication-nesting-2.png new file mode 100644 index 0000000..1963470 Binary files /dev/null and b/Assets/NetworkSecurity-communication-nesting-2.png differ diff --git a/Assets/NetworkSecurity-communication-nesting-3.png b/Assets/NetworkSecurity-communication-nesting-3.png new file mode 100644 index 0000000..26c98c5 Binary files /dev/null and b/Assets/NetworkSecurity-communication-nesting-3.png differ diff --git a/Assets/NetworkSecurity-communication-nesting.png b/Assets/NetworkSecurity-communication-nesting.png new file mode 100644 index 0000000..e085988 Binary files /dev/null and b/Assets/NetworkSecurity-communication-nesting.png differ diff --git a/Assets/NetworkSecurity-communication-tunneling.png b/Assets/NetworkSecurity-communication-tunneling.png new file mode 100644 index 0000000..d5476f5 Binary files /dev/null and b/Assets/NetworkSecurity-communication-tunneling.png differ diff --git a/Assets/NetworkSecurity-communication-tunnelung-2.png b/Assets/NetworkSecurity-communication-tunnelung-2.png new file mode 100644 index 0000000..89b6def Binary files /dev/null and b/Assets/NetworkSecurity-communication-tunnelung-2.png differ diff --git a/Assets/NetworkSecurity-des-algorithm.png b/Assets/NetworkSecurity-des-algorithm.png new file mode 100644 index 0000000..7dd7c24 Binary files /dev/null and b/Assets/NetworkSecurity-des-algorithm.png differ diff --git a/Assets/NetworkSecurity-des-single-iteration.png b/Assets/NetworkSecurity-des-single-iteration.png new file mode 100644 index 0000000..7b7e801 Binary files /dev/null and b/Assets/NetworkSecurity-des-single-iteration.png differ diff --git a/Assets/NetworkSecurity-dual-elliptic-curve-deterministic-random-bit-generator.png b/Assets/NetworkSecurity-dual-elliptic-curve-deterministic-random-bit-generator.png new file mode 100644 index 0000000..846a3e7 Binary files /dev/null and b/Assets/NetworkSecurity-dual-elliptic-curve-deterministic-random-bit-generator.png differ diff --git a/Assets/NetworkSecurity-ecc-1.png b/Assets/NetworkSecurity-ecc-1.png new file mode 100644 index 0000000..300c160 Binary files /dev/null and b/Assets/NetworkSecurity-ecc-1.png differ diff --git a/Assets/NetworkSecurity-ecc-2.png b/Assets/NetworkSecurity-ecc-2.png new file mode 100644 index 0000000..ce5f5da Binary files /dev/null and b/Assets/NetworkSecurity-ecc-2.png differ diff --git a/Assets/NetworkSecurity-ecc-3.png b/Assets/NetworkSecurity-ecc-3.png new file mode 100644 index 0000000..f812eae Binary files /dev/null and b/Assets/NetworkSecurity-ecc-3.png differ diff --git a/Assets/NetworkSecurity-ecc-4.png b/Assets/NetworkSecurity-ecc-4.png new file mode 100644 index 0000000..157e805 Binary files /dev/null and b/Assets/NetworkSecurity-ecc-4.png differ diff --git a/Assets/NetworkSecurity-ecc-5.png b/Assets/NetworkSecurity-ecc-5.png new file mode 100644 index 0000000..5ac4eac Binary files /dev/null and b/Assets/NetworkSecurity-ecc-5.png differ diff --git a/Assets/NetworkSecurity-electronic-code-book-mode.png b/Assets/NetworkSecurity-electronic-code-book-mode.png new file mode 100644 index 0000000..2d77551 Binary files /dev/null and b/Assets/NetworkSecurity-electronic-code-book-mode.png differ diff --git a/Assets/NetworkSecurity-feistel.png b/Assets/NetworkSecurity-feistel.png new file mode 100644 index 0000000..453100d Binary files /dev/null and b/Assets/NetworkSecurity-feistel.png differ diff --git a/Assets/NetworkSecurity-gcm.png b/Assets/NetworkSecurity-gcm.png new file mode 100644 index 0000000..8b92229 Binary files /dev/null and b/Assets/NetworkSecurity-gcm.png differ diff --git a/Assets/NetworkSecurity-gprs-handover-execution.png b/Assets/NetworkSecurity-gprs-handover-execution.png new file mode 100644 index 0000000..2b8bfef Binary files /dev/null and b/Assets/NetworkSecurity-gprs-handover-execution.png differ diff --git a/Assets/NetworkSecurity-gprs-logical-architecture.png b/Assets/NetworkSecurity-gprs-logical-architecture.png new file mode 100644 index 0000000..11aeda4 Binary files /dev/null and b/Assets/NetworkSecurity-gprs-logical-architecture.png differ diff --git a/Assets/NetworkSecurity-gprs-protocol-architecture.png b/Assets/NetworkSecurity-gprs-protocol-architecture.png new file mode 100644 index 0000000..d48def6 Binary files /dev/null and b/Assets/NetworkSecurity-gprs-protocol-architecture.png differ diff --git a/Assets/NetworkSecurity-gsm-authentication-2.png b/Assets/NetworkSecurity-gsm-authentication-2.png new file mode 100644 index 0000000..28617f7 Binary files /dev/null and b/Assets/NetworkSecurity-gsm-authentication-2.png differ diff --git a/Assets/NetworkSecurity-gsm-authentication.png b/Assets/NetworkSecurity-gsm-authentication.png new file mode 100644 index 0000000..954c3e6 Binary files /dev/null and b/Assets/NetworkSecurity-gsm-authentication.png differ diff --git a/Assets/NetworkSecurity-ieee802.1AE-frame.png b/Assets/NetworkSecurity-ieee802.1AE-frame.png new file mode 100644 index 0000000..8b4582f Binary files /dev/null and b/Assets/NetworkSecurity-ieee802.1AE-frame.png differ diff --git a/Assets/NetworkSecurity-ieee802.1X-example.png b/Assets/NetworkSecurity-ieee802.1X-example.png new file mode 100644 index 0000000..aba92d5 Binary files /dev/null and b/Assets/NetworkSecurity-ieee802.1X-example.png differ diff --git a/Assets/NetworkSecurity-ieee802.1X-ports.png b/Assets/NetworkSecurity-ieee802.1X-ports.png new file mode 100644 index 0000000..d46aa4d Binary files /dev/null and b/Assets/NetworkSecurity-ieee802.1X-ports.png differ diff --git a/Assets/NetworkSecurity-ieee802.1q-scenario.png b/Assets/NetworkSecurity-ieee802.1q-scenario.png new file mode 100644 index 0000000..711acdf Binary files /dev/null and b/Assets/NetworkSecurity-ieee802.1q-scenario.png differ diff --git a/Assets/NetworkSecurity-ipsec-AH.png b/Assets/NetworkSecurity-ipsec-AH.png new file mode 100644 index 0000000..f9e3301 Binary files /dev/null and b/Assets/NetworkSecurity-ipsec-AH.png differ diff --git a/Assets/NetworkSecurity-ipsec-ESP.png b/Assets/NetworkSecurity-ipsec-ESP.png new file mode 100644 index 0000000..3437294 Binary files /dev/null and b/Assets/NetworkSecurity-ipsec-ESP.png differ diff --git a/Assets/NetworkSecurity-ipsec-protect-payload.png b/Assets/NetworkSecurity-ipsec-protect-payload.png new file mode 100644 index 0000000..73fc511 Binary files /dev/null and b/Assets/NetworkSecurity-ipsec-protect-payload.png differ diff --git a/Assets/NetworkSecurity-ipsec-replay-protection.png b/Assets/NetworkSecurity-ipsec-replay-protection.png new file mode 100644 index 0000000..5a59e10 Binary files /dev/null and b/Assets/NetworkSecurity-ipsec-replay-protection.png differ diff --git a/Assets/NetworkSecurity-ipsec-replay-protection2.png b/Assets/NetworkSecurity-ipsec-replay-protection2.png new file mode 100644 index 0000000..8204ea5 Binary files /dev/null and b/Assets/NetworkSecurity-ipsec-replay-protection2.png differ diff --git a/Assets/NetworkSecurity-ipsec-router-implementation.png b/Assets/NetworkSecurity-ipsec-router-implementation.png new file mode 100644 index 0000000..9c91091 Binary files /dev/null and b/Assets/NetworkSecurity-ipsec-router-implementation.png differ diff --git a/Assets/NetworkSecurity-ipsec-transport-mode.png b/Assets/NetworkSecurity-ipsec-transport-mode.png new file mode 100644 index 0000000..4b7349a Binary files /dev/null and b/Assets/NetworkSecurity-ipsec-transport-mode.png differ diff --git a/Assets/NetworkSecurity-ipsec-tunnel-mode.png b/Assets/NetworkSecurity-ipsec-tunnel-mode.png new file mode 100644 index 0000000..396f852 Binary files /dev/null and b/Assets/NetworkSecurity-ipsec-tunnel-mode.png differ diff --git a/Assets/NetworkSecurity-ipv4-packet-format.png b/Assets/NetworkSecurity-ipv4-packet-format.png new file mode 100644 index 0000000..3032339 Binary files /dev/null and b/Assets/NetworkSecurity-ipv4-packet-format.png differ diff --git a/Assets/NetworkSecurity-kasumi-singe-iteration.png b/Assets/NetworkSecurity-kasumi-singe-iteration.png new file mode 100644 index 0000000..d9514d6 Binary files /dev/null and b/Assets/NetworkSecurity-kasumi-singe-iteration.png differ diff --git a/Assets/NetworkSecurity-md5.png b/Assets/NetworkSecurity-md5.png new file mode 100644 index 0000000..91d8e26 Binary files /dev/null and b/Assets/NetworkSecurity-md5.png differ diff --git a/Assets/NetworkSecurity-multi-domain-kerberos.png b/Assets/NetworkSecurity-multi-domain-kerberos.png new file mode 100644 index 0000000..5c319b7 Binary files /dev/null and b/Assets/NetworkSecurity-multi-domain-kerberos.png differ diff --git a/Assets/NetworkSecurity-output-feedback-mode.png b/Assets/NetworkSecurity-output-feedback-mode.png new file mode 100644 index 0000000..9784ee5 Binary files /dev/null and b/Assets/NetworkSecurity-output-feedback-mode.png differ diff --git a/Assets/NetworkSecurity-proactive-multicast-discovery.png b/Assets/NetworkSecurity-proactive-multicast-discovery.png new file mode 100644 index 0000000..1308bc8 Binary files /dev/null and b/Assets/NetworkSecurity-proactive-multicast-discovery.png differ diff --git a/Assets/NetworkSecurity-reference-monitor.png b/Assets/NetworkSecurity-reference-monitor.png new file mode 100644 index 0000000..a309e30 Binary files /dev/null and b/Assets/NetworkSecurity-reference-monitor.png differ diff --git a/Assets/NetworkSecurity-rijndael-one-round.png b/Assets/NetworkSecurity-rijndael-one-round.png new file mode 100644 index 0000000..5269d65 Binary files /dev/null and b/Assets/NetworkSecurity-rijndael-one-round.png differ diff --git a/Assets/NetworkSecurity-secure-network-model.png b/Assets/NetworkSecurity-secure-network-model.png new file mode 100644 index 0000000..b144677 Binary files /dev/null and b/Assets/NetworkSecurity-secure-network-model.png differ diff --git a/Assets/NetworkSecurity-sha-2.png b/Assets/NetworkSecurity-sha-2.png new file mode 100644 index 0000000..bbd384e Binary files /dev/null and b/Assets/NetworkSecurity-sha-2.png differ diff --git a/Assets/NetworkSecurity-sha-3.png b/Assets/NetworkSecurity-sha-3.png new file mode 100644 index 0000000..97e61f6 Binary files /dev/null and b/Assets/NetworkSecurity-sha-3.png differ diff --git a/Assets/NetworkSecurity-sha1.png b/Assets/NetworkSecurity-sha1.png new file mode 100644 index 0000000..b9b1109 Binary files /dev/null and b/Assets/NetworkSecurity-sha1.png differ diff --git a/Assets/NetworkSecurity-sponge-wrap.png b/Assets/NetworkSecurity-sponge-wrap.png new file mode 100644 index 0000000..90d9b82 Binary files /dev/null and b/Assets/NetworkSecurity-sponge-wrap.png differ diff --git a/Assets/NetworkSecurity-ssh-transport-protocol-packet.png b/Assets/NetworkSecurity-ssh-transport-protocol-packet.png new file mode 100644 index 0000000..e929338 Binary files /dev/null and b/Assets/NetworkSecurity-ssh-transport-protocol-packet.png differ diff --git a/Assets/NetworkSecurity-ssl-protocol-architecture.png b/Assets/NetworkSecurity-ssl-protocol-architecture.png new file mode 100644 index 0000000..96723bb Binary files /dev/null and b/Assets/NetworkSecurity-ssl-protocol-architecture.png differ diff --git a/Assets/NetworkSecurity-tcp-ip-suite.png b/Assets/NetworkSecurity-tcp-ip-suite.png new file mode 100644 index 0000000..13fc39d Binary files /dev/null and b/Assets/NetworkSecurity-tcp-ip-suite.png differ diff --git a/Assets/NetworkSecurity-tkip-mpdu-data-format.png b/Assets/NetworkSecurity-tkip-mpdu-data-format.png new file mode 100644 index 0000000..d9a8007 Binary files /dev/null and b/Assets/NetworkSecurity-tkip-mpdu-data-format.png differ diff --git a/Assets/NetworkSecurity-tkip-processing.png b/Assets/NetworkSecurity-tkip-processing.png new file mode 100644 index 0000000..2f43ba9 Binary files /dev/null and b/Assets/NetworkSecurity-tkip-processing.png differ diff --git a/Assets/NetworkSecurity-tkip-receiver.png b/Assets/NetworkSecurity-tkip-receiver.png new file mode 100644 index 0000000..0eb26ec Binary files /dev/null and b/Assets/NetworkSecurity-tkip-receiver.png differ diff --git a/Assets/NetworkSecurity-tkip-rekey.png b/Assets/NetworkSecurity-tkip-rekey.png new file mode 100644 index 0000000..85ee70f Binary files /dev/null and b/Assets/NetworkSecurity-tkip-rekey.png differ diff --git a/Assets/NetworkSecurity-tkip-replay-protection.png b/Assets/NetworkSecurity-tkip-replay-protection.png new file mode 100644 index 0000000..0d3cf6b Binary files /dev/null and b/Assets/NetworkSecurity-tkip-replay-protection.png differ diff --git a/Assets/NetworkSecurity-umts-authentication-mechanism.png b/Assets/NetworkSecurity-umts-authentication-mechanism.png new file mode 100644 index 0000000..4e44788 Binary files /dev/null and b/Assets/NetworkSecurity-umts-authentication-mechanism.png differ diff --git a/Assets/NetworkSecurity-umts-authentication-vectors.png b/Assets/NetworkSecurity-umts-authentication-vectors.png new file mode 100644 index 0000000..bc318a5 Binary files /dev/null and b/Assets/NetworkSecurity-umts-authentication-vectors.png differ diff --git a/Assets/NetworkSecurity-umts-security-architecture.png b/Assets/NetworkSecurity-umts-security-architecture.png new file mode 100644 index 0000000..b4e5652 Binary files /dev/null and b/Assets/NetworkSecurity-umts-security-architecture.png differ diff --git a/Assets/NetworkSecurity-umts-user-authentication-usim.png b/Assets/NetworkSecurity-umts-user-authentication-usim.png new file mode 100644 index 0000000..d8ee0ee Binary files /dev/null and b/Assets/NetworkSecurity-umts-user-authentication-usim.png differ diff --git a/Assets/NetworkSecurity-x509-certificates.png b/Assets/NetworkSecurity-x509-certificates.png new file mode 100644 index 0000000..2b8098a Binary files /dev/null and b/Assets/NetworkSecurity-x509-certificates.png differ diff --git a/Assets/NetworkSecurity-x509-hierarchy.png b/Assets/NetworkSecurity-x509-hierarchy.png new file mode 100644 index 0000000..0b22eb5 Binary files /dev/null and b/Assets/NetworkSecurity-x509-hierarchy.png differ diff --git a/Assets/Neurowissenschaften-Catechol.png b/Assets/Neurowissenschaften-Catechol.png new file mode 100644 index 0000000..5f8a34c Binary files /dev/null and b/Assets/Neurowissenschaften-Catechol.png differ diff --git a/Assets/Neurowissenschaften-Nervensystem-gesamt.png b/Assets/Neurowissenschaften-Nervensystem-gesamt.png new file mode 100644 index 0000000..f867d2a Binary files /dev/null and b/Assets/Neurowissenschaften-Nervensystem-gesamt.png differ diff --git a/Assets/Neurowissenschaften-acetylocholin.png b/Assets/Neurowissenschaften-acetylocholin.png new file mode 100644 index 0000000..299e9d8 Binary files /dev/null and b/Assets/Neurowissenschaften-acetylocholin.png differ diff --git a/Assets/Neurowissenschaften-archicortex.png b/Assets/Neurowissenschaften-archicortex.png new file mode 100644 index 0000000..522440b Binary files /dev/null and b/Assets/Neurowissenschaften-archicortex.png differ diff --git a/Assets/Neurowissenschaften-aspartat.png b/Assets/Neurowissenschaften-aspartat.png new file mode 100644 index 0000000..4358319 Binary files /dev/null and b/Assets/Neurowissenschaften-aspartat.png differ diff --git a/Assets/Neurowissenschaften-axon.png b/Assets/Neurowissenschaften-axon.png new file mode 100644 index 0000000..2cc164e Binary files /dev/null and b/Assets/Neurowissenschaften-axon.png differ diff --git a/Assets/Neurowissenschaften-chemische-synapsen-verknüpfung.png b/Assets/Neurowissenschaften-chemische-synapsen-verknüpfung.png new file mode 100644 index 0000000..dc25081 Binary files /dev/null and b/Assets/Neurowissenschaften-chemische-synapsen-verknüpfung.png differ diff --git a/Assets/Neurowissenschaften-chemische-synapsen.png b/Assets/Neurowissenschaften-chemische-synapsen.png new file mode 100644 index 0000000..fba32fd Binary files /dev/null and b/Assets/Neurowissenschaften-chemische-synapsen.png differ diff --git a/Assets/Neurowissenschaften-ebenen.png b/Assets/Neurowissenschaften-ebenen.png new file mode 100644 index 0000000..33e0566 Binary files /dev/null and b/Assets/Neurowissenschaften-ebenen.png differ diff --git a/Assets/Neurowissenschaften-ebenen.svg b/Assets/Neurowissenschaften-ebenen.svg new file mode 100644 index 0000000..4cd4162 --- /dev/null +++ b/Assets/Neurowissenschaften-ebenen.svg @@ -0,0 +1,598 @@ + + + + + Neurowissenschaften Ebenen + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + Neurowissenschaften Ebenen + + + Robert Jeutter + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Anterior,Rostral + Dorsal,Superior + Posterior,Kaudal + Ventral,Inferior + Ventral + Dorsal + Posterior + Anterior + Lateral + Medial + Proximal + Distal + Sagittal-Ebene + Frontalebene(koronal) + + diff --git a/Assets/Neurowissenschaften-gaba.png b/Assets/Neurowissenschaften-gaba.png new file mode 100644 index 0000000..78739ac Binary files /dev/null and b/Assets/Neurowissenschaften-gaba.png differ diff --git a/Assets/Neurowissenschaften-gehirn.png b/Assets/Neurowissenschaften-gehirn.png new file mode 100644 index 0000000..fa9846f Binary files /dev/null and b/Assets/Neurowissenschaften-gehirn.png differ diff --git a/Assets/Neurowissenschaften-gehirn.svg b/Assets/Neurowissenschaften-gehirn.svg new file mode 100644 index 0000000..8dbfc55 --- /dev/null +++ b/Assets/Neurowissenschaften-gehirn.svg @@ -0,0 +1,736 @@ + + + + + Gehrin + + + + + + image/svg+xml + + Gehrin + + + Robert Jeutter + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Kleinhirn (Cerebellum) + Hinterhautlappen + Temporallappen + Riechkolben + Frontallappen + Primär-motorische Rinde + Primärer somatosensorischer Kortex + Hyptothalamus + Mittelhirn + Brücke + verlängertes Rückenmark + Rückenmark + Scheitellappen + Balken + Thalamus + Hypophyse + Zwischenhirn + Impulskontrolle, + Persönlichkeit, + sozial Verhalten + Bewegung + Wahrnehmung aus Körper + Sensorik, Lesen, Sprache + Hören, Sprechen, + Sehen, + Feinmotorik, Balance + (Medulla oblongata) + (Medulla spinalis) + (Pons) + (Mesencephalon) + (Diencephalon) + (Corpus collosum) + Gedächtnis, Gefühle + Atmung, Herzrate, Temperatur + Wahrnehmung + räumliches Denken + + + + + + + + + + + + + + + + + + + + + + diff --git a/Assets/Neurowissenschaften-glutamat.png b/Assets/Neurowissenschaften-glutamat.png new file mode 100644 index 0000000..72a8fbf Binary files /dev/null and b/Assets/Neurowissenschaften-glutamat.png differ diff --git a/Assets/Neurowissenschaften-glycin.png b/Assets/Neurowissenschaften-glycin.png new file mode 100644 index 0000000..a335c4e Binary files /dev/null and b/Assets/Neurowissenschaften-glycin.png differ diff --git a/Assets/Neurowissenschaften-histamin.png b/Assets/Neurowissenschaften-histamin.png new file mode 100644 index 0000000..da6cf8e Binary files /dev/null and b/Assets/Neurowissenschaften-histamin.png differ diff --git a/Assets/Neurowissenschaften-hypothalamus.png b/Assets/Neurowissenschaften-hypothalamus.png new file mode 100644 index 0000000..b31cbe2 Binary files /dev/null and b/Assets/Neurowissenschaften-hypothalamus.png differ diff --git a/Assets/Neurowissenschaften-neuron.png b/Assets/Neurowissenschaften-neuron.png new file mode 100644 index 0000000..cd81dfe Binary files /dev/null and b/Assets/Neurowissenschaften-neuron.png differ diff --git a/Assets/Neurowissenschaften-neuron.svg b/Assets/Neurowissenschaften-neuron.svg new file mode 100644 index 0000000..54e39fe --- /dev/null +++ b/Assets/Neurowissenschaften-neuron.svg @@ -0,0 +1,438 @@ + + + + + Neurowissenschaften Neuron + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + Neurowissenschaften Neuron + + + Robert Jeutter + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Soma + Dentrit + Schwann'scheZelle + Ranvier'scherSchnürring + Kolatterale + Terminale,Synapse + Zellkern + Axon + + diff --git a/Assets/Neurowissenschaften-neurotransmitter.png b/Assets/Neurowissenschaften-neurotransmitter.png new file mode 100644 index 0000000..090ecef Binary files /dev/null and b/Assets/Neurowissenschaften-neurotransmitter.png differ diff --git a/Assets/Neurowissenschaften-orientierung-1.png b/Assets/Neurowissenschaften-orientierung-1.png new file mode 100644 index 0000000..d3e63f9 Binary files /dev/null and b/Assets/Neurowissenschaften-orientierung-1.png differ diff --git a/Assets/Neurowissenschaften-orientierung-2.png b/Assets/Neurowissenschaften-orientierung-2.png new file mode 100644 index 0000000..0e186f6 Binary files /dev/null and b/Assets/Neurowissenschaften-orientierung-2.png differ diff --git a/Assets/Neurowissenschaften-periphere-nerven-2.png b/Assets/Neurowissenschaften-periphere-nerven-2.png new file mode 100644 index 0000000..47ef7f7 Binary files /dev/null and b/Assets/Neurowissenschaften-periphere-nerven-2.png differ diff --git a/Assets/Neurowissenschaften-periphere-nerven-3.png b/Assets/Neurowissenschaften-periphere-nerven-3.png new file mode 100644 index 0000000..d803c1f Binary files /dev/null and b/Assets/Neurowissenschaften-periphere-nerven-3.png differ diff --git a/Assets/Neurowissenschaften-rückemark.svg b/Assets/Neurowissenschaften-rückemark.svg new file mode 100644 index 0000000..903983a --- /dev/null +++ b/Assets/Neurowissenschaften-rückemark.svg @@ -0,0 +1,1790 @@ + + + + + Rückenmark + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + Rückenmark + + + Robert Jeutter + + + + + + + + + + + + + + + + + + + + + + + + + + + graue Substanz + weiße Substanz + Zentralkanal + Dura Mater + Pia Mater + vordere Wurzel + Spinalnerv + Spinalganglion + + + + + + + + + + + + diff --git a/Assets/Neurowissenschaften-rückenmark.png b/Assets/Neurowissenschaften-rückenmark.png new file mode 100644 index 0000000..9ebe1f1 Binary files /dev/null and b/Assets/Neurowissenschaften-rückenmark.png differ diff --git a/Assets/Neurowissenschaften-serotonin.png b/Assets/Neurowissenschaften-serotonin.png new file mode 100644 index 0000000..220e74c Binary files /dev/null and b/Assets/Neurowissenschaften-serotonin.png differ diff --git a/Assets/Neurowissenschaften-zunge.png b/Assets/Neurowissenschaften-zunge.png new file mode 100644 index 0000000..d013c02 Binary files /dev/null and b/Assets/Neurowissenschaften-zunge.png differ diff --git a/Assets/Neurowissenschaften-zunge.svg b/Assets/Neurowissenschaften-zunge.svg new file mode 100644 index 0000000..7506549 --- /dev/null +++ b/Assets/Neurowissenschaften-zunge.svg @@ -0,0 +1,189 @@ + + + Zunge + + + + image/svg+xml + + Zunge + + + + Robert Jeutter + + + + + + + + + + + + + + + + + + + + + + + + + + Umami Bitter + Sauer + Sauer + Süß + Salzig + diff --git a/Assets/PraktikumSchaltsysteme.jpeg b/Assets/PraktikumSchaltsysteme.jpeg new file mode 100644 index 0000000..2a81c9d Binary files /dev/null and b/Assets/PraktikumSchaltsysteme.jpeg differ diff --git a/Assets/Programmierparadigmen-Aktormodell.png b/Assets/Programmierparadigmen-Aktormodell.png new file mode 100644 index 0000000..8127f16 Binary files /dev/null and b/Assets/Programmierparadigmen-Aktormodell.png differ diff --git a/Assets/Programmierparadigmen-Architekturen.png b/Assets/Programmierparadigmen-Architekturen.png new file mode 100644 index 0000000..1e2415f Binary files /dev/null and b/Assets/Programmierparadigmen-Architekturen.png differ diff --git a/Assets/Programmierparadigmen-Arithmetische-Operationen-2.png b/Assets/Programmierparadigmen-Arithmetische-Operationen-2.png new file mode 100644 index 0000000..6e7ff43 Binary files /dev/null and b/Assets/Programmierparadigmen-Arithmetische-Operationen-2.png differ diff --git a/Assets/Programmierparadigmen-Arithmetische-Operationen.png b/Assets/Programmierparadigmen-Arithmetische-Operationen.png new file mode 100644 index 0000000..e58d17c Binary files /dev/null and b/Assets/Programmierparadigmen-Arithmetische-Operationen.png differ diff --git a/Assets/Programmierparadigmen-CPU-vs-GPU.png b/Assets/Programmierparadigmen-CPU-vs-GPU.png new file mode 100644 index 0000000..c7f68b6 Binary files /dev/null and b/Assets/Programmierparadigmen-CPU-vs-GPU.png differ diff --git a/Assets/Programmierparadigmen-Datenparallelität.png b/Assets/Programmierparadigmen-Datenparallelität.png new file mode 100644 index 0000000..2f9fb79 Binary files /dev/null and b/Assets/Programmierparadigmen-Datenparallelität.png differ diff --git a/Assets/Programmierparadigmen-Instruktionsparallelität.png b/Assets/Programmierparadigmen-Instruktionsparallelität.png new file mode 100644 index 0000000..8ab2d7d Binary files /dev/null and b/Assets/Programmierparadigmen-Instruktionsparallelität.png differ diff --git a/Assets/Programmierparadigmen-Lambda_Abstraktion.png b/Assets/Programmierparadigmen-Lambda_Abstraktion.png new file mode 100644 index 0000000..a257825 Binary files /dev/null and b/Assets/Programmierparadigmen-Lambda_Abstraktion.png differ diff --git a/Assets/Programmierparadigmen-Multicore-Systeme.png b/Assets/Programmierparadigmen-Multicore-Systeme.png new file mode 100644 index 0000000..54a8ba5 Binary files /dev/null and b/Assets/Programmierparadigmen-Multicore-Systeme.png differ diff --git a/Assets/Programmierparadigmen-Multiprozessorsysteme.png b/Assets/Programmierparadigmen-Multiprozessorsysteme.png new file mode 100644 index 0000000..db33c70 Binary files /dev/null and b/Assets/Programmierparadigmen-Multiprozessorsysteme.png differ diff --git a/Assets/Programmierparadigmen-NUMA.png b/Assets/Programmierparadigmen-NUMA.png new file mode 100644 index 0000000..7361ee8 Binary files /dev/null and b/Assets/Programmierparadigmen-NUMA.png differ diff --git a/Assets/Programmierparadigmen-Programmiermodelle.png b/Assets/Programmierparadigmen-Programmiermodelle.png new file mode 100644 index 0000000..25d0aa3 Binary files /dev/null and b/Assets/Programmierparadigmen-Programmiermodelle.png differ diff --git a/Assets/Programmierparadigmen-SMP Erlang.png b/Assets/Programmierparadigmen-SMP Erlang.png new file mode 100644 index 0000000..883fc2c Binary files /dev/null and b/Assets/Programmierparadigmen-SMP Erlang.png differ diff --git a/Assets/Programmierparadigmen-SMP.png b/Assets/Programmierparadigmen-SMP.png new file mode 100644 index 0000000..c63d3db Binary files /dev/null and b/Assets/Programmierparadigmen-SMP.png differ diff --git a/Assets/Programmierparadigmen-Shared-Memory-vs-Message-Passing.png b/Assets/Programmierparadigmen-Shared-Memory-vs-Message-Passing.png new file mode 100644 index 0000000..ba58aa3 Binary files /dev/null and b/Assets/Programmierparadigmen-Shared-Memory-vs-Message-Passing.png differ diff --git a/Assets/Programmierparadigmen-Speedup-Bestimmung.png b/Assets/Programmierparadigmen-Speedup-Bestimmung.png new file mode 100644 index 0000000..0b76e3f Binary files /dev/null and b/Assets/Programmierparadigmen-Speedup-Bestimmung.png differ diff --git a/Assets/Programmierparadigmen-Speedup-Diskussion.png b/Assets/Programmierparadigmen-Speedup-Diskussion.png new file mode 100644 index 0000000..7a568ad Binary files /dev/null and b/Assets/Programmierparadigmen-Speedup-Diskussion.png differ diff --git a/Assets/Programmierparadigmen-Taskparallelität.png b/Assets/Programmierparadigmen-Taskparallelität.png new file mode 100644 index 0000000..1fc4efa Binary files /dev/null and b/Assets/Programmierparadigmen-Taskparallelität.png differ diff --git a/Assets/Programmierparadigmen-alternate-bit-protokoll.png b/Assets/Programmierparadigmen-alternate-bit-protokoll.png new file mode 100644 index 0000000..79561b4 Binary files /dev/null and b/Assets/Programmierparadigmen-alternate-bit-protokoll.png differ diff --git a/Assets/Programmierparadigmen-amdahlsches-gesetz.png b/Assets/Programmierparadigmen-amdahlsches-gesetz.png new file mode 100644 index 0000000..8e5503e Binary files /dev/null and b/Assets/Programmierparadigmen-amdahlsches-gesetz.png differ diff --git a/Assets/Programmierparadigmen-asynchron-empfangen.png b/Assets/Programmierparadigmen-asynchron-empfangen.png new file mode 100644 index 0000000..e96970e Binary files /dev/null and b/Assets/Programmierparadigmen-asynchron-empfangen.png differ diff --git a/Assets/Programmierparadigmen-asynchrones-senden.png b/Assets/Programmierparadigmen-asynchrones-senden.png new file mode 100644 index 0000000..5506a86 Binary files /dev/null and b/Assets/Programmierparadigmen-asynchrones-senden.png differ diff --git a/Assets/Programmierparadigmen-aws-lambda-designer.png b/Assets/Programmierparadigmen-aws-lambda-designer.png new file mode 100644 index 0000000..f7cb0e2 Binary files /dev/null and b/Assets/Programmierparadigmen-aws-lambda-designer.png differ diff --git a/Assets/Programmierparadigmen-aws-produkte.png b/Assets/Programmierparadigmen-aws-produkte.png new file mode 100644 index 0000000..c7af813 Binary files /dev/null and b/Assets/Programmierparadigmen-aws-produkte.png differ diff --git a/Assets/Programmierparadigmen-cloud-architekturen.png b/Assets/Programmierparadigmen-cloud-architekturen.png new file mode 100644 index 0000000..efeff11 Binary files /dev/null and b/Assets/Programmierparadigmen-cloud-architekturen.png differ diff --git a/Assets/Programmierparadigmen-diamant-beispiel.png b/Assets/Programmierparadigmen-diamant-beispiel.png new file mode 100644 index 0000000..72f55d3 Binary files /dev/null and b/Assets/Programmierparadigmen-diamant-beispiel.png differ diff --git a/Assets/Programmierparadigmen-diamant-eigenschaft.png b/Assets/Programmierparadigmen-diamant-eigenschaft.png new file mode 100644 index 0000000..063ee47 Binary files /dev/null and b/Assets/Programmierparadigmen-diamant-eigenschaft.png differ diff --git a/Assets/Programmierparadigmen-einordnung-programmierung.png b/Assets/Programmierparadigmen-einordnung-programmierung.png new file mode 100644 index 0000000..c6ee18e Binary files /dev/null and b/Assets/Programmierparadigmen-einordnung-programmierung.png differ diff --git a/Assets/Programmierparadigmen-ereignisbasiertes-modell.png b/Assets/Programmierparadigmen-ereignisbasiertes-modell.png new file mode 100644 index 0000000..3d82a04 Binary files /dev/null and b/Assets/Programmierparadigmen-ereignisbasiertes-modell.png differ diff --git a/Assets/Programmierparadigmen-erlang-Beispiele.png b/Assets/Programmierparadigmen-erlang-Beispiele.png new file mode 100644 index 0000000..ede99af Binary files /dev/null and b/Assets/Programmierparadigmen-erlang-Beispiele.png differ diff --git a/Assets/Programmierparadigmen-erlang-map.png b/Assets/Programmierparadigmen-erlang-map.png new file mode 100644 index 0000000..c8258b8 Binary files /dev/null and b/Assets/Programmierparadigmen-erlang-map.png differ diff --git a/Assets/Programmierparadigmen-erlang-reduce-parallel.png b/Assets/Programmierparadigmen-erlang-reduce-parallel.png new file mode 100644 index 0000000..c9df5e8 Binary files /dev/null and b/Assets/Programmierparadigmen-erlang-reduce-parallel.png differ diff --git a/Assets/Programmierparadigmen-erlang-reduce.png b/Assets/Programmierparadigmen-erlang-reduce.png new file mode 100644 index 0000000..ef0a1bc Binary files /dev/null and b/Assets/Programmierparadigmen-erlang-reduce.png differ diff --git a/Assets/Programmierparadigmen-erlang-scheduler.png b/Assets/Programmierparadigmen-erlang-scheduler.png new file mode 100644 index 0000000..6badeb3 Binary files /dev/null and b/Assets/Programmierparadigmen-erlang-scheduler.png differ diff --git a/Assets/Programmierparadigmen-erlang-überwachung.png b/Assets/Programmierparadigmen-erlang-überwachung.png new file mode 100644 index 0000000..29591f0 Binary files /dev/null and b/Assets/Programmierparadigmen-erlang-überwachung.png differ diff --git a/Assets/Programmierparadigmen-flynn-architekturklassifikation.png b/Assets/Programmierparadigmen-flynn-architekturklassifikation.png new file mode 100644 index 0000000..bbec0a2 Binary files /dev/null and b/Assets/Programmierparadigmen-flynn-architekturklassifikation.png differ diff --git a/Assets/Programmierparadigmen-future-task.png b/Assets/Programmierparadigmen-future-task.png new file mode 100644 index 0000000..86d8e3e Binary files /dev/null and b/Assets/Programmierparadigmen-future-task.png differ diff --git a/Assets/Programmierparadigmen-grpc.png b/Assets/Programmierparadigmen-grpc.png new file mode 100644 index 0000000..c75ea88 Binary files /dev/null and b/Assets/Programmierparadigmen-grpc.png differ diff --git a/Assets/Programmierparadigmen-java-synchronized.png b/Assets/Programmierparadigmen-java-synchronized.png new file mode 100644 index 0000000..a648ccb Binary files /dev/null and b/Assets/Programmierparadigmen-java-synchronized.png differ diff --git a/Assets/Programmierparadigmen-javaSpaces.png b/Assets/Programmierparadigmen-javaSpaces.png new file mode 100644 index 0000000..fec0fb7 Binary files /dev/null and b/Assets/Programmierparadigmen-javaSpaces.png differ diff --git a/Assets/Programmierparadigmen-kodierung-natürlicher-zahlen.png b/Assets/Programmierparadigmen-kodierung-natürlicher-zahlen.png new file mode 100644 index 0000000..04d2237 Binary files /dev/null and b/Assets/Programmierparadigmen-kodierung-natürlicher-zahlen.png differ diff --git a/Assets/Programmierparadigmen-kommunikation-fehler-2.png b/Assets/Programmierparadigmen-kommunikation-fehler-2.png new file mode 100644 index 0000000..62d64bd Binary files /dev/null and b/Assets/Programmierparadigmen-kommunikation-fehler-2.png differ diff --git a/Assets/Programmierparadigmen-kommunikation-fehler.png b/Assets/Programmierparadigmen-kommunikation-fehler.png new file mode 100644 index 0000000..34ea880 Binary files /dev/null and b/Assets/Programmierparadigmen-kommunikation-fehler.png differ diff --git a/Assets/Programmierparadigmen-kommunikation.png b/Assets/Programmierparadigmen-kommunikation.png new file mode 100644 index 0000000..45b9b34 Binary files /dev/null and b/Assets/Programmierparadigmen-kommunikation.png differ diff --git a/Assets/Programmierparadigmen-master-worker-thread.png b/Assets/Programmierparadigmen-master-worker-thread.png new file mode 100644 index 0000000..4ea5b68 Binary files /dev/null and b/Assets/Programmierparadigmen-master-worker-thread.png differ diff --git a/Assets/Programmierparadigmen-microservice.png b/Assets/Programmierparadigmen-microservice.png new file mode 100644 index 0000000..8f88c5f Binary files /dev/null and b/Assets/Programmierparadigmen-microservice.png differ diff --git a/Assets/Programmierparadigmen-mutex-c.png b/Assets/Programmierparadigmen-mutex-c.png new file mode 100644 index 0000000..21306de Binary files /dev/null and b/Assets/Programmierparadigmen-mutex-c.png differ diff --git a/Assets/Programmierparadigmen-netzwerk-stubs.png b/Assets/Programmierparadigmen-netzwerk-stubs.png new file mode 100644 index 0000000..80d7769 Binary files /dev/null and b/Assets/Programmierparadigmen-netzwerk-stubs.png differ diff --git a/Assets/Programmierparadigmen-parallelisierung.png b/Assets/Programmierparadigmen-parallelisierung.png new file mode 100644 index 0000000..5734211 Binary files /dev/null and b/Assets/Programmierparadigmen-parallelisierung.png differ diff --git a/Assets/Programmierparadigmen-philosophen.png b/Assets/Programmierparadigmen-philosophen.png new file mode 100644 index 0000000..c485c91 Binary files /dev/null and b/Assets/Programmierparadigmen-philosophen.png differ diff --git a/Assets/Programmierparadigmen-rabbitmq.png b/Assets/Programmierparadigmen-rabbitmq.png new file mode 100644 index 0000000..fbeca85 Binary files /dev/null and b/Assets/Programmierparadigmen-rabbitmq.png differ diff --git a/Assets/Programmierparadigmen-spotify-api.png b/Assets/Programmierparadigmen-spotify-api.png new file mode 100644 index 0000000..4dced34 Binary files /dev/null and b/Assets/Programmierparadigmen-spotify-api.png differ diff --git a/Assets/Programmierparadigmen-springio.png b/Assets/Programmierparadigmen-springio.png new file mode 100644 index 0000000..46e7596 Binary files /dev/null and b/Assets/Programmierparadigmen-springio.png differ diff --git a/Assets/Programmierparadigmen-synchron-empfangen.png b/Assets/Programmierparadigmen-synchron-empfangen.png new file mode 100644 index 0000000..ec9121a Binary files /dev/null and b/Assets/Programmierparadigmen-synchron-empfangen.png differ diff --git a/Assets/Programmierparadigmen-synchrones-senden.png b/Assets/Programmierparadigmen-synchrones-senden.png new file mode 100644 index 0000000..f91e24a Binary files /dev/null and b/Assets/Programmierparadigmen-synchrones-senden.png differ diff --git a/Assets/Programmierparadigmen-zustände-bit-protokoll.png b/Assets/Programmierparadigmen-zustände-bit-protokoll.png new file mode 100644 index 0000000..6d638bd Binary files /dev/null and b/Assets/Programmierparadigmen-zustände-bit-protokoll.png differ diff --git a/Assets/RA2-61330.jpg b/Assets/RA2-61330.jpg new file mode 100644 index 0000000..c4ec539 Binary files /dev/null and b/Assets/RA2-61330.jpg differ diff --git a/Assets/RA2-62418.jpg b/Assets/RA2-62418.jpg new file mode 100644 index 0000000..e1f5e03 Binary files /dev/null and b/Assets/RA2-62418.jpg differ diff --git a/Assets/RA2-62729.jpg b/Assets/RA2-62729.jpg new file mode 100644 index 0000000..717ae7c Binary files /dev/null and b/Assets/RA2-62729.jpg differ diff --git a/Assets/RA2-63122.jpg b/Assets/RA2-63122.jpg new file mode 100644 index 0000000..9fa2a2e Binary files /dev/null and b/Assets/RA2-63122.jpg differ diff --git a/Assets/RA2-63323.jpg b/Assets/RA2-63323.jpg new file mode 100644 index 0000000..8b15842 Binary files /dev/null and b/Assets/RA2-63323.jpg differ diff --git a/Assets/RA2-63642.jpg b/Assets/RA2-63642.jpg new file mode 100644 index 0000000..d192a87 Binary files /dev/null and b/Assets/RA2-63642.jpg differ diff --git a/Assets/RA2-63915.jpg b/Assets/RA2-63915.jpg new file mode 100644 index 0000000..dc3d6f3 Binary files /dev/null and b/Assets/RA2-63915.jpg differ diff --git a/Assets/RA2-64222.jpg b/Assets/RA2-64222.jpg new file mode 100644 index 0000000..26bd89f Binary files /dev/null and b/Assets/RA2-64222.jpg differ diff --git a/Assets/RA2-64400.jpg b/Assets/RA2-64400.jpg new file mode 100644 index 0000000..e8d2342 Binary files /dev/null and b/Assets/RA2-64400.jpg differ diff --git a/Assets/RA2-64617.jpg b/Assets/RA2-64617.jpg new file mode 100644 index 0000000..feb8af7 Binary files /dev/null and b/Assets/RA2-64617.jpg differ diff --git a/Assets/RA2-65225.jpg b/Assets/RA2-65225.jpg new file mode 100644 index 0000000..06b0768 Binary files /dev/null and b/Assets/RA2-65225.jpg differ diff --git a/Assets/RA2-65346.jpg b/Assets/RA2-65346.jpg new file mode 100644 index 0000000..b699346 Binary files /dev/null and b/Assets/RA2-65346.jpg differ diff --git a/Assets/RA2-65517.jpg b/Assets/RA2-65517.jpg new file mode 100644 index 0000000..5140b76 Binary files /dev/null and b/Assets/RA2-65517.jpg differ diff --git a/Assets/RA2-65743.jpg b/Assets/RA2-65743.jpg new file mode 100644 index 0000000..90da277 Binary files /dev/null and b/Assets/RA2-65743.jpg differ diff --git a/Assets/RA2-70806.jpg b/Assets/RA2-70806.jpg new file mode 100644 index 0000000..012755e Binary files /dev/null and b/Assets/RA2-70806.jpg differ diff --git a/Assets/RA2-70953.jpg b/Assets/RA2-70953.jpg new file mode 100644 index 0000000..dfa68ae Binary files /dev/null and b/Assets/RA2-70953.jpg differ diff --git a/Assets/RA2-73350.jpg b/Assets/RA2-73350.jpg new file mode 100644 index 0000000..4b17d6a Binary files /dev/null and b/Assets/RA2-73350.jpg differ diff --git a/Assets/RA2_2-wege-cache.png b/Assets/RA2_2-wege-cache.png new file mode 100644 index 0000000..48ea6e9 Binary files /dev/null and b/Assets/RA2_2-wege-cache.png differ diff --git a/Assets/RA2_ATiny.png b/Assets/RA2_ATiny.png new file mode 100644 index 0000000..e3766c8 Binary files /dev/null and b/Assets/RA2_ATiny.png differ diff --git a/Assets/RA2_Adresspipelining.png b/Assets/RA2_Adresspipelining.png new file mode 100644 index 0000000..74c1a5f Binary files /dev/null and b/Assets/RA2_Adresspipelining.png differ diff --git a/Assets/RA2_Architekturen.png b/Assets/RA2_Architekturen.png new file mode 100644 index 0000000..a2a1efe Binary files /dev/null and b/Assets/RA2_Architekturen.png differ diff --git a/Assets/RA2_Aufbau.png b/Assets/RA2_Aufbau.png new file mode 100644 index 0000000..000142c Binary files /dev/null and b/Assets/RA2_Aufbau.png differ diff --git a/Assets/RA2_Ausführungsphase.png b/Assets/RA2_Ausführungsphase.png new file mode 100644 index 0000000..6960dd1 Binary files /dev/null and b/Assets/RA2_Ausführungsphase.png differ diff --git a/Assets/RA2_Befehlsholphase.png b/Assets/RA2_Befehlsholphase.png new file mode 100644 index 0000000..6c24384 Binary files /dev/null and b/Assets/RA2_Befehlsholphase.png differ diff --git a/Assets/RA2_BlueGeneArchitektur.png b/Assets/RA2_BlueGeneArchitektur.png new file mode 100644 index 0000000..d07a524 Binary files /dev/null and b/Assets/RA2_BlueGeneArchitektur.png differ diff --git a/Assets/RA2_BlueGeneKnoten.png b/Assets/RA2_BlueGeneKnoten.png new file mode 100644 index 0000000..798eb09 Binary files /dev/null and b/Assets/RA2_BlueGeneKnoten.png differ diff --git a/Assets/RA2_Cache-Controller.png b/Assets/RA2_Cache-Controller.png new file mode 100644 index 0000000..e84d9cd Binary files /dev/null and b/Assets/RA2_Cache-Controller.png differ diff --git a/Assets/RA2_Cache-Funktion.png b/Assets/RA2_Cache-Funktion.png new file mode 100644 index 0000000..65c62de Binary files /dev/null and b/Assets/RA2_Cache-Funktion.png differ diff --git a/Assets/RA2_Cache-Index.png b/Assets/RA2_Cache-Index.png new file mode 100644 index 0000000..ffb2895 Binary files /dev/null and b/Assets/RA2_Cache-Index.png differ diff --git a/Assets/RA2_Cache-Tags.png b/Assets/RA2_Cache-Tags.png new file mode 100644 index 0000000..8eda8aa Binary files /dev/null and b/Assets/RA2_Cache-Tags.png differ diff --git a/Assets/RA2_Cache-Tags2.png b/Assets/RA2_Cache-Tags2.png new file mode 100644 index 0000000..23a04d3 Binary files /dev/null and b/Assets/RA2_Cache-Tags2.png differ diff --git a/Assets/RA2_Cache-line.png b/Assets/RA2_Cache-line.png new file mode 100644 index 0000000..18e1256 Binary files /dev/null and b/Assets/RA2_Cache-line.png differ diff --git a/Assets/RA2_CacheIOEinheit.png b/Assets/RA2_CacheIOEinheit.png new file mode 100644 index 0000000..1cf6726 Binary files /dev/null and b/Assets/RA2_CacheIOEinheit.png differ diff --git a/Assets/RA2_CacheKohärenz.png b/Assets/RA2_CacheKohärenz.png new file mode 100644 index 0000000..1210fdd Binary files /dev/null and b/Assets/RA2_CacheKohärenz.png differ diff --git a/Assets/RA2_Cachehit.png b/Assets/RA2_Cachehit.png new file mode 100644 index 0000000..0c7efcd Binary files /dev/null and b/Assets/RA2_Cachehit.png differ diff --git a/Assets/RA2_DRAM.png b/Assets/RA2_DRAM.png new file mode 100644 index 0000000..5824363 Binary files /dev/null and b/Assets/RA2_DRAM.png differ diff --git a/Assets/RA2_DualCoreSystem.png b/Assets/RA2_DualCoreSystem.png new file mode 100644 index 0000000..bd09172 Binary files /dev/null and b/Assets/RA2_DualCoreSystem.png differ diff --git a/Assets/RA2_Enge und lose Kopplung.png b/Assets/RA2_Enge und lose Kopplung.png new file mode 100644 index 0000000..c798e4a Binary files /dev/null and b/Assets/RA2_Enge und lose Kopplung.png differ diff --git a/Assets/RA2_Interleaving.png b/Assets/RA2_Interleaving.png new file mode 100644 index 0000000..da023d2 Binary files /dev/null and b/Assets/RA2_Interleaving.png differ diff --git a/Assets/RA2_MESI-Bedingungen.png b/Assets/RA2_MESI-Bedingungen.png new file mode 100644 index 0000000..b042f4e Binary files /dev/null and b/Assets/RA2_MESI-Bedingungen.png differ diff --git a/Assets/RA2_MESI-Protokoll.png b/Assets/RA2_MESI-Protokoll.png new file mode 100644 index 0000000..4f0e5b9 Binary files /dev/null and b/Assets/RA2_MESI-Protokoll.png differ diff --git a/Assets/RA2_MESI-Zustände.png b/Assets/RA2_MESI-Zustände.png new file mode 100644 index 0000000..54befc7 Binary files /dev/null and b/Assets/RA2_MESI-Zustände.png differ diff --git a/Assets/RA2_MIMD.png b/Assets/RA2_MIMD.png new file mode 100644 index 0000000..99e00a9 Binary files /dev/null and b/Assets/RA2_MIMD.png differ diff --git a/Assets/RA2_MISD.png b/Assets/RA2_MISD.png new file mode 100644 index 0000000..37ae43b Binary files /dev/null and b/Assets/RA2_MISD.png differ diff --git a/Assets/RA2_MultiprozessorHochleistungssystem.png b/Assets/RA2_MultiprozessorHochleistungssystem.png new file mode 100644 index 0000000..e2672a3 Binary files /dev/null and b/Assets/RA2_MultiprozessorHochleistungssystem.png differ diff --git a/Assets/RA2_Operanden.png b/Assets/RA2_Operanden.png new file mode 100644 index 0000000..7376a19 Binary files /dev/null and b/Assets/RA2_Operanden.png differ diff --git a/Assets/RA2_Partitionierung.png b/Assets/RA2_Partitionierung.png new file mode 100644 index 0000000..9cf2c9a Binary files /dev/null and b/Assets/RA2_Partitionierung.png differ diff --git a/Assets/RA2_Pipeline.png b/Assets/RA2_Pipeline.png new file mode 100644 index 0000000..eeddf81 Binary files /dev/null and b/Assets/RA2_Pipeline.png differ diff --git a/Assets/RA2_Pipelines.png b/Assets/RA2_Pipelines.png new file mode 100644 index 0000000..adc9f4a Binary files /dev/null and b/Assets/RA2_Pipelines.png differ diff --git a/Assets/RA2_SIMD.png b/Assets/RA2_SIMD.png new file mode 100644 index 0000000..db82714 Binary files /dev/null and b/Assets/RA2_SIMD.png differ diff --git a/Assets/RA2_SISD.png b/Assets/RA2_SISD.png new file mode 100644 index 0000000..726a284 Binary files /dev/null and b/Assets/RA2_SISD.png differ diff --git a/Assets/RA2_SharedMemorySystem.png b/Assets/RA2_SharedMemorySystem.png new file mode 100644 index 0000000..f7e5b01 Binary files /dev/null and b/Assets/RA2_SharedMemorySystem.png differ diff --git a/Assets/RA2_Simultaneous-Multithreading.png b/Assets/RA2_Simultaneous-Multithreading.png new file mode 100644 index 0000000..b3071fa Binary files /dev/null and b/Assets/RA2_Simultaneous-Multithreading.png differ diff --git a/Assets/RA2_Speicherhierarchie.png b/Assets/RA2_Speicherhierarchie.png new file mode 100644 index 0000000..8605a44 Binary files /dev/null and b/Assets/RA2_Speicherhierarchie.png differ diff --git a/Assets/RA2_Speicherstrukturen.png b/Assets/RA2_Speicherstrukturen.png new file mode 100644 index 0000000..2c589ab Binary files /dev/null and b/Assets/RA2_Speicherstrukturen.png differ diff --git a/Assets/RA2_Speicherzugriff.png b/Assets/RA2_Speicherzugriff.png new file mode 100644 index 0000000..b943023 Binary files /dev/null and b/Assets/RA2_Speicherzugriff.png differ diff --git a/Assets/RA2_Sprungvorhersage.png b/Assets/RA2_Sprungvorhersage.png new file mode 100644 index 0000000..bb9a4b6 Binary files /dev/null and b/Assets/RA2_Sprungvorhersage.png differ diff --git a/Assets/RA2_Tomasulo-Prinzip.png b/Assets/RA2_Tomasulo-Prinzip.png new file mode 100644 index 0000000..c6bf9b0 Binary files /dev/null and b/Assets/RA2_Tomasulo-Prinzip.png differ diff --git a/Assets/RA2_VLIW-dynamisch.png b/Assets/RA2_VLIW-dynamisch.png new file mode 100644 index 0000000..2c05099 Binary files /dev/null and b/Assets/RA2_VLIW-dynamisch.png differ diff --git a/Assets/RA2_VLIW-vergleich.png b/Assets/RA2_VLIW-vergleich.png new file mode 100644 index 0000000..d24604d Binary files /dev/null and b/Assets/RA2_VLIW-vergleich.png differ diff --git a/Assets/RA2_Verbindungsnetzwerke.png b/Assets/RA2_Verbindungsnetzwerke.png new file mode 100644 index 0000000..e2699d6 Binary files /dev/null and b/Assets/RA2_Verbindungsnetzwerke.png differ diff --git a/Assets/RA2_Verbindungsnetzwerke2.png b/Assets/RA2_Verbindungsnetzwerke2.png new file mode 100644 index 0000000..58a076f Binary files /dev/null and b/Assets/RA2_Verbindungsnetzwerke2.png differ diff --git a/Assets/RA2_Vorhersagen.png b/Assets/RA2_Vorhersagen.png new file mode 100644 index 0000000..ac63d6a Binary files /dev/null and b/Assets/RA2_Vorhersagen.png differ diff --git a/Assets/RA2_WriteBack.png b/Assets/RA2_WriteBack.png new file mode 100644 index 0000000..7811647 Binary files /dev/null and b/Assets/RA2_WriteBack.png differ diff --git a/Assets/RA2_WriteInvalidate.png b/Assets/RA2_WriteInvalidate.png new file mode 100644 index 0000000..40b9f3e Binary files /dev/null and b/Assets/RA2_WriteInvalidate.png differ diff --git a/Assets/RA2_cache-write-trough-vs-back.png b/Assets/RA2_cache-write-trough-vs-back.png new file mode 100644 index 0000000..3ff0000 Binary files /dev/null and b/Assets/RA2_cache-write-trough-vs-back.png differ diff --git a/Assets/RA2_decodierphase.png b/Assets/RA2_decodierphase.png new file mode 100644 index 0000000..fbc099c Binary files /dev/null and b/Assets/RA2_decodierphase.png differ diff --git a/Assets/RA2_in-order-pipeline.png b/Assets/RA2_in-order-pipeline.png new file mode 100644 index 0000000..918f87e Binary files /dev/null and b/Assets/RA2_in-order-pipeline.png differ diff --git a/Assets/RA2_mehrzyklenCPU.png b/Assets/RA2_mehrzyklenCPU.png new file mode 100644 index 0000000..5ac458d Binary files /dev/null and b/Assets/RA2_mehrzyklenCPU.png differ diff --git a/Assets/RA2_out-of-order-execution.png b/Assets/RA2_out-of-order-execution.png new file mode 100644 index 0000000..6a59639 Binary files /dev/null and b/Assets/RA2_out-of-order-execution.png differ diff --git a/Assets/RA2_pipelineCPU.png b/Assets/RA2_pipelineCPU.png new file mode 100644 index 0000000..ac6e7e0 Binary files /dev/null and b/Assets/RA2_pipelineCPU.png differ diff --git a/Assets/RA2_weitereSprungbefehle.png b/Assets/RA2_weitereSprungbefehle.png new file mode 100644 index 0000000..e9171b2 Binary files /dev/null and b/Assets/RA2_weitereSprungbefehle.png differ diff --git a/Assets/Schaltsysteme-praktika-v2.png b/Assets/Schaltsysteme-praktika-v2.png new file mode 100644 index 0000000..2480928 Binary files /dev/null and b/Assets/Schaltsysteme-praktika-v2.png differ diff --git a/Assets/Schaltsysteme-praktika-v3.png b/Assets/Schaltsysteme-praktika-v3.png new file mode 100644 index 0000000..187cc5f Binary files /dev/null and b/Assets/Schaltsysteme-praktika-v3.png differ diff --git a/Assets/Schaltsysteme-praktika-v4-2.png b/Assets/Schaltsysteme-praktika-v4-2.png new file mode 100644 index 0000000..a833b20 Binary files /dev/null and b/Assets/Schaltsysteme-praktika-v4-2.png differ diff --git a/Assets/Schaltsysteme-praktika-v4.png b/Assets/Schaltsysteme-praktika-v4.png new file mode 100644 index 0000000..e904769 Binary files /dev/null and b/Assets/Schaltsysteme-praktika-v4.png differ diff --git a/Assets/Softwaretechnik1_Analyseformen1.png b/Assets/Softwaretechnik1_Analyseformen1.png new file mode 100644 index 0000000..005181d Binary files /dev/null and b/Assets/Softwaretechnik1_Analyseformen1.png differ diff --git a/Assets/Softwaretechnik1_Analyseformen2.png b/Assets/Softwaretechnik1_Analyseformen2.png new file mode 100644 index 0000000..5209ddf Binary files /dev/null and b/Assets/Softwaretechnik1_Analyseformen2.png differ diff --git a/Assets/Softwaretechnik1_Anforderungsentwicklung.png b/Assets/Softwaretechnik1_Anforderungsentwicklung.png new file mode 100644 index 0000000..9095cd8 Binary files /dev/null and b/Assets/Softwaretechnik1_Anforderungsentwicklung.png differ diff --git a/Assets/Softwaretechnik1_Bruegge1.png b/Assets/Softwaretechnik1_Bruegge1.png new file mode 100644 index 0000000..8190ab6 Binary files /dev/null and b/Assets/Softwaretechnik1_Bruegge1.png differ diff --git a/Assets/Softwaretechnik1_Bruegge2.png b/Assets/Softwaretechnik1_Bruegge2.png new file mode 100644 index 0000000..f6abb54 Binary files /dev/null and b/Assets/Softwaretechnik1_Bruegge2.png differ diff --git a/Assets/Softwaretechnik1_Burndownchart.png b/Assets/Softwaretechnik1_Burndownchart.png new file mode 100644 index 0000000..1bb6a51 Binary files /dev/null and b/Assets/Softwaretechnik1_Burndownchart.png differ diff --git a/Assets/Softwaretechnik1_Codegenerierung.png b/Assets/Softwaretechnik1_Codegenerierung.png new file mode 100644 index 0000000..172b531 Binary files /dev/null and b/Assets/Softwaretechnik1_Codegenerierung.png differ diff --git a/Assets/Softwaretechnik1_FPA1.png b/Assets/Softwaretechnik1_FPA1.png new file mode 100644 index 0000000..6455f95 Binary files /dev/null and b/Assets/Softwaretechnik1_FPA1.png differ diff --git a/Assets/Softwaretechnik1_FPA2.png b/Assets/Softwaretechnik1_FPA2.png new file mode 100644 index 0000000..d8b3d71 Binary files /dev/null and b/Assets/Softwaretechnik1_FPA2.png differ diff --git a/Assets/Softwaretechnik1_FPA3.png b/Assets/Softwaretechnik1_FPA3.png new file mode 100644 index 0000000..07c910b Binary files /dev/null and b/Assets/Softwaretechnik1_FPA3.png differ diff --git a/Assets/Softwaretechnik1_Kano1.png b/Assets/Softwaretechnik1_Kano1.png new file mode 100644 index 0000000..5deb6af Binary files /dev/null and b/Assets/Softwaretechnik1_Kano1.png differ diff --git a/Assets/Softwaretechnik1_Kano2.png b/Assets/Softwaretechnik1_Kano2.png new file mode 100644 index 0000000..a2788dd Binary files /dev/null and b/Assets/Softwaretechnik1_Kano2.png differ diff --git a/Assets/Softwaretechnik1_Organisation_hierarchisch.png b/Assets/Softwaretechnik1_Organisation_hierarchisch.png new file mode 100644 index 0000000..042e464 Binary files /dev/null and b/Assets/Softwaretechnik1_Organisation_hierarchisch.png differ diff --git a/Assets/Softwaretechnik1_Organisation_matrix.png b/Assets/Softwaretechnik1_Organisation_matrix.png new file mode 100644 index 0000000..283756d Binary files /dev/null and b/Assets/Softwaretechnik1_Organisation_matrix.png differ diff --git a/Assets/Softwaretechnik1_ProjektplanungBeispiel.png b/Assets/Softwaretechnik1_ProjektplanungBeispiel.png new file mode 100644 index 0000000..c2457bd Binary files /dev/null and b/Assets/Softwaretechnik1_ProjektplanungBeispiel.png differ diff --git a/Assets/Softwaretechnik1_Projektstruktur.png b/Assets/Softwaretechnik1_Projektstruktur.png new file mode 100644 index 0000000..6cb1cda Binary files /dev/null and b/Assets/Softwaretechnik1_Projektstruktur.png differ diff --git a/Assets/Softwaretechnik1_Ressourcenplanung.png b/Assets/Softwaretechnik1_Ressourcenplanung.png new file mode 100644 index 0000000..09ba6d6 Binary files /dev/null and b/Assets/Softwaretechnik1_Ressourcenplanung.png differ diff --git a/Assets/Softwaretechnik1_ScrumVorgehen.png b/Assets/Softwaretechnik1_ScrumVorgehen.png new file mode 100644 index 0000000..b710a68 Binary files /dev/null and b/Assets/Softwaretechnik1_ScrumVorgehen.png differ diff --git a/Assets/Softwaretechnik1_Spiralmodell.png b/Assets/Softwaretechnik1_Spiralmodell.png new file mode 100644 index 0000000..5bfb104 Binary files /dev/null and b/Assets/Softwaretechnik1_Spiralmodell.png differ diff --git a/Assets/Softwaretechnik1_UnifiedProcess.png b/Assets/Softwaretechnik1_UnifiedProcess.png new file mode 100644 index 0000000..cddd44a Binary files /dev/null and b/Assets/Softwaretechnik1_UnifiedProcess.png differ diff --git a/Assets/Softwaretechnik1_VModell.png b/Assets/Softwaretechnik1_VModell.png new file mode 100644 index 0000000..0547445 Binary files /dev/null and b/Assets/Softwaretechnik1_VModell.png differ diff --git a/Assets/Softwaretechnik1_XP.png b/Assets/Softwaretechnik1_XP.png new file mode 100644 index 0000000..f8d4061 Binary files /dev/null and b/Assets/Softwaretechnik1_XP.png differ diff --git a/Assets/Softwaretechnik2-Accuracy-and-Precision.png b/Assets/Softwaretechnik2-Accuracy-and-Precision.png new file mode 100644 index 0000000..0f04d6c Binary files /dev/null and b/Assets/Softwaretechnik2-Accuracy-and-Precision.png differ diff --git a/Assets/Softwaretechnik2-Behavioral-test-model.png b/Assets/Softwaretechnik2-Behavioral-test-model.png new file mode 100644 index 0000000..f9dcc8a Binary files /dev/null and b/Assets/Softwaretechnik2-Behavioral-test-model.png differ diff --git a/Assets/Softwaretechnik2-CapabilityMaturityModel.png b/Assets/Softwaretechnik2-CapabilityMaturityModel.png new file mode 100644 index 0000000..411de84 Binary files /dev/null and b/Assets/Softwaretechnik2-CapabilityMaturityModel.png differ diff --git a/Assets/Softwaretechnik2-Classification-Trees.png b/Assets/Softwaretechnik2-Classification-Trees.png new file mode 100644 index 0000000..25f2805 Binary files /dev/null and b/Assets/Softwaretechnik2-Classification-Trees.png differ diff --git a/Assets/Softwaretechnik2-CoffeeMachine.png b/Assets/Softwaretechnik2-CoffeeMachine.png new file mode 100644 index 0000000..37e5e3d Binary files /dev/null and b/Assets/Softwaretechnik2-CoffeeMachine.png differ diff --git a/Assets/Softwaretechnik2-CoffeeMachine2.png b/Assets/Softwaretechnik2-CoffeeMachine2.png new file mode 100644 index 0000000..30936f3 Binary files /dev/null and b/Assets/Softwaretechnik2-CoffeeMachine2.png differ diff --git a/Assets/Softwaretechnik2-Communicationpath-1.png b/Assets/Softwaretechnik2-Communicationpath-1.png new file mode 100644 index 0000000..b07af48 Binary files /dev/null and b/Assets/Softwaretechnik2-Communicationpath-1.png differ diff --git a/Assets/Softwaretechnik2-Communicationpath-2.png b/Assets/Softwaretechnik2-Communicationpath-2.png new file mode 100644 index 0000000..3d2d156 Binary files /dev/null and b/Assets/Softwaretechnik2-Communicationpath-2.png differ diff --git a/Assets/Softwaretechnik2-Cone-of-Uncertainty.png b/Assets/Softwaretechnik2-Cone-of-Uncertainty.png new file mode 100644 index 0000000..8229ccd Binary files /dev/null and b/Assets/Softwaretechnik2-Cone-of-Uncertainty.png differ diff --git a/Assets/Softwaretechnik2-Cycling-Computers.png b/Assets/Softwaretechnik2-Cycling-Computers.png new file mode 100644 index 0000000..5a54de8 Binary files /dev/null and b/Assets/Softwaretechnik2-Cycling-Computers.png differ diff --git a/Assets/Softwaretechnik2-Decomposition-example.png b/Assets/Softwaretechnik2-Decomposition-example.png new file mode 100644 index 0000000..3163e99 Binary files /dev/null and b/Assets/Softwaretechnik2-Decomposition-example.png differ diff --git a/Assets/Softwaretechnik2-Decorator.png b/Assets/Softwaretechnik2-Decorator.png new file mode 100644 index 0000000..933c871 Binary files /dev/null and b/Assets/Softwaretechnik2-Decorator.png differ diff --git a/Assets/Softwaretechnik2-Design-pattern.png b/Assets/Softwaretechnik2-Design-pattern.png new file mode 100644 index 0000000..5b1c7df Binary files /dev/null and b/Assets/Softwaretechnik2-Design-pattern.png differ diff --git a/Assets/Softwaretechnik2-Divide-and-Conquer.png b/Assets/Softwaretechnik2-Divide-and-Conquer.png new file mode 100644 index 0000000..6edf343 Binary files /dev/null and b/Assets/Softwaretechnik2-Divide-and-Conquer.png differ diff --git a/Assets/Softwaretechnik2-Domain-specific-languages.png b/Assets/Softwaretechnik2-Domain-specific-languages.png new file mode 100644 index 0000000..24bf291 Binary files /dev/null and b/Assets/Softwaretechnik2-Domain-specific-languages.png differ diff --git a/Assets/Softwaretechnik2-Einflussgröße-Personal.png b/Assets/Softwaretechnik2-Einflussgröße-Personal.png new file mode 100644 index 0000000..6dded28 Binary files /dev/null and b/Assets/Softwaretechnik2-Einflussgröße-Personal.png differ diff --git a/Assets/Softwaretechnik2-Einflussgröße-Programmiersprache.png b/Assets/Softwaretechnik2-Einflussgröße-Programmiersprache.png new file mode 100644 index 0000000..d2cf540 Binary files /dev/null and b/Assets/Softwaretechnik2-Einflussgröße-Programmiersprache.png differ diff --git a/Assets/Softwaretechnik2-Elicitation Techniques.png b/Assets/Softwaretechnik2-Elicitation Techniques.png new file mode 100644 index 0000000..6b16e55 Binary files /dev/null and b/Assets/Softwaretechnik2-Elicitation Techniques.png differ diff --git a/Assets/Softwaretechnik2-Equivalence-Class-Testing.png b/Assets/Softwaretechnik2-Equivalence-Class-Testing.png new file mode 100644 index 0000000..58f1289 Binary files /dev/null and b/Assets/Softwaretechnik2-Equivalence-Class-Testing.png differ diff --git a/Assets/Softwaretechnik2-Estimationresults.png b/Assets/Softwaretechnik2-Estimationresults.png new file mode 100644 index 0000000..f0e9271 Binary files /dev/null and b/Assets/Softwaretechnik2-Estimationresults.png differ diff --git a/Assets/Softwaretechnik2-Expert-Judgement.png b/Assets/Softwaretechnik2-Expert-Judgement.png new file mode 100644 index 0000000..59dba16 Binary files /dev/null and b/Assets/Softwaretechnik2-Expert-Judgement.png differ diff --git a/Assets/Softwaretechnik2-FP-to-LOC.png b/Assets/Softwaretechnik2-FP-to-LOC.png new file mode 100644 index 0000000..e626130 Binary files /dev/null and b/Assets/Softwaretechnik2-FP-to-LOC.png differ diff --git a/Assets/Softwaretechnik2-Function-Points.png b/Assets/Softwaretechnik2-Function-Points.png new file mode 100644 index 0000000..274f1f3 Binary files /dev/null and b/Assets/Softwaretechnik2-Function-Points.png differ diff --git a/Assets/Softwaretechnik2-Function-Points2.png b/Assets/Softwaretechnik2-Function-Points2.png new file mode 100644 index 0000000..ba3edfa Binary files /dev/null and b/Assets/Softwaretechnik2-Function-Points2.png differ diff --git a/Assets/Softwaretechnik2-GQM-abstraction-sheet1.png b/Assets/Softwaretechnik2-GQM-abstraction-sheet1.png new file mode 100644 index 0000000..fd7afce Binary files /dev/null and b/Assets/Softwaretechnik2-GQM-abstraction-sheet1.png differ diff --git a/Assets/Softwaretechnik2-GQM-abstraction-sheet2.png b/Assets/Softwaretechnik2-GQM-abstraction-sheet2.png new file mode 100644 index 0000000..af05483 Binary files /dev/null and b/Assets/Softwaretechnik2-GQM-abstraction-sheet2.png differ diff --git a/Assets/Softwaretechnik2-Graphviz-dot.png b/Assets/Softwaretechnik2-Graphviz-dot.png new file mode 100644 index 0000000..625aa9f Binary files /dev/null and b/Assets/Softwaretechnik2-Graphviz-dot.png differ diff --git a/Assets/Softwaretechnik2-Kano-1.png b/Assets/Softwaretechnik2-Kano-1.png new file mode 100644 index 0000000..0d978a0 Binary files /dev/null and b/Assets/Softwaretechnik2-Kano-1.png differ diff --git a/Assets/Softwaretechnik2-Kano-2.png b/Assets/Softwaretechnik2-Kano-2.png new file mode 100644 index 0000000..cb94877 Binary files /dev/null and b/Assets/Softwaretechnik2-Kano-2.png differ diff --git a/Assets/Softwaretechnik2-LALR-Parser-1.png b/Assets/Softwaretechnik2-LALR-Parser-1.png new file mode 100644 index 0000000..1730fd5 Binary files /dev/null and b/Assets/Softwaretechnik2-LALR-Parser-1.png differ diff --git a/Assets/Softwaretechnik2-LALR-Parser-2.png b/Assets/Softwaretechnik2-LALR-Parser-2.png new file mode 100644 index 0000000..2323c20 Binary files /dev/null and b/Assets/Softwaretechnik2-LALR-Parser-2.png differ diff --git a/Assets/Softwaretechnik2-LCOM-1.png b/Assets/Softwaretechnik2-LCOM-1.png new file mode 100644 index 0000000..e5d8407 Binary files /dev/null and b/Assets/Softwaretechnik2-LCOM-1.png differ diff --git a/Assets/Softwaretechnik2-LCOM-2.png b/Assets/Softwaretechnik2-LCOM-2.png new file mode 100644 index 0000000..e10542b Binary files /dev/null and b/Assets/Softwaretechnik2-LCOM-2.png differ diff --git a/Assets/Softwaretechnik2-LCOM-3.png b/Assets/Softwaretechnik2-LCOM-3.png new file mode 100644 index 0000000..c0cc46f Binary files /dev/null and b/Assets/Softwaretechnik2-LCOM-3.png differ diff --git a/Assets/Softwaretechnik2-LCOM-4.png b/Assets/Softwaretechnik2-LCOM-4.png new file mode 100644 index 0000000..4ac0b16 Binary files /dev/null and b/Assets/Softwaretechnik2-LCOM-4.png differ diff --git a/Assets/Softwaretechnik2-Lexer.png b/Assets/Softwaretechnik2-Lexer.png new file mode 100644 index 0000000..bfd25ee Binary files /dev/null and b/Assets/Softwaretechnik2-Lexer.png differ diff --git a/Assets/Softwaretechnik2-Productivity-Rates.png b/Assets/Softwaretechnik2-Productivity-Rates.png new file mode 100644 index 0000000..f13a638 Binary files /dev/null and b/Assets/Softwaretechnik2-Productivity-Rates.png differ diff --git a/Assets/Softwaretechnik2-Reengineering.png b/Assets/Softwaretechnik2-Reengineering.png new file mode 100644 index 0000000..c3094d5 Binary files /dev/null and b/Assets/Softwaretechnik2-Reengineering.png differ diff --git a/Assets/Softwaretechnik2-Requirements Engineering.png b/Assets/Softwaretechnik2-Requirements Engineering.png new file mode 100644 index 0000000..54d7056 Binary files /dev/null and b/Assets/Softwaretechnik2-Requirements Engineering.png differ diff --git a/Assets/Softwaretechnik2-Requriements-Engineering-2.png b/Assets/Softwaretechnik2-Requriements-Engineering-2.png new file mode 100644 index 0000000..9892f00 Binary files /dev/null and b/Assets/Softwaretechnik2-Requriements-Engineering-2.png differ diff --git a/Assets/Softwaretechnik2-Spiralmodell.png b/Assets/Softwaretechnik2-Spiralmodell.png new file mode 100644 index 0000000..bfe8135 Binary files /dev/null and b/Assets/Softwaretechnik2-Spiralmodell.png differ diff --git a/Assets/Softwaretechnik2-Sprint Burndown Chart.png b/Assets/Softwaretechnik2-Sprint Burndown Chart.png new file mode 100644 index 0000000..a538548 Binary files /dev/null and b/Assets/Softwaretechnik2-Sprint Burndown Chart.png differ diff --git a/Assets/Softwaretechnik2-Test-software-example.png b/Assets/Softwaretechnik2-Test-software-example.png new file mode 100644 index 0000000..57c2e1e Binary files /dev/null and b/Assets/Softwaretechnik2-Test-software-example.png differ diff --git a/Assets/Softwaretechnik2-Testklassifikation.png b/Assets/Softwaretechnik2-Testklassifikation.png new file mode 100644 index 0000000..01776ed Binary files /dev/null and b/Assets/Softwaretechnik2-Testklassifikation.png differ diff --git a/Assets/Softwaretechnik2-Testmodell-statechart.png b/Assets/Softwaretechnik2-Testmodell-statechart.png new file mode 100644 index 0000000..ba553b1 Binary files /dev/null and b/Assets/Softwaretechnik2-Testmodell-statechart.png differ diff --git a/Assets/Softwaretechnik2-Testprozess.png b/Assets/Softwaretechnik2-Testprozess.png new file mode 100644 index 0000000..a531e84 Binary files /dev/null and b/Assets/Softwaretechnik2-Testprozess.png differ diff --git a/Assets/Softwaretechnik2-UML-1.png b/Assets/Softwaretechnik2-UML-1.png new file mode 100644 index 0000000..50f4f2f Binary files /dev/null and b/Assets/Softwaretechnik2-UML-1.png differ diff --git a/Assets/Softwaretechnik2-UML-2.png b/Assets/Softwaretechnik2-UML-2.png new file mode 100644 index 0000000..f1c06a4 Binary files /dev/null and b/Assets/Softwaretechnik2-UML-2.png differ diff --git a/Assets/Softwaretechnik2-V-model.png b/Assets/Softwaretechnik2-V-model.png new file mode 100644 index 0000000..a06c3a2 Binary files /dev/null and b/Assets/Softwaretechnik2-V-model.png differ diff --git a/Assets/Softwaretechnik2-Variability-cases.png b/Assets/Softwaretechnik2-Variability-cases.png new file mode 100644 index 0000000..278eac2 Binary files /dev/null and b/Assets/Softwaretechnik2-Variability-cases.png differ diff --git a/Assets/Softwaretechnik2-Veränderungen.png b/Assets/Softwaretechnik2-Veränderungen.png new file mode 100644 index 0000000..f686d67 Binary files /dev/null and b/Assets/Softwaretechnik2-Veränderungen.png differ diff --git a/Assets/Softwaretechnik2-W-model.png b/Assets/Softwaretechnik2-W-model.png new file mode 100644 index 0000000..9d0aa95 Binary files /dev/null and b/Assets/Softwaretechnik2-W-model.png differ diff --git a/Assets/Softwaretechnik2-abstract-factory-god.png b/Assets/Softwaretechnik2-abstract-factory-god.png new file mode 100644 index 0000000..edc091e Binary files /dev/null and b/Assets/Softwaretechnik2-abstract-factory-god.png differ diff --git a/Assets/Softwaretechnik2-abstract-factory-pattern.png b/Assets/Softwaretechnik2-abstract-factory-pattern.png new file mode 100644 index 0000000..ee7cee5 Binary files /dev/null and b/Assets/Softwaretechnik2-abstract-factory-pattern.png differ diff --git a/Assets/Softwaretechnik2-anforderungsschablone1.png b/Assets/Softwaretechnik2-anforderungsschablone1.png new file mode 100644 index 0000000..ad2ae31 Binary files /dev/null and b/Assets/Softwaretechnik2-anforderungsschablone1.png differ diff --git a/Assets/Softwaretechnik2-anforderungsschablone2.png b/Assets/Softwaretechnik2-anforderungsschablone2.png new file mode 100644 index 0000000..4f2e8f2 Binary files /dev/null and b/Assets/Softwaretechnik2-anforderungsschablone2.png differ diff --git a/Assets/Softwaretechnik2-anforderungsschablone3.png b/Assets/Softwaretechnik2-anforderungsschablone3.png new file mode 100644 index 0000000..26e053f Binary files /dev/null and b/Assets/Softwaretechnik2-anforderungsschablone3.png differ diff --git a/Assets/Softwaretechnik2-aop-authentication.png b/Assets/Softwaretechnik2-aop-authentication.png new file mode 100644 index 0000000..82deac7 Binary files /dev/null and b/Assets/Softwaretechnik2-aop-authentication.png differ diff --git a/Assets/Softwaretechnik2-aop-routing.png b/Assets/Softwaretechnik2-aop-routing.png new file mode 100644 index 0000000..e16c9c7 Binary files /dev/null and b/Assets/Softwaretechnik2-aop-routing.png differ diff --git a/Assets/Softwaretechnik2-aspect-oriented-programming.png b/Assets/Softwaretechnik2-aspect-oriented-programming.png new file mode 100644 index 0000000..71c3d34 Binary files /dev/null and b/Assets/Softwaretechnik2-aspect-oriented-programming.png differ diff --git a/Assets/Softwaretechnik2-change-control-process.png b/Assets/Softwaretechnik2-change-control-process.png new file mode 100644 index 0000000..9fe8353 Binary files /dev/null and b/Assets/Softwaretechnik2-change-control-process.png differ diff --git a/Assets/Softwaretechnik2-compiler-generator.png b/Assets/Softwaretechnik2-compiler-generator.png new file mode 100644 index 0000000..c4e9606 Binary files /dev/null and b/Assets/Softwaretechnik2-compiler-generator.png differ diff --git a/Assets/Softwaretechnik2-doxygen1.png b/Assets/Softwaretechnik2-doxygen1.png new file mode 100644 index 0000000..b01323a Binary files /dev/null and b/Assets/Softwaretechnik2-doxygen1.png differ diff --git a/Assets/Softwaretechnik2-doxygen2.png b/Assets/Softwaretechnik2-doxygen2.png new file mode 100644 index 0000000..60cf9a3 Binary files /dev/null and b/Assets/Softwaretechnik2-doxygen2.png differ diff --git a/Assets/Softwaretechnik2-doxygen3.png b/Assets/Softwaretechnik2-doxygen3.png new file mode 100644 index 0000000..97006d0 Binary files /dev/null and b/Assets/Softwaretechnik2-doxygen3.png differ diff --git a/Assets/Softwaretechnik2-eclipse-refactoring.png b/Assets/Softwaretechnik2-eclipse-refactoring.png new file mode 100644 index 0000000..bf152fc Binary files /dev/null and b/Assets/Softwaretechnik2-eclipse-refactoring.png differ diff --git a/Assets/Softwaretechnik2-embUnit.png b/Assets/Softwaretechnik2-embUnit.png new file mode 100644 index 0000000..9c491c0 Binary files /dev/null and b/Assets/Softwaretechnik2-embUnit.png differ diff --git a/Assets/Softwaretechnik2-evolutionsmodell.png b/Assets/Softwaretechnik2-evolutionsmodell.png new file mode 100644 index 0000000..49ee745 Binary files /dev/null and b/Assets/Softwaretechnik2-evolutionsmodell.png differ diff --git a/Assets/Softwaretechnik2-factory-method.png b/Assets/Softwaretechnik2-factory-method.png new file mode 100644 index 0000000..da55569 Binary files /dev/null and b/Assets/Softwaretechnik2-factory-method.png differ diff --git a/Assets/Softwaretechnik2-feature-mandatory.png b/Assets/Softwaretechnik2-feature-mandatory.png new file mode 100644 index 0000000..f51e4c5 Binary files /dev/null and b/Assets/Softwaretechnik2-feature-mandatory.png differ diff --git a/Assets/Softwaretechnik2-feature-modeling.png b/Assets/Softwaretechnik2-feature-modeling.png new file mode 100644 index 0000000..6d828f0 Binary files /dev/null and b/Assets/Softwaretechnik2-feature-modeling.png differ diff --git a/Assets/Softwaretechnik2-feature-modeling2.png b/Assets/Softwaretechnik2-feature-modeling2.png new file mode 100644 index 0000000..4bb4a0d Binary files /dev/null and b/Assets/Softwaretechnik2-feature-modeling2.png differ diff --git a/Assets/Softwaretechnik2-feature-optional.png b/Assets/Softwaretechnik2-feature-optional.png new file mode 100644 index 0000000..acb8f8a Binary files /dev/null and b/Assets/Softwaretechnik2-feature-optional.png differ diff --git a/Assets/Softwaretechnik2-feature-or.png b/Assets/Softwaretechnik2-feature-or.png new file mode 100644 index 0000000..7550ae3 Binary files /dev/null and b/Assets/Softwaretechnik2-feature-or.png differ diff --git a/Assets/Softwaretechnik2-feature-xor.png b/Assets/Softwaretechnik2-feature-xor.png new file mode 100644 index 0000000..8bfd82a Binary files /dev/null and b/Assets/Softwaretechnik2-feature-xor.png differ diff --git a/Assets/Softwaretechnik2-highly-coupled.png b/Assets/Softwaretechnik2-highly-coupled.png new file mode 100644 index 0000000..c9286bf Binary files /dev/null and b/Assets/Softwaretechnik2-highly-coupled.png differ diff --git a/Assets/Softwaretechnik2-mars-rover-software.png b/Assets/Softwaretechnik2-mars-rover-software.png new file mode 100644 index 0000000..90b851b Binary files /dev/null and b/Assets/Softwaretechnik2-mars-rover-software.png differ diff --git a/Assets/Softwaretechnik2-memory-leaks.png b/Assets/Softwaretechnik2-memory-leaks.png new file mode 100644 index 0000000..66d3ea9 Binary files /dev/null and b/Assets/Softwaretechnik2-memory-leaks.png differ diff --git a/Assets/Softwaretechnik2-memory-leaks2.png b/Assets/Softwaretechnik2-memory-leaks2.png new file mode 100644 index 0000000..7dc2a69 Binary files /dev/null and b/Assets/Softwaretechnik2-memory-leaks2.png differ diff --git a/Assets/Softwaretechnik2-mindmap.png b/Assets/Softwaretechnik2-mindmap.png new file mode 100644 index 0000000..ce25912 Binary files /dev/null and b/Assets/Softwaretechnik2-mindmap.png differ diff --git a/Assets/Softwaretechnik2-moodle.png b/Assets/Softwaretechnik2-moodle.png new file mode 100644 index 0000000..b6c8c8b Binary files /dev/null and b/Assets/Softwaretechnik2-moodle.png differ diff --git a/Assets/Softwaretechnik2-openUp-beispiel.png b/Assets/Softwaretechnik2-openUp-beispiel.png new file mode 100644 index 0000000..653d6ed Binary files /dev/null and b/Assets/Softwaretechnik2-openUp-beispiel.png differ diff --git a/Assets/Softwaretechnik2-openUp-lifecycle.png b/Assets/Softwaretechnik2-openUp-lifecycle.png new file mode 100644 index 0000000..666662a Binary files /dev/null and b/Assets/Softwaretechnik2-openUp-lifecycle.png differ diff --git a/Assets/Softwaretechnik2-openUp-phasen.png b/Assets/Softwaretechnik2-openUp-phasen.png new file mode 100644 index 0000000..e723f8a Binary files /dev/null and b/Assets/Softwaretechnik2-openUp-phasen.png differ diff --git a/Assets/Softwaretechnik2-pairwise-testing.png b/Assets/Softwaretechnik2-pairwise-testing.png new file mode 100644 index 0000000..0772c3a Binary files /dev/null and b/Assets/Softwaretechnik2-pairwise-testing.png differ diff --git a/Assets/Softwaretechnik2-parameter-testing.png b/Assets/Softwaretechnik2-parameter-testing.png new file mode 100644 index 0000000..d1396f5 Binary files /dev/null and b/Assets/Softwaretechnik2-parameter-testing.png differ diff --git a/Assets/Softwaretechnik2-phasenmodell.png b/Assets/Softwaretechnik2-phasenmodell.png new file mode 100644 index 0000000..f4138ee Binary files /dev/null and b/Assets/Softwaretechnik2-phasenmodell.png differ diff --git a/Assets/Softwaretechnik2-product-line-cost.png b/Assets/Softwaretechnik2-product-line-cost.png new file mode 100644 index 0000000..ccf097b Binary files /dev/null and b/Assets/Softwaretechnik2-product-line-cost.png differ diff --git a/Assets/Softwaretechnik2-product-line-development-concept.png b/Assets/Softwaretechnik2-product-line-development-concept.png new file mode 100644 index 0000000..328f22e Binary files /dev/null and b/Assets/Softwaretechnik2-product-line-development-concept.png differ diff --git a/Assets/Softwaretechnik2-project-document-setup.png b/Assets/Softwaretechnik2-project-document-setup.png new file mode 100644 index 0000000..83b72fb Binary files /dev/null and b/Assets/Softwaretechnik2-project-document-setup.png differ diff --git a/Assets/Softwaretechnik2-prototypmodell.png b/Assets/Softwaretechnik2-prototypmodell.png new file mode 100644 index 0000000..2156533 Binary files /dev/null and b/Assets/Softwaretechnik2-prototypmodell.png differ diff --git a/Assets/Softwaretechnik2-repertory-grid.png b/Assets/Softwaretechnik2-repertory-grid.png new file mode 100644 index 0000000..170e4fa Binary files /dev/null and b/Assets/Softwaretechnik2-repertory-grid.png differ diff --git a/Assets/Softwaretechnik2-scrum.png b/Assets/Softwaretechnik2-scrum.png new file mode 100644 index 0000000..55f5990 Binary files /dev/null and b/Assets/Softwaretechnik2-scrum.png differ diff --git a/Assets/Softwaretechnik2-splint-information.png b/Assets/Softwaretechnik2-splint-information.png new file mode 100644 index 0000000..87ab53a Binary files /dev/null and b/Assets/Softwaretechnik2-splint-information.png differ diff --git a/Assets/Softwaretechnik2-splint-null-pointer.png b/Assets/Softwaretechnik2-splint-null-pointer.png new file mode 100644 index 0000000..f4efca7 Binary files /dev/null and b/Assets/Softwaretechnik2-splint-null-pointer.png differ diff --git a/Assets/Softwaretechnik2-splint-variable.png b/Assets/Softwaretechnik2-splint-variable.png new file mode 100644 index 0000000..b602c36 Binary files /dev/null and b/Assets/Softwaretechnik2-splint-variable.png differ diff --git a/Assets/Softwaretechnik2-statistical-testing.png b/Assets/Softwaretechnik2-statistical-testing.png new file mode 100644 index 0000000..ca54241 Binary files /dev/null and b/Assets/Softwaretechnik2-statistical-testing.png differ diff --git a/Assets/Softwaretechnik2-time-to-market.png b/Assets/Softwaretechnik2-time-to-market.png new file mode 100644 index 0000000..7933563 Binary files /dev/null and b/Assets/Softwaretechnik2-time-to-market.png differ diff --git a/Assets/Softwaretechnik2-variability.png b/Assets/Softwaretechnik2-variability.png new file mode 100644 index 0000000..1c76fc8 Binary files /dev/null and b/Assets/Softwaretechnik2-variability.png differ diff --git a/Assets/Systemsicherheit-Certificate-server.png b/Assets/Systemsicherheit-Certificate-server.png new file mode 100644 index 0000000..bdcfe28 Binary files /dev/null and b/Assets/Systemsicherheit-Certificate-server.png differ diff --git a/Assets/Systemsicherheit-Risk-Matrix-2.png b/Assets/Systemsicherheit-Risk-Matrix-2.png new file mode 100644 index 0000000..6a1cd8a Binary files /dev/null and b/Assets/Systemsicherheit-Risk-Matrix-2.png differ diff --git a/Assets/Systemsicherheit-access-control-matrix.png b/Assets/Systemsicherheit-access-control-matrix.png new file mode 100644 index 0000000..f9d087f Binary files /dev/null and b/Assets/Systemsicherheit-access-control-matrix.png differ diff --git a/Assets/Systemsicherheit-acl-in-unix-2.png b/Assets/Systemsicherheit-acl-in-unix-2.png new file mode 100644 index 0000000..38b7f67 Binary files /dev/null and b/Assets/Systemsicherheit-acl-in-unix-2.png differ diff --git a/Assets/Systemsicherheit-acl-in-unix.png b/Assets/Systemsicherheit-acl-in-unix.png new file mode 100644 index 0000000..7fd00f6 Binary files /dev/null and b/Assets/Systemsicherheit-acl-in-unix.png differ diff --git a/Assets/Systemsicherheit-acyclic-tam-example.png b/Assets/Systemsicherheit-acyclic-tam-example.png new file mode 100644 index 0000000..4e77c5c Binary files /dev/null and b/Assets/Systemsicherheit-acyclic-tam-example.png differ diff --git a/Assets/Systemsicherheit-apache-axis-2.png b/Assets/Systemsicherheit-apache-axis-2.png new file mode 100644 index 0000000..d2de6e8 Binary files /dev/null and b/Assets/Systemsicherheit-apache-axis-2.png differ diff --git a/Assets/Systemsicherheit-application-embedded-policy.png b/Assets/Systemsicherheit-application-embedded-policy.png new file mode 100644 index 0000000..f15f318 Binary files /dev/null and b/Assets/Systemsicherheit-application-embedded-policy.png differ diff --git a/Assets/Systemsicherheit-blp-example.png b/Assets/Systemsicherheit-blp-example.png new file mode 100644 index 0000000..0ec8b29 Binary files /dev/null and b/Assets/Systemsicherheit-blp-example.png differ diff --git a/Assets/Systemsicherheit-blp-vs-biba.png b/Assets/Systemsicherheit-blp-vs-biba.png new file mode 100644 index 0000000..f66595e Binary files /dev/null and b/Assets/Systemsicherheit-blp-vs-biba.png differ diff --git a/Assets/Systemsicherheit-brewer-example-2.png b/Assets/Systemsicherheit-brewer-example-2.png new file mode 100644 index 0000000..32ed62f Binary files /dev/null and b/Assets/Systemsicherheit-brewer-example-2.png differ diff --git a/Assets/Systemsicherheit-brewer-example.png b/Assets/Systemsicherheit-brewer-example.png new file mode 100644 index 0000000..fc57f66 Binary files /dev/null and b/Assets/Systemsicherheit-brewer-example.png differ diff --git a/Assets/Systemsicherheit-cobra-1.png b/Assets/Systemsicherheit-cobra-1.png new file mode 100644 index 0000000..5f48b0c Binary files /dev/null and b/Assets/Systemsicherheit-cobra-1.png differ diff --git a/Assets/Systemsicherheit-cobra-2.png b/Assets/Systemsicherheit-cobra-2.png new file mode 100644 index 0000000..7caf90f Binary files /dev/null and b/Assets/Systemsicherheit-cobra-2.png differ diff --git a/Assets/Systemsicherheit-engineering-process.png b/Assets/Systemsicherheit-engineering-process.png new file mode 100644 index 0000000..7025fe4 Binary files /dev/null and b/Assets/Systemsicherheit-engineering-process.png differ diff --git a/Assets/Systemsicherheit-fundamental-flask.png b/Assets/Systemsicherheit-fundamental-flask.png new file mode 100644 index 0000000..bd3199c Binary files /dev/null and b/Assets/Systemsicherheit-fundamental-flask.png differ diff --git a/Assets/Systemsicherheit-ibac-basic.png b/Assets/Systemsicherheit-ibac-basic.png new file mode 100644 index 0000000..191b0f4 Binary files /dev/null and b/Assets/Systemsicherheit-ibac-basic.png differ diff --git a/Assets/Systemsicherheit-ibac-model-comparison.png b/Assets/Systemsicherheit-ibac-model-comparison.png new file mode 100644 index 0000000..220efef Binary files /dev/null and b/Assets/Systemsicherheit-ibac-model-comparison.png differ diff --git a/Assets/Systemsicherheit-kerberos-login.png b/Assets/Systemsicherheit-kerberos-login.png new file mode 100644 index 0000000..602413b Binary files /dev/null and b/Assets/Systemsicherheit-kerberos-login.png differ diff --git a/Assets/Systemsicherheit-lattice-vs-acm.png b/Assets/Systemsicherheit-lattice-vs-acm.png new file mode 100644 index 0000000..36bbc6b Binary files /dev/null and b/Assets/Systemsicherheit-lattice-vs-acm.png differ diff --git a/Assets/Systemsicherheit-mealy-automaton.png b/Assets/Systemsicherheit-mealy-automaton.png new file mode 100644 index 0000000..d2c5205 Binary files /dev/null and b/Assets/Systemsicherheit-mealy-automaton.png differ diff --git a/Assets/Systemsicherheit-mealy-beispiel.png b/Assets/Systemsicherheit-mealy-beispiel.png new file mode 100644 index 0000000..5b64a40 Binary files /dev/null and b/Assets/Systemsicherheit-mealy-beispiel.png differ diff --git a/Assets/Systemsicherheit-middleware-level-policy.png b/Assets/Systemsicherheit-middleware-level-policy.png new file mode 100644 index 0000000..73f7e82 Binary files /dev/null and b/Assets/Systemsicherheit-middleware-level-policy.png differ diff --git a/Assets/Systemsicherheit-mls-conflict-classes.png b/Assets/Systemsicherheit-mls-conflict-classes.png new file mode 100644 index 0000000..f71d71e Binary files /dev/null and b/Assets/Systemsicherheit-mls-conflict-classes.png differ diff --git a/Assets/Systemsicherheit-mls-information-flow.png b/Assets/Systemsicherheit-mls-information-flow.png new file mode 100644 index 0000000..dc32868 Binary files /dev/null and b/Assets/Systemsicherheit-mls-information-flow.png differ diff --git a/Assets/Systemsicherheit-model-family.png b/Assets/Systemsicherheit-model-family.png new file mode 100644 index 0000000..d9e11d0 Binary files /dev/null and b/Assets/Systemsicherheit-model-family.png differ diff --git a/Assets/Systemsicherheit-needham-schreoeder.png b/Assets/Systemsicherheit-needham-schreoeder.png new file mode 100644 index 0000000..7031243 Binary files /dev/null and b/Assets/Systemsicherheit-needham-schreoeder.png differ diff --git a/Assets/Systemsicherheit-nizza-application-view.png b/Assets/Systemsicherheit-nizza-application-view.png new file mode 100644 index 0000000..9bbff0e Binary files /dev/null and b/Assets/Systemsicherheit-nizza-application-view.png differ diff --git a/Assets/Systemsicherheit-nizza-enigmail-tcb.png b/Assets/Systemsicherheit-nizza-enigmail-tcb.png new file mode 100644 index 0000000..e9bcd01 Binary files /dev/null and b/Assets/Systemsicherheit-nizza-enigmail-tcb.png differ diff --git a/Assets/Systemsicherheit-nizza-enigmail.png b/Assets/Systemsicherheit-nizza-enigmail.png new file mode 100644 index 0000000..fafb5a3 Binary files /dev/null and b/Assets/Systemsicherheit-nizza-enigmail.png differ diff --git a/Assets/Systemsicherheit-nizza-os-view.png b/Assets/Systemsicherheit-nizza-os-view.png new file mode 100644 index 0000000..76c4c9e Binary files /dev/null and b/Assets/Systemsicherheit-nizza-os-view.png differ diff --git a/Assets/Systemsicherheit-object-managers.png b/Assets/Systemsicherheit-object-managers.png new file mode 100644 index 0000000..c4a16b1 Binary files /dev/null and b/Assets/Systemsicherheit-object-managers.png differ diff --git a/Assets/Systemsicherheit-orcon-problem.png b/Assets/Systemsicherheit-orcon-problem.png new file mode 100644 index 0000000..3d6d2bd Binary files /dev/null and b/Assets/Systemsicherheit-orcon-problem.png differ diff --git a/Assets/Systemsicherheit-policy-controlled-app-application.png b/Assets/Systemsicherheit-policy-controlled-app-application.png new file mode 100644 index 0000000..fded08f Binary files /dev/null and b/Assets/Systemsicherheit-policy-controlled-app-application.png differ diff --git a/Assets/Systemsicherheit-policy-controlled-app-tcp-functional.png b/Assets/Systemsicherheit-policy-controlled-app-tcp-functional.png new file mode 100644 index 0000000..c91b243 Binary files /dev/null and b/Assets/Systemsicherheit-policy-controlled-app-tcp-functional.png differ diff --git a/Assets/Systemsicherheit-policy-controlled-app-tcp-implementation.png b/Assets/Systemsicherheit-policy-controlled-app-tcp-implementation.png new file mode 100644 index 0000000..db7a5a2 Binary files /dev/null and b/Assets/Systemsicherheit-policy-controlled-app-tcp-implementation.png differ diff --git a/Assets/Systemsicherheit-policy-controlled-os-tcp-functional.png b/Assets/Systemsicherheit-policy-controlled-os-tcp-functional.png new file mode 100644 index 0000000..ed91e6a Binary files /dev/null and b/Assets/Systemsicherheit-policy-controlled-os-tcp-functional.png differ diff --git a/Assets/Systemsicherheit-policy-controlled-os-tcp-implementation.png b/Assets/Systemsicherheit-policy-controlled-os-tcp-implementation.png new file mode 100644 index 0000000..521c782 Binary files /dev/null and b/Assets/Systemsicherheit-policy-controlled-os-tcp-implementation.png differ diff --git a/Assets/Systemsicherheit-policy-controlled-os.png b/Assets/Systemsicherheit-policy-controlled-os.png new file mode 100644 index 0000000..2f4c0dc Binary files /dev/null and b/Assets/Systemsicherheit-policy-controlled-os.png differ diff --git a/Assets/Systemsicherheit-policy-microkernel-os-policy.png b/Assets/Systemsicherheit-policy-microkernel-os-policy.png new file mode 100644 index 0000000..2046b91 Binary files /dev/null and b/Assets/Systemsicherheit-policy-microkernel-os-policy.png differ diff --git a/Assets/Systemsicherheit-policy-microkernel-tcp-functional.png b/Assets/Systemsicherheit-policy-microkernel-tcp-functional.png new file mode 100644 index 0000000..3b04de3 Binary files /dev/null and b/Assets/Systemsicherheit-policy-microkernel-tcp-functional.png differ diff --git a/Assets/Systemsicherheit-pos.png b/Assets/Systemsicherheit-pos.png new file mode 100644 index 0000000..c3154eb Binary files /dev/null and b/Assets/Systemsicherheit-pos.png differ diff --git a/Assets/Systemsicherheit-rbac-0.png b/Assets/Systemsicherheit-rbac-0.png new file mode 100644 index 0000000..e898afb Binary files /dev/null and b/Assets/Systemsicherheit-rbac-0.png differ diff --git a/Assets/Systemsicherheit-risk-classification.png b/Assets/Systemsicherheit-risk-classification.png new file mode 100644 index 0000000..88f85e3 Binary files /dev/null and b/Assets/Systemsicherheit-risk-classification.png differ diff --git a/Assets/Systemsicherheit-risk-matrix-1.png b/Assets/Systemsicherheit-risk-matrix-1.png new file mode 100644 index 0000000..7d18a33 Binary files /dev/null and b/Assets/Systemsicherheit-risk-matrix-1.png differ diff --git a/Assets/Systemsicherheit-risk.png b/Assets/Systemsicherheit-risk.png new file mode 100644 index 0000000..a4b0720 Binary files /dev/null and b/Assets/Systemsicherheit-risk.png differ diff --git a/Assets/Systemsicherheit-security-architecture-distributed.png b/Assets/Systemsicherheit-security-architecture-distributed.png new file mode 100644 index 0000000..f81b46c Binary files /dev/null and b/Assets/Systemsicherheit-security-architecture-distributed.png differ diff --git a/Assets/Systemsicherheit-selinux-architecture.png b/Assets/Systemsicherheit-selinux-architecture.png new file mode 100644 index 0000000..a4a2da2 Binary files /dev/null and b/Assets/Systemsicherheit-selinux-architecture.png differ diff --git a/Assets/Systemsicherheit-tam-sts-convenience.png b/Assets/Systemsicherheit-tam-sts-convenience.png new file mode 100644 index 0000000..7bae1cc Binary files /dev/null and b/Assets/Systemsicherheit-tam-sts-convenience.png differ diff --git a/Assets/Systemsicherheit-tam-sts-specific.png b/Assets/Systemsicherheit-tam-sts-specific.png new file mode 100644 index 0000000..092020c Binary files /dev/null and b/Assets/Systemsicherheit-tam-sts-specific.png differ diff --git a/Assets/Systemsicherheit-tam-sts.png b/Assets/Systemsicherheit-tam-sts.png new file mode 100644 index 0000000..9fe5021 Binary files /dev/null and b/Assets/Systemsicherheit-tam-sts.png differ diff --git a/Assets/Systemsicherheit-university-information-system.png b/Assets/Systemsicherheit-university-information-system.png new file mode 100644 index 0000000..5b05f7f Binary files /dev/null and b/Assets/Systemsicherheit-university-information-system.png differ diff --git a/Assets/prakBMT-DeepLearning-01.png b/Assets/prakBMT-DeepLearning-01.png new file mode 100644 index 0000000..46100d8 Binary files /dev/null and b/Assets/prakBMT-DeepLearning-01.png differ diff --git a/Assets/prakBMT-DeepLearning-02.png b/Assets/prakBMT-DeepLearning-02.png new file mode 100644 index 0000000..99b3780 Binary files /dev/null and b/Assets/prakBMT-DeepLearning-02.png differ diff --git a/Assets/prakBMT-DeepLearning-03.png b/Assets/prakBMT-DeepLearning-03.png new file mode 100644 index 0000000..0d1c6d6 Binary files /dev/null and b/Assets/prakBMT-DeepLearning-03.png differ diff --git a/Assets/prakBMT-DeepLearning-04.png b/Assets/prakBMT-DeepLearning-04.png new file mode 100644 index 0000000..e03a532 Binary files /dev/null and b/Assets/prakBMT-DeepLearning-04.png differ diff --git a/Assets/prakBMT-DeepLearning-05.png b/Assets/prakBMT-DeepLearning-05.png new file mode 100644 index 0000000..22aaef6 Binary files /dev/null and b/Assets/prakBMT-DeepLearning-05.png differ diff --git a/Assets/prakBMT-DeepLearning-06.png b/Assets/prakBMT-DeepLearning-06.png new file mode 100644 index 0000000..4f2ae35 Binary files /dev/null and b/Assets/prakBMT-DeepLearning-06.png differ diff --git a/Assets/prakBMT-DeepLearning-07.png b/Assets/prakBMT-DeepLearning-07.png new file mode 100644 index 0000000..cd85200 Binary files /dev/null and b/Assets/prakBMT-DeepLearning-07.png differ diff --git a/Assets/prakBMT-DeepLearning-08.png b/Assets/prakBMT-DeepLearning-08.png new file mode 100644 index 0000000..6a8ee5b Binary files /dev/null and b/Assets/prakBMT-DeepLearning-08.png differ diff --git a/Assets/prakBMT-DeepLearning-09.png b/Assets/prakBMT-DeepLearning-09.png new file mode 100644 index 0000000..c76b0a5 Binary files /dev/null and b/Assets/prakBMT-DeepLearning-09.png differ diff --git a/Assets/prakBMT-DeepLearning-10.png b/Assets/prakBMT-DeepLearning-10.png new file mode 100644 index 0000000..bbe1324 Binary files /dev/null and b/Assets/prakBMT-DeepLearning-10.png differ diff --git a/Assets/prakBMT-DeepLearning-11.png b/Assets/prakBMT-DeepLearning-11.png new file mode 100644 index 0000000..c53ac4e Binary files /dev/null and b/Assets/prakBMT-DeepLearning-11.png differ diff --git a/Assets/prakBMT-DeepLearning-12.png b/Assets/prakBMT-DeepLearning-12.png new file mode 100644 index 0000000..6544148 Binary files /dev/null and b/Assets/prakBMT-DeepLearning-12.png differ diff --git a/Assets/prakBMT-DeepLearning-13.png b/Assets/prakBMT-DeepLearning-13.png new file mode 100644 index 0000000..27ee28e Binary files /dev/null and b/Assets/prakBMT-DeepLearning-13.png differ diff --git a/Assets/prakBMT-DeepLearning-14.png b/Assets/prakBMT-DeepLearning-14.png new file mode 100644 index 0000000..ed98edd Binary files /dev/null and b/Assets/prakBMT-DeepLearning-14.png differ diff --git a/Assets/prakBMT-DeepLearning-15.png b/Assets/prakBMT-DeepLearning-15.png new file mode 100644 index 0000000..9e74981 Binary files /dev/null and b/Assets/prakBMT-DeepLearning-15.png differ diff --git a/Betriebssysteme.md b/Betriebssysteme.md new file mode 100644 index 0000000..fdd1fdb --- /dev/null +++ b/Betriebssysteme.md @@ -0,0 +1,2484 @@ +--- +title: Betriebssysteme +date: Wintersemester 20/21 +author: Robert Jeutter +--- + +- [Einführung](#einführung) + - [Extrem breites Anwendungsspektrum](#extrem-breites-anwendungsspektrum) + - [Funktionale und nicht-Funktionale Eigenschaften](#funktionale-und-nicht-funktionale-eigenschaften) + - [Funktionale Eigenschaften (= Funktionen, Aufgaben)](#funktionale-eigenschaften--funktionen-aufgaben) + - [Nichtfunktionale Eigenschaften](#nichtfunktionale-eigenschaften) + - [Blick in Betriebssystem-Zoo](#blick-in-betriebssystem-zoo) +- [Prozessormanagement: Prozesse und Threads](#prozessormanagement-prozesse-und-threads) + - [Grundsätzliches](#grundsätzliches) + - [Prozesserzeugung](#prozesserzeugung) + - [Was geschieht bei der Prozesserzeugung](#was-geschieht-bei-der-prozesserzeugung) + - [Prozesserzeugung: notwenige Vorraussetzungen](#prozesserzeugung-notwenige-vorraussetzungen) + - [Prozesserzeugung: Namensvergabe](#prozesserzeugung-namensvergabe) + - [Prozesserzeugung: Stammbaumpflege](#prozesserzeugung-stammbaumpflege) + - [Prozesserzeugung: Allokation (Zuordnung) von Ressourcen](#prozesserzeugung-allokation-zuordnung-von-ressourcen) + - [Prozesserzeugung: Management Datenstrukturen](#prozesserzeugung-management-datenstrukturen) + - [Aktionen des Prozessmanagements](#aktionen-des-prozessmanagements) + - [Prozessterminierung](#prozessterminierung) + - [Threads](#threads) +- [Scheduling](#scheduling) + - [Das Problem](#das-problem) + - [Aufgabe der Zustandsmodelle](#aufgabe-der-zustandsmodelle) + - [Scheduleraktivierung](#scheduleraktivierung) + - [Scheduling Strategien](#scheduling-strategien) + - [Batch-System („Stapelverarbeitungs“-System)](#batch-system-stapelverarbeitungs-system) + - [Interaktives System](#interaktives-system) + - [Einbeziehung von Prioritäten](#einbeziehung-von-prioritäten) + - [Schedulingziele in Echtzeitsystemen](#schedulingziele-in-echtzeitsystemen) + - [Zusammenfassung](#zusammenfassung) +- [Privilegierungsebenen](#privilegierungsebenen) +- [Kommunikation und Synchronisation](#kommunikation-und-synchronisation) + - [Elementare Konzepte](#elementare-konzepte) + - [Algorithmen zum wechselseitigen Ausschluss](#algorithmen-zum-wechselseitigen-ausschluss) + - [Synchronisations- & Kommunikationsmechanismen](#synchronisations---kommunikationsmechanismen) + - [(binäre) Semaphore](#binäre-semaphore) + - [Hoare'sche Monitore](#hoaresche-monitore) + - [weitere Konzepte](#weitere-konzepte) + - [Transaktionaler Speicher](#transaktionaler-speicher) + - [Botschaften](#botschaften) + - [Fernaufrufe (Remote Procedure Calls, RPCs)](#fernaufrufe-remote-procedure-calls-rpcs) + - [Systemaufrufe](#systemaufrufe) + - [Ereignismanagement](#ereignismanagement) + - [IPC Modell](#ipc-modell) + - [pop-up-Thread-Modell](#pop-up-thread-modell) + - [Implementierungstechniken](#implementierungstechniken) + - [Zusammenfassung](#zusammenfassung-1) +- [Speichermanagement](#speichermanagement) + - [Speichertechnologien und -klassen](#speichertechnologien-und--klassen) + - [Was muss Arbeitsspeicher können?](#was-muss-arbeitsspeicher-können) + - [Layout des (physischen) Arbeitsspeichers: 50er Jahre](#layout-des-physischen-arbeitsspeichers-50er-jahre) + - [Layout des physischen Arbeitsspeichers: 60er Jahre](#layout-des-physischen-arbeitsspeichers-60er-jahre) + - [Relokation](#relokation) + - [Swapping](#swapping) + - [Virtueller Speicher](#virtueller-speicher) + - [Virtuelles Speichermanagement (VMM)](#virtuelles-speichermanagement-vmm) + - [Begriffe](#begriffe) + - [Abbildung $vm_p$](#abbildung-vm_p) + - [Memory Management Units (MMUs)](#memory-management-units-mmus) + - [Seitenabbildungstabellen](#seitenabbildungstabellen) + - [Seitenaustausch-Algorithmen](#seitenaustausch-algorithmen) + - [First-In , First-Out (FIFO)](#first-in--first-out-fifo) + - [Second Chance (Variante des FIFO-Algorithmus)](#second-chance-variante-des-fifo-algorithmus) + - [Least Recently Used (LRU)](#least-recently-used-lru) + - [Working Set](#working-set) + - [WSClock](#wsclock) + - [Zusammenfassung](#zusammenfassung-2) + - [Segmentierung](#segmentierung) + - [VMM- Abstraktionen in der Praxis](#vmm--abstraktionen-in-der-praxis) + - [Zusammenfassung](#zusammenfassung-3) +- [Dateisystem](#dateisystem) + - [Dateimodelle](#dateimodelle) + - [Aufgabe: Präzise Festlegung der Semantik der Abstraktion „Datei“](#aufgabe-präzise-festlegung-der-semantik-der-abstraktion-datei) + - [Aufgabe: Identifikation von Dateien mittels symbolischer Namen](#aufgabe-identifikation-von-dateien-mittels-symbolischer-namen) + - [Datei-Attribute](#datei-attribute) + - [Operationen auf Dateien](#operationen-auf-dateien) + - [Zusammenfassung Dateimodelle](#zusammenfassung-dateimodelle) + - [Dateisysteme](#dateisysteme) + - [Speichermedien](#speichermedien) + - [Management-Datenstrukturen auf Speichermedien](#management-datenstrukturen-auf-speichermedien) + - [Verzeichnisse](#verzeichnisse) + - [Freiliste](#freiliste) + - [Superblock](#superblock) + - [Datenstrukturen u. Algorithmen des Betriebssystems](#datenstrukturen-u-algorithmen-des-betriebssystems) +- [Netzwerkmanagement](#netzwerkmanagement) +- [E/A Systeme](#ea-systeme) + - [Hardware Prinzipien](#hardware-prinzipien) + - [Kommunikationsmuster mit einem Controller](#kommunikationsmuster-mit-einem-controller) + - [E/A- Adressräume](#ea--adressräume) + - [Memory Mapped E/A](#memory-mapped-ea) + - [Software Prinzipien](#software-prinzipien) + - [Zusammenfassung](#zusammenfassung-4) +- [High-End-Betriebssysteme](#high-end-betriebssysteme) + - [Was sind High-End- Betriebssysteme?](#was-sind-high-end--betriebssysteme) + - [Sicherheit](#sicherheit) + - [Ein Beispiel: SELinux](#ein-beispiel-selinux) + - [Robustheit](#robustheit) + - [Abschließend](#abschließend) +- [Abschließende Zusammenfassung und Schwerpunkte](#abschließende-zusammenfassung-und-schwerpunkte) + +# Einführung +worauf es ankommt: +- Korrektheit +- Sicherheit +- Verfügbarkeit +- Skalierbarkeit +- Echtzeitfähigkeit +- Robustheit +- Sparsamkeit + +## Extrem breites Anwendungsspektrum +- funktionale Eigenschaften + - Authentisierung, Verschlüsselung + - Fahrzeug/Verkehrsmanagement + - Informationsmanagement + - Kommunikationsmanagement +- nichtfunktionale Eigenschaften + - Sicherheit + - Korrektheit + - Echtzeitfähigkeit + - Skalierbarkeit + - Offenheit + - Sparsamkeit + - Verfügbarkeit + - Robustheit + +mit vielen Gemeinsamkeiten +- Architekturprinzipien +- Programmierparadigmen + +voller individueller Strategien mit teils konfligierenden Zielen +- Performanz $\leftrightarrow$ Robustheit +- Echtzeitfähigkeit $\leftrightarrow$ Effizienz + +$\Rightarrow$ spezialisierte Betriebssystem-Familien1. Einführung + +## Funktionale und nicht-Funktionale Eigenschaften +Beispiel Essen: +- funktionale Eigenschaft: es soll satt machen +- nichtfunktional: Geschmack, Aussehen,... + +### Funktionale Eigenschaften (= Funktionen, Aufgaben) +- Betriebssysteme: sehr komplexe Softwareprodukte +- Ein Grund für diese Komplexität: besitzen Reihe von Aufgaben - also funktionale Eigenschaften +- Hauptaufgaben dabei: + 1. Verwalten der Resourcen des Systems (Hard-u. Software-Ressourcen) + 2. Transformation der „hässlichen“ Hardwareschnittstellen in angenehme nutzerfreundliche Schnittstelle (Betriebssystem als „Erweiterung“ der Maschine, auch Hardware + BS = „virtuelle Maschine“) + 3. Dabei für beide Aufgaben: Schaffung sinnvoller Abstraktionen(Prozess, Datei,... $\rightarrow$ Softwareressourcen) + +### Nichtfunktionale Eigenschaften +Wie - mit welchen speziellen weiteren Eigenschaften sollen die funktionalen Eigenschaften realisiert werden. Z.B. schon genannt: +- Echtzeitfähigkeit: Betriebssystem-Komponenten, -Algorithmen usw. mit solchen Eigenschaften realisieren, dass Betriebssystem insgesamt echtzeitfähig ist +- Robustheit: Betriebssystem-Komponenten, -Algorithmen usw. mit solchen Eigenschaften realisieren, dass Betriebssystem insgesamt robust ist +- usw + +## Blick in Betriebssystem-Zoo +- Mainframe Betriebssystem + - performante E/A + - Massendatenverarbeitung +- Server Betriebssystem + - viele Klienten, permanente Kommunikation + - Web Server, Fileshare +- Parallelrechner Betriebssystem + - Number Crunching, parallele Algorithmen mit hohem Rechenbedarf + - schnelle IPC +- Desktop/Laptop Betriebssystem + - Interaktivität/Responsivität +- Echtzeit Betriebssystem + - Einhaltung zeitlicher Garantien, Safety + - Fahrzeug-, Anlagensteuerung +- Eingebettete Systeme + - in Fahrzeugen, Kaffeemaschinen, Telefonen... + - z.T. Spezialaufgaben + +# Prozessormanagement: Prozesse und Threads +## Grundsätzliches +1. Computer bearbeiten Aufgaben in wohldefinierten Arbeitsabläufen (beschrieben durch Programme/Algorithmen) +2. bei abarbeitung von Programmen entstehen oft Wartesituationen +3. Wartezeiten sind ~ relativ zur Prozessorgeschwindigkeit ~ gigantisch (1 Sek ~ 10 Milliarden Prozessorzyklen) +4. statt zu warten, lässt sich besseres tun (parallele Ausführung mehrerer Aufgaben) +5. Parallelität geht nicht immer (vorraussetzung Nebenläufigkeit) + +Begriffe +1. Aktivitäten heißen nebenläufig, wenn zwischen ihnen keine kausalen abhängigkeiten bestehen +2. Aktivitäten heißen parallel, wenn sie zeitlich überlappend druchgeführt werden + + +> Definition Prozess: Ein Prozess ist eine Abstraktion zur vollständigen Beschreibung einer sequenziell ablaufenden Aktivität + +parallele Aktivitäten werden repräsentiert durch parallele Prozesse + +> Prozess = betriebssystem-Abstraktion zur Ausführung von programmen + +> Prozessmodelle: definieren konkrete Prozesseigenschaften + +> Prozessmanagement: Komponente eines Betriebssystems, die Prozessmodell dieses Betriebssystems implementiert + +> Aufgabe: präzise Definition der Betriebssystem-Abstraktion "Prozess" +(definiert durch Semantik und nichtfunktionale Eigenschaften; implementiert durch Datenstrukturen/Algorithmen) + +> Prozesserzeugung: Erzeugen einer Programmablaufumgebung + +## Prozesserzeugung +### Was geschieht bei der Prozesserzeugung +1. Prüfen notwendiger Vorraussetzungen (Rechte, Ressoucenverfügbarkeit,...) +2. Namensvergabe und "Stammbaumpflege" +3. Allokation von Ressourcen (Arbeitsspeicher, Prozessorzeit) +4. Anlegen von Managementstrukturen (belegte Ressourcen, Laufzetmanagement) + +### Prozesserzeugung: notwenige Vorraussetzungen +1. Rechte: zur Prozesserzeugung und Ressourcenallokation (Kontingente) +2. Ressourcenverfügbarkeit (Arbeitsspeicher, Rechenzeit, Kommunikation) +3. Sicherheit (Authentizität und Integrität des auszuführenden Programms) +4. bei Echtzeitbetriebssystem + - Erfüllung von Ressourcenanforderung + - Einhaltung gegebener Garantien +5. Fairness (Quoten) +6. robustheit/Überlastvermeidung (Lastsituation) + +### Prozesserzeugung: Namensvergabe +Identifikation ist positive ganze Zahl durch Vergabe Algorithmus. Kann nach Terminierung eines Prozesses erneut vergeben werden +- eindeutig: zu einem Zeitpunkt bzgl aller existierenden Prozesse +- nicht unbedingt eindeutig: für zeitlich nicht überlappende Prozesse +- erst recht nicht eindeutig: über Systemgrenze hinweg + +### Prozesserzeugung: Stammbaumpflege +Abstammungsbeziehung: definieren Eltern/Kind Hierarchie +1. Prozess erzeugt weitere Prozesse: Kinder +2. diese wiederum erzeugen weitere Prozesse usw +-> baumartige Abstammungshierarchie +Nutzung: Rechte und Verantwortlichkeiten + +Verwaiste Prozesse -> Adoption (durch Urprozess) + +### Prozesserzeugung: Allokation (Zuordnung) von Ressourcen +1. Arbeitsspeicher + 1. Größe: Wie viel Arbeitsspeicher benötigt der Prozess? + 2. Zeitpunkt: zu welchem Zeitpunkt? Echtzeiteigenschaften (Planbarkeit) oder Performanz (proaktivität)? + 3. Isolation: wie ist er geschützt? (Robustheit, Sicherheit, Korrektheit) +2. Prozessorzeit + 1. in Prozessmodellen echtzeitfähiger Systeme: Größe und Zeitpunkt + 2. in Prozessmodellen ohne diese Eigenschaften: dynamisches ad-hoc-Scheduling + +für richtige Initialisierung: präzise Formatvereinbarung zwischen +- Linker (Programmdatei-Produzent) +- Prozessmanagement des BS (Programmdatei Nutzer) + +1. das a.out-Format (veraltet; ursprünglich Unix Format) +2. das Mach Object File Format (Mach-O; heutiger Standard für OS X, iOS) +3. das Executable and Link(age/able) Format (ELF; heutiger Linux standard) + +### Prozesserzeugung: Management Datenstrukturen +Buchführung über sämtliche zum management notwendigen Informationen +- Prozessidentifikation +- Rechtemanagement +- Speichermanagement +- Prozessormanagement +- Kommunikationsmanagement + +a. Prozessdeskriptor (process control block ~ PCB) +b. Prozessdeskriptortabelle: Deskriptioren sämtlicher Prozesse + +| Prozessormanagement (Prozessdeskriptor) | | +| Identifikation | eindeutige Prozessbezeichnung; einordnung in Abstammungshierarchie | +| Scheduling | Informationen für Schedulingalgorithmen | +| Prozessorkontext | gesichert bei Verdrängung des Prozesses, restauriert bei Reaktivierung | +| Ereignismanagement | what if... | +| Accounting (Kontoführung) | zur Prioritätsbestimmung, Statisik, kostenberechnung | +| Virtueller Adressraum | Beschreibung des Speicherlayouts | +| Kernel Stack | Prozedurmanagement innerhalb des BS | +| Rechtemanagement | | +| Allgemeines Ressourcenmanagement | Filedeskriptoren, Socketdeskriptoren,... | + +### Aktionen des Prozessmanagements +- Prüfen notweniger Vorraussetzungen +- Namensvergabe und Stammbaum +- Allokation von Ressourcen +- Anlegen von Managementdatenstrukturen (Prozessdeskriptor) + +### Prozessterminierung +durch +- Aufgabe erledigt +- Fehler aufgetreten +- durch Nutzer/Eigentümer geschlossen +- ... + +1. Freigabe der Ressourcen +2. Benachrichtigung der "Eltern" +3. Adoption der "Kinder" + +## Threads +Naive Lösung: für jede nebenläufige Aktivität einen Prozess erstellen. Jedoch hat ein Prozess: +- Kosten des Managements +- kosten der isolation +- Kosten der Kommunikation + +$\rightarrow$ Parallelität mittels Prozessen ist teuer (revidiertes Prozessmodell) + +Daher suche nach kostengünstigerem Modell zur Parallelisierung nebenläufiger Aktivitäten + +> Definition Prozess: Ein (Multithread-) Prozess ist eine vollständige Beschreibung einer ablaufenden Aktivität. Dazu gehört insbesondere +> 1. Das ablaufende Programm +> 2. zugeordnete Betriebsmittel +> 3. Rechte +> 4. prozessinterne parallele Aktivitäten (Threads) und ihre Bearbeitungszustände + +> Definition Thread: ist eine sequenzielle Aktivität im Betriebsmittelkontext (d.h. innerhalb) eines Prozesses + +parallele Aktivitäten innerhalb eines Prozesses werden durch parallele Threads repräsentiert. + +Anmerkung: +1. **Eigentümer von Ressourcen und Rechten** sind immer noch prozesse +2. das **Programm eines Prozesses** kann nun Code für mehr als eine sequenzielle Aktivität enthalten +3. **Gegenstand der Prozesszuteilung** sind nun Threads +4. das **ursprüngliche Prozessmodell** ist eine Spezialisierung dieses Modells (ein Prozess mit genau einem Thread) +5. ein **Prozessdescriptor** (PCB) eines Multithread-Prozessmodells enhält alle Informationen des PCBs eines Single-Thread-Prozessmodells plus Informationen über alle seine Threads +6. ein **TCB** enthält lediglich den Threadszustand und den Ablaufkontext + +Threads werden daher oft als *Leichtgewichtprozesse* bezeichnet + + +Threads treten in verschiedenen Varianten auf +1. komfortabel (integriert in Programmiersprache) +2. "zu Fuß" (durch Bibiliotheken oder API) + +Implementierungsebenen +1. Prozessmodell des Betriebssystems ist Multithread Modell + - Thread Implementierung im Betriebssystem + - das Betriebssystem hat Kenntnis über Threads + - Kernel Level Threads (KLTs) +2. Prozessmodell des Betriebssystems ist Single-Thread-Modell + - Thread Implementierung auf Anwendungsebene + - nur auf Endbenutzer-Ebene ist Kenntnis über Threads + - User Level Thread (ULTs) + +| Pro KLT | Pro ULT | +| Performanz durch Parallelität | Performanz durch geringen Overhead | +| Nutzung von Mehrprozessor/Mehrkernarchitektur | Thread Management ohne Systemaufrufe | +| ein blockierender Systemaufruf in einem Thread blockiert nicht auch gleichzeitig alle anderen Threads des gleichen Prozesses | Thread Umschaltung ohne Mitwirkung des Betriebssystems | +| | Individualität: anwendungsindividuelle Thread Schedulingstrategien möglich | +| | Portabilität | + +es gibt Work-Arounds: alle gefährlichen Systemaufrufe einpacken (in Pakete) + +Wahl zwischen ULT- und KLT hängt ab von: +1. Vorraussetzung: Prozessmodell des Betriebssystems Multithread Modell? +2. Anwendungsprofil: E/A-Profil, Parallelität, Portabilität, Individualität + +# Scheduling +## Das Problem +Anzahl der Aktivitäten >> Anzahl der Prozessoren +- nicht alle können gleichzeitig arbeiten +- eine Auswahl muss getroffen werden +- Auswahlstrategie: Schedunling-Strategie/Algorithmus +- die Betriebssystem Komponente Scheduler +- Ziel: Effizientes Ressourcenmanagement + +Threads können +- aktiv sein (besitzt einen Prozessor) +- rechenbereit sein (Bsp. hätte gerne einen Prozessor) +- kurzfristig warten (Bsp. benötigt keinen Prozesoor aber Arbeitsspeicher) +- langfristig warten (Bsp. benötigt länger keinen Prozessor/Arbeitsspeicher) + +Threadzustände im 3/5-Zustandsmodell +- bereit: kann aktiv werden, sobald Prozessor frei wird +- aktiv: besitzt einen Prozessor, arbeitet +- blockiert: wartet auf Ereignis (Timer Ablauf,...) +- frisch: erzeugt, Betriebsmittel/Rechte zum Ablauf fehlen noch +- beendet: Betriebsmittel in der Freigabephase + +Folge: effizientes Ressourcenmanagement benötigt präzise Informationen über Threadzustände. + +## Aufgabe der Zustandsmodelle +Beschreibung: +- des Ablaufzustands von Threads (aktiv/bereit/wartend) +- der mögliche Zustandsübergänge (z.B. bereit->aktiv) + +Nutzung +- jeder Thread ist zu jedem Zeitpunkt in genau einem dieser Zustände +- jeder Thread wechselt seinen Zustand gemäß der im Modell definierten Zustandsübergänge, hervorgerufen durch z.B. Zuteilung eines Prozessors +- Ressourcenmanagement: nutz Zustand als Informationsquelle für Entscheidungen + +Beschreibungsmittel: endliche deterministische Automaten +- Menge der annehmbaren Zustände ist endlich +- Folgezustand ist immer eindeutig bestimmt + +## Scheduleraktivierung +Wann wird die letzte Scheduling-Entscheidung überprüft? +1. Prozess/Thread erzeugung (neuer, rechenbereiter Thread) +2. Threadterminierung, Threadblockierung (ein Prozessor wird frei) +3. Ereigniseintritt (Thread wird rechenbereit) +4. Wechsel von Prioritäten (in prioritätenbastierten Schedulingalgorithmen) +5. periodisch (in zeitscheibenbasierten Schedulingalgorithmen) + +Ein Kontextwechsel umfasst: +- bei Wechsel zwischen Threads desselben Prozesses + - Stackkontext + - Prozessorregister + - floating point unit (hohe Kosten) (FPU) +- zusätzlicher Wechsel zwischen Threads verschiedener Prozesse + - Speicherlayout (sehr hohe Kosten) +- starke Auswirkungen auf + - Gesamtperformanz + - Reaktivität + - Echtzeiteigenschaften + +Kostenfaktor FPU +- Kopieren des FPU-Kontexts: sehr viele Register (sofortkosten) + - Realisierung: "faul" + - Hardware hilft: FPU Protection +- Auswirkung + - nur ein Thread benutzt FPU: tatsächliches Sichern erfolgt nie + - wenige Threads benutzen FPU: tatsächliches Sichern minimiert + +## Scheduling Strategien +Strategische Ziele +- abhängig vom Einsatzfeld eines Betriebssystems + - Echtzeitsysteme: Einhaltung von Fristen + - interaktive Systeme: Reaktivität + - Serversysteme: Reaktivität, E/A-Performanz + - Batch-Verarbeitungssysteme: Durchsatz +- ergänzt durch allgemeine Ziele + - Fairness: Threads bekommen einen fairen Anteil an Rechenzeit + - Lastbalancierung: alle Systemkomponenten (CPUs, Speicher, E/A-Peripherie) sind gleichmäßig ausgelastet + - Overhead: z.B. wenig Prozesswechsel +- Ausbalancierung mehrerer Ziele + - multikriterielle Optimierungsaufgabe, i.d.R. NP-vollständig + - heuristische Scheduling-Algorithmen + +Typische Muster aktiver Threadphasen: +- CPU lastig (mathematische Berechnung, Verschlüsselung,...) +- E/A lastig (interaktiver Prozess, ...) +- periodische Last (Echtzeitvideoverarbeitung, ...) +- chaotische Last (server mit inhomogenen Diensten) + +Differenzierte Scheduling-Strategien +- nutzen Wissen über Lastmuster zur Optimierung, z.B. + 1. Einhaltung von Fristen + 2. Minimierung der Thread/Prozesswechsel + +### Batch-System („Stapelverarbeitungs“-System) +- Aufträge: in Gruppen („Stapel“) eingeteilt u. so verarbeitet +- Abarbeitung: ohne aktive Mitwirkung eines Benutzers (Gegensatz: interaktiv) +- ursprünglich: frühe Entwicklungsstufe von Betriebssystemen + +Ziele hier +1. Auslastung teurer Betriebsmittel (i.d.R. Maximierung der CPU-Auslastung) +2. Minimierung der Scheduling-Kosten (wenig Prozesswechsel, kurze Laufzeit des Scheduling-Algorithmus) +3. Maximierung des Durchsatzes (erledigte Arbeit / Zeit) + +zwei der bekannteren: +1. First Come, First Served (FCFS) + - in Reihenfolge, in der Threads rechenbereit werden + - extrem einfache Strategie, guter Durchsatz + - nicht immer sehr klug +2. Shortest Remaining Time Next (SRTN) + - Prozessor erhält Thread mit voraussichtlich kürzester Restrechenzeit + - preemptiv* ) , d.h. Threads können von konkurrierenden Threads verdrängt werden + - (Schätzwert über) Restlaufzeit muss vorliegen + +### Interaktives System +- Benutzer: kann bei Programmabarbeitung in Aktivitäten des Computers eingreifen +- Abarbeitung: mit aktiver Mitwirkung eines Benutzers (Gegensatz: batch processing) +- fortgeschrittenere Betriebssystem-Technik + +Ziele hier +1. Minimierung von Reaktionszeiten (subjektiver Eindruck von Performanz) +2. Fairness (mehrere Benutzer/Klienten) + +Algorithmen: Round Robin Varianten + - jeder Thread: bekommt ein gleich großes Teil „des Kuchens“: die Zeitscheibe + - einfach zu implementieren (1 Warteschlange, Uhr) + - geringe Algorithmuskosten (O(1): FIFO-Warteschlange, Ring) + - schnelle Entscheidungen (O(1): Nr. 1 aus Warteschlange) + - notwendiges Wissen gering (CPU-Nutzungsdauer des aktiven Threads) + +#### Einbeziehung von Prioritäten +Ziel: Ausdrucksmöglichkeit der Wichtigkeit von Threads +1. niedrig: z.B. + - Dämonen (die z.B. im Hintergrund Emails abrufen) + - Putzarbeiten (z.B. Defragmentierung) +2. hoch: z.B. + - auf Aufträge reagierende Threads (z.B. in Servern) + - auf Benutzereingaben reagierende Threads (z.B. aktives Fenster einer GUI) + - unter Echtzeitbedingungen arbeitende Threads (z.B. Motormanagement, DVD-Spieler) + +Idee(n) +1. jeder Thread: erhält individuelle Priorität +2. Threads der höchsten Prioritäten: erhalten einen Prozessor +3. zwischen Threads gleicher Priorität: Round-Robin + +viele Varianten dieses Schemas +- statische Prioritäten, z.B. in + - planbaren Echtzeitsystemen (Autoradio: Reaktion auf Stationswechseltaste hat Vorrang vor Senderfeldstärkenüberwachung) + - kommerziellen Rechenzentren (wer mehr zahlt, ist eher an der Reihe) +- dynamische Prioritäten, abhängig z.B. von + - verbrauchter CPU-Zeit (Verhinderung der Dominanz) + - E/A-Intensität + - Wartegrund + +### Schedulingziele in Echtzeitsystemen +Finden einer Bearbeitungsreihenfolge (ein „Schedule“), +- die Fristen einhält +- deren Berechnung ökonomisch ist (Kosten des Scheduling-Algorithmus) +- die selbst ökonomisch ist (Minimierung der Threadwechsel) +- die sich (evtl.) an wechselnde Lastmuster anpasst + +Verbreitete Algorithmen +- EDF: früheste Frist zuerst (earliest deadline first) + - für dynamische Lasten + - wird ein Thread rechenbereit, so „nennt“ er seine nächste Deadline (Frist) + - von allen bereiten Threads ist immer derjenige mit der frühesten Deadline aktiv (dringend=wichtig) + - Folglich + - arbeitet der Algorithmus mit dynamischen Prioritäten → adaptiv + - ist die Thread-Priorität um so höher, je näher dessen Frist liegt + - ist er preemptiv + - Voraussetzung: kausale und zeitliche Unabhängigkeit der Threads (keine wechselseitige Blockierung) +- RMS: Raten-monotones Scheduling (rate-monotonic scheduling) + - für periodische Lasten (z.B. Mischpult, DVD-Spieler, technische Prozesse) + - wird ein Thread rechenbereit, so „nennt“ er seine Periodendauer + - von allen bereiten Threads ist immer derjenige mit der kürzesten Periodendauer aktiv + - Folglich: + - arbeitet der Algorithmus mit statischen Prioritäten + - ist die Thread-Priorität um so höher, je kürzer die Periodendauer ist + - ist er preemptiv + - Voraussetzung: periodische Threads; kausale und zeitliche Unabhängigkeit der Threads + +## Zusammenfassung +Anzahl der Threads >> Anzahl der Prozessoren +- nicht alle können gleichzeitig rechnen +- eine Auswahl muss getroffen werden +- → Auswahlstrategie: Schedulingalgorithmen + +# Privilegierungsebenen +Problematik: Anwendungsprozesse und Betriebssystem nutzen gemeinsame (Hardware-)Ressourcen + +Schutz vor fehlerbedingten oder bösartigen räumlichen/zeitlichen Wechselwirkungen + +2 Konzepte +1. private Adressräume +2. Zugriffsschutz auf Arbeitsspeicherbereiche + +Verhinderung zeitlicher Wechselwirkungen +- Ursache: Prozesse geben freiwillig keine Prozessoren auf +- Umgang damit + - periodische Aktivierungen preemptiver Scheduler (Uhr) + - Scheduler-Aktivierungen durch asynchrone Ereignisse +- kritisch also: Operationen zum Abschalten von + 1. Uhr + 2. Ereignismanagement +- weitere kritische Operationen + 1. Veränderung des Speicherlayouts + 2. Veränderung kritischer Prozessorkontrollregister + 3. Zugriff auf E/A-Geräte +- notwendig: Schutz kritischer Operationen des Instruktionssatzes + +Lösungskonzept: Privilegierungsebenen ablaufender Aktivitäten, z.B. + - „kernel mode“ (≈ Betriebssystem-Modus) + - „user mode“ (Nutzer-Modus) +- ermöglichen: Durchsetzung von Regeln: + - „Nur eine im „kernel mode“ ablaufende Aktivität hat Zugriff auf ...“ +- Privilegierungsebenen steuern Rechte ... + 1. zur Ausführung privilegierter Prozessorinstruktionen + 2. zur Konfiguration des Arbeitsspeicher-Layouts + 3. zum Zugriff auf Arbeitsspeicherbereiche + 4. zum Zugriff auf E/A-Geräte + +Realisierung: abhängig von Prozessorarchitektur +- in Ringen 0 (höchste Priorität) bis 3 (niedrigste Priorität) + +Implementierung: Hardware-Unterstützung +- aktuelle Privilegierungsebene ist + - Teil des Prozessor-Statusregisters: „Current Privilege Level“ (CPL) + - Grundlage der Hardware-Schutzmechanismen; permanente Überwachung + - der ausgeführten Instruktionen + - der Arbeitsspeicherzugriffe + - der E/A-Peripheriezugriffe +- Modifikation des CPLs nur + 1. durch privilegierte Instruktionen + 2. bei Beginn und Abschluss + - des Aufrufs von Systemdiensten + - einer Ereignisbehandlung + +Botschaften +- jede auf Privilegierungsebene < 3 ablaufende Aktivität hat Zugriff auf kritische Ressourcen +- jede auf Privilegierungsebene 0 ablaufende Aktivität hat Zugriff auf + 1. sämtliche Ressourcen eines Prozessors + - sämtliche Instruktionen (z.B. HALT) + - sämtliche Prozessorregister (z.B. Prozessor-Status-Register (PSR) ) + 2. MMU-Register zur Arbeitsspeicherkonfiguration + 3. sämtliche Register der E/A-Peripherie + +Sämtliche Schutz- und Sicherheitsmechanismen von +- Anwendungsprozessen +- Betriebssystem +beruhen elementar auf 2 Bits: „Current Privilege Level“ (CPL) im Prozessor-Status-Register (PSR) + + +# Kommunikation und Synchronisation +## Elementare Konzepte +Beispiele: +- Aufträge an Geräte und (Dienstleistungs-)Prozesse, z.B. +- Kooperative Arbeit von Betriebssystem-Komponenten +- Arbeit verschiedener Betriebssystemkomponenten mit (gemeinsamen) Management-Datenstrukturen +- Interaktionen zwischen Anwendungsprozessen + +Die Auftragstabelle ist eine (Software-)Ressource. +- Problem: ein Fehler entsteht dadurch, dass zwei (oder mehr) Prozesse oder Threads „durcheinander“ auf der Ressource arbeiten +- Lösung: Unkoordiniertes Arbeiten mit der Ressource muss verhindert werden! +Erst wenn ein Prozess (oder Thread) seine Arbeit mit der Ressource vollständig abgeschlossen hat, darf der nächste aktiv werden. +Die Befehlsfolge innerhalb der Prozesse, während deren Abarbeitung auf die Ressource zugegriffen wird, ist ein kritischer Abschnitt. +- Außerdem: genauere Betrachtung eines einzelnen Auftrags; kann aus mehreren Komponenten bestehen +- Problem: durch „unkoordiniertes“ Arbeiten mehrerer Threads kann es auch bei den Auftrags-Einträgen zu Inkonsistenzen kommen + +Fazit: +- Gesamte Arbeit an Auftragstabelle ist kritischer Abschnitt. +- Nur 1 Thread darf zu einem Zeitpunkt mit Auftragstabelle arbeiten. +- Erst wenn dieser Arbeit beendet hat, darf ein neuer Thread mit der Auftragstabelle arbeiten. + +Definitionen:\\ +Es gibt Ressourcen, die als ganzes oder bzgl. einzelner Operationen nur exklusiv, d.h. zu einem Zeitpunkt nur durch einen einzigen Thread nutzbar sind. +1. Eine Phase, in der ein Thread eine exklusive Operation auf einer Ressource ausführt, heißt kritischer Abschnitt. +2. Kritische Abschnitte erfordern den wechselseitigen Ausschluss (die Isolation) konkurrierender Threads bzw. Prozesse. + +Beispiel 2: Kommunikation von 2 Prozessen über gemeinsamen Speicherbereich („Erzeuger-Verbraucher-Problem“) +- Problembeschreibung: + - Ein Prozess schreibt Daten in den Speicherbereich ... + - Der zweite Prozess liest diese Daten ... + - Die Datenmenge ist so umfangreich, dass dieser Vorgang mehrmals (abstrahiert: unendlich oft) wiederholt werden muss. +- 1. Problem (Puffer voll, Puffer leer); unterschiedliche Geschwindigkeiten von Erzeuger und Verbraucher +- 2. Problem (Puffer wird gerade benutzt); gleichzeitiges Lesen und Schreiben des selben Pufferelements + +## Algorithmen zum wechselseitigen Ausschluss +Genauere Definition des Problems (Annahmen) +1. konkurrierende Threads arbeiten asynchron, z.B. in einer unendlichen Schleife +2. dabei betreten und verlassen sie irgendwann einen kritischen Abschnitt +3. Betreten und Verlassen dieses Abschnitts: wird durch Algorithmen organisiert, die den kritischen Abschnitt umgeben (Entry/Exit-Code) + +Grundsätzliche Anforderungen +1. Korrektheit: In einem kritischen Abschnitt befindet sich zu jedem Zeitpunkt höchstens ein Thread (**wechselseitiger Ausschluss**). +2. Lebendigkeit: Falls ein Thread einen kritischen Abschnitt betreten möchte, dann betritt (irgendwann) (irgend-) ein Thread diesen Abschnitt. [Folglich kann **irgendwann** auch der erstgenannte Thread **den kritischen Abschnitt betreten**.] +3. Verhungerungsfreiheit: **Kein Thread wartet für immer** vor einem kritischen Abschnitt. + +Wechselseitiger Ausschluss: ein erster (naiver) Versuch +- Ideen + 1. während Benutzung des Puffers: wird dieser als „busy“ markiert + 2. bei Vorfinden eines so markierten Puffers: wird gewartet +- Verhungern: z.B. bei Pseudoparallelität (fortwährende Unterbrechung des Writers im kritischen Abschnitt) + +## Synchronisations- & Kommunikationsmechanismen +- Austausch von Daten zwischen Prozessen $\rightarrow$ Kommunikation (Inter-Prozess-Kommunikation, IPC) +- Abweichende Geschwindigkeiten von Sender und Empfänger $\rightarrow$ Synchronisation + +Betrachtete Mechanismen: +- Semaphore +- Hoare ́sche Monitore +- Transaktionalen Speicher +- Botschaften +- Fernaufrufe + +### (binäre) Semaphore +Idee: Flagge +- mit 2 Zuständen + 1. frei + 2. belegt +- mit 2 atomaren Operationen + 1. belegen: P( Semaphorname ) („Passeren“) + 2. freigeben: V (Semaphorname) („Vriegeven“) +- Sämtliche Nutzer dieses kritischen Abschnitts müssen diese semaphore verwenden (Entry-/Exit-Code, Türwächter) +- besser: kein aktives Warten + +```cpp +// pic ← codePicFromCamStream(); +if bufferBusy.zustand = frei then +bufferBusy.zustand ← belegt +else +bufferBusy.warteliste ← aufrufer +fi +//write(buffer, pic); +if bufferBusy.warteliste = leer then +bufferBusy.zustand ← frei +else +bufferBusy.warteliste.vorne.continue +fi +``` + +Implementierung von Semaphoren z.B. als Klasse (Objekt-Orientiert), +- die die Methoden P und V exportiert +- mit einer lokalen Thread-Warteliste +- mit (aus dem Maschinenraum) importierten Operationen atomicBegin und atomicEnd, die Atomarität herstellen +```cpp +P(semaphore s) { + atomicBegin(s); + if (s.zustand = frei) + s.zustand ← belegt; + else + s.warteliste ← aufrufer; + scheduler.suspend(aufrufer); + fi + atomicEnd(s); +} + +V(semaphore s) { + atomicBegin(s); + if (s.warteliste = leer) + s.zustand ← frei; + else + scheduler.continue + (s.warteliste.vorne) + fi + atomicEnd(s); +} +``` + +Unterstützung durch Hardware: die TSL-Operation +- Atomarität +- Ausschluss paralleler Ausführung → TestAndSetLock („TSL“) im Instruktionssatz eines Prozessors +```cpp +atomicBegin(s): +TSL s.state, callingThread.Id // try to get lock +CMP s.state, callingThread.Id // did I get it? +JZE gotIt // yes +CALL scheduler.yield // optional in manycores, mandatory +// in monocores: yield processor +JMP atomicBegin // try again +gotIt: RET // got it, may enter critical region +``` + +Nutzung von Semaphoren: +- Multi-Thread-Anwendungen (Webserver, PowerPoint, etc.) +- auf Betriebssystem Ebene von allen nebenläufigen Aktivitäten + +Implementierung +- im Ressourcenmanagement des Betriebssystems +- mit Hilfe des „Maschinenraums“: atomicBegin(s), atomicEnd(s) + +!ungelöst: Geschwindigkeitsdifferenz +```cpp +//Writer-Thread: +forever do { + codePicFromCamStream(pic); + P(bufferEmpty); + P(bufferBusy); + write(buffer,pic); + V(bufferBusy); + V(bufferFull); +} +``` +- bufferBusy: verhindert gleichzeitigen Zugriff +- bufferEmpty: gibt Weg frei, wenn der Puffer leer ist +- bufferFull: gibt Weg frei, wenn er gefüllt ist + +Mehrwertiger Semaphor (oder Zählsemaphor) mit mehreren Semaphoren; maximaler Sem-Wert = n, bestimmt maximale Anzahl von Threads, die gleichzeitig aktiv sein können + +Zusammenfassend: +| bei Eintritt in kritischen Abschnitt | Bei Verlassen eines kritischen Abschnitts | +| -- | -- | +| P(Sem) - binärer Semaphor | V(Sem) - binärer Semaphor | +| Down(Sem) - Zählsemaphor | Up(Sem) - Zählsemaphor | +| Wait(Sem) - allgemein | Signal(Sem) - allgemein | +| Haben die gleiche Wirkung auf den Wert des Semaphors: | Haben die gleiche Wirkung auf den Wert des Semaphors: | +| - Dekrementieren, bis Wert „Null“ erreicht | - Inkrementieren des Semaphorwertes | +| - Trifft ein Thread auf den Wert „Null“, wird dieser blockiert (und in eine Warteliste eingefügt) | | +| - Nimmt der Semaphor wieder einen Wert > 0 an, setzt (normalerweise) erster Thread in Warteliste fort | | + +### Hoare'sche Monitore +- Problem bei Anwendung von Semaphoren: Softwarequalität +- Problematisch in größeren Systemen: + - Synchronisationsoperationen (P und V) + - umgeben kritische Operationen (z.B. read/write) + - müssen explizit gesetzt werden + +Korrektheitsproblem. Die unabdingbare + - Vollständigkeit + - Symmetrie +der P- und V-Operationen ist schwierig erreichbar und nachweisbar. + +- Die Idee: implizite/automatische Synchronisation kritischer Operationen +- Der Weg: Nutzung des Prinzips der Datenabstraktion + - Zusammenfassung von Daten, darauf definierten Operationen und der Zugriffssynchronisation zu einem abstrakten Datentyp, dessen Operationen wechselseitigen Ausschluss garantieren + - Zugriff auf Daten: über implizit synchronisierende Operationen („Inseln der Ruhe“ in turbulenten Multithread-Umgebungen) + - Die kritischen Abschnitte und die zugehörigen Daten liegen jetzt in einem durch einen Monitor geschütztem Bereich + +Aufrufer muss nicht wissen +1. ob Synchronisation nötig ist +2. mit welchen Mechanismen dies erfolgen muss +3. welche Regeln dabei gelten + +Ziel der Regeln\\ +Wechselseitiger Ausschlusses der Monitoroperationen ⟺ zu jedem Zeitpunkt ist höchstens ein Thread in einem Monitor aktiv +1. Jede Monitoroperation ist am Eingang und an den Ausgängen durch einen Türsteher gesichert +2. Das Betreten des Monitors erfolgt nur mit dessen Zustimmung („Anklopfen“) +3. Falls ein anderer Thread im Monitor aktiv ist, wird die Zustimmung verweigert und der anklopfende Thread suspendiert ( $\approx$ P-Operation) +4. Wenn ein Thread den Monitor verlässt, wird ein wartender Thread eingelassen (fortgesetzt), ( $\approx$ V-Operation) +5. Gerät ein Thread innerhalb einer Monitoroperation in eine Wartesituation (Warten auf Bedingungsvariable), so verlässt er den Monitor +6. Bevor ein auf eine Bedingung wartender Thread fortgesetzt wird, muss er wieder am Türsteher vorbei + +Implementierung der Regeln basierend auf Semaphoren +- je Monitor: ein Semaphor +- jede Operation eines Monitors enthält + - am Eingang: eine P-Operation + - an jedem (!) Ausgang: eine V-Operation +$\rightarrow$ wechselseitiger Ausschluss + +Bedingungsvariable „Puffer nicht voll“, „Puffer nicht leer“ mit 2 Operationen: +1. Warten auf das Vorliegen der Bedingung +2. Signalisieren des Vorliegens der Bedingung +$\rightarrow$ Monitore mit Bedingungsvariablen + +Monitore: komfortabler Mantel für Semaphore + +Allgemeines Erzeuger/Verbraucher-Problem +Lösung 2er Aspekte der Synchronisation +1. wechselseitiger Ausschluss der Zugriffe auf gemeinsame Daten („buffer“) + - durch wechselseitigen Ausschluss von Monitoroperationen + - kurzzeitiges Ausbremsen +2. Anpassung unterschiedlicher Geschwindigkeiten von Erzeuger und Verbraucher + - durch Warten auf und Signalisieren von Bedingungen (nonFull, nonMt) + - längerfristiges Ausbremsen + +Methoden und Mechanismen verwendbar für +1. Threads und Prozesse innerhalb eines Betriebssysteme +2. Threads innerhalb eines Anwendungsprozesses +3. Anwendungsprozesse untereinander (notwendig: gemeinsamer Speicher!) + +## weitere Konzepte +### Transaktionaler Speicher +Problem: Semaphore/ Hoare‘sche Monitore lösen das Problem wechselseitigen Ausschlusses durch Sperren. +damit: Verhinderung paralleler Abläufe (da in einem kritischen Abschnitt jeweils nur ein Thread aktiv sein kann, werden gegebenenfalls weitere Threads blockiert, und somit für bestimmte Zeit von der Bearbeitung ausgeschlossen, d.h. also zeitweilig gestoppt) + +Lange Zeit war Performanz sehr bequem/ Wachsende Leistung der Hardware durch: +1. Erhöhung der Taktfrequenz +2. Erhöhung der Transistorzahl + - Pipelining: Zerlegung und fließbandartige parallele Abarbeitung einzelner Instruktionen + - Hyperthreading: Lückenfüllung in den Pipelines durch Füttern aus verschiedenen Threads + - spekulative Ausführung von Instruktionsfolgen + - Arbeitsspeichercaches + - TLBs +- für Software weitgehend unsichtbar +- vertraute sequenzielle Programmierparadigmen ausreichend + +Diese Ära ist beendet +1. physikalische Aspekte der Energieverteilung/Wärmeableitung auf Chip; Limitierung der Steigerung der Taktfrequenz +2. logische Aspekte der Instruktionsausführung; Limitierung spekulativer Ausführung und Instruktionsparallelität +Weitere Leistungssteigerung +- durch Paradigmenwechsel der Prozessorarchitektur: Multicore-Prozessoren +- dadurch bedingt: Paradigmenwechsel der Software: Parallele (und verteilte) Algorithmen + +Parallele Algorithmen +- erfordern: + - hochparallele, sperrenfreie Synchronisationsmodelle + - Konzept: transaktionaler Speicher +- Beobachtung: + - nicht jede konkurrente Benutzung kritischer Abschnitte durch mehr als 1 Thread verursacht Fehler +- Pessimistische Herangehensweise: + - „Aussperren“ weiterer Threads (z.B. durch Semaphore u. Monitore) + - Dadurch: ausgesperrte Threads werden am Weiterkommen gehindert (Performanzverluste besonders bei intensiver Parallelarbeit) +- Optimistische Herangehensweise: + - Kein „Aussperren“ von Threads (z.B. durch Semaphore u. Monitore) + - Hinterher: Untersuchung auf Fehler und Korrektur, z.B. durch erneuten Versuch +- Geeignete Verfahrensweise: + - Kombination mit Transaktionen (-> transaktionaler Speicher) +- Transaktionen: + - stammen aus der Datenbanktechnik + - ermöglichen u.a.: Zurückfahren fehlerhaft ausgeführter Programmabschnitte (genannt Transaktionen) u. Wiederholung von deren Ausführung auf elegante Weise + +### Botschaften +Problem: Semaphore/Hoare‘sche Monitore/Transaktionaler Speicher erfordern zu ihrer Implementierung gemeinsamen Speicher der Beteiligten + +Gibt es nicht +1. falls die Beteiligten auf unterschiedlichen Rechnern ablaufen +2. falls die Beteiligten disjunkte Adressräume besitzen +3. in lose gekoppelten Multiprozessor-Architekturen +Hierfür: muss ein anderes Kommunikationsparadigma her + +2 elementare Operationen +1. Senden einer Botschaft an einen Empfänger + `send(IN Empfänger, IN Botschaft)` +2. Empfangen einer Botschaft von einem Absender + `receive(OUT Absender, OUT Botschaft)` + +Anmerkungen +- genutzt: für Kommunikation zwischen + - Prozessen innerhalb eines (Mikrokern-) Betriebssystems + - Anwendungsprozesse untereinander (Klienten, Server) +- Betriebssysteme: implementieren send/receive-IPC +- Anwendungsprozesse: nutzen Bibliotheken oder Betriebssystem-Dienste, + +### Fernaufrufe (Remote Procedure Calls, RPCs) +- Problem + - Datenmodell des send/receive-Modells: Zeichenfolge $\rightarrow$ sehr primitiv + - gewohnte Datenmodelle z.B. aus Programmiersprachen $\rightarrow$ Signaturen (Methodenaufruf, typisierte Parameterlisten) +- Idee: Anpassung eines + - anwendungsnahen, + - unkomplizierten und + - vertrauten +- Kommunikationsmodells an die Eigenschaften verteilter Systeme: + - Prozedurfernaufruf (Remote Procedure Call, RPC) + - Methodenfernaufruf (Remote Method Invocation, RMI $\rightarrow$ Objekt-orientiert) + +Grundidee dieser Architekturform +1. elementare Betriebssystem-Funktionalität: + - in sehr kleinem, hochprivilegiertem Betriebssystemkern (  Kern) + - typische Aufgaben: Threads, Adressräume, IPC +2. weniger elementare Aufgaben: + -schwächer privilegiert ( reguläre Anwendungssysteme = „Nutzerprozesse“) +3. Folgen + - Isolation der Betriebssystem-Komponenten + - → Robustheit (Fehlerisolation) + - → IT-Sicherheit [Security] (TCB-Größe) $\rightarrow$ TCB: Trusted Computing Base + - → Korrektheit (Verifizierbarkeit) + - → Adaptivität (Auf- und Abskalierung der Systemfunktionalität) + - → Kommunikationskosten + +Kommunikationskosten +- Prozeduraufruf: monolithische Architektur: innerhalb eines Adressraums +- Prozedurfernaufruf: $\mu$-Kern-Architektur: über Adressraumgrenzen hinweg + +### Systemaufrufe +Problem: Kommunikation Anwendungsprozess ↔ BS +- BS stellt zahlreiche Dienste bereit (Linux  250, Apple OS X  500); z.B. + - Prozesserzeugung (fork) + - Programmausführung (exec∗) + - Dateimanagement (open, close, read, write) + - Kommunikation (msg∗, socket, shm∗) +- In diesem Abschnitt: Aufrufmethoden und -mechanismen + +1. Wünsche des Anwendungsentwicklers + - Bequemlichkeit + - Performanz (hohe Aufruffrequenz, tausende pro Sekunde) +2. Wünsche des Betriebssystem-Entwicklers + - Sicherheit + - Robustheit +- reguläre Prozeduraufrufe: erfüllen Kriterien nicht (isolierte Adressräume, Privilegien, Programmiersprachen) +- Prozedurfernaufrufe: + - bequem, performant, sicher, robust + - teuer +- gesucht: leichtgewichtiges RPC-Modell + +1. Problem: Unterschiedliche Programmiersprachen + - kein einheitliches Format der Aufrufparameter (Reihenfolge, Format) + - Lösung: normierte Parameterstruktur und Datentyprepräsentation zwischen Anwendungsprogramm und Betriebssystem + - definiert durch: API-Spezifikation des Betriebssystems + - implementiert durch: zwischengeschaltete Bibliothek + - (z.B. libc; Stellvertreter-Prozeduren, Urform heutiger Middleware-Stubs) +2. Problem: Separate Namensräume + - „do_sys_write“ liegt nicht im Namensraum des Anwendungsprozesses + - Lösung: Einigung auf Namenskonventionen („push(write_C)“) +3. Problem: Separate Adressräume/Adressraumbereiche + - kein direkter Zugriff auf Parameter seitens der aufgerufenen Prozedur + - Lösung: + - Parameter-Datenstruktur auf User-Stack + - performante Alternative: in Registern +4. Problem: Privilegienwechsel User→Kernel→User + - TRAP/RTT-Mechanismus (ReTurn from Trap) + +Kosten: Systemaufruf = Prozeduraufruf+X +X= +1. Standardisierung der Parameterübergabe + - Kosten gering bei Übergabe in Registern (  reguläre Prozedur) +2. Isolation + - Privilegienwechsel durch Interrupt ( TRAP/RTT ) + - je  100 Taktzyklen (Kontextsicherung) + - Verlust der Sprungziel-Vorausberechnungen + - Verlust spekulativer Ausführungen + - sehr teuer + - Optimierung (seit Pentium 2): SysEnter/SysCall-Instruktionen +- Kosten gegenüber regulärem Prozeduraufruf: heute ca. Faktor 2 + +### Ereignismanagement +Das Problem: Betriebssystemen laufen sehr viele Aktivitäten parallel ab +1. Ausführung von Anwendungsprogrammen +2. Management von Prozessor-, Speicher-, Kommunikations-Ressourcen +3. Bedienung der E/A-Peripherie +dabei: entstehen immer wieder Situationen, in denen auf unterschiedlichste Ereignisse reagiert werden muss, z.B. +- Timerablauf +- Benutzereingaben (Maus, Tastatur) +- Eintreffen von Daten von Netzwerken, Festplatten, ... +- Einlegen/stecken von Datenträgern +- Aufruf von Systemdiensten +- Fehlersituationen + +- Qualitativ + - Windows-System (Laptop), gestartete GUI + - Jederzeit: können ca. 400 verschiedene Ereignisse eintreten +- Quantitativ + - MacOS MacBook Pro + - allein Systemaufruf-Ereignisse („SysEnter“) > 1.000.000/sek +- $\rightarrow$ Umgangsformen mit Ereignissen + +Umgangsformen mit Ereignissen +1. „busy waiting“ + - spezialisierte Threads innerhalb des BS prüfen andauernd Ereigniseintritt + - sehr kurze Reaktionszeit + - ineffiziente Prozessornutzung + - hoher Energieverbrauch + - akzeptabel bei + - bekannt kurzen Wartezeiten + - Multiprozessormaschinen, falls + - ausreichend Prozessoren vorhanden sind + - ausreichend Energie vorhanden ist +2. „periodic testing“ + - spezialisierte Threads prüfen hin und wieder den Ereigniseintritt + - je nach Prüfperiode + - lang: fragliche Reaktionszeit + - kurz: fragliche Effizienz der Prozessornutzung + - akzeptabel bei: relaxten Reaktionszeitanforderungen +3. Unterbrechungen („Interrupts“) + - Benachrichtigung über Ereignis + - Zur Wirksamkeit dieser Technik + - Verhältnis Anzahl Festplattenoperationen zu CPU-Operationen + - Laptop: ca. 1:10.000.000 + +Ereignisklassen +1. E/A-Gerätemeldung („ich habe fertig“, „ich habe Fehler“) +2. Timer-Ablauf +3. Ausfall der Hardware (Stromausfall, Speicher-Paritätsfehler) +4. Fehlverhalten ablaufender Programme , z.B. + - Ausführung privilegierter oder illegaler Instruktionen + - Zugriff auf geschützte Speicheradressen + - arithmetischer Überlauf (z.B. „$2^{40}* 2^{40}$ “ bei 64-Bit-Arithmetik) + - Division durch 0 +5. Seitenfehler (bei virtueller Speicherverwaltung, s.u.) +6. explizit per Programm ausgelöste Ereignisse („TRAP“) + +Ereignisquellen +1. Hardware: E/A-Geräte, Uhren, CPU, MMU, ALU, FPU +2. Software: Instruktionen wie TRAP, SysCall +Technisch: Signalisierung z.B. durch „5 Volt an Prozessorbeinchen“ +Programmiermodell: HW/SW-Schnittstelle? + +Programmiermodelle zur Unterbrechungsbehandlung +- Idee + - Verknüpfung von (HW-)Interrupts mit (SW-)Abstraktionen; + 1. Prozeduren (→ inline Prozeduraufrufmodell) + 2. IPC-Operationen (→ IPC-Modell) + 3. Threads (→ pop-up Thread Modell) +- Wirkung + - Interrupt ↷ Ausführung der assoziierten Abstraktion, z.B. + 1. Interrupt Nr. 42: ↷ rufe Prozedur „InterruptHandler_42()“ auf + 2. Interrupt Nr. 42: ↷ sende Botschaft „Interrupt 42“ an einen Thread + 3. Interrupt Nr. 42: ↷ erzeuge Thread „Interrupt_42_Thread“ + +Das inline-Prozeduraufrufmodell +- Interruptbehandlungen: besitzen syntaktisches Aussehen einer Prozedur: + - „Handlerprozeduren“ (interrupt service routines (ISRs)) +- Ablauf der Interruptbehandlung: erzwungener Prozeduraufruf + - kein Threadwechsel, sondern + 1. Unterbrechung des Tuns des momentan ablaufenden Threads + 2. Sicherung seines Ablaufkontexts (Lesezeichen: IP, SP, PSR, ...) + 3. Versetzen des Threads in Ablaufkontext der Unterbrechungsbehandlung (z.B. andere Privilegierungsebene) + 4. Ausführung der Handlerprozedur (untergeschobener (inline-) Prozeduraufruf) + 5. Restauration des Threads in den unterbrochenen Ablaufkontext (beim Lesezeichen) +- Planung der Interruptbehandlung: + - Prozedurname mit Interruptquelle assoziieren + - Interruptvektortabelle + - es gibt: viele unterschiedliche Interruptquellen + - es gibt: entsprechend viele unterschiedliche Reaktionen auf Interrupts +- Aufruf der zugehörigen Handlerprozedur: + - wir haben: ein konkretes Interruptsignal: „5 Volt“ und eine Nummer $\rightarrow$ Hardwareebene + - wir möchten: die Ausführung der zugehörigen Handlerprozedur im Betriebssystem, z.B. im Timer-Management $\rightarrow$ Softwareebene + +Problem also: geeignete Hardware/Softwareschnittstelle + +Lösung: Die Interruptvektor-Tabelle (IVT): Assoziationen („Interruptvektoren“) der Form + - Interruptquelle → Handlerprozedur (ISR) + - Interruptquelle: Nummer + - Handlerprozedur: Code oder Codeadresse + - Speicherort: BS und Interrupthardware bekannt; Varianten: + 1. fester Ort: z.B. im Arbeitsspeicher, beginnend bei Adresse 0 + 2. variabel: lokalisiert über Adressregister (Interruptvektor Adressregister, IVA) + - Format: (HW-)architekturspezifisch, dem Betriebssystem bekannt + - erstellt: + - in früher Boot-Phase des Systems + - als Ergebnis einer Analyse möglicher Interrupt-Quellen (z.B. vorhandene E/A-Geräte) (BIOS, UEFI) + +Fazit des inline-Prozeduraufrufmodells +1. Unterbrechungsbehandlung: durch Interrupt Service Routinen +2. Planung: in Interruptvektor-Tabelle +3. Ablauf: erzwungener Prozeduraufruf + 1. Sicherung des Ablaufkontexts des momentan aktiven Threads + 2. Auswahl der Handlerprozedur gemäß IVT-Eintrag + 3. Ausführung der Handlerprozedur durch untergeschobenen Prozeduraufruf + 4. Restaurierung des unterbrochenen Tuns des Threads + +### IPC Modell +2-stufig +1. Stufe der Interruptbehandlung: erzeugt IPC-Operation +2. Stufe der Interruptbehandlung: Reaktion auf diese IPC-Operation +- Interrupts: abgebildet auf reguläre IPC-Operationen +- Interruptbehandlungen: sind reguläre Reaktionen der IPC-Adressaten +- zeitliche Kalkulierbarkeit und Kürze der primären Interruptbehandlung (Echtzeitsysteme!) + +Planung +- IPC-Erzeugung mit Interruptquelle verknüpfen → Interruptvektor +- Beim Interrupt + 1. Stufe: + - I. Unterbrechung des momentan aktiven Threads + - II. Erzeugen der IPC-Operation, z.B. Senden einer Botschaft (klein – passt in IVT, sehr schnell) + - III. Fortsetzung des unterbrochenen Threads + 2. Stufe: IPC-Adressat, z.B. Thread eines Gerätemanagers, reagiert auf IPC + +### pop-up-Thread-Modell +2-stufig +1. Stufe der Interruptbehandlung: erzeugt Thread +2. Stufe der Interruptbehandlung: erfolgt in diesem Thread +- Interruptsignale: abgebildet auf Thread-Erzeugungen +- Interruptbehandlungen: sind reguläre Thread-Abläufe +- zeitliche Kalkulierbarkeit und Kürze der primären Interruptbehandlung (Echtzeitsysteme!) + +Planung +- Thread-Erzeugung mit Interruptquelle verknüpfen → Interruptvektor +- Beim Interrupt + 1. Stufe: + - I. Unterbrechung des momentan aktiven Threads + - II. Erzeugen des Threads (klein – passt in IVT, sehr schnell) + - III. Fortsetzung des unterbrochenen Threads + 2. Stufe: + - Thread (z.B. in Gerätemanager) wird (irgendwann) vom Scheduler aktiviert + + +### Implementierungstechniken +Ablauf +1. Ereignis entsteht: z.B. auf E/A-Geräteplatine, in MMU, in SW ... +2. Interruptsignal wird (evtl. über Kommunikationsbus) Prozessor zugestellt +3. Prozessor schließt Ausführung der laufenden Instruktion ab (falls möglich) +4. Prozessor sichert Ablaufkontext des aktiven Threads +5. Prozessor stellt Ablaufkontext der Interruptbehandlung her + - dazu benötigt er minimal: Adresse der Interrupt-Behandlungsroutine + - dies: setzt vorherige Einplanung in der IVT voraus +6. Fortsetzung des aktiven Threads im neuen Kontext der Interrupt-Behandlung; dabei u.U. Wechsel der Privilegierungsebene +7. der neue Kontext + - führt Code in der IVT aus + - dies ist je nach Interrupt-Programmiermodell: Aufruf einer Prozedur, Erzeugung einer IPC-Operation, Erzeugung eines Threads +8. bei Abschluss (RTI): + - Rückversetzen des aktiven Threads in den gesicherten Ablaufkontext; dabei u.U. Rückkehr zur vorherigen Privilegierungsebene + +Was bleibt der Software? +- Definition der Interrupt-Behandlungsalgorithmen (in Form von Prozeduren, IPC-Reaktionen, Threads; oft Teil des BS-E/A-Systems) +- Vorausplanung der Interrupt-Behandlungen in der IVT + - Bootphase + - Nachladen von Gerätemanagern + +Die Realität ist häufig komplexer +1. Interruptquellen besitzen unterschiedliche Wichtigkeit + - Priorisierung (Eignung der 3 Modelle?) +2. Echtzeiteigenschaften (zeitlich garantierte Reaktion auf Ereignisse) + 1. Unterbrechbarkeit der Interruptbehandlung durch höherpriore Interrupts + 2. geschachtelte Interruptbehandlung (Eignung der 3 Modelle?) +3. moderne Prozessorarchitekturen (superskalare (intern parallele) + - Prozessoren) arbeiten mit spekulativer und paralleler Instruktionsausführung + - viele Instruktionen befinden sich zum Unterbrechungszeitpunkt in unterschiedlichen Bearbeitungszuständen + - Sicherung/Wiederaufsetzung des unterbrochenen Ablaufkontexts (HW) komplex und zeitaufwändig + +Fazit soweit +- 100e von Ereignissen jede Sekunde + - erfordert: effizientes und ökonomisches Ereignismanagement +- die Hardware hilft + 1. Schnittstelle: IVT + 2. Unterbrechungsmanagement +- Software: 3 alternative Programmiermodelle + 1. eine Prozedur wird aufgerufen + 2. eine Botschaft wird gesendet + 3. ein Thread wird erzeugt +- Wahl abhängig von + 1. Echtzeiteigenschaften + 2. Performanzanforderungen + +Asynchrone Signalisierungsmechanismen außerhalb von Betriebssystemen +1. Meldung von Ereignissen (terminierte Kindprozesse, Ausführung illegaler Instruktionen, Speicherschutzverletzungen ...) +2. Stoppen, Fortsetzen, Abbruch von Prozessen + +Umgang damit +1. Definition von ESRs (event service routines) in Anwendungssystemen; +deren syntaktische Form z.B. in C: Prozeduren (inline-Modell) +2. Planung der Ereignisreaktion + 1. Reaktionstyp festlegen + - a) ignorieren + - b) Prozessabbruch + - c) ESR-Aufruf + 2. im letzteren Fall: Verknüpfen einer ESR mit einem Ereignis per Systemaufruf (z.B. in Unix: signal( , ) ) + 3. Betriebssystem: merkt sich Anbindung im Prozessdeskriptor (Ereignismanagement, „Handler-Vektor“; = Interruptvektortabelle) PD + 4. bei Ereigniseintritt: untergeschobener Prozeduraufruf (durch Modifikation des IP*-Registers (Anfang der ESR-Prozedur)) + 5. nach Prozedurende: Fortsetzen an unterbrochener Stelle + +Auslösung von Ereignissen durch +1. Hardware (z.B. Speicherzugriffsfehler, arithmetischer Fehler) +2. Betriebssystem (z.B. Prozessmanagement: Terminierung von Kindprozessen) +3. andere Benutzerprozesse (API-Aufruf) (z.B. in Unix: kill( , ) ) + +bei Auftreten des Ereignisses; erfolgt gemäß obiger Planung +- a) ignorieren +- b) Prozessabbruch +- c) ESR-Aufruf + 1. inline-Prozeduraufruf der ESR-Prozedur + 2. Rückkehr zum unterbrochen Kontext nach dessen Ende + +Zusammenfassung Ereignismanagement/Botschaften +1. Ereignismanagement erlaubt: + - schnelle + - effiziente + - hardwareunterstützte + - Reaktionen auf synchrone und asynchrone Ereignisse +2. Programmiermodelle: Abbildung von Ereignissen auf + 1. erzwungene Prozeduraufrufe + 2. IPC-Operationen + 3. Threaderzeugung +3. Planung: durch Definition der ISR und Eintrag in IVT +4. analoges Konzept auf Anwendungsebene , z.B. + - Unix-Signale + - Apple Events + +## Zusammenfassung +IPC: Kommunikation und Synchronisation + - Semaphore und Hoare‘sche Monitore: blockierend, pessimistisch + - transaktionaler Speicher: neu, optimistisch, transaktional + - Botschaften: kein gemeinsamer Speicher, Datentransport + - Fernaufrufe, Systemaufrufe: „Spezialisierungen“ + - Ereignismanagement: Interrupts, Unterbrechungen auf Anwendungsebene + + +# Speichermanagement +Ideale Speichermedien sind +- beliebig schnell und +- beliebig groß und +- beliebig billig und +- persistent (speichern Daten ohne andauernde Energiezufuhr) + +Reale Speichermedien sind +- schnell, teuer, flüchtig oder +- langsam, preiswert, persistent oder +- eine Vielzahl von Schattierungen dazwischen + +Fazit: Speicherhierarchie +- Speichermanagement: Management dieser Speicherhierarchie + +## Speichertechnologien und -klassen +- Prozessorregister, Cache-Speicher + - sehr schnell (Pikosek., 10 11 -10 12 Zugriffe/s) + - sehr teuer → klein (≈ KByte-MByte) + - flüchtig +- Arbeitsspeicher + - schnell (Nanosekunden, ≈ 10 10 Zugriffe/s) + - weniger teuer → mittelgroß (≈ GByte) + - flüchtig +- Flash-EEPROM (SSDs, USB-Sticks) + - langsam (Mikrosekunden, 10 8 Zugriffe/s) + - preiswert → groß (≈ GByte-TByte) + - persistent +- Magnetplatten, optische Medien, Archivierungsbänder + - langsam (Mikro-/Millisekunden, 10 6 -10 8 Zgr./s) + - mittel bis sehr groß (≈ GByte-PByte) + - persistent + +### Was muss Arbeitsspeicher können? +- Prozesse: Programmcode, statische Daten, dynamische Daten, Stack + - Struktur + - Typisierung +- große Prozesse -> Größe +- parallele, potentiell fehlerhafte/unfreundliche Prozesse -> Isolation + +### Layout des (physischen) Arbeitsspeichers: 50er Jahre +Merkmale: +- extrem einfaches Speichermanagement (fester Adressbereich für Anwendungsprogramm) +- keine Hardware-Unterstützung +- Betriebssystem: Bibliothek +- Problem: zu jedem Zeitpunkt nur ein Programm + +### Layout des physischen Arbeitsspeichers: 60er Jahre +Merkmale: +- einfaches Speichermanagement (Freiliste, first-fit oder best-fit-Vergabe) +- parallele Prozesse + +Bezahlt mit +- Verletzbarkeit: Zugriff auf Speicherbereiche fremder Prozesse +- Enge: weniger Raum für einzelne Prozesse +- Komplexität: + - Wachsen von Prozessen problematisch + - keine feste Startadresse; Erzeugung von + - Codeadressen (Sprünge, Prozeduraufrufe) + - Datenadressen (Variablen + +-> Relokation + +## Relokation +Ziele +1. Platzieren eines Prozesses an beliebigen Speicheradressen +2. Verschieben zwecks Vergrößerung/Speicherbereinigung + +Idee +1. sämtliche Speicheradressen in einem Programm werden + - vom Compiler/Linker relativ zur Speicheradresse „0“ berechnet + - als „Relativadressen“ markiert +2. beim Anlegen/Verschieben eines Prozesses werden markierte Adressen aktualisiert (= Relokation): + `tatsächliche Adresse = Relativadresse + Prozessanfangsadresse` + +Realisierung +- per Software → durch Betriebssystem beim Erzeugen/Verschieben +- per Hardware → durch Offset-Register zur Laufzeit: „my first MMU“ + +Erreicht +1. Anlegen eines Prozesses an beliebiger Adresse +2. Verschiebbarkeit +( gegen Enge und Verletzbarkeit hilft Relokation nicht) + +Bezahlt mit +- entweder: verteuertem Programmstart (wenn Startadresse bekannt): + - Aktualisierung der Relativadressen per Software (Betriebssystem-Prozessmanagement) +- oder: höheren Hardware- und Laufzeitkosten: + - mini-MMU mit Offset-Register + - Adressumrechnung bei jedem Speicherzugriff + +## Swapping +Ziel: Beseitigung der Enge +- Schaffen von freiem Arbeitsspeicher durch Auslagerung von Prozessen +- Erstes Auftauchen einer Speicherhierarchie + +Erreicht: mehr Platz (gegen Verletzbarkeit hilft Relokation nicht) + +Bezahlt mit: +1. Prozesswechsel werden teurer + - Aus/Einlagerungszeiten + - Relokation bei Wiedereinlagerung an neue Adresse +2. fortschreitende Zerstückelung des Arbeitsspeichers + - Verluste durch Verschnitt +3. der pro Prozess adressierbare Speicherbereich wird durch Swapping nicht größer (limitiert durch physische Arbeitsspeichergröße) + - virtueller Speicher + +## Virtueller Speicher +Idee: Jeder Prozess erhält einen privaten, sehr großen Arbeitsspeicher + +Damit +- besitzt jeder Prozess einen riesigen Vorrat an Speicheradressen +- bei $2^{Adressenlänge}$ = Anzahl Speicheradressen gilt: sämtliche von einem Prozess erzeugbaren Speicheradressen (sein Adressraum) + - gehören per Definition: zu seinem eigenen Arbeitsspeicher + - dadurch: keine Möglichkeit des Zugriffs auf Arbeitsspeicher anderer Prozesse +- ist keine Relokation mehr notwendig + +Problem: so viel Speicher können wir physisch gar nicht bauen (es gibt nicht einmal $2^64$ Atome im Sonnensystem!!) +Lösung: +- Betriebssysteme lügen (vermitteln Prozessen eine Illusion) +- virtuelle Adressräume + +### Virtuelles Speichermanagement (VMM) +ist die Realisierung dieser Idee durch +1. Abstraktionen physischen Arbeitsspeichers: + - private virtuelle Adressräume +2. Abbildungen $vm_p$: + - virtueller Adressraum → physischer Adressraum +3. MMUs: + - Hardware, die diese Abbildungen effizient implementiert + +Ausgangsidee: Jeder Prozess p besitzt einen privaten, großen virtuellen Adressraum $VA_p$ (z.B. 2 64 adressierbare Speicherzellen). +Damit +1. ist es nicht mehr eng +2. können Prozesse sich gegenseitig nicht mehr verletzen + +### Begriffe +> Adressraum: Ein Adressraum ist eine (endliche) Menge von Adressen +> - Menge aller Postadressen einer Stadt +> - Menge aller IP-Adressen +> - die natürlichen Zahlen 0 ... 2 64 -1 + +> Adressraum eines Prozesses: Der Adressraum eines Prozesses (im Kontext des VMMs) ist die Menge aller ihm zur Verfügung stehender Arbeitsspeicheradressen + +> physischer Adressraum: Ein physischer Adressraum (PA) ist die Menge aller Adressen eines physischen (realen) Speichers + +> virtueller Adressraum: Ein virtueller Adressraum (VA) ist die Menge aller Adressen eines virtuellen Speichers; im Allgemeinen gilt: |VA|>>|PA| + +> virtueller Speicher: ist eine Abstraktion physischen Speichers zwecks Vortäuschung großer physischer Adressräume + +> virtuelles Speichermanagement (besser: Management virtueller Speicher): befasst sich mit der Abbildung virtueller auf physische Adressräume + +### Abbildung $vm_p$ +Realisierung: Jeder virtuelle Adressraum $VA_p$ wird mittels einer individuellen Abbildung $vm_p: VA_p \rightarrow PA$ auf den physischen Adressraum PA abgebildet (siehe: „Speicherlayout“). + +Eigenschaften der Abbildung $vm_p$ +1. Definitionsbereich + - $VA_p$ sehr groß + - $\exists$ unbenutzte/undefinierte Adressbereiche + - $vm_p$ partiell +2. Realisierung + - $|VA_p | >> |PA|$ + - Abwesenheit (Seitenfehler, s.u.) + - $vm_p$ nicht zu jedem Zeitpunkt vollständig gültig +3. Isolation + - Adressen verschiedener virtueller Adressräume werden nie zum selben Zeitpunkt auf dieselbe Adresse des physischen Adressraums abgebildet + +Aufgaben des virtuellen Memory Management (VMM): Realisierung der Abbildung $vm_{pi}: VA_{pi} \rightarrow PA$ einschließlich +- Definitionsbereich: $vm_{pi} partiell +- Anwesenheitskontrolle: $vm_{pi} nicht immer gültig +- Isolation und Kommunikation: Injektivität +- Zugriffsschutz: lesen/schreiben/ausführen + +... bei jedem einzelnen Speicherzugriff! + +Effizienz +- massive Unterstützung durch Hardware (MMU) +- Mengenreduktion: sowohl $VA_{pi}\rightarrow PA$ als auch die Definition von Zugriffsrechten + - erfolgen nicht für jede virtuelle Adresse individuell + - sondern in größeren Einheiten („Seiten“); typische Größe 4 oder 8 KByte + +### Memory Management Units (MMUs) +Integration in die Hardware-Architektur im Zugriffspfad: Prozessor (virtuelle Adressen) → Speicher (physische Adressen) + +Abbildung $vm_p: VA_p\rightarrow PA$ in der MMU +1. Aufteilung jedes virtuellen Prozessadressraums in Seiten gleicher Größe (typisch 4 oder 8 KByte) +2. Aufteilung des physischen Adressraums in Seitenrahmen gleicher Größe +3. Seite eines virtuellen Prozessadressraums mit Seitenrahmen des physischen Adressraums assoziieren („Fliesen legen“): die Seiten(abbildungs)tabelle + +$\rightarrow$ Realisierung der Abbildung $vm_p: VA_p\rightarrow PA$ seitenweise + +### Seitenabbildungstabellen +Beispiel (mit kleinen Zahlen) +- Seitengröße: 2 KByte +- Größe des VA: 2^14 =16 KByte (→ 8 Seiten, virtuelle Adressen haben 14 Bit) +- Größe des PA: 2^13 =8 KByte (→ 4 Seitenrahmen, phys. Adressen haben 13 Bit ) + +Prinzipieller Aufbau eines Seitentabelleneintrags (davon gibt es genau einen je Seite eines virtuellen Adressraums): +`| Rahmennummer im Arbeitsspeicher (PA) | anwesend | benutzt | verändert | Schutz | Caching |` + +Seitenattribute +1. anwesend: Indikator, ob Seite im Arbeitsspeicher liegt („present“-Bit) +2. benutzt: Indikator, ob auf die Seite zugegriffen wurde („used/referenced“- Bit ) +3. verändert: Indikator, ob Seite „schmutzig“ ist („dirty/ modified “-Bit) +4. Schutz: erlaubte Zugriffsart je Privilegierungsebene („access control list“) +5. Caching: Indikator, ob Inhalt der Seite ge“cached“ werden darf + +Von MMU und BS gemeinsam genutzte Datenstruktur: HW/SW Schnittstelle +- von MMU bei jedem Speicherzugriff genutzt zur + - Prüfung auf Präsenz der die Zugriffsadresse enthaltenden Seite + - Prüfung der Rechte des Zugreifers (Privilegierungsebene und Zugriffsart vs. Schutz) + - Umrechnung der virtuellen in die physische Adresse +- vom BS verändert + - bei jedem Adressraumwechsel (Prozesswechsel; Grundlage: Adressraum-Beschreibung im Prozessdeskriptor) + - beim Einlagern/Auslagern einer Seite (present-Bit, phys. (Seitenrahmen-)Adresse) + - bei Rechteänderungen +- von der MMU verändert: zur Lieferung statistischer Informationen + - bei einem Zugriff auf eine Seite (used-Bit) + - bei einem Schreibzugriff auf eine Seite (dirty-Bit) +- vom BS genutzt: zum effizienten Speichermanagement + - z.B. zum Finden selten genutzter Seiten bei Arbeitsspeicher-Engpässen (used-Bit) + - z.B. müssen nur veränderte Seiten bei Freigabe zurückgeschrieben werden (dirty-Bit) + +Problem: VMM „is not for free“ +1. Speicher: Seitentabellen können sehr sehr groß werden +2. Performanz: je Speicherzugriff (mehrere) Zugriff(e) auf Seitentabelle +3. algorithmische Komplexität: Auftreten von Seitenfehlern (Zugriff auf abwesende Seiten) bei vollständig belegtem physischen Arbeitsspeicher: + 1. Untersuchung: Welche Seite soll verdrängt werden? + 2. Ausführen: Seitenaustauschalgorithmen + 3. viele Prozesse können gleichzeitig aktiv sein: jederzeit kann ein Seitenfehler („Page Fault“) auftreten + +Lösungen +1. mehrstufige Seitentabellen: basieren auf Beobachtung, dass Adressräume häufig nur dünn besetzt sind +2. alternative Datenstrukturen + 1. gesehen: mehrstufige, baumstrukturierte Seitentabellen + - grundsätzlich beliebige Baumtiefe + - können selbst dem Paging unterliegen (belegen dann zwar Adressraum, jedoch physischen Speicher nur dann, wenn sie tatsächlich gebraucht werden) + - Nachteil: Performanz; mehrere Tabellenzugriffe zur Umrechnung einer virtuellen Adresse erforderlich, evtl. dabei erneut Seitenfehler + 2. invertierte Seitentabellen (1 Eintrag je physischer Seite) + - Nachteil: virtuelle Adresse kann nicht mehr als Index zum Finden des Tabelleneintrags verwendet werden → aufwendige Suchoperationen + 3. gehashte Seitentabellen + 4. guarded page tables +3. Seitentabelle in schnellem Register-Array (innerhalb der MMU) + - schnell (keine Speicherzugriffe für Adressumrechnung) + - teuer in der Realisierung (Hardware-Kosten) + - teuer bei Prozess-(Adressraum-)Wechsel (Umladen) + - sinnvoll daher nur für relativ kleine Tabellen +4. Seitentabellen im Arbeitsspeicher, Ort in Adressregister + - schnelle Prozesswechsel (keine Rekonfigurierung der MMU, lediglich Aktualisieren des Adressregisters) + - skaliert für große Seitentabellen + - hohe Adressumrechnungskosten (Zugriff(e) auf Arbeitsspeicher) +5. Seitentabellen im Arbeitsspeicher, Ort in Adressregister, plus Caching von Seitentabelleneinträgen + - „TLBs“ (Translation Look-aside Buffer) + - Aufbewahren benutzter Tabelleneinträge + - basiert auf Lokalität von Speicherzugriffen + - reduziert Adressumrechnungskosten speichergehaltener Seitentabellen + + + +Translation Look-aside Buffer (TLB) +- schneller Cache-Speicher für Seitentabelleneinträge +- lokalisiert in der MMU +- Aufbau eines Cacheeintrags identisch dem eines Seitentabelleneintrags +- Cache-Management: + 1. Invalidierung bei Adressraumwechsel erforderlich! + - Sekundärkosten eines Adressraumwechsels durch „kalten“ TLB + 2. cache-refill bei TLB-miss aus Seitentabelle + 1. durch MMU-Hardware („Page Table Walker“, automatisch) + 2. durch Betriebssystem (nach Aufforderung durch MMU (Interrupt)) + +Ablauf einer Seitenfehlerbehandlung +1. Erkennung durch MMU (present-Bit in Seitentabelleneintrag) +2. Anfertigungung einer Seitenfehlerbeschreibung +3. Auslösung eines Seitenfehler-Interrupts; hierdurch: + - a) Unterbrechung der auslösenden Instruktion (mittendrin!) + - b) Aufruf der Seitenfehlerbehandlung (ISR des VMM); dort: + - Suche eines freien Seitenrahmens + - evtl. explizit freimachen (auslagern); + - Auswahl: strategische Entscheidung durch Seitenaustauschalgorithmus + - Einlagern der fehlenden Seite vom Hintergrundspeicher + - z.B. von lokaler Festplatte + - z.B. über LAN von Server + - Aktualisierung des Seitentabelleneintrags (physische Adresse, present-Bit) +4. Fortsetzung des unterbrochenen Prozesses + +### Seitenaustausch-Algorithmen +Problem: Seitenfehler bei vollständig belegtem physischen Arbeitsspeicher + +Strategie: Welche Seite wird verdrängt? + +Optimale Strategie: Auslagerung derjenigen Arbeitsspeicherseite, deren ... +1. nächster Gebrauch am weitesten in der Zukunft liegt (dazu müsste man Hellseher sein) +2. Auslagerung nichts kostet, dazu müsste man wissen, ob eine Seite seit ihrer Einlagerung verändert wurde + +im Folgenden: einige Algorithmen, die sich diesem Optimum annähern +1. First-In, First-Out (FIFO) +2. Second-Chance +3. Least Recently Used (LRU) +4. Working Set / WSClock + +#### First-In , First-Out (FIFO) +- Annahme: Je länger eine Seite eingelagert ist, desto weniger wahrscheinlich ist ihre zukünftige Nutzung +- Strategie: Auslagerung der ältesten Seite +- Realisierung + - Einlagerungsreihenfolge merken, z.B. durch FIFO-organisierte Seitenliste + - Auslagerung derjenigen Seite, die am „out“-Ende der Liste steht +- Wertung + - einfacher Algorithmus + - effizient implementierbar (Komplexität: Listenoperationen in O(1)) +- Beobachtung: soeben ausgelagerte Seiten werden oft wieder benötigt + - Annahme stimmt oft nicht (entfernt z.B. alte, aber oft benutzte Seiten) + +#### Second Chance (Variante des FIFO-Algorithmus) +- Annahme + -statt: Je länger eine Seite eingelagert ist, desto weniger wahrscheinlich ist ihre zukünftige Nutzung + - nun: Je länger eine Seite nicht mehr benutzt wurde, desto weniger wahrscheinlich ist ihre zukünftige Nutzung +- Strategie + - Eine FIFO-gealterte Seite bekommt eine 2. Chance, falls die Seite während des Alterns benutzt wurde (used-Bit der MMU) + - Verjüngungskur: + 1. Umsortieren der Seite ans junge Ende der FIFO-Liste, + 2. Löschen des used-Bits +- Wertung + - einfacher Algorithmus + - effizient implementierbar + - used-Bit der MMU + - Listenoperationen in O(1) + - bessere Ergebnisse im Vergleich zu FIFO → die „Kur“ wirkt + - zutreffendere Seitenmerkmale berücksichtigt: Zeitpunkt der letzten Nutzung + - aber immer noch sehr grobgranular: 16 GByte physischer Adressraum u. 4 KByte Seitengröße: ~4.000.000 Seiten im physischen Adressraum -> Prüfintervall ~ 4.000.000 Seitenfehler + +#### Least Recently Used (LRU) +- Annahme: Je länger eine Seite nicht mehr benutzt wurde, desto weniger wahrscheinlich ist ihre zukünftige Nutzung (also dieselbe wie 2 nd Chance) +- Strategie: Feinere Granularität: genauere Nutzungszeitpunkte je Seite +- Notwendiges Wissen: ist teuer + 1. Speicher: Nutzungszeitpunkte für jede Seite des Prozess-Adressraums (einige Millionen) + 2. Laufzeit: Aktualisierung bei jedem Speicherzugriff (einige Milliarden/Sekunde) +- Griff in die Trickkiste + - Hardware-Unterstützung speziell für diesen Algorithmus (MMU) + - eine logische Uhr + - tickt bei jeder ausgeführten Prozessorinstruktion + - wird bei jedem Arbeitsspeicherzugriff in den Seitentabelleneintrag der betroffenen Seite eingetragen + - die am längsten nicht mehr benutzte Seite hat dann den ältesten Uhrenstand + - Software-Realisierungen: Annäherung des Hardware-Tickers + +Variante 1 +- jeder Seitentabelleneintrag erhält Zählerfeld +- periodisch (nicht bei jedem Zugriff, wäre zu teuer) wird für residente Seiten + 1. used-Bit zu diesem Zähler addiert + 2. used-Bit anschließend gelöscht +- Ergebnis + - recht effizient implementierbar + - Zählerwert: nur Annäherung der Nutzungshäufigkeit + - daher: suboptimale Ergebnisse + +Variante 2 +- jeder Seitentabelleneintrag erhält Zählerfeld (wie eben) +- periodisch wird + 1. der Zähler aber gealtert: nach rechts verschoben (= Division durch 2) + 2. das used-Bit jetzt in das höchstwertige Bit des Zählers geschrieben + 3. das used-Bit anschließend gelöscht +- Ergebnis + - recht effizient implementierbar + - Zähler: enthält jetzt einen Alterungsfaktor + - Annäherung an Zeitpunkt der letzten Nutzung + - bessere Annäherung an LRU-Grundannahme + - bessere Ergebnisse + +#### Working Set +- Annahmen + 1. Arbeitsspeicher-Zugriffsmuster von Prozessen besitzen „hot spots“: Bereiche, innerhalb derer fast sämtliche Zugriffe stattfinden + 2. hot spots: bewegen sich während des Prozessablaufs relativ langsam durch den virtuellen Adressraum + 3. die zu den hot spots eines Prozesses gehörenden Seiten nennt man seine Arbeitsmenge (Working Set) +- Idee + 1. Zugriffe auf Seiten der Arbeitsmenge: sind erheblich wahrscheinlicher als auf nicht zur Arbeitsmenge gehörende Seiten + 2. Auslagerungskandidaten: sind Seiten, die zu keiner der Arbeitsmengen irgendeines Prozesses gehören + +Bestimmung der Arbeitsmenge eines Prozesses +1. Wann gehört eine Seite dazu? Beobachtung der Speicherzugriffe +2. Wann tut sie es nicht mehr? Beobachtungs-Zeitfenster der Größe + +> Definition: Die Arbeitsmenge $W_p (t, \tau)$ eines Prozesses p zum Zeitpunkt t ist die Menge der virtuellen Seiten, die p innerhalb des Intervalls $[t-\tau , t]$ benutzt hat. + +Quantifizierung von $\tau$: +- asymptotisches Verhalten +- für $\tau$ existieren sinnvolle Schranken + +Beobachtung von Arbeitsspeicherzugriffen: ist teuer +- Speicher: Zeitpunkt der letzten Nutzung für jede Seite eines VA (Linux: Billionen/VA) +- Zeit: Aktualisierung bei jedem Speicherzugriff (Milliarden/Sekunde) +- also auch hier gesucht: gute Annäherung (vgl. LRU) + +Schema der Implementierung +- wir brauchen + 1. used-Bit der MMU + 2. virtuelle Laufzeit der Prozesse +- das VMM + 1. stempelt benutzte Seiten (used-Bit) periodisch mit virtueller Laufzeit des Eigentümers (prozessindividuell) + 2. löscht deren used-Bits + +- Wir kennen damit (ungefähr) die Zeitpunkte der letzten Nutzung aller Seiten aller Prozesse (ausgedrückt in virtueller Prozesslaufzeit). +- Wir können damit ausrechnen: Die Arbeitsmengen aller Prozesse +- Wir nutzen diese nun zur Bestimmung von Auslagerungskandidaten +- Wann? → Genau dann wenn + 1. ein Seitenfehler auftritt und + 2. kein Seitenrahmen (im Arbeitsspeicher) frei ist +- Wie? + 1. Bestimmung der Arbeitsmenge $W_p$ eines Prozesses p zum Zeitpunkt t mit + - $z_s$ als Zeitstempel einer Seite $s\in VA_p$ + - $v_p(t)$ als virtueller Prozesszeit von p zum Zeitpunkt t + - $\tau$ als Beobachtungsintervall gilt: + - $s\in W_p(t,\tau)\leftrightarrow z_s\geq v_p(t)-\tau$ + 2. Bestimmung der Auslagerungskandidaten + - Seite s ist Auslagerungskandidat zum Zeitpunkt t $\leftrightarrow$ s gehört zu keiner Arbeitsmenge, d.h. + - $s\not\in\bigcup_{p\in P} W_p(t,\tau)$ + - $\exists$ kein Kandidat: Auswahl gemäß LRU-Regel + - $\exists$ mehrere Kandidaten: Auslagerungskosten berücksichtigen (dirty-Bit) + +Algorithmus zur Kandidatenbestimmung: +```cpp +for p in P + W_p ← null; + for s in PA + if s in VA_p OR z_s >= v_p(t)-tau then W_p ← W_p + {s}; +kandSet ← PA-U + W_p ; +``` + +Bewertung: +- bei zutreffender Grundannahme (hot spots): sehr gute Ergebnisse +- Effizienz: Arbeitsmenge kann schon vor einer Prozessreaktivierung eingelagert werden („prepaging“) + - schneller Prozessanlauf +- Kosten + - periodisch: + 1. Löschen der used-Bits sämtlicher PA-Seiten + 2. Stempeln (z.B. 16GB → 2 21 Seiten, verteilt auf die Seitentabellen der Prozesse) + - je Suche eines Auslagerungskandidaten + - Bestimmung sämtlicher Working Sets: $O(|P|*|PA|)$ + - Bestimmung der Auslagerungskandidaten: $PA- U_{p\in P} W_p$ + +2 Methoden zur Kostenreduzierung +1. Trennung + - Seitentabellen der Prozesse und + - Seitentabelle zur Buchführung der Zeitstempel (nur auf Seiten im PA kann überhaupt zugegriffen werden) + - Reduzierung der Tabellenzugriffe bei Stempeln und W p –Bildung +2. Nutzung von Informationen der letzten Suche (soo viel hat sich seitdem nicht geändert) + - Reduzierung der Suchoperationsanzahl +- WSClock , der heute wohl meistgebrauchte Paging-Algorithmus + +#### WSClock +Umsetzung: +- Zeitstempel-Datenstruktur: ringartige Liste der Seiten im physischen Adressraum („Uhren-Zifferblatt“) +- Kandidatensuche: je Seite Zugehörigkeit zum Working Set prüfen +- Zustandsinformationen: Ende der letzten Suche (Uhrzeiger) +- Stopp der Suche: sobald eine Seite $s\not\in U_{p\in P} W_p$ gefunden wird + +- Beobachtung: hot spots → individuelle Arbeitsmenge je Prozess +- Idee: Verdrängung von nicht zu einer Arbeitsmenge gehörenden Seiten +- Realisierung: Arbeitsmengenbildung über Zeitstempel der letzten Nutzung + +effizient implementiert durch +1. Zeitstempel virtueller Prozesslaufzeit in den Seitentabellen (Hardware) +2. periodische Inspektion des used-Bits (vgl. LRU) +3. Nutzung vorausgegangener Scan-Ergebnisse durch zifferblattartige Datenstruktur der Seiten im physischen Adressraum + +### Zusammenfassung +- Ziele: + 1. großer Arbeitsspeicher  virtuelle Adressräume + 2. Isolation von Prozessen  private Adressräume +- Methoden und Techniken + - Abbildung vm p : VA p → PA + - effizient implementiert durch MMU: Seitentabellen + 1. Abbildung: $vm_p: VA_p\rightarrow PA$ + 2. Zugriffsüberwachung: Rechte, Anwesenheit + 3. Statistik: used, dirty +- Problembereiche + 1. sehr große Seitentabellen/Adressräume: mehrstufige (/invertierte/gehashte) Seitentabellen + 2. Zugriffszeit auf Seitentabelle: TLBs + 3. $|VA_p| >> |PA|$: Paging, Seitenaustauschalgorithmen + +## Segmentierung +Das Problem: Arbeitsspeicher aus Sicht eines Prozesses -> strukturiert, typisiert + +Probleme des Speichermanagements der Compiler und Linker +- Bibliotheken + - a) dynamisch gebunden: Adressen (Code, Daten) zur Übersetzungszeit unbekannt + - b) gemeinsame Nutzung: Relokation der Adressen zur Nutzungszeit nicht möglich +- Speichertypen + - vom Compiler organisierte statische Datensegmente (Programmvariablen) + - vom Compiler organisierte dynamische Datensegmente (Stacks) + - vom Prozess zur Laufzeit organisierte dynamische Datensegmente (Heaps) („new“: malloc, shared segments) + +Dies alles in einem eindimensionalen, linearen Adressraum + +Strukturierung des Arbeitsspeichers → Zweidimensionales Adressraum-Layout +- n Segmente (z.B.16384 bei Intel Pentium Architektur) +- je Segment eigener linearer Adressraum, z.B. Adressen 0..2 32 -1 +- je Segment individuelle Schutzmöglichkeiten, z.B. rw oder x + +Aufbau einer Arbeitsspeicheradresse eines Programms (erzeugt vom Compiler/Linker): 2-dimensional + +Gewinn +1. typisierte Segmente (Code, Daten, Stack) mit dediziertem Zugriffsschutz + - Robustheit, Sicherheit +2. je Segment beginnen Adressen bei 0 + - komfortabel für Compiler/Linker, gemeinsame Nutzung (Bibliotheken, IPC) +3. viele Segmente + - Organisierbarkeit; Shared Libraries, DLLs + +## VMM- Abstraktionen in der Praxis +Wir kennen nun die Abstraktionen des VMMs zum Umgang mit physischem Speicher: +1. private Adressräume + - schaffen Illusion individuellen Arbeitsspeichers je Prozess +2. virtuelle Adressräume + - schaffen Illusion beliebig großen Arbeitsspeichers +3. Segmente + - schaffen Abstraktion typisierten 2-dimensionalen Arbeitsspeichers +4. Schutzmechanismen auf Seiten- und Segmentebene + +Nutzung von Sicherheits- und Robustheitseigenschaften +- Standard: Isolation + 1. Anwendungsprozesse untereinander + 2. Anwendungs- und Systemprozesse + +## Zusammenfassung +1. viele Prozesse + - Relokation, Swapping +2. Prozess-Adressraum >> physischer Adressraum + - virtueller Speicher +3. Isolation von Anwendungsprozessen + - private Adressräume +4. strukturierter und typisierter 2D-Arbeitsspeicher + - Segmentierung +5. differenzierter Zugriffsschutz auf Segmente und Seiten + - schützt Prozesse vor eigenen Fehlern + - schützt Betriebsystem vor Anwendungsprozessen +6. effiziente Realisierungen: + - Hardware: MMUs + +Adressraum-Layout beeinflusst massiv +1. Sicherheitseigenschaften +2. Robustheitseigenschaften +3. Korrektheitseigenschaften +4. Performanzeigenschaften + +Architekturprinzipien +1. monolithische Betriebssystem-Architekturen + - großer, monolithischer Betriebssystem-Adressraum + - aus Performanzgründen oft in private Adressräume der Anwendungsprozesse eingeblendet (s. Linux-Beispiel) +2. mikrokernbasierte Architekturen + - feingranulare Adressraum-Isolation, auch zwischen Betriebssystem-Komponenten + +# Dateisystem +Prozesse +- verarbeiten Informationen, +- speichern diese, +- rufen diese ab, + - deren Lebenszeit >> Lebenszeit Prozesse → Persistenz + - deren Datenvolumen >> Arbeitsspeicher → Größe + - zur gemeinsamen Nutzung → individuelle Zugriffsrechte +- benötigt wird: geeignetes Paradigma + - Datei: Betriebssystem-Abstraktion zum Management persistenter Daten + - Dateisystem: „Aktenschrank“, der Dateien enthält + +## Dateimodelle +### Aufgabe: Präzise Festlegung der Semantik der Abstraktion „Datei“ +Varianten unterscheiden sich durch: +1. Dateinamen; z.B. + - Typtransparenz („kap4.pptx“ vs. „kap4“) + - Ortstransparenz („C:\Users\maier“ vs. „/Users/maier“) + - Struktur (flach, hierarchisch) +2. Dateiattribute; z.B. + - Sicherheitsattribute, + - Zugriffsstatistiken +3. Operationen auf Dateien + - Erzeugen, + - Löschen, + - Lese/Schreiboperationen + +### Aufgabe: Identifikation von Dateien mittels symbolischer Namen +Namensmerkmale +1. Grundmerkmale + - verwendbare Zeichen, Groß/Kleinschreibungssensitivität, Längenbeschränkungen, ... +2. Typtransparenz + - Windows-Familie: explorer.exe, kap4.pdf, LadyInBlack.flac + - Unix-Familie: explorer, kap4, LadyInBlack +3. Ortstransparenz + - Windows: C:\Users\maier + - Mac OS X, Linux: /Users/maier +4. Namensstruktur + +Hierarchischer Namensraum: Kennen wir schon; z.B. +- Postadressen: Land/Stadt/Straße/Hausnummer/Name +- große Dateianzahlen: Beherrschbarkeit +1. Eindeutigkeit + - vorlesungen/bs/kap1 vs. vorlesungen/va/kap1 +2. Eingrenzung von Sichten (Mehrbenutzersysteme) + - /Users/schindler vs. /Users/amthor +- Darstellung: baumartige Strukturen + - „Pfadnamen“ = Pfade im Namensraum + +Varianten +1. unstrukturiert: lineare Bytefolgen (Linux, Windows, Mac OS X) +2. satz- oder baumstrukturiert, indexsequenziell (Mainframes) + +Unstrukturierte Dateien (= das Unix/Windows/-Modell) +- Datei: Bytefolge + - keinerlei inhaltliche/strukturelle Interpretation durch Betriebssystem + - elementares Model + - hohe Flexibilität + - performant realisierbar + - manchmal: auch mühevoll, z.B. + - Speicherung strukturierter Daten wie Bankkonten + - Datenstrukturen aus Programmen etc. + +Strukturierte Dateien (Mainframe-Dateisysteme) +- oft genutzte Standard-Strukturen + - satzstrukturiert, baumstrukturiert, indexsequenziell + - komfortabel, anwendungsnah + - Vorstufe der DBMS-Schemata +- z.B. satzstrukturiert oder baumstrukturiert mit Schlüsseln + +### Datei-Attribute +Sicherheitsattribute +- Standard seit 50 Jahren: wahlfreie Zugriffssteuerung (Discretionary Access Control [DAC]) +1. Eigentümer, Gruppe +2. Zugriffssteuerungslisten: Listen mit Benutzern und Rechten + - z.B. Unix: Eigentümer, Gruppe, Rest der Welt; jeweils rwx-Flags + - z.B. NTFS, Mac OS EFS: Listen von Paaren (Name, Rechte), (etwas) leistungsfähiger +- jüngere, leistungsfähigere Dateisysteme (SELinux, TrustedBSD, SEAndroid): obligatorische Zugriffssteuerung (Mandatory Access Control [MAC]) +1. Klassifikationen (z.B. „öffentlich/vertraulich/geheim“) +2. Sicherheitslabel (z.B. Zugehörigkeit zu Organisationseinheit, örtliche Beschränkungen) + +Weitere Attribute +1. Zugriffsstatistiken; Datum + - der Erstellung + - des letzten Lesezugriffs + - des letzten Schreibzugriffs +2. Nutzungszähler + +### Operationen auf Dateien +Benutzung von Dateien: Operationen der Betriebssystem-API + +| Operationen (Systemaufrufe) | Typische Parameter| +| -- | -- | +| Erzeugen (create, open) | Name, Attribute -> Filedesckriptor (fd) | +| Löschen (unlink) | Name | +| Öffnen (open) | Name, Zugriffsart -> fd | +| Schließen (close) | fd | +| Inhalt lesen (read) | fd, Anzahl Bytes (,Position)-> Daten | +| Inhalt schreiben (write) | fd, Anzahl Bytes (, Position), Daten | +| Positionszeiger setzten (Iseek) | fd, Position | +| in virtuellen AR einbinden (mmap) | fd, virtuelle Adresse | +| Attribute lesen (stat) | Name -> Attribute | +| Attribute setzten (chmod/own/grp) | Name, Attribute | + +(in Klammern die Namen der Unix-API) + + Syntax und Semantik: BS-spezifisch, definiert in API-Spezifikation + +### Zusammenfassung Dateimodelle +- unterscheiden sich durch + 1. Namen und Namensräume (hierarchisch, Semantik) + 2. Dateistrukturen (un-, satz- oder baumstrukturiert) + 3. Attribute (Zugriffsschutz (Eigentümer, Zugriffsrechte, Klassifikationen, Zugriffsstatistiken) + 4. Operationen (Semantik von Erzeugen, Löschen, Lese/Schreiboperationen) +- werden implementiert: durch Dateisysteme + +## Dateisysteme +Problem + 1. schnelles + 2. effizientes + 3. robustes + 4. sicheres +Speichern und Wiederfinden von Dateien auf persistenten Speichermedien + +Dateisystem $\approx$ Aktenschrank, bestehend aus +1. Metadaten: Datenstrukturen zum Management der Nutzdaten +2. Nutzdaten der Dateien +3. Algorithmen, die ein Dateisystem realisieren +4. +Verbreitete „Aktenschrank“-Typen: +- FAT (File Allocation Table): QDOS, MS-DOS (1978) +- NTFS (New Technology File System): Windows 2000/XP/Vista/7+ +- HFS+ (Mac OS Extended (journaled)): Mac OS, APFS: iOS +- Ext∗ (Extended File System (∗=4: journaled)): Linux, IBM AIX +- NFS (Network File System): Sun; Unix-Systeme, Windows-Systeme, ... +- ISO 9660 für optische Speichermedien + +### Speichermedien +- Physisches Layout von **Magnetplattenlaufwerken** + 1. Plattengeometrie: Sektoren, Spuren; mehrere Lagen: Oberflächen + 2. Sektoren: elementare Zugriffseinheiten, z.B. 1024 Byte groß +- Sektor eindeutig identifiziert durch 3D-Adresse (Sektornummer, Spurnummer, Oberflächennummer) +- Zugriffszeiten (Desktop/Server Laufwerke, 2017) + - Rotationszeit = 4-8 Millisekunden (10.000 min -1 ) + - Armpositionierzeit = 4-8 Millisekunden (voller Schwenk, 200-400 Armpositionierungen/Sek) + - Zugriffszeit auf Sektor + - abhängig von Lage des Sektors in Relation zur aktuellen + - Rotationsposition der Platte + - Schwenkposition des Armes + - Größenordnung bei heutigen PC-typischen Laufwerken: 6-12 Millisekunden + - kein wahlfreier Speicher !! + - Datenrate = 40-170 MByte/Sekunde + - um Größenordnungen langsamer als Arbeitsspeicher !! + +SSDs vs. Magnetplatten (2017) +1. wahlfreier Zugriff (c.g.s.) +2. erheblich geringerer Stromverbrauch (technologieabhängig, 10%) +3. erheblich geringere Zugriffszeiten, 5% +4. erheblich höhere Datenraten, Faktor 3 +5. erheblich teurer, Faktor 5-10 + +### Management-Datenstrukturen auf Speichermedien +- Ziele + 1. Speichern + 2. Wiederfinden + von Dateien; schnell, effizient, robust, sicher +- Management-Datenstrukturen (Metadatenstrukturen) +- Datenstrukturen zur Organisation der Nutzdaten + 1. Informationen über das Dateisystem selbst + 2. Inhaltsverzeichnisse + 3. Informationen über individuelle Dateien + +Informationen über individuelle Dateien: i-Nodes +- i-Node: Metainformationen über genau eine Datei (allg.: persistentes Objekt) +- abhängig von konkretem Dateisystem: + 1. enthaltene Informationen + 2. Layout + 3. Größe (≥ 128 Byte, teils >>) +- beim Lesen von Dateien + 1. i-Node-Index der Datei besorgen (aus Verzeichnis, s.u.) + 2. mit diesem Index: i-Node in der i-Node-Tabelle finden + 3. aus dem i-Node lesen: + - a) Schutzinformationen (Sicherheitsattribute) + - b) Adressen der Nutzdaten +- beim Erzeugen von Dateien create(“/home/anna/ProjectXBoard“,) + 1. Suche nach freiem i-Node in der i-Node-Tabelle + 2. Dateiinfos in i-Node schreiben (z.B. Struktur, Schutzinformationen) + 3. Name und i-Node-Index in Verzeichnis eintragen +- beim Schreiben von Daten + 1. Adressierungsinformationen im i-Node aktualisieren +- bei der Freigabe von Dateien + 1. Verzeichniseintrag löschen + 2. falls letzter Verzeichniseintrag dieser Datei (↑Referenzzähler): + - a) i-Node in i-Node-Tabelle als „frei“ markieren + - b) Ressourcen (belegte Sektoren) freigeben + + +#### Verzeichnisse +Aufgabe: Symbolische, hierarchische Namen ⟼ eindeutige Objekt-Id (=i-Node-Index) +- Idee + 1. Verzeichnis: Abbildung + - symbolischer Namensraum → Objektnamensraum + - Pfadnamenskomponente ⟼ Objekt-Id + 2. alle Verzeichnisse gemeinsam: Abbildung + - hierarchischer symbolischer Namensraum → Objektnamensraum + - Pfadname ⟼ Objekt-Id +- in Graph-Notation + - symbolischer Namensraum: baumähnlicher Graph + - Knoten: Verzeichnisse + - Kanten: attributiert mit Namen + - Pfadname: Folge von Kantennamen +- Realisierung: Verzeichnis = Menge von Paaren (Name, i-Node-Index) + +#### Freiliste +Management-Datenstruktur für freien Speicher +- Sektoren sind + 1. entweder in Benutzung; enthalten dann + - a) Nutzdaten von Dateien oder Verzeichnissen + - b) Metadaten, z.B. i-Nodes + 2. oder frei +- alle freien Plattensektoren: Freiliste +- Organisation + - z.B. als Bitmap, je Plattensektor ein Bit (frei/belegt) + - z.B. als B-Baum (HFS) + - effiziente Suche von Mustern + - zusammenhängende Bereiche + - benachbarte Bereiche + - Bereiche bestimmter Größe + +#### Superblock +Einstiegspunkt eines Dateisystems +- erzeugt: bei Erstellung eines Dateisystems („mkfs“, „formatieren“) +- steht: an wohldefiniertem Ort (direkt hinter (eventuellem) Boot-Sektor) +- enthält: Schlüsselparameter + 1. Name des Dateisystems + 2. Typ (NTFS, Ext ∗ , HFS, ...) → Layout der Metadaten + 3. Größe und Anzahl Sektoren + 4. Ort und Größe der i-Node-Tabelle + 5. Ort und Größe der Freiliste + 6. i-Node-Nummer des Wurzelverzeichnisses +- wird als erstes beim Öffnen („montieren“, s.u.) eines Dateisystems vom Betriebssystem gelesen: + - Typ: passende Betriebssystem-Komponente + - i-Node-Liste, Freiliste: Metadaten zum Management + - Wurzelverzeichnis: logischer Einstiegspunkt + +## Datenstrukturen u. Algorithmen des Betriebssystems +Ablauf eines Dateizugriffs +1. Anwendungsprogramm +2. im Folgenden: beteiligte Datenstrukturen und Algorithmen des Betriebssystems + +`fd=open(“/home/jim“, O_RDONLY);` +Pfadnamenauflösung +1. Lesen des i-Nodes des Wurzelverzeichnisses (Superblock) +2. Lesen der Nutzdaten des Wurzelverzeichnisses: Suchen von „home“ +3. Lesen des i-Nodes von „home“ +4. Lesen der Nutzdaten des „home“-Verzeichnisses: Suchen von „jim“ +5. Lesen des i-Nodes von „jim“: Prüfen der Rechte zum Lesen (O_RDONLY) +6. Anlegen eines Filedeskriptors im Prozess-Deskriptor, +7. Rückgabe von dessen Index (fd) an Aufrufer + +`read(fd, &buffer, nbytes);` +Transfer von nbytes aus der geöffneten Datei fd zur Variablen buffer +1. Rechteprüfung +2. Zugriff auf Nutzdatenadressen im i-Node über fd-Tabelle im Prozessdeskriptor; Ergebnis: Sektornummer(n) auf Speichermedium +3. Auftrag an Gerätetreiber: „Transfer der Sektoren in den BS-Cache“ +4. Nach Fertigstellung (Interrupt): + - Kopie des Caches nach buffer, + - Rückgabe der Anzahl der tatsächlich gelesenen Bytes / Fehler + +Alternative Zugriffsmethode: per VMM +- `mmap(start, length, PROT_READ, MAP_PRIVATE, fd, offset);` +- Einblenden einer Datei in (eigenen) Adressraum: vm p , Kap. 3 +- Zugriffsoperationen: sind reguläre Arbeitsspeicherzugriffe +- Zugriff auf Medium: durch reguläre Seitenfehlerbehandlung des VMMs + +Vergleich Bsp Kontozugriff + +read/write +```bash +struct konto_t konto; +off_t kontoOffset; +fd=open(“kontodatei“, O_RDWR); +kontoOffset = kontoNr*sizeof(konto_t); +lseek(fd,kontoOffset); +read(fd, &konto, sizeof(konto_t)); +konto.stand = 0; +lseek(fd,kontoOffset); +write(fd, &konto, sizeof(konto_t)); +``` +=> 6 Operationen + +mmap +```bash +struct konto_t kontenDB[kontenZahl]; +fd=open(“kontodatei“, O_RDWR); +mmap(&kontenDB, ... , RW, ..., fd, 0); +kontenDB[kontoNr].stand = 0; +``` +=> 1 Operation + + +- read/write + - Umständliche Benutzung + - jede Operation erfordert Kopieren (teuer!) + - Caching des Dateisystems wird genutzt + - kleinste Transfereinheit 1 Sektor +- mmap + - direkter Zugriff auf Daten, implizite Leseoperationen per VMM + - keine Kopieroperationen + - VMM, working set, wird genutzt + - kleinste Transfereinheit 1 Seite + +- close(fd) + 1. Freigabe des Filedeskriptors im Prozess-Deskriptor + 2. Zurückschreiben der gecachten Informationen (i-Node, Nutzdaten) + - implizit, im Rahmen des Dateisystem-internen Cachemanagements (Alterung) + - explizit, durch fsync() +- munmap(start,length) + 1. hebt Assoziation zwischen Datei und Arbeitsspeicher auf (vm p ) + - weitere Zugriffe: Speicherzugriffsfehler + 2. Zurückschreiben modifizierter Seiten + - implizit, im Rahmen des regulären Pagings (Verlassen des working sets) + - explizit, durch msync() + +# Netzwerkmanagement +Räumlich verteilte Systeme +- Arbeitsplatzrechner, Server, Laptops, Smartphones, dedizierte IT-Geräte +- Kommunikationsmedien (LANs, WLANs, WANs; diverse Technologien) + +Verteilte Dienste und Anwendungen +- Email, Web +- Netzwerk-Dateisysteme, ssh +- Grid-Computing, Cloud-Computing +- Energieinfrastrukturmanagementsysteme + +Rechnergrenzen überschreitende Kommunikation +- ein geeignetes Paradigma muss her +- Socket: standardisierte Betriebssystem-Abstraktion zur Botschaften basierten Kommunikation in heterogenen verteilten Systemen + +(Berkeley * -)Sockets +- botschaftenbasiert, send/receive-Modell +- komplex in der Nutzung, da + 1. universell: Implementierungsbasis anwendungsnäherer Modelle (RPC, RMI, Blackboards, Tuple Spaces, ... → Kommunikationsmodelle) + 2. problemspezifisch konfigurierbar hinsichtlich + - Synchronität (send/receive-Operationen) + - Verlässlichkeit (Garantien über Zustellung, Reihenfolgeerhalt) + - Kommunikationsdomäne (Internet, lokales System, Novell-Netz, ...) + +Die Socket-Abstraktion: +- Socket: Steckdose ins Netzwerk (Betriebssystem-)Objekt, zu dem gesendet oder von dem empfangen wird) +- mit Socket assoziiert: + 1. Name (z.B. IP-Adresse in der Internet-Domäne, Port-Nummer) + 2. Protokoll (z.B. TCP, UDP) +- Kommunikation: über Socket-Paare + +Betriebssystem-Integration +- Socket als Betriebssystem-Abstraktion: Teil der API +- BS-Komponente: Integrationsrahmen für Protokollimplementierungen +- Darstellung: Rahmen, den Betriebssysteme zur Integration von Protokollen bieten + +Socketframework des Betriebssystems +- auf Anwendungsebene implementierte, Sockets nutzende Protokolle (smtp, http, ftp, ...) +- Kommunikationsframework im Betriebssystem + 1. Socket-Level + 2. TCP/UDP/...-Level + 3. IP-Level + 4. Netzwerktreiber + 5. Gerätecontroller-Hardware ("Netzwerkkarten") + + werden die 7 Ebenen des ISO/OSI-Schichtenmodells implementiert + +Zusammenfassung +- Betriebssystem-Abstraktion zur (Rechnergrenzen überschreitenden) Kommunikation +- botschaftenorientiertes Kommunikationsmodell +- vielfältig konfigurierbar (Protokolle, Verlässlichkeit, Synchronität, ...) +- weitgehend unabhängig von Netzwerk-Technologien +- als Betriebssystem-Abstraktion Teil der API +- Betriebssystem-Komponente: Integrationsrahmen für Protokollimplementierungen + +# E/A Systeme +85% der Ausfälle heutiger Standard-Betriebssysteme haben ihre Ursache im E/A-System! + +Programmierung eines Plattenlaufwerks +- Geräteschnittstelle + - ein Bündel von Steuerungs-, Status-, Adress- und Datenregistern + - erreichbar über bestimmte (s.u.) Adressen +- Typische Operationen + - Start/Stopp/Zustandsabfrage des Spindelmotors + - Positionierung des Lese/Schreibkopfes + - Datentransferoperationen (bspw. Toshiba Laptop-Laufwerk) +- Nach Abschluss einer Operation: Ergebnisanalyse + - 23 Status- und Fehlerbits, verteilt über diverse Kontroll- und Statusregister + - Traum eines jeden Softwareentwicklers + +Umgang damit +1. Kapselung gerätespezifischer Merkmale + - Anzahl, Layout und Adressen der Steuerungs-, Status- und Adressregister + - Gerätekommandos und Timing + - Fehler und Fehlerbehandlung in gerätespezifischen Softwarekomponenten → Gerätemanager („Treiber“) +2. hierauf aufbauende Abstraktionsschichten + +## Hardware Prinzipien +- Prinzipieller Aufbau von E/A-Geräten: Hardware/Software-Interface (Programmierschnittstelle): Controllerregister +- Programmierparadigma: Lesen und Schreiben von Steuerungs- und Datenregistern + +### Kommunikationsmuster mit einem Controller +Das Betriebssystem (Gerätemanager) +1. schreibt einen Befehlscode in ein Steuerungsregister +2. schreibt Parameter in Datenregister +3. setzt Interrupt-Enable-Bit des Steuerungsregisters +4. setzt go-Bit des Kontrollregisters +Wenn die Operation ausgeführt ist: Die Controller-Hard/Firmware +1. löscht go- und Interrupt-Enable-Bits +2. schreibt Ergebnis/Fehlercode in Statusregister +3. setzt ready-Bit +4. löst (evtl.) Interrupt aus + +Wie "sieht" ein Betriebssystem diese Geräte-Register? +- adressiert: über Arbeitsspeicheradressen +- 2 Varianten + - in separatem E/A Adressraum (I/O Address Space) + - Zugriff: über spezielle Operationen (Prozessor-Instruktionssatz) auf + - "I/O-Ports" + - in regulärem physischen Adressraum (Memory Mapped I/O) + - Zugriff: durch Einblendung in regulären virtuellen Adressraum + - Nutzung regulärer virtueller Adressen + +### E/A- Adressräume +E/A-Adressraumzugriff über 2 (privilegierte!) Prozessorinstruktionen: + - `IN R8, #0x42` liest im E/A-Adressraum das auf Adresse 0x42 liegende Controllerregister `(I/O-Port 42_16)` ins Prozessorregister R8 + - `OUT #0x42,R8` schreibt den Inhalt von Prozessorregister R8 in das im E/A-Adressraum auf Adresse `42_16` liegende Controllerregister + +Technik: PCI-Bridge +- Bridge-Stellung bei Zugriff auf regulären physischen Speicher: + ![PCI Bridge](Assets/Betriebssysteme_PCI_Bridge.png) +- Bridge-Stellung bei Zugriff auf E/A-Adressen: + ![PCI Bridge 2](Assets/Betriebssysteme_PCI_Bridge2.png) +- Bridge-Umschaltung + - Benachrichtigen der PCI-Bridge durch eigene Busleitung + - veranlasst durch "IN"- und "OUT"-Instruktionen +- Probleme hiermit + - IN/OUT sind Operationen im Prozessorinstruktionssatz + - stehen in höheren Programmiersprachen nicht direkt zur Verfügung + - (Teile der) Gerätemanagementsoftware in nativem Code des Prozessors + - Schutzkonzept des E/A-Adressraums: + - ist die Privilegierung der IN/OUT-Operationen (IO Privilege Level) + - extrem grobgranular: + - jeder Gerätemanager hat Zugriff auf sämtliche Geräte + - keine Isolation nicht vertrauenswürdiger Gerätemanager + - keine Fehlerisolation + - nicht sicher, nicht robust + +### Memory Mapped E/A +Controllerregisterzugriff über reguläre physische Arbeitsspeicheradressen + +Schutzkonzept + - Abbildung verschiedener Geräte auf verschiedene Seiten des PA + - Abbildung dieser Seiten in die verschiedenen privaten VAe der Gerätemanager + - Isolation nicht vertrauenswürdiger Treibersoftware + - Robustheit, Sicherheit, kleine TCB (Mikrokernarchitekturen!) + +Technik +- Zugriff auf Controllerregister: + - Konfiguration der PCI-Bridge beim Booten: "alle Adressen > 0xFF00... sind E/A-Register" +- E/A-Controllerregister sind hier Teil des Arbeitsspeichers + - Arbeitsspeicher: unterliegt i.A. Caching-Mechanismen + - MMU: muss „nicht cachebare Seiten“ kennen (Cache bekommt Veränderungen der Controllerregister durch Gerät nicht mit!) +- Varianten in der Praxis + 1. reiner E/A-Adressraum + 2. reine memory mapped I/O + 3. Hybridansätze (z.B. Pentium-Architektur): sowohl als auch + +## Software Prinzipien +- E/A-Operationen dauern – vergleichsweise – lange + - Wartesituationen +- ökonomische Überbrückung + - Prozessor: führt andere Aktivitäten durch +- am Ende einer E/A-Operation + - Prozessor: erhält Nachricht (Interrupt) + - von E/A-Controllern erzeugt + - über Kommunikationsbusse dem Prozessor zugestellt, dort + - asynchrone Unterbrechung des regulären Prozessablaufs + - Start der ISRs der Gerätemanager + +Gerätemanager ("Treiber") +- gerätespezifische Software mit direktem Zugriff auf HW-Ressourcen +- Komponenten: + 1. Auftragsannahme + - Schnittstelle zu höheren BS-Ebenen (Reader/Writer-Queues) + - Kommunikation mit Gerät (Controller-HW): Auftragserteilung + 2. Ergebnisanalyse (ISR) + - Kommunikation mit Gerät (Controller-HW): Interruptbehandlung + - Kommunikation mit höheren BS-Ebenen: Ergebnisrückgabe + +BS-Integration +- im Maschinenraum +- Integrationsrahmen für gerätespezifische Software + +In heutigen Standardbetriebssystemen +- nehmen Gerätemanager ca. 80% der Distributionssoftware ein + - Hardware spezifische Konfiguration +- liegt die Ursache ca. 85% aller Systemausfälle in (Fremd-) Gerätemanagern: + - Komplexität der Programmierung: zeitliche Bedingungen, Parallelität, Synchronisation + - Diversität des Gerätezoos + - Diversität der HW- und Gerätemanager-Hersteller + - Innovationsfreudigkeit und time-to-market → Bananensoftware +- Massive Robustheits- und Sicherheitsprobleme ! + +Problemfolgen +1. Management der Schwachstellen + - Treiberzertifizierung (automatisierte Korrektheitsanalysen) + - Flicken "42 wichtige Updates stehen bereit" ... +2. Architekturprinzipien robuster und sicherer Systeme (→ Kap. 7) + - Isolation nicht verifizierter verifizierbarer (Treiber-)Software + - Ausfallerkennung und -behandlung + - Treiberwrapping, micro-reboot + - Mikrokernarchitekturen + +## Zusammenfassung +HW-Programmierung mittels +- Controller-Register + - in E/A-Adressräumen + - im Arbeitsspeicher (Memory Mapped E/A) + - Isolation, Robustheit, Sicherheit +- Interruptsystem + - asynchrone Benachrichtigungen + +Software-Prinzipien +- Gerätemanager (Treiber) + - Auftragsmanagement + - ISRs + +# High-End-Betriebssysteme +## Was sind High-End- Betriebssysteme? +In-etwa-Übersetzung: „Fortgeschrittene“ Betriebssysteme (engl. „Advanced Operating Systems“) + +Es geht um: +- „Einbau“ nichtfunktionaler Eigenschaften +- neue Konzepte für die Architektur von Betriebssystemen +- neue Abstraktionen innerhalb von Betriebssystemen +- ... + +Wir greifen 2 nichtfunktionale Eigenschaften von Betriebssystemen heraus, die insbesondere damit zu tun haben, dass kein (Betriebs)System vollständig fehlerfrei ist! und eine wichtige Notwendigkeit besteht in der **Reduktion operationaler Risiken Verantwortbarkeit** + +## Sicherheit +Das Problem: Paradigmatische Grundlagen heutiger Mainstream-Betriebssysteme stammen aus den 60er Jahren des letzten Jahrtausends (Prozesse, Dateien, Kommunikation, ...) + +Die Folge: Für viele kritische Anwendungsgebiete +- unzulängliche Paradigmen +- schwache Implementierungen +- unzureichende Sicherheit (engl. Security – nicht Safety!!) z.B. gegen Hacker, Spionage, Sabotage ... + +High End: Paradigmenwechsel + +### Ein Beispiel: SELinux +Ziel: Security Enhanced Linux +1. state-of-the-art Betriebssystem +2. state-of-the-art Sicherheitsparadigmen + +Idee: durch Sicherheitspolitik gesteuertes Betriebssystem + +Technischer Ansatz (z.B.) SELinux = Linux + Sicherheitspolitiken + +Sicherheitspolitiken in SELinux +- neue Betriebssystem-Abstraktion (die erste seit 50 Jahren) +- absolute Kontrolle über kritische Funktionen des Betriebssystems +- spezifiziert durch Regelmenge +- implementiert durch die SELinux-Sicherheitsarchitektur + +SELinux-Sicherheitsarchitektur +- Security Server (strategische Komponente): Laufzeitumgebung für Sicherheitspolitik in Schutzdomäne des BS-Kerns +- Interzeptoren (Politikdurchsetzung): vollständige Kontrolle + +Spezifikation einer Sicherheitspolitik +- Sicherheitspolitik: Regelmenge der Art + ``` + allow + : + allow + : + ``` +- kritisch + - Korrektheit (100.000 Regeln ...) + - Vollständigkeit + - Widerspruchsfreiheit +- Security Engineering + - Politikspezifikation + - Politikanalyse + - Sicherheitsarchitekturen + +## Robustheit +Ziel: Tolerierung unvorhergesehener Fehler und Ausfälle + +Auch hier ein Beispiel: Architekturprinzipien +1. monolithische Architektur + - BS-Komponenten zusammengefasst zu + - einem Programmsystem + - in einem Adressraum + - Kommunikation untereinander mittels Prozeduraufrufen + - Fehlerausbreitung: innerhalb des (großen) BS-Adressraums +2. Mikrokernarchitektur + - BS-Komponenten bilden + - separate Funktionseinheiten + - mit individuellen Adressräumen + - Kommunikation: mittels Prozedurfernaufrufen + - Fehlerausbreitung: gestoppt an Adressraumgrenze(n) + +Folgen +1. Korrektheit + - Fehlerausbreitung + - Aussagekraft formaler Verifikation von BS-Komponenten +2. Robustheit + - Fehlerisolation + - Fehlerbehebung (vgl. Micro-Reboot) + +## Abschließend +Risikoszenarien und High-End Betriebssysteme +- IT-Sicherheit & Security Engineering + - Design von Sicherheitseigenschaften und Architekturen +- AOS + - (z.B. Robustheit) + - Konzepte, Architekturen, Algorithmen + +# Abschließende Zusammenfassung und Schwerpunkte +1. Betriebssysteme + - Spektrum der Anwendungsszenarien + - Spektrum der Aufgaben + - funktionale u. nichtfunktionale Eigenschaften von Betriebssystemen +2. Prozessormanagement + 1. Prozesse u. Threads + - Betriebssystem-Abstraktion „Prozess“ + - Prozessmodelle + - Prozessmanagement und Prozessdeskriptor + - Threads, Multithread-Prozessmodelle u. Threaddeskriptor + 2. Prozesse u. Threads + - Betriebssystem-Abstraktion „Prozess“ + - Prozessmodelle + - Prozessmanagement und Prozessdeskriptor + - Threads u. Thread-Typen + - Multithread-Prozessmodelle u. Threaddeskriptor + 3. Scheduling u. Scheduling-Strategien + - Scheduling: Notwendigkeit, Sinn u. Grundaufgabe + - Zustandsmodelle + - Kontextwechsel + - diverse Scheduling-Strategien + 4. Privilegierungsebenen + - Prozessormodi: Zweck u. Handhabung +3. Kommunikation & Synchronisation + 1. Kommunikation und Synchronisation + - Kritische Abschnitte u. wechselseitiger Ausschluss + - Mechanismen zur Kommunikation u. Synchronisation + 2. Botschaften und Botschaften basierte Kommunikation + - Motivation + - elementare Operationen + - Fernaufrufe (RPCs) + - Systemaufrufe + 3. Ereignismanagement + - Notwendigkeit des Ereignismanagement + - Umgangsformen mit Ereignissen + - Interrupts und Programmiermodelle zum Umgang damit + - Interrupt-Vektor(en) und Interrupt-Service-Routinen + - Interrupts auf Anwendungsebene +4. Speichermanagement + 1. Speichermedien + - Speichertechnologien u. deren Eigenschaften + - Speicherhierarchien + - Arbeitsspeicher, Relokation u. Swapping + 2. Virtueller Speicher und dessen Management + - Virtuelle Prozessadressräume und physischer Adressraum + - Abbildungen aus virtuellen Adressräumen in den physischen Adressraum + - Seiten(abbildungs)tabellen: Funktion u. Aufbau + - Seitentabelleneinträge + - Funktion von MMU und TLB + - Seitenfehler u. Seitenfehlerbehandlung + - Seitenaustauschalgorithmen + 3. Segmentierung + - Prinzip + - Sinn der Segmentierung + - Segmentierung u. Paging +4. Dateisysteme + 1. Motivation + 2. Dateimodelle + - Dateinamen + - Dateistrukturen + - Dateiattribute + - Operationen auf Dateien + 3. Speichermedien: Magnetplatten u. SSDs + 4. Management-Datenstrukturen + - i-Nodes + - Verzeichnisse + - Superblock u. Freilisten +5. Netzwerkmanagement + 1. Verteilte Systeme + 2. Socket-Abstraktion +6. E/A Systeme + 1. Hardware-Prinzipien + - Geräteschnittstelle + - E/A-Adressräume + - Memory-Mapped E/A + 2. Software-Prinzipien + - Treiber (Gerätemanager): Funktion u. Struktur + - Treiber-Integration ins Betriebssystem + - Problemzonen +7. High End Betriebssysteme + 1. Nichtfunktionale Eigenschaften von Betriebssystemen + - Sicherheit u. SELinux-Ansatz + - Robustheit + 2. Betriebssystem-Architekturen + - Makrokerne u. Mikrokerne diff --git a/Computergrafik.md b/Computergrafik.md new file mode 100644 index 0000000..75bc131 --- /dev/null +++ b/Computergrafik.md @@ -0,0 +1,2340 @@ +--- +title: Computergrafik +date: Wintersemester 20/21 +author: Robert Jeutter +--- + +Computergrafik ist in erster Linie Bildsynthese mit dem Computer! + +dabei zu lösende Teilaufgaben: +- identifizierung relevanter mathematischer Funktionen +- Umsetzung passender/effizienter Algorithmen und Datenstrukturen +- Erzeugung virtueller Umgebungen +- Kompromisse zwischen Genauigkeit und Berechnungsaufwand + +Aspekte der Computergrafik +- Mathematik +- Rasterkonvertierung +- Physik +- Physiologie +- Bildverarbeitung + +# Grundlagen der Vektorgeometrie +## Grundlagen +### Vektorräume und Vektorrechnung +- ein Vektor $\vec{x}$ wird definiert als Element eines n-dimensionalen Zahlenraums +- ein Vektor wird als Zahlentupel (skalarer Wert) dargestellt, entweder als Zeilenvektor oder Spaltenvektor +- der Spaltenvektor wird auch $\vec{x}^t$ (Transponierte von x) genannt (und umgekehrt) +- Verallgemeinerung von Vektoren als Matrizen und Tensoren +- Tensoren dienen der Darstellung (Datenstruktur) von grafischen Objekten und Transformationen aber auch von Signalen, Farben und Bildern +- Vektoralgebra ist ein mächtiges Mittel zur Datenverarbeitung in der Vektorgeometrie + +$\vec{x}=(x_1,x_2,...,x_n)$ oder $\vec{x}^T=\begin{pmatrix}x_1 \\ x_2 \\ ... \\ x_n \end{pmatrix}$ + +**Multiplikation**: Multiplikation eines Vektors mit einer skalaren Größe resultiert wiederum in einen Vektor + +$\vec{q}=\alpha * \vec{x} = (\alpha *x_1, \alpha *x_2,...)$ + +**Addition**: Das Addieren zweier Vektoren im selben Vektorraum ergibt wieder einen Vektor + +$\vec{x}+\vec{r}=(x_1+r_1, x_2+r_2,...)$ + +**Linearkombination**: Die Linearkomination mehrerer Vektoren ergibt einen Vektor + +$\vec{o} = (\alpha * \vec{p})+(\beta *\vec{q})+(\gamma * \vec{r})$ + +**Lineare Unabhängigkeit**: eine Menge von Vektoren heißt linear unabhängig wenn keiner von ihnen als Linearkombination der anderen erzeugt werden kann. + +**Länge** (Betrag) eines Vektors: $\vec{p}=(x,y,z): |\vec{p}|=\sqrt{x^2+y^2+z^2}$ Der Abstand zwischen zwei Punkten ist gleich der Länge des Differenzvektors + +**Skalarprodukt**: $\vec{x}*\vec{r}=\sum_{i=0}^{n-1} x_i*r_i$ Das Skalarprodukt ist somit ein skalarer Zahlenwert. – Aus der Definition folgt u.a. die beiden Vektoren m ̈ussen dieselbe Anzahl Koordinaten haben.Senkrecht zu einander stehende Vektoren $\vec{x}$ und \vec{r} ergeben immer das Skalarprodukt Null. + +**Winkel**: Ein Winkel $\phi$ zwischen den Vektoren $\vec{a}$ und $\vec{b}$ aus: $\vec{a}*\vec{b}=|\vec{a}|*|\vec{b}|*cos(\phi)$ mit $cos(\phi)=\frac{\vec{a}*\vec{b}}{|\vec{a}|*|\vec{b}|}$ + +Diese Winkelbestimmung ist im Bereich -180° bis +180° vorzeichenunabhängig, da $cos(\phi)=cos(-\phi)$. Es können also nur Winkel im Bereich $0 \geq \phi \geq \pi$ + +**Vektorprodukt** (Kreuzprodukt): Das Vektorprodukt $\vec{a}\times\vec{b}$ ist ein Vektor. +$$\vec{a}\times\vec{b} = \begin{pmatrix} a_y b_z - a_z b_y \\ a_z b_x - a_x b_z \\ a_x b_y - a_y b_x \end{pmatrix}$$ +Die Richtung des resultierenden Vektors ist senkrecht auf $\vec{a}$ und auf $\vec{b}$. Das Vorzeichen hängt von der Reihenfolge der Vektoren ab: $\vec{a}\times \vec{b}=-\vec{b}\times \vec{a}$. +Entsprechend der Rechte-Hand-Regel ergibt eine Drehung von a nach b im Uhrzeigersinn ein negatives Vorzeichen und entgegen dem Uhrzeigersinn ein positives. + +**Betrag des Kreuzprodukts**: Der Betrag des Vektors $(|\vec{a}\times\vec{b}|)$ ist gleich der Fläche des durch $\vec{a}$ und $\vec{b}$ aufgespannten Parallelogramms (Fläche = Basis * Höhe des Parallelogramms): +$$|\vec{a}\times\vec{b}|=|\vec{a}|*|\vec{b}|*sin(\phi) =|\vec{a}|·h$$ +Der Winkel $\beta$ lässt sich also aus dem Kreuzprodukt ableiten. Aus dem Kreuzprodukt resultiert ein orientierungsabhängiges Vorzeichen. Es gilt: $sin(-\phi)=-sin(\phi)$ + +**Matrizen**: Matrizen sind Tupel von Vektoren aus demselben Vektorraum. Die Verallgemeinerung einer Matrix, nämlich ein Tupel von Matrizen wird auch Tensor genannt. Daher sind Matrizen und Vektoren spezielle Tensoren. + +**Matrizenmultiplikation**: Jede Koordinate des resultierenden Vektors berechnet man als Skalarprodukt des entsprechenden Zeilenvektors der Matrix mit dem Vektor: +$$r_i = A_i * \vec{x} = \sum_{k=1}^n a_{ik}*x_k$$ +Vektoren werden als Spaltenvektor geschrieben und stehen bei der Multiplikation immer rechts der Matrix. +Bei einer entsprechenden Multiplikation für Zeilenvektoren würde die Matrix rechts stehen und wäre transponiert. + +Die Koeffizienten der resultierenden Matrix $c_{ij}$ entsprechen dem Skalarprodukt der i-ten Zeile $A_i$ und der j-ten Spalte $B_j$ von A resp B. + +Entsprechend der Definition für Skalarprodukte muss die Matrix A gleich viele Spalten haben wie Matrix B Zeilen. Es können folglich n x m-Matrizen mit m x o-Matrizen multipliziert werden, was in einer n x o-Matrix resultiert. + +**Einheitsmatrix E**: Die Einheitsmatrix ist eine (quadratische) n x n-Matrix welche nur in der diagonalen Einsen als Koeffizienten und sonst überall Nullen enthält. Die Multiplikation einer Einheitsmatrix mit einem Vektor $\vec{x}$ lässt den Vektor unverändert, gleiches gilt für die Multiplikation mit einer Matrix ($E*\vec{x}=\vec{x}$). + +**Inverse $A^{-1}$**: Die Inverse der Matrix A wird als $A^{-1}$ notiert. Sie ist definiert durch $A*A^{-1}=E$. Eine Inverse existiert nur für quadratische n x n-Matrizen welche aus n linear unabhängigen Vektoren zusammengesetzt ist. + +**Transposition** von Matrizen: $(A*B)^T = B^T * A^T$ + +**Assoziativität**: Die Matrixmultiplikation ist immer assoziativ $A*(B*C)=(A*B)*C$ + +**Inversion**: $(A*B)^{-1} = B^{-1}*A^{-1}$ + +**Kommutativität**: ist im Allgemeinen bei Matrixmultiplikation nicht gewährleistet $A*B \not = B*A$ + +### Kartesische Koordinaten +Dreidimensionales kartesisches Koordinatensystem werden aufgespannt durch die drei linear unabhängigen Einheitsvektoren $\vec{x}$,$\vec{y}$ und $\vec{z}$. + +3D-Punktobjekte werden durch Vektoren im $\R^3$ repräsentiert. Diese Vektoren werden Ortsvektoren genannt, da Sie einen Ort im Raum repräsentieren. Die Koordinaten eines Vektors sind wiederum eine senkrechte Projektion des Vektors auf die Koordinatenachse. + +**Drehsinn**: Koordinatensysteme haben einen Drehsinn (positiv/negativ). Rechte-Hand-Regel: Daumen ist Rotationsachse, Fingerspitze zeigt positive Richtung. + +### Elemente der Geometrie +Objekte werden als Linearkombination von Orts- und Richtungsvektoren zusammengesetzt. (Bsp Unendliche Gerade, Liniensegment,...) + +Beachte: Orts und Richtungsvektoren haben die gleiche Darstellung im kartesischen Vektorraum, müssen aber unterschiedlich behandelt werden. Z.B. eine Translation einer Geraden darf sich nur auf den Orts- nicht auf den Richtungsvektor auswirken. Die Rotation muss auf beide Teile angewendet werden, etc. + +**Ebenen**: Eine unbegrenzte Ebene p kann wiederum als Linearkombination aus Ortsvektor $\vec{q}$ und zwei linear unabhängigen Richtungsvektoren $\vec{r}$ und $\vec{s}$ definiert werden $p=\vec{q}+\alpha*\vec{r}+\beta * \vec{s}$ + +**Dreieck**: Punkte A,B und C $\vec{A}+\alpha*(B-A)+\beta*(C-A)$ + +## Transformationen 2D +Ziel der Transformation im Allgemeinen: Einheitliche Beschreibung der Transformation durch einheitliche Transformationsmatrizen +- alle auf iene Punktmenge anzuwendende Matrizen können dann vor der Anwendung auf die Punkte in einer Gesamtmatrix zusammengefasst werden +- auf jeden Punkt ist statt mehrerer Matrixoperationen nur noch eine anzuwenden +- effizientere Berechnung der Transformation + +Arten: + +**Translation**: Verschiebung eines mehrere Punkte P um den Vektor $\vec{t}$ + +**Skalierung**: Stauchung oder Streckung eines Objekts bezüglich des Koordinatenursprungs $P'=S*P$ (univorm vs nichtuniform). + +**Spiegelung**: Spezialfall der Skalierung +- an der x-Achse $S=\begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}$ (Vorzeichenumkehr für y-Koordinaten) +- an der y-Achse $S=\begin{pmatrix} -1 & 0 \\ 0 & 1 \end{pmatrix}$ (Vorzeichenumkehr für x-Koordinaten) +- am Ursprung $S=\begin{pmatrix} -1 & 0 \\ 0 & -1 \end{pmatrix}$ (entspricht Spiegelung an x-und y-Achse) + +**Scherung**: Positionsabhängige Stauchung oder Streckung (Objekte ändern die Form, sind nicht starr) Punkte auf einer Geraden liegen aber auch nach der Scherung wieder auf einer Geraden (Eigenschaft von affinen Abbildungen): +$S=\begin{pmatrix} 1 & S_x \\ S_y & 1 \end{pmatrix}$ + +**Rotation mit Polarkoordinaten**: Die Rotation eines Punktes $P=(x,y)$ mit dem Drehwinkel $\theta$ um den Nullpunkt lässt sich einfacher über Polarkoordinaten $(r,\phi)$ herleiten. Der gedrehte Punkt wird dann $P'=(r,\phi+\theta)$ + +$r=\sqrt{x^2+y^2}$, $x=r* cos(\phi)$, $y=r* sin(\phi)$ + +$$\binom{x'}{y'}=\begin{pmatrix} cos(\theta) & -sin(\theta) \\ sin(\theta) & cos(\theta)\end{pmatrix}*\binom{x}{y}$$ + +Somit gilt $p'=R_\theta * P$ + +**Koordinatentransformation**: Ein Punkt P soll in ein gedrehtes (lokales) Koordinatensystem transformiert werden. Die lokalen Koordinaten erhält man durch Projektion des Punktes auf die lokalen Achsen (Skalarprodukte). Die lokalen Koordinatenachsen sind als Vektoren im Ursprungskoordinatensystem definiert. Sie stehen senkrecht aufeinander und haben die Länge 1. Die Koordinaten-Transformation kann als Matrixmultiplikation realisiert werden. +$$P' =T*P = \begin{pmatrix} x_x & x_y\\ y_x & y_y \end{pmatrix} * \binom{P_x}{P_y}$$ + +**Zusammenfassung**: Viele zweidimensionale Transformationen lassen sich als 2x2 Matrizen darstellen (ausnahme Translation). Um verschiedene Transformationen durch Operationen auszudrücken und Fallunterscheidungen vorzubeugen werden homogene Vektorräume verwendet. + +## Homogene Vektorräume +Ein kartesischer Punkt $P_k$ mit dem Ortsvektor $(x',y')$ wird im homogenen Vektorraum durch eine zusätzliche Dimension w, als 3-Tupel $(x,y,w)$ dargestellt. Ein homogener Vektor $(x,y,w)$ entspricht dem kartesischen Vektor $(\frac{x}{w},\frac{y}{w})$. +Die homogene Komponente w kann dabei frei gewählt werden: Alle Punkte $P_H$ auf der unendlichen Geraden $(0,0,0)(x',y',1)$ entsprechen demselben kartesichen Vektor $(x',y')$ (Zentralprojektion auf kartesischer Ebene). + +In vielen Anwendungsfällen wird bei Ortsvektoren im homogenen Vektorraum $w=1$ gewählt (1="Punkt", 0="Richtung"; kartesische Zahlenebene). + +**Skalare Multiplikation** verändert das kartesische Äquivalent nicht: $\alpha * P_h = (\alpha*x, \alpha*y, \alpha*w)$ (Spezialfall 0 !) + +**Translation**: Die Multiplikation mit einer Matrix A muss dasselbe Ergebnis liefern, wie eine Addition eines Translationsvektors $(\Delta x, \Delta y)$ zum kartesischen Punkt: $A*P=P+(\Delta x, \Delta y)$ + +Die Herleitung einer Matrix für A erfolgt durch folgendes Gleichungssystem für die Koeffizienten der Matrix: +$$\begin{pmatrix} a_{11} & a_{12} & a_{13}\\ a_{21} & a_{22} & a_{23}\\ a_{31} & a_{32} & a_{33} \end{pmatrix} * \begin{pmatrix}x \\ y \\ 1 \end{pmatrix} = \begin{pmatrix}x+\Delta x \\ y+\Delta y \\ 1\end{pmatrix}$$ + +**Skalierung, Projektion, Spiegelung** können durch folgende Matrix dargestellt werden: +$$\begin{pmatrix} F_x & 0 & 0 \\ 0 & F_y & 0 \\ 0 & 0 & 1 \end{pmatrix} * \begin{pmatrix} x \\ y \\ 1 \end{pmatrix} = \begin{pmatrix} F_x*x \\ F_y*y \\ 1 \end{pmatrix}$$ + +Für eine Skalierung gilt $F_x,F_y>0$, für uniforme Skalierung gilt zusätzlich $F_X=F_y$. + +Mit $F_x=0$ oder $F_y=0$ kann eine Projektion auf die y-, bzw x-Achse ausgedrückt werden. Eine Projektion ist keine Skalierung im eigentlichen Sinne (und nicht invertierbar). + +$F_x=-1$ oder $f_y=-1$ entspricht einer Spiegelung an der y- bzw x-Achse. Sind beide Faktoren $F_x=F_y=-1$, wird damit eine Spiegelung am Ursprung ausgedrückt. Eine Spiegelung ist invers zu sich selbst. + + + +**Scherung** wird durch folgende Matrix repräsentiert: +$$\begin{pmatrix} 1 & a & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{pmatrix} * \begin{pmatrix} x \\ y \\ w \end{pmatrix} = \begin{pmatrix} x+a*y \\ y \\ w \end{pmatrix}$$ + +Sie bewirkt eine Translation der Punkte in x-Richtung, proportional zum Wert der y-Koordinate. Ein Rechteck wird dabei zu einem Parallelogramm verformt. Diese Transformation kann auch durch eine nicht uniforme Skalierung in einem gedrehten Raum realisiert werden (zusammen mit entsprechender Rotationsfunktion). + + + +**Rotation**: Die Herleitung ist analog zur Rotation für kartesische Vektoren (die 2x2 Untermatrix ist identisch zum kartesischen Fall). Die w-Koordinate für Ortsvektoren bleibt durch Anwendung der Matrix unverändert. +$$R_\theta *P= \begin{pmatrix}cos(\theta) & -sin(\theta) & 0 \\ sin(\theta) & cos(\theta) & 0 \\ 0 & 0 & 1 \end{pmatrix} * \begin{pmatrix}x & y & 1 \end{pmatrix} = \begin{pmatrix} x cos(\theta) - y sind(\theta)\\ x sin(\theta)+y cos(\theta)\\ 1 \end{pmatrix}$$ + +Verknüpfung von Transformationen: Da sowohl die Rotation R als auch die Translation T sich als 3x3-Matrizen darstellen lassen, kann man die beiden Operationen durch Matrixmultiplikation in einer 3x3-Matrix verknüpfen. Man beachte, dass Matrixmultiplikationen zwar assoziativ, im Allgemeinen jedoch nicht kommutativ sind: $T*R*{Haus} = R*T*{Haus}$ + +### 2D Transformation mit Fixpunkten +Ein Objekt soll um einen Frei Wählbaren Pivotpunkt P gedreht werden. Für diese Transformation gibt es noch keine direkte Matrizenform. Daher wird die Operation aus bekannten Operationen zusammengesetzt +1. verschiebe von P in den Ursprung (Translation $T_{-P}$) +2. rotiere um Ursprung ($R_{90}$) +3. Translation zurück ($T_{+P}$) +In Matrixform sieht die Operation wie folgt aus: $T_{+P}*R_{90}*T_{+P}*{Objekt}$ + +Da die Matrixmultiplikation assoziativ ist, können zuerst die Matrizen multipliziert und dann auf das Polygon angewendet werden. Dies bewirkt dieselbe Transformation, ist viel eleganter und auch effizienter als einzelne Matrizen anzuwenden. + + +### Inverse Transformation +Eine inverse Translationsmatrix konstruiert man indem man bei der früher hergeleiteten Translationsmatrix den negativen Verschiebungsvektor einsetzt: $T_{\Delta x, \Delta y}^{-1} = T_{-\Delta x, -\Delta y}$ + +Korrektheit ergibt sich durch $T^{-1}*T=E$. + +### Inverse Skalierung +definiert durch die Matrix: +$$S_{F_x, F_y}^{-1}=S_{\frac{1}{F_x},\frac{1}{F_y}}=\begin{pmatrix} \frac{1}{F_x} &0&0\\ 0&\frac{1}{F_y}&0\\ 0&0&1 \end{pmatrix}$$ + +### Inverse Rotation +ergibt sich als Drehung im Uhrzeigersinn +$$R_{-\theta} = \begin{pmatrix} cos(\theta) & sin(\theta) & 0 \\ -sin(\theta) & cos(\theta) & 0 \\ 0 & 0 & 1 \end{pmatrix} = R_{\theta}^{T}$$ + +### Invertierung von verknüpften Transformationen +Die inverse Matrix der drei verknüpften Operationen A,B,C ergibt: $(A*B*C)^{-1}=C^{-1}*B^{-1}*A^{-1}$ + +D.h. die inverse Matrix ist die Verknüpfung der inversen Einzeloperation in umgekehrter Reihenfolge (Undo-Operation). DIe Korrektheit der Formel ergibt sich aus der folgenden Gleichung unter Anwendung des Assoziativgesetztes der Matrixmultiplikation $(ABC)^{-1}*ABC=E$ + +### Affine Abbildung +Affine Abbildungen sind Teilmengen der homogenen Abbildungen. Durch entsprechende Wahl von reellwertigen Koeffizienten können die bis hier eingeführten homogenen Transformationen der Ebene dargestellt werden. +$$\begin{pmatrix}a_1 & b_1 & c_1\\a_2 &b_2 & c_2\\ 0&0&1\end{pmatrix}*\begin{pmatrix} x_1\\y_1\\1\end{pmatrix}= \begin{pmatrix}x_1'\\y_1'\\1 \end{pmatrix}$$ + +- die letzte Zeile der affinen Matrix bleibt immer 0,0,1 +- paralleles bleibt bei affinen Abbildungen stets parallel + +Eine Zerlegung einer beliebigen affinen Transformation in die speziellen Transformationen (Rotation, Translation, Skalierung, Scherung) ist im Allgemeinen nicht eindeutig möglich. Die Summe der Parameter für Translation (2 Parameter) Rotation (1 Parameter), Skalierung (2 Parameter), Scherung (2 Parameter) beträgt 7 von denen allerdings nur 6 unabhängig sein können, da die Matrix 6 Koeffizienten besitzt. Daraus kann lässt sich schließen, dass einige Transformationen aus anderen Transformationen zusammengesetzt werden können. Z.B. Scherung aus Rotation und nicht uniformer Skalierung oder umgekehrt Rotation aus Scherungund nicht uniformer Skalierung. + +**Affine Abbildung zwischen zwei Dreiecken** kann zwischen zwei beliebig gewählten Dreiecken in der Ebene definiert werden. 3 Punkte (6 Koordinaten) führen zu 6 Gleichungen zum Bestimmen der 6 Koeffizienten der affinen Abbildung (a,b,c,d,e,f). + +### Transformation auf Orts- und Richtungsvektor +Richtungsvektoren können als Differenz zweier Ortsvektoren hergeleitet werden. Richtungsvektoren entsprechen kartesischen Punkten im Unendlichen. Sie werden auch uneigentliche Punkte genannt. + +Eine Translations-Matrix wirkt sich nur auf Ortsvektoren aus. Richtungsvekoren bleiben bei Translation unverändert. Da bei der Berechnung nicht zwischen Orts- und Richtungsvektoren unterschiedenwerden lassen sich verknüpfte Transformationen effizient berechnen. + +### Zusammenfassung bisher +- durch den "Kunstgriff" werden Transformationen vereinheitlicht und damit vereinfacht +- 2D kartesische Vektoren werden im 3D homogenen Vektorraum dargestellt +- wichtige Transformationen können einheitlich durch 3x3 Matrizen dargestellt werden +- Orts- und Richtungsvektoren werden unterschiedlich dargestellt aber mit der selben Transformationsmatrix automatisch korrekt und effizient transformiert. + +## Homogene Transformation in 3D +Analog zum 2D Fall wird der Vektorraum um eine zusätzliche Dimension erweitert (Koordinate w). + +3 Dimensionale kartesische koordinaten werden durch eine 4-dimensionale homogeen Vektorraum repräsentiert; er wird als 4-Tupel dargestellt. In vielen Anwendungsfällen wir w=1 gewählt (karteische Hyperebene). + +Affine Abbildungen lassen die w-Koordinate unverändert + +### Ebenen +- lassen sich grundsätzlich auch als Referenzpunkt und Richtung speichern +- für Berechnungen ist folgende Repräsentation sinnvoll: (a,b,c,d) wobei (a,b,c)=(nx,ny,nz) und d der Abstand der Ebene zum Ursprung. Dann ist für einen in der Ebene enthaltenen Punkt das Skalarprodukt aus Ebene und Punkt gleich 0 + +1. Ebene definiert durch 3 Punkte + $$\begin{pmatrix} + x_1 & x_2 & x_3 & 0\\ + y_1 & y_2 & y_3 & 0\\ + z_1 & z_2 & z_3 & 0\\ + 1 & 1 & 1 & 1 + \end{pmatrix}$$ +2. Translation um Vektor $(\Delta x, \Delta y,\Delta z)$ + $$\begin{pmatrix} + 1 & 0 & 0 & \Delta x\\ + 0 & 1 & 0 & \Delta y\\ + 0 & 0 & 1 & \Delta z\\ + 0 & 0 & 0 & 1 + \end{pmatrix}$$ +3. Skalierung um Faktor $F_x,F_y,F_z$ + $$\begin{pmatrix} + F_y & 0 & 0 & 0\\ + 0 & F_y & 0 & 0\\ + 0 & 0 & F_z & 0\\ + 0 & 0 & 0 & 1 + \end{pmatrix}$$ +4. Rotation um z-Achse + $$\begin{pmatrix} + cos(\theta) & -sin(\theta) & 0 & 0\\ + sin(\theta) & \cos(\theta) & 0 & 0\\ + 0 & 0 & 1 & 0\\ + 0 & 0 & 0 & 1 + \end{pmatrix}$$ +5. Rotation um die x-Achse + $$\begin{pmatrix} + 1 & 0 & 0 & 0\\ + 0 & cos(\theta) & -sin(\theta) & 0\\ + 0 & sin(\theta) & cos(\theta) & 0\\ + 0 & 0 & 0 & 1 + \end{pmatrix}$$ +6. Rotation um die y-Achse + $$\begin{pmatrix} + cos(\theta) & 0 & sin(\theta) & 0\\ + 0 & 1 & 0 & 0\\ + -sin(\theta) & 0 & cos(\theta) & 0\\ + 0 & 0 & 0 & 1 + \end{pmatrix}$$ + +### Kommutativität +allgemein sind Transformationen nicht kommutativ; außnahme bilden zwei Rotationen um die selbe Achse + +### Kameratransformation +Kamera ist definiert durch +- Lage des Augpunktes E (in Weltkoordinaten) +- Blickrichtung D +- Oben-Vektor U ("view up vector", senkrecht zu D) + +## Projektion +3D Objekt auf eine Ebene projiezieren: +- Teil der Kameratransformation +- erfolgt meist in Kamerakoordinaten +- Projektionsarten + - Parallelprojektion (z.B. Ansicht von oben) stets affine Projektion + - zentralperspektivische Projektion (Zentralperspektive) keine affine Projektion, d.h. im Allgemeinen bleibt paralleles nicht parallel + +### Orthogonale Projektion +- einfachste der Parallelprojektionen +- Projektionsebene ist parallel zur XY Ebene +- Projektionsrichtung hier stets parallel zur z-Achse (rechtwinklig zur Projektionsebene) +- z Koordinaten werden auf gleichen Wert gesetzt (z.B. 0 ist dann die Projektionsmatrix) +- Anwendung: $O'=P*R*T*O$ wenn T und R die Transformationsschritte der Kameraprojektion sind und O das Objekt in Weltkoordinaten +$$P=\begin{pmatrix} + 1&0&0&0\\ + 0&1&0&0\\ + 0&0&0&0\\ + 0&0&0&1 + \end{pmatrix}$$ + +### Schiefwinklige Parallelprojektion +- typische Parallelprojektion mit 2 Parametern +- Projektionsebene ist parallel zur XY Ebene +- Projektionsrichtung hat zwei Freiheitsgrade und ist typischerweise nicht orthogonal zur Projektionsebene (d.h. schiefwinklig) +- Projektionsrichtung (Schiefe) ist über 2 Winkel parametrisierbar +- Herleitung + $P=\begin{pmatrix} + 1 & 0 & -cos(\alpha)*f & 0 \\ + 0 & 1 & -sin(\alpha)*f & 0 \\ + 0 & 0 & 0 & 0 \\ + 0 & 0 & 0 & 1 + \end{pmatrix}$$ +- es gilt: $x'=x-cos(\alpha)*f*z$ und $y'=y-sin(\alpha)*f*z$ + + +### Zentralperspektive +- entspricht einer Lochkamera bzw etwa dem "einäugigen" Sehen +- Augpunkt im Ursprung des Kamerakoordinatensystems +- Projektionsfläche ist eine Ebene parallel zu XY Ebene +- Eigenschaften + - perspektivische Verkürzung + - parallele Linien des Objekts fluchten oft in einen Fluchtpunkt + +$$\begin{pmatrix} d&0&0&0\\ 0&d&0&0 \\ 0&0&0&1 \\ 0&0&1&0 \end{pmatrix} * \begin{pmatrix}x\\y\\z\\1\end{pmatrix} = \begin{pmatrix} d*x\\ d*y\\ 1 \\ z \end{pmatrix} \rightarrow \begin{pmatrix} \frac{d*x}{z} \\ \frac{d*y}{z} \\ \frac{1}{z} \end{pmatrix}$$ + +Fluchtpunkte +- hat ein Modell parallele Kanten oder parallele Striche in Texturen, dann ergibt sich für jede solche Richtung r in der Abbildung ein Fluchtpunkt, auf den diese parallelen Kanten/Striche hinzu zu laufen scheinen +- es gibt jedoch Ausnahmen, bei denen Paralleles in der Abbildung Parallel bleibt (z.B. horizontale Kanten der Schwellen in der Abbildung) +- Da es beliebig viele Richtungen geben kann, sind auch beliebig viele Fluchtpunkte in einem Bild möglich +- Rotationen können Fluchtpunkte ändern, Translationen jedoch nicht + +Ermittlung eines Fluchtpunktes: Wird aus einer Richtung r und dem Aufpunkt eine Gerade definiert, dann schneidet diese Gerade die Projektionsfläche im Fliuchtpunkt für die Richtung r. + +- Eine Richtung r, die in der Projektionsfläche enthalten ist, führt zu einer Gerade durch den Augpunkt, welche nie die Projektionsfläche schneidet. Alle Linien mit einer solchen Richtung bleiben folglich parallel +- Der Fluchtpunkt der Richtung r ist abhängig von 1. dieser Richtung, 2. der Projektionsfläche und 3. dem Augpunkt +- Nur wenn eines der 3 obigen Elemente geändert wird, ändert sich die Lage des Fluchtpunktes von r +- da Verschiebungen von Objekten weder deren Richtungen, den Augpunkt oder die Projektionsebene verändern, belibt die Lage der Fluchtpunkte bei Verschiebungen stets erhalten +- Die Rotation eines Objektes ändert im Allgemeinen die im Objekt enthaltenen Richtungen und damit auch deren Fluchtpunkt + + +### Zusammenfassung +- Mittels Matrixmultiplikation kann eine Folge unterschiedlicher 3D-Transformationen in einer einzigen 4x4-Matrix zusammengefasst werden. Dies schließt Projektionsmatrizen (Abbildung von 3D nach 2D) mit ein. +- Affine Abbildungen lassen die w-Koordinate unverändert. Bei Parallelprojektionen ist das so. +- Die perspektivische Kameratransformation ist eine allgemeine homogene Matrix und keine affine Abbildung. Die w-Koordinate kann dadurch verändert werden. Zur Rückführung in kartesische Koordinaten ist eine Division durch die w-Koordinate erforderlich! +- Bei zentralperspektivischer Projektion ergibt sich pro Schar paralleler Kanten/Texturlinien/etc jeweils ein Fluchtpunkt (Spezialfall: Richtung ist parallel zur Projektionsebene, dann Fluchtpunkt im Unendlichen). Durch Rotation eines Objektes (relativ zur Kamera) ändert sich im Allgemeinen die Lage der Fluchtpunkte. Neben dem gestalterischen Aspekt (Bildkomposition) spielen Fluchtpunkte bei der Bilderkennung (z.B. Berechnung der Ausrichtung von 3D-Objekten) eine Rolle + + +# Modellierung +## Geometrische Modellierung +### Grundlagen +Bei der geometrischen Modellierung geht es im allgemeinen um die computergestütze Beschreibung der Form geometrischer Objekte + +Objekte: +- Beschreibung von dreidimensionalen geometrischen Formen +- verschiedenste Formate existieren, meistens eine Gruppierung der geometrischen Eigenschaften (Eckpunkte, Kanten, Flächen) + +Dateiformate: +- für das speichern der dreidimensionalen geometrischen Formen gibt es verschiedenste Dateiformate +- STL: ist beispielweise Standard für viele CAD Systeme +- OBJ: weitverbreitetes Dateiformat + + +### B-Rep +B-Rep = Boundary Representation: Für die Beschreibung dreidimensionaler Festkörper gibt es mehrere Möglichkeiten. Ein Standard ist die Boundary Representation, eine Modellgeschreibung durch die festlegung begrenzender Oberflächen +- Darstellungsform eines Flächen- oder Volumenmodells +- beschreibt Objekt durch begrenzende Oberflächen +- sind schnell verarbeitbar +- Definition eines Ojekts erfolgt über einen vef-Graph (vertex, edge, face) + - Knotenliste: beinhaltet Koordinatenpunkt + - Kantenliste: für jede Kante werden zwei Punkte referenziert + - Flächenliste: für jede Fläche wird Reihenfolge von Kanten angegeben + + +## Szenengraph +Szene (Computergrafik) +- eine dreidimensionale Beschreibung von Objekten, Lichtquellen und Materialeigenschaften +- setzt virtuellen Betrachter voraus, sowie dessen Position und Blickwinkel + +Szenegraph: +- hierarchische Gruppierung der Objekte in einer Szene +- somit eine objektorientierte Datenstruktur +- aus graphentheoretischer Sich: gerichteter Graph ohne Kreise + + +## Rendering +Beim rendern erfolgt eine Bilderzeugung aus einer gegebenen Szene. Der Weg von der Szene bis zum fertigen Bild erfolgt dabei über eine sogenannte **Render-Pipeline**: + +Geometrisches Objekt-> Transformieren-> Vertex Shader-> Raster Konvertierung-> Fragment Shader-> Ausgabebild + +### Vertex Shader +- verarbeitet alle Eckpunkte (Vertices) des 3D-Modells +- für jeden Vertex wird dieser Shader im Normalfall einmal aufgerufen +- ermöglicht eine Beeinflussung der Objektform +- Hauptaufgabe ist die Transformation der virtuellen 3D Position auf 2D koordinaten für den Bildschirm +- Input + - Vertices aller relevanter Objekte der Szene + - gewünschte Transformation +- Output + - auf Bildschirm projizierte 2D Koordinaten + - zugehörige Tiefeninformationen + +Alle Transformationen die auf ein Vertex wirken und die anschließende Projektion wird als eine sogenannte MVP-Matrix zusammengefasst. + +### Model View Projection +Gegeben: +- Modell als Vertices mit kartesischen 3D koordinaten und definierten Dreiecken +- Kamera (3D Position, Ausrichtung) welche das Modell betrachtet +Gesucht: +- transformierte Position +- Rendering des Modells aus Sicht der Kamera + +$\rightarrow$ benötigen Abbildung von 3D-Vertexkoordinaten auf 2D-Kamerabildkoordinaten + +Umsetzung: +- zuerst Transformation von Modellraum (gegebenen Koordinaten) in Weltkoordinaten (Model) +- danach Transformation in Kameraraum, für einfachere Projektion (View) +- abschließende projektion auf Kamerabildebene und Umrechnung in Bildraum (Projektion) + +Model: $M=T*R*S$ (Transformation in Weltkoordinaten) + +View: $V=T_V^{-1}*R_V^{-1}$ (Transformation in Kameraraum) + +Kameraraum: +- Kamera sitzt im ursprung (0,0,0) +- hat keine Rotation + +Projektion: P +- Bildebenenprojektion kann durch Zentralperspektivische Projektionsmatrix erfolgen +- Frustum (Kamerasichtfeld) legt fest welche Objekte im Sichtfeld liegen und somit in der Bildebene sichtbar sind + +Ergebnis +- Zusammenfassung der Transformation ergibt die Model-View-Projektion-Matrix $P*V*M=MVP_{Matrix}$ +- Anwendung der MVP-Matrix auf alle Vertices eines Modells $p_m$ ergibt die notwendige Bildraumprojektion des Modells: $p'_m=P*V*M*p_m$ +- Vorteile: die MVP-Matrix muss nur einmal berechnet werden und kann auf alle Vertices eines Modells angewandt werden + +### Zusammenfassung +- geometrische Modellierung zur Beschreibung von Objekten +- Anwendung der Transformation +- Projektion der Objekte auf den Bildschirm + +## Effiziente geometrische Algorithmen und Datenstrukturen +### Bintree +- effizientes Suchen und Einfügen in eindimensionale Domänen +- logarithmische Komplexität pro Zugriff möglich +- Gefahr: lineare Komplexität, wenn nicht balanciert + +analog zu Quad- und Octrees: +- typisch ost Teilung in Mitte (bisektion) +- Bereiche mit homogenem Inhalt (gleiche Farbe/ keine Elemente) werden nicht weiter unterteilt +- Komprimierungseffekt + +### Quadtree +- eine (meist quadratische) Fläche kann bei Bedarf in vier gleichgroße Quadranten unterteilt werden +- Bedarf entsteht, wenn die Fläche keine homogenen Eigenschaften aufweist (z.B. bei unterschiedlich gefärbten Pixeln). D.h. Flächen (bzw Quadranten) werden solange unterteilt, bis sie homogen sind +- Anwendung + - Geometrische 2D Objekte können in hierarischische Struktur einsortiert werden, wodurch die räumliche Suche nach diesen Objekten beschleunigt wird + - Effiziente Speicherung von Rasterbildern wird möglich (Komprimierung, da nur strukturierte Bereiche unterteilt werden) + + +### Octree +Jeder Knoten hat 0 oder 8 Kindknoten. Damit wird bei Bedarf ein 3D Bereich in 8 Unterbereiche unterteilt. Geometrische Objekte (z.B. 3D Punkte) können in diese hierarchische Strukturen einsortiert werden, wodurch die räumliche Suche nach diesen Punkten beschleunigt wird. + +Beispiel Punktsuche:\\ +Suche einen Punkt mit Koordinaten (x,y,z) im Octree. Rekursive Suche von der Wurzel. In jedem Schritt wird einer von 8 möglichen Pfaden im Teilbaum ausgewählt -> Zeitaufwand Tiefe des Baumes O(log n) + +### KD Tree +- mehrdimensionaler binärer Baum (k-dimensional) +- unterteilt z.B. abwechselnd in x-,y-, und z-Richtung (deshalb binärer Baum) +- Teilung nicht zwangsläufig mittig (wie bei Octre) -> an Daten angepasst +- jeder neue Punkt teilt den Bereich in dem er einsortiert wird; pro Hierarchiestufe stets wechsel der Teilungsrichtung +- ein Octree lässt sich auf einen kd-Baum abbilden, beide Baumarten haben daher vergleichbare Eigenschaften + +KD-Baum mit der Median-Cut Strategie:\\ +Der Median-Cut teilt Daten in zwei gleich großen Hälften. Damit wird der Baum garantiert balanciert und die tiefe wird minimal. Damit wird das O(log n) Verhalten garantiert. Probleme können bei lokalen Häufungen (Cluster) auftreten. Die Mediancut Strategie bewirkt eine degenerierte globale Teilung des Gesamtraumes aufgrund von lokalen Situationen. Dies wirkt sich ungünstig bei der Suche weit weg vom Cluster aus +- vollständig balanciert +- unnötige Unterteilung weit weg vom Cluster (Artefakt) + +Vergleich Middlecut-Strategie: +- nicht balanciert +- keine Unterteilung weit weg vom Cluster + +Praxis: Kompromiss Strategie, Mischung zwischen Median und Mitte. Bei Situations-Analyse: Explizite Abkapselung des Clusters. Außerdem: In (2D, 3D) kann man natürlich das strikt zyklische Abwechseln der Achsen aufgeben und bei fast ebenen/linearen Strukturen lokal nur noch in zwei bzw 1 Richtung(en) unterteilen! + +### BSP Tree +Verallgemeinerung des kd-Baums. Trennebenen sind nicht nur achsenparallel. Unterteilung in beliebigen Richtungen, adaptiv an Modellflächen angepasst. + +Beachte: Trennebenen die an einer Objektebene anliegen können dennoch weiter wegliegende Objekte schneiden. + +BSP-Tree führt bei konvexen Polyedern zu entarteten Bäumen + +### Hüllkörper Hierarchie +#### AABB (Axia-Aligned-Bounding-Box) +sehr einfache Abfrage (nur ein Vergleich < in jeder Koordinatenrichtung, wie bei kd-Baum) einfach zu erstellen (min, max), dafür nicht optimale Packungsdichte bei schräger Lage der Objekte. + +#### OBB (Oriented Bounding Boxes) +passen sich besser der räumlichen Ausrichtungen an, lassen sich auch leicht transformieren (Rotation bei Animation). Jedoch schwieriger zu erstellen (Wahl der Richtung), komplexere Überlappungsberechnung (Transformation, Ebenengleichung). +D.h. OBB-trees werden typischerweise weniger tief, weniger räumliche Abfragen dafür wesentlich mehr Berechnungsaufwand pro Rekursionsstufe. + +#### KDOP (k-dimensional Discretly Oriented Polytopes) +Polyeder mit festen vorgegebenen Richtungen (z.B. 45 Grad). Eigenschaften zwischen AABB und OBB. Bessere Raumausnützung als AABB, weniger Transformationene als OBB. + +#### BS (Bounding Spheres) +Schnelle 3D Überlappungstest (Abstand der Mittelpunkte < Summe der Radien). Langgezogene Objekte können mit mehreren Hüllkugeln (Bounding Spheres) begrenz werden um besseren Füllgrad zu erreichen. BS sind bis auf die Lage der Kugelmittelpunkte invariant gegenüber Rotation (eignen sich für Kollisionserkennung bewegter Objekte/ Echtzeit-Computer-Animation). + +#### weitere Anwendungsfälle +- Kollisionserkennung in Computeranmiation (Computerspiele). Reduktion der potenziellen Kollisionspaare durch räumliche Trennung +- Beschleunigung des Echtzeitrenderings großer Datenmengen. Reduktion des Aufwands durch Culling (Weglassen) + +### Ray Picking mit KD Baum +Raytracing/Strahlverfolgung, Ray picking mit KD-Baum: Vorverarbeitun, abspeicherung von Objekten (Dreiecken) im kd-Baum O(n log n) + +Strahl/Objektschnitt: (als rekursive Suche im kd-Baum) + +treeIntersect(p,d): Findet Schnittpunkt des Strahls (Punkt p, Richtung d) mit den im Baum gepseicherten Dreiecken und liefert die Beschreibung des nächsten Schnittpunktes bzw t=unendlich, falls kein Schnittpunkt existiert. + +triangleIntersect(node,p,d): Findet Schnittpunkt des Strahles (Punkt p, Richtung d) mit einer Menge von Dreiecken in node + +subdivide(node, p, d, tmin, tmax): Findet rekursiv den nächstgelegenen Schnittpunkt (kleinstes t) des Strahls (p,d) mit den Dreiecken in oder unterhalb von node im Parameterbereich tmin ...tmax + +### Aufwandsabschätzung bzgl Dreiecksanzahl +Komplexität Strahl Objektschnitt (Extremfälle + typischer Fall) +1. Extremfall (beinahe) kovexes Objekt (max 2 Schnitte möglich) + - hat ca die Komplexität einer räumlichen Punktsuche, also dem Aufwand zur Untersuchung einer Baumzelle (finden + dortige Dreiecke testen) O(log n) +2. Extremfall "Polygonnebel" (viele sehr kleine Dreiecke im Such-Volumen) + - Annahme: alle Zellen enthalten konstante kleine Anzahl von Dreiecken -> Aufwand proportional zur Anzahl durchlaufener Baumzellen + - Anzahl dieser Zellen ist proportional zur Länge des Strahls durchs Volumen, da der 1. Schnitt sehr wahrscheinlich mitten im Volumen oder gar nicht stattfindet -> Anzahl ist proportional zur Seitenlänge des Suchvolumens + - bei n Dreiecken im Suchvolumen ist die Anzahl t der zu untersuchenden Zellen also ca $t=O(\sqrt{n})$ -> Suchaufwand pro Strahl folglich $O(\sqrt{n} log (n))$ + +typische Szene: Suchaufwand fast immer wesentlich besser als O(n). Aufwand oft zwischen beiden extremen, bei mittlerer Dichte sogar eher O(log n). + +### Aufwandsabschätzung in fps +Effektiver Zeitauwand für Raytracing (RT): +- absoluter Gesamtaufwand zum Raytracing einer Szene (z.B. in ms) ist (auch) proportional zur Anzahl der Strahlen +- Annahme: 1 Strahl pro Pixel (keine Rekursion), typische Bildgröße sei 1 Mio Pixel, Szene haben mittlere Komplexität (1 Mio Polygone) +- Performancebeispiel: + - Stand 2006, PC mit 1 CPU ca 1 Mio Strahlen/Sek -> 1 fps + - Stand 2019, PC mit "RTX 2080 Sup23" ca 10 Giga Strahlen/Sek -> 10000 fps +- rekursives RT (Reflexion, Brechung, Schattenstrahlen etc) entsprechend mehr Strahlen, d.h. weniger Performance +- Parallelisierung einfach möglich (z.B. da Pixel voneinander unabhängig berechenbar) -> früher CPU-basiert, heute eher GPU +- 2019 mit entsprechender Hardware: rekursives Echtzeit Raytracing möglich + +### Heurisitk zur Unterteilung +Surface Area Heuristic (SAH): +- Annahme: Strahl i, trifft Zelle j mit Wahrscheinlichkeit P(i,j), zudem sei $n_j$ die Anzahl Dreiecke in Zelle j, +- Aufwand für Raytracing pro Zelle proportional zur Baumtiefe ( O(log n) für balancierte Bäume, wird nicht weiter betrachtet) sowie die Anzahl der dortigen Dreiecke $n_j$; beachte $n_j$ wird hier nicht als konstant angenommen -> Gesamtaufwand für Strahl i sei also $\sum(P(i,j)*n_j)$ + +Heuristik: große Zellen mit wenigen Dreiecken, senken Gesamtaufwand +- Schätzung: P(i,j) ist etwa proportional zur Oberfläche einer Zelle (auf großer Oberfläche treffen mehr Strahlen auf) +- die SAH optimiert auf jeder Teilstufe im Baum das Produkt der Zellgröße mal Anzahl Dreiecke im Teilbaum. Für den kD-Baum gilt bei der Unterteilung des Bereichs D in Richtung k: $D_k = D_{k_links} + D_{k_rechts}$ + +Bei ungleicher Verteilung der Dreiecke (z.B. Cluster) enthalten dann große Zellen wenige oder keine Dreiecke und Baum ist nicht balanciert -> implizite Abtrennung des Clusters vom Rest des Baums (vgl Middle-Cut-Strategie) + +### Behandlung ausgedehnter Objekte +Problematik: Abspeicherung ausgedehnter Objekte + +Punkte haben keine Ausdehnung und können an einem eindeutigen Ort im kD-Baum abgelegt sein. Ausgedehnte Objekte (Kreise, Kugeln, Rechtecke, Dreiecke, Hüllquader, etc) können räumlich mehrere Blatt-Zellen überlappen. Ein solches Objekt müsste dann in mehreren Blattzellen einsortiert sein. + +1. Ansatz: Auftrennung von Objekten, d.h. Objekte müssen an der Zellgrenze aufgeteilt werden. Einsortierung der Teilobjekte in passende Zellen. Geht gut für Dreiecke +2. Ansatz: Keine Unterscheidung zwischen Blattknoten und inneren Knoten. In diesem Ansatz werden Objekte soweit oben im Baum einsortiert, dass sie keine Zellgrenze schneiden. Nachteil: auch relativ kleine Objekte müssen in große Zellen einsortiert werden, wenn sie deren Unterteilungsgrenze schneiden +3. Ansatz: Loose Octree (überlappende Zellen): die Zellen des Octrees werden so vergrößert, dass sie mit ihren direkten Nachbarn in jeder Richtung um 50% überlappen. Objekte, die im einfachen Octree aufgrund ihrer Größe Grenzen schneiden würden, können im Loose Octree in den Zwischenknoten gespeichert werden. Ein Objekt mit Durchmesser bis zu $\frac{D}{2^L}$ kann auf der Ebene L abgelegt werden. Eine Suche im Loose Octree muss daher außer der direkt betroffenen Zelle auch die überlappenden direkten Nachbarn berücksichtigen. Dadurch vergrößert sich der Aufwand einer Suche um einen konstantne Faktor. Beachte: Die asymptotosche Komplexität (O-Notation) ist dadurch nicht beeinflusst. + +# Rastergrafik +## Rasterkonversion grafischer Objekte +Algorithmus zum Zeichnen einer Strecke:\\ +Endpunktkoordinaten sind nach Projektion in die Bildebene passend auf die Fensterkoordinaten skaliert und auf ganzzahlige Werte (Pixelkoordinaten) gerundet. + +## Midpoint Algorithmus +- von J. Bresenham 1965 bei IBM entwickelt +- Grundidee: Effizient durch Verwendung von Ganzzahlen, Vermeiden von Multiplikation/Division sowie Nutzung einer inkrementellen Arbeitsweise + +Die Linie geht zwischen den Endpunkten nicht durch ganzzahlige Gitterpunkte. Da nur ganzzahlige Pixel-Koordinaten gesetzt werden können müssten auch zwischenpunkte zuerst genau berechnet werden und dann auf ganzzahlige Pixelwerte gerundet werden. Dies ist unzuverlässig und ineffizient. Zur Herleitung des effizienten Bresenham-Algorithmus führen wir den Mittelpunkt M als Referenzpunkt ein. Fernser seinen der jeweils aktuellen Punkt P, der rechts von im liegende E (east) und der rechts oben liegende NE north-east) benannt. +- die Linie wird als Funktion $y=f(x)$ repräsentiert: $y=\frac{\delta y}{\delta x}*x+B$ +- in implizierter Form: $d: F(x,y)=\delta y*x-\delta x*y+B*\delta x = 0$ +- für Punkte aud der Linie wird $F(x,y)=0$ +- für Punkte unterhalb der Linie wird $F(x,y)>0$ +- für Punkte oberhalb der Linie wird $F(x,y)<0$ + +Herleitung mit Einschränkung:\\ +Steigung der Linie m ($1 < m < 1$), Mittelpunkt M = Punkt vertikal zwischen zwei möglichen Pixeln E und NE. Ausgehend von bereits gesetzten Pixel P auf der Linie für den nächsten Mittelpunkt M. Für gefundenen Mittelpunkt, berechne die Distanzfunktion d. Daraus Kriterium zur Wahl des nächsten Pixels: Falls $F(x_p + 1, y_p+\frac{1}{2})>0$ wird das nächste Pixel NE, andernfalls E. + +Insgesamt acht verschiedene Fälle: +1. Oktant($\delta y < \delta x$) +2. Oktant($\delta y > \delta x$) +3. Oktant($\frac{\delta y}{\delta x}< 0$) +4. Oktant($\frac{\delta y}{\delta x}< -1$) +5. -8. Oktant($\delta x < 0$) + +## Anti Aliasing +Effekte der Rasterisierung: Aliasing +- Treffenstufeneffekt bei gerasterten Linien +- Regelmäßigkeiten werden verstärkt vom Auge wahrgenommen + +Das Auflösungsvermögen des Auges für Punkte sei e. Strukturen wie Linien (bestehend aus vielen Punkten) werden durch Mittelwertbildung (Fitting) vom auge viel genauer als e lokalisiert. Eine Stufe wird umso eher erkannt, jelänger die angrenzenden Segmente sind. + +### Grundlagen +Grundidee des Anti-Aliasing +1. Original der Linie +2. Statt der Linie wird ein Rechteck mit der Breite von einem Pixel betrachtet +3. Graustufen der darunter liegenden Pixelflächen entsprechen dem jeweiligen Überdekckungsgrad + +Praktische Umsetzung mit vereinfachtem/effizienterem Algorithmus +1. Rasterkonvertierung der Linie bei doppelter örtlicher Auflösung (Supersampling) +2. Replizieren der Linie (vertikal und/oder horizontal) um Linienbreite näherungsweise zu erhalten +3. Bestimmmung des Überdeckungsgrades pro Pixel in der ursprünglichen Auflösung (Downsampling) +4. Bestimmung des Farbwertes entsprechend des Überdeckungsgrades + +Problem: +- Ausgabe von Linien/Polygonen auf Rastergeräten muss auf vorgegebenem Raster erfolgen +- Farbvariation ist zwar möglich, Farbberechnung muss aber effizient erfolgen + +Ohne Antialiasing: +- es erfolgt ein einfacher Test über die Pixelkoordinate +- verwendet Farbe in der Pixelmitte + +Ideales Antialiasing: Hat wegen der beliebig komplexen Geometrie allgemein einen sehr/zu hohen Aufwand! + +Ansatz für eine "reale Lösung" +- eine ideale Berechnung von Farbwerten nach dem Überdeckungsgrad ist allgemein beliebig aufwendig und daher praktisch irrelevant +- Gesucht werden Ansätze mit gut abschätzbarem/konstanten Aufwand +- "reales" Antialiasing beruht in der Regel auf der Verwendung von mehreren Samples pro Pixel, d.h. Berechnung dieser n Samples statt nur einem (typisch: n-facher Aufwand) + +### Supersampling + Downsampling +Beim Supersampling-Ansatz wird die Graphik zunächst in höherer Auflösung gerendert (z.B. 4-fach), und dann aus den Samples ein Farbwert gemittelt (z.B. per arithmetischem Mittel). +Wie wirksam ist das Antialiasing bei 4x-Supersampling +- Ohne Anti-Aliasing kommt pro Pixel genau eine Sampleposition zum Zuge. Das Pixel wird demnach gefärbt oder nicht gefärbt: Das sind zwei mögliche Stufen. +- Bei vier Subpixeln können minimal 0 und maximal 4 Subpixel im (Makro-)Pixel gesetzt sein, d.h. es sind Intensitäten von 0%, 25%, 50%, 75% oder 100% möglich (nur 5 Abstufungen)! +- Der Zusammenhang ist einfach: Es gibt immer eine Abstufung mehr als Subpixel pro Pixel. +- Beim idealen Antialiasing entsprechend Flächenbedeckungsgrad gibt es "beliebig" viele Abstufungen (aus Aufwandsgründen aber praktisch nicht relevant). +- Gibt es eine Formabhängigkeit? Ja, z.B. bei 45° gibt es z.B. nur eine Zwischenstufe, und zwar je nach Phasenlage mit 25% oder 75% → Kante "pumpt" bei Objektbewegung. + +### Supersampling + Rotated Grids +Minderung der Formabhängigkeit → Supersampling mit Rotated Grids +- Kleine Winkel zu den Achsen führen zu langen "Stufen" der digitalen Polygonkante +- Bessere Verhältnisse der Grauabstufung ergeben sich für flache Winkel, wenn statt des "ordered grid" ein "rotated grid" für das Supersampling verwendet wird. +- Rotated grids sind dafür bei anderen Winkeln etwas schlechter als das ordered grid. Dies wird aber kaum wahrgenommen, da dort die Treppen der digitalen Geraden kürzer sind. + +Vorteile: +- Gute Grauabstufung bei sehr flachen Kanten zur Zeilen- oder Spaltenrichtung. +- Optimaler Winkel liegt bei ca. 20 ◦ − 30 ◦ (z.B. arctan(0.5) ≈ 26, 6 ◦ ). +- Sehr dünne Linien (dünner als 1 Pixel) bleiben auch bei Bewegung zusammenhängend bzw. sichtbar (Vermeidung von "Line Popping"). + + +### Supersampling + Multisampling +Realisierung der Subpixelberechnung durch einen Superbackbuffer (Supersampling in entsprechend großem Buffer) oder mehrere Multisamplebuffer (Multisampling in mehrere Buffer der ursprünglichen Größe): +1. Superbackpuffer + - Nachteil (bei rotated grid): Anpassung der Rasterkonvertierung an verschobene Positionen erforderlich + - Vorteil: Verwendung von mehr Texturinformation (Textur wird subpixelgerecht eingetragen) +2. Multisamplebuffer + - Mehrfachrendering in normaler Größe mit leicht versetzter Geometrie (Vertexverschiebung pro Sub-Bild) + - Vorteil: keine Veränderung im Rendering + - Nachteil: nur ein Texturwert pro Makro-/Sub-Pixel + +Gezielter Ressourceneinsatz: +1. Kantenglättung: + - Effizienzsteigerung durch Beschränkung auf reine Kantenglättung möglich! + - Kanten vs. Flächen: Anzahl der Kantenpixel oft wesentlich kleiner als Anzahl der Flächenpixel + - Aliasing bei Kanten/Mustern in Texturen schon beim Auslesen der Werte aus der Pixeltextur unterdrückbar + - Kantenpixel bekannt als: separate Linien oder Berandung von Polygonen/Dreiecken +2. adaptives Samplen: + - statt feste Anzahl von Samples kann die Anzahl nach dem Bedarf gesteuert werden + +### Quincunx Verfahren +Quincunx → Überfilterung + +Ausgangspunkt ist das 2x Multisampling mit rotated grid! Entsprechend dem Grundprinzip des Anti-Aliasings sollen Aliasingartefakte durch Erzeugung höher aufgelöster Information reduziert werden. Bei dem vorausgesetzten Muster ist der Informationszuwachs durch die doppelte Anzahl von Samples gekennzeichnet, egal wie ausgewertet wird! + +Quincunx-Verfahren: +- Information für die Kantenglättung beruht nach wie vor auf 2 Subpixeln +- Entspricht einer zusätzlichen Tiefpass-Überfilterung. Durch die Unschärfe sehen Polygonkanten glatter aus. +- Harte Kanten sind gar nicht mehr möglich, dadurch wird auch "Zappeln" an Polygonrändern reduziert. +- Aber Nachteil: Texturinformation, die nur zu 2 Subpixeln gehört, wird verschmiert ! + +### Pseudozufälliges Supersampling +Kombinationen und Pseudozufälliges Supersampling: +- Grundsätzlich ist die Kombination von Supersampling, Multisampling und Quincunx möglich und einige Graphikkarten unterstützen solche Überlegungen in jeweils festgelegten Grenzen (ordered oder rotated grid, gemischtes Sampling, Downsampling-Ansatz). Der Gewinn hält sich bisher in Grenzen, bei unqualifiziertem Mix ergeben sich eher Nachteile. +- Bei Überwindung der für Füllrate und Bandbreite gegebenen Grenzen überwiegen die Vorteile des Supersamplings. +- Ordered grid und rotated grid weisen bei bestimmten Strukturklassen Vor- und Nachteile auf. Die verbleibenden Artefakte wiederholen sich bei großen Flächen, so dass derartige Muster vom Menschen oft als störend empfunden werden. → aus diesen und ähnlichen Überlegungen → Ansätze für die Weiterentwicklung: + - pseudozufällige Auswahl von Abtastmustern für das Supersampling + - nachträgliche Abminderung regelmäßiger Strukturen durch vorsichtiges Verrauschen (Rauschfilter) + - entfernungsabhängiges Antialiasing + +pseudozufällig: +- Samples können nur an n vordefinierten Positionen stattfinden (Sample-Positionsmuster). +- Je nach Methode werden daraus m Positionen für das Samplen zufällig ausgewählt (beachte: m < n) +- Anzahl der Muster als kombinatorisches Problem: m aus n (ohne Wiederholungen) + +### abschließende Betrachtung zum Downsampling: +Beim Anti-Aliasing zur Glättung von Polygonkanten kommt für das Downsampling die Mittelwertbildung in Frage (lineare Filterung (2x – AA), bilineare Filterung (4x – AA)), gleichgültig ob ordered oder rotated grid. Beim pseudozufälligen Supersampling ist entsprechend der "frei gewählten" Positionen der "Subpixel" zu modifizieren (z.B. Gewichte nach Abstand der Abfragepositionen zur Makropixelposition). + + +## Polygonfüllalgorithmus +Ansatz: +- finde die Pixel innerhalb des Polygons +- weise ihnen Farbe zu +- dabei zeilenweises Vorgehen, pro Rasterlinie: +- für jede Polygonkante: + - schneide die Polygonkante mit der aktuellen Bildzeile (→ $x_s$ ) + - füge Schnittpunkt $x_s$ in eine Liste ein +- sortiere Schnittpunkte der aktuellen Bildzeile in x-Richtung +- Paritätsregel: fülle die Pixel jeweils zwischen ungeradem und nächstem geraden Schnittpunkt (Pixel zwischen geraden und ungeraden Schnittpunkten aber nicht!) + +Beachte: Die Schnittpunkte in floating point zu berechnen und zu runden ist ineffizient. Wir suchen, ähnlich wie beim Bresenham-Algorithmus, einen inkrementellen Ansatz mit Ganzzahl-Arithmetik. + +Allgemeinere Sicht auf die Füll- bzw. Auswahlstrategie: Ein Pixel wird mit der Farbe des Polygons gefüllt, das sich rechts von ihm befindet. Sollte dort eine Kante sein, so wird die Farbe des oberen Polygons verwendet. +Grundsätzlich könnten beliebige Richtungen als Referenzrichtung zur Farbbestimmung gewählt werden. Dann müssten die zuvor besprochenen Regeln oder der gesamte Algorithmus entsprechend angepasst werden. + +Effiziente Ermittlung der Schnittpunkte von Polygonkante und Rasterzeile: +- Vorbetrachtungen: + - Polygonkanten werden stets von unten nach oben bearbeitet + - horizontale Polygonkanten müssen nicht bearbeitet werden (geschieht in Scanline) → im Algorithmus stets m ungleich 0 + - $d_y = y_1 - y_0$ ist stets positiv (auch nie 0) + - $d_x = x_1 - x_0$ kann positiv und negativ sein + - damit können 4 Bereiche unterschieden werden +- Idee + - Berechnung von x bzw y: $y=y_0+m(x-x_0)$,$y=y_0+\frac{y_1-y_0}{x_1-x_0}(x-x_0)$,$x=x_0+\frac{1}{m}(y-y_0)$, $x=x_0+\frac{x_1-x_0}{y_1-y_0}(y-y_0)$ + - Zwar sind die x- bzw. y-Werte immer noch nicht ganzzahlig, jedoch können sie als rationale Zahlen explizit mit Zähler und Nenner repräsentiert werden. + - Die Rundung (nächstes x oder y erreicht?) kann inkrementell ermittelt werden. + - Die Rundungsregel für Bruchwerte hängt davon ab, ob es eine linke oder rechte Kante ist. Links wird z.B. aufgerundet (Pixel ist auf oder rechts v. der Kante). + + +Edge-Tabelle: +- Verkettete Liste (oder Array, siehe unten) für die nicht horizontalen Kanten. +- Sortierung nach der Scan-Line, wo die Kanten beginnen (unteres Ende, $y_0$ ). +- Innerhalb der Scan-Line wiederum Liste (nach $x_0$-Werten sortiert). Je nach Implementierung werden z.B. $x_0 , y_1$ , sowie Zähler und Nenner gespeichert. + +Active-Edge-Tabelle: +- Die AET speichert alle Kanten, die die gegenwärtige Scan-Linie schneiden. +- Die Liste hat die gleiche Struktur wie eine Zeile der ET. +- Die Kanten werden gelöscht, wenn das obere Ende der Kante erreicht ist. + +Bemerkung zu Scan Convert Polygon: +1. Es existiert immer eine gerade Anzahl Kanten. Bei konvexen Polygonen sind immer null oder zwei Kanten in der AET. Die Sortierung ist dadurch trivial bzw. entfällt bei konvexen Polygonen. Bei vielen Grafikbibliotheken (z.B. OpenGL) beschränkt man sich auf konvexe Polygone. Nichtkonvexe Polygone müssen daher vorher in konvexe Komponenten zerlegt werden. Dafür ist das Füllen dieser Polygone danach effizienter. +2. Dieser Teil entspricht einem Schleifendurchlauf der Prozedur EdgeScan. Die Unterscheidung zwischen linker und rechter Kante wird beim Auffüllen der Pixel gemacht. + +Bemerkungen zur Effizienz:\\ +Der Polygonfüllalgorithmus ist zentraler Bestandteil jeder Grafikbibliothek für Rastergrafik. Für Echtzeitanwendungen ist Effizienz essentiell. Ein Polygon belegt +meistens viel mehr Pixel als es Eckpunkte bzw. Kanten besitzt. Deshalb sind effiziente per-Pixel-Operationen besonders wichtig. Der Rechenaufwand sollte folglich möglichst vermieden werden (mit fallender Priorität): +- pro Pixel (Annahme: sehr häufig auszuführen, deshalb möglichst effizient) +- pro Rasterzeile +- pro Kante (hier sollte möglichst viel vorberechnet werden, um pro Rasterzeile bzw. Pixel Rechenzeit zu sparen) +Neben der reinen Rasterisierung des Polygons existieren Erweiterungen des inkrementellen Ansatzes für effiziente Berechnungen in der 3D-Grafik, z.B.: +- Füllen des Z-Buffers (Tiefenwertberechnung) +- lineare Interpolation beim Gouraud Shading (Farbwertberechnungen) + +### Füllmuster +Füllen eines Polygons mit einem Pattern statt mit einem konstanten Farbwert +- benutze dazu BITMAPs: + - 2-dimensionales Array + - besteht aus M Spalten und N Zeilen + - BITMAP = ARRAY [0 · · · M − 1, 0 · · · N − 1] + +Anwendung des Backsteinmusters bei einem Polygon: +```cpp +drawPoly(Polygon poly, Pattern pat){ + foreach pixelPosition x, y in poly + poly.set(x, y, pat[x mod pat.width, y mod pat.height]); +} +``` + +### Dithering +Grundidee: Ersetzen "genauer" Farbwerte durch grobe Quantisierung +- gegeben sei Tabelle (z.B. Lookup-Table) von im Output zulässigen Farben +- Durchlaufen aller Pixel (mit genauen Werten) beginnend links oben +- pro Pixel P die beste Ersetzung in Tabelle finden + setzen +- verursachten Fehler ∆ jeweils nach Schema auf unbearbeitete Nachbarpixel in der (noch) genauen Repräsentation verteilen + +bei kleinen Bildern mit hoher Auflösung ist Dithering kaum wahrnehmbar + +Dithering vs. Anti-Aliasing:\\ Anti-Aliasing und Dithering sind komplementär zueinander: +- Anti-Aliasing erhöht die empfundene räumlich Auflösung durch Anwendung von Zwischenwerten in der Grau-, bzw. Farbabstufung +- Dithering erhöht die Farbauflösung (verringert die empfundene Farbquantisierung) durch das Verteilen des Quantisierungsfehlers auf mehrere Pixel → Verringerung der räumlichen Auflösung. +- Beispiele zur Anwendung von Dithering: + - verlustbehaftete Bildkompression (z.B. GIF) + - Drucker (Halbtonverfahren) – benötigt eine feine Auflösung des Druckrasters + + +# Farbräume +## Motivation +Wie (und wie gut) lässt sich der visuelle Eindruck der physischen Realität durch eine Bildanzeige technisch reproduzieren? Bzw durch Computergrafik simulieren? + +Ziel realistische Darstellung von Bildern: +- möglichst genaue Reproduktion von Farben und Helligkeitswerten (auf der Bildfläche) +- Ziel existiere schon bevor es Computergrafik gab (Photorealistische Malereien) + +Ziel der Computergrafik: +- die technische Realisierung eines digitalen Bildes mit Hilfe des Computers aufeinem Bildschirm oder Druck, +- dazu Herleitung einer systematischen Repräsentation des Bildes als mathematisches Modell, bzw in einer Datenstruktur sowie ihre physische Reproduktion + +## Farbwahrnehmung +Verschiedene Aspekte zum Verständnis des menschlichen visuellen Systems (Farbe, Helligkeit, Bild,...) +- Phänonmenologische Betrachtung: Hell- und Farbempfinden als Sinneseindruck beschreiben. Einiges kann dadurch bereits qualitativ erschlossen werden +- Phisiologie des menschlichen visuellen Systems: (Rezeptoren des Auges und neuronale Verschaltung) Dies hilft beim Verstehen der Wahrnehmung der physischen Realität und der Herleitung von exakten Farbraummodellen +- Physik: Licht als elektromagnetische Strahlung +- +### Phänomenologisch +- Tageslicht kann als weiß bzw grau mit unterschiedlichen Helligkeiten, jedoch unbunt (farblos) empfunden werden +- Abwesenheit von Licht wird als schwarz empfunden (zB Nachthimmel) +- Regenbogen wird als bunt mit verschiedenen Farbtönen empfunden: Rot, Orange, Gelb, Grün, Cyan, Blau, Violett,... + + +### Farbton +- Zwischen den grob unterscheidbaren Farbtönen des Regenbogens lassen sich zwischenstufen orten, welche eine praktisch stufenlose Farbpalette ergeben +- direkt nebeneinanderliegende Farben im Farbspektrum werden als ähnlich empfunden +- wieder andere Farben werden als sehr unterschiedlich empfunden +- mit dieser Beobachtung lassen sich Farbwerte ordnen (Dimensionen des Farbtons als eine der Dimensionen zur Beschreibung von Farbwerten) +- All diese Farben ist jedoch gemein, dass sie als sehr bunt empfunden werden (voll gesättigte Farben im Gegensatz zu Grautönen) + +### Farbsättigung +- Zwischen bunten Farben und Grau lassen sich Zwischenstufen finden +- Pastelltöne sind zwar weniger bunt aber nicht völlig farblos (Farbwerte sind noch unterscheidbar) +- Grauton (keine Farbwerte unterscheidbar) +- zu jedem einzelnen bunten Farbton können Abstufungen von Pastelltönen bis zum gänzlich unbunten Grau zugeordnet werden + - diese Abstufung nennen wir Sättigung der Farbe + - Links maximal gesättigte Farbe, rechts völlig ungesättigte Farbe (grau) +- In jeder Zeile wird der gesättigte Farbton als nicht prinzipiell anders als die zugehörige Pastellfarbe empfunden (aber weniger bunt) nur weniger gesättigt +- +### Helligkeitsstufen +- Zu jedem Farbton (gesättigt oder nicht) können unterschiedliche Helligkeitsabstufungen bis zum tiefen Schwarz zugeordnet werden + - links maximale Helligkeit, rechts dunkelster Wert (schwarz) + - in jeder Zeile werden die hellen Farbtöne als nicht prinzipiell anders als die zugehörigen dunkleren Farbtöne empfunden + - im schwarzen sind ebenfalls keine Farbtöne mehr unterscheidbar + +### Zusammenfassung +damit haben wir phänomenologisch drei unabhängige Richtungen identifiziert, die wir den Farbeindrücken zuordnen können: +- Farbton (Hue) +- Farbsättigung (Saturation) +- Helligkeit (Lightness) + +## Das Modell der Farben +> Definition DIN 5033: Farbe ist die Empfindung eines dem Auge strukturlos erscheinenden Teils eines Gesichtsfeldes, durch die sich dieser Teil bei einäugiger Beobachtung mit unbewegtem Auge von einem gleichzeitig gesehenem, ebenfalls strukturlos angrenzendem bezirk allein unterscheidet. +> Farbe (in unbunter Umgebung) ist durch Helligkeit, Buntton und Sättigung eindeutig bestimmt. Dieses oder ein ähnliches dreidimensionales (3D) Modell ist für das Verständnis der Farbe erforderlich + + +### HSL Farbraum +bzw HSB, HSV, HSI + +Mit den gewonnen Erkenntnissen wir der HSL Farbraum definiert: +- Farbton: **H**ue +- Sättigung: **S**aturation +- Helligkeit: **L**ightness/**B**rightness/**V**alue/**I**ntensity +Da sich die Dimension des Farbtons periodisch wiederholt wird das System oft als Winkelkoordinate eines Polarkooridnaten-Systems in der HS-Ebene, bzw dreidimensional als Zylinderkoordinaten HSl darstellt. + +Darstellungsformen: Die Darstellungsform des HSL Farbraums ist nicht fest vorgeschrieben. Eine Darstellung als (Doppel)-Kegel oder sechseitige (Doppel-) Pyramide ist ebenso möglich. + +Der HSl Farbraum entspricht zumindest grob unserer Farbwahrnehmung. Daher eignet er sich zur intuitiven und qualitativen Einstellung von Farben in Illustrationsgrafiken +- Relative Skala 0..255 +- Quantisierbarkeit der Farben und Helligkeit z.B. beruhend auf physiologischen Messungen +- Bezug zur Physik des Lichtes (Energie, Spektrum) + +### RGB Farbraum +> Hypothese, dass Farbsehen auf drei Arten von Sinneszellen beruht (rot, grün, blau) ~ T. Young, 1807 + +> ein und diesselbe Farbwahrnehmung kann durch unendlich viele unterschiedliche Farbreize erzeugt werden, Farbwahrnehmungen sind durch drei beliebige, linear unabhängige Größen darstellbar. ~ Graßmann, 1853 + +Im menschlichen Auge befinden sich Zäpfchen, welche mit unterschiedlicher Empfindlichkeit auf die verschiedenen Wellenlängen des Lichtes reagieren. Es gilt: gleicher Reiz heißt gleiche Farbwahrnehmung + +Beispiel für Reizung durch monochromatisches Licht (Laser) einer bestimmten Stärke: +- $r=0,2R(\lambda)4 +- $y=0,5R(\lambda)+0,3G(\lambda)$ +- $g=0,2R(\lambda)+0,5G(\lambda)$ +- $b=0,02B(\lambda)$ + +Farberzeugung durch Mischung: +$$1,9r + 0,6g = 0,38R(\lambda)+0,12R(\lambda)+0,3G(\lambda)=0,5R(\lambda)+0,3G(\lambda) = y$$ + +geschichtliche/physikalische Aspekte: +- Sonnenlicht ist eine Mischung von einzelnen Farben +- Korpuskular- bzw Emissiontheorie +- Spektralfarben sind objektive Eigenschaften des Lichtes +- Prisma spaltet das weiße (Sonnen-) Licht in Spektralfarben +- durch Sammellinse lässt sich aus dem Spektrum wieder weißes Licht erzeugen +- kammartige Ausblendung führt zu bunten Mischfarben + +Additive Farbmischung in RGB:\\ +Mit den Grundfarben Rot, Grün und Blau können weitere bekannte Farben additiv gemischt werden (Rot+Blau=Magenta). Weitere Zwischenfarbtöne können durch kontinuierliches Variieren der Anteile der Grundfarben gemischt werden (alle Pastellfarben und Graustufen) + +Bestimmen der Anteile der Mischfarben:\\ +- zur Mischung beliebiger Farben verwenden wir die experimentiell bestimmten drei Empfindlichkeitskurven: R,G,B und zugehörige Lichtquellen r,g,b +- alle 3 Lichtquellen zusammen ergeben weiß wahrgenommenes Licht: r=g=b=1~weiß (muss gut abgestimmt werden -> Weißabgleich) +- wir können damit einen dreidimensionalen Farbraum (RGB-Farbraum) aufspannen +- die Lage einer monochromatischen Lichtwuelle $x(\lambda_0)$ in diesem RGB Farbraum lässt sich wie folgt berechnen: $x(\lambda_0)=p*r+\gamma*g+\beta*b$ +- Achtung: die Lösung hängt von den Wellenlängen der verwendeten Grundfarben r,g,b (Primärvalenzen) ab. Nimmt man andere Grundfarben, ergeben sich andere Werte für $p,\gamma,\beta$ +- RGB ist nicht gleich RGB! Man muss "eigentlich" immer die Wellenlängen der verwendeten Grundfarben r,g und b mit angeben! + +Innere Farbmischung: $F=p*r + \gamma*g + \beta*b$ + +Äußere Farbmischung:\\ +die gemischte Farbe Cyan wird zwar als derselbe Buntton wie die Referenzfarbe F wahrgenommen, jedoch weniger gesättigt. Um die beiden Farben gleich aussehen zu lassen wird der Referenzfarbe F etwas Rot beigemischt. Damit sind beide Farben gleich ungesättigt. Das Verfahren wird äußere Farbmischung genannt: $F=p*r + \gamma *g - \beta *b$. +Um die aus Blau und Grün gemischte Farbe Cyan voll gesättigt aussehend zu lassen, müsste Rot aus der Mischfarbe subtrahiert werden. Dies ist allerdings technisch nicht realisierbar. Durch die negative Farbvalenz wird das Modell jedoch theoretisch konsistent und es lassen sich alle Farben durch Mischen von Rot, Grün und Blau darstellen. Daraus wird ein vollstänfiges RGB-Farbmodell abgeleitet. + +Idee: +- es werden drei linear-unabhängige Größen benötigt + - zur beschreibung der Farbempfindung + - zur (technischen) Reproduktion der Farbempfindung +- zunächst werden folgende Werte gewertet + - die additive Mischung als Reproduktionsmethode + - drei Primärfarben Rot, Grün, Blau +- drei linear unabhängige Größen spannen stets einen 3D Raum auf + - die RGB Werte werden den drei ortogonalen Achsen dieses Raumes zugeordnet + +Darstellung des RGB Farbraums: +- alle mit drei Farblichtquellen technisch (additiv) erzeugbaren Farben liegen innerhalb eines Würfels +- Im Koordinatenursprung befindet sich Schwarz, diagonal gegenüber weiß. +- auf der Raumdiagonalen liegen dazwischen die Graustufen + +Bei entsprechender Normierung liegen die vom RGB Farbsynthesesystem erzeugbare Farben im Einheitswürfel. Zunächst wird der Begriff Intensität eingeführt: $I=\frac{R+G+B}{3}$. Der Ausschnitt aus der Ebene konstanter Intensität, der im Einheitswürfel liegt, wird im Interesse der einfachen Darstellung als Farbebene (Farbtafel) genutzt. Dabei bleibt die Ordnung der Farbvalenzen erhalten. Die Länge |F| der Farbvalenz bzw die Intensität geht verloren. +Die in der Ebene konstanter Intensität liegenden Werte definieren die Chrominanz durch welche die Farbwertanteile erfasst werden (zwei reichen aus da 2D). Es kann auch die Projektion der Ebene auf RG (grau überlagert) als Farbtafel genutzt werden, ohne die Ordnung der Farborte zu stören. Vorteil: orthonoales rg-System + +RGB Farbtafel:\\ +Alle Farben gleicher Buntheit (unterscheiden sich nur in der Länge von F) führen zum gleichen Farbort, der durch die Farbwertantwile r,g,b beschrieben wird: +$$r=\frac{R}{R+G+B}, g=\frac{G}{R+G+B}, b=\frac{B}{R+G+B} \leftrightarrow r+g+b=1$$ + +Aus dem rechten Teil der Gleichung folgt mit $b=1-r-g$, dass sich die Buntheit allein durch r und g darstellen lässt (entspricht $\R^2$). +Die Farbwertanteile lassen sich bei bekanntem Farbort in der Farbtafel nach der angegebenen Konstruktionsvorschrift ermitteln oder direkt ablesen. + + +### CIE System +Um eine Relation zwischen der menschlichen Farbwahrnehmung und den physikalischen ursachen des Farbreizes herzustellen, wurde das CIE-Normvalenzsystem von der Internationalen Beleuchtungskommission (CIE) definiert. Es stellt die Gesammtheit der wahrnehmbaren Farben dar. + +Farbkörperunterschiede:\\ +Es finden sich Unterschiede welche Farbbereiche nach dem CIE Normalvalenzsystem von den jeweiligen Systemen dargestellt werden können: +- menschliche Farbwahrnehmung ca 2-6 Mio Farben +- Monitor: ca 1/3 davon. Bei Monitoren wird die additive Farbmischung verwendet, da die einzelnen Lichtquellen aufsummiert werden. +- Druckprozess: meist deutlich weniger Farben. Bei Druckernwerden einzelne Farbschichten auf Papier gedruckt und das resultierende Bild wird über die subtraktive Farbmischung bestimmt. + +Subtraktive Farbmischung:\\ +Je nachdem welche Farbe ein Material hat, werden entsprechende Farbanteile absorbiert oder reflektiert. Eine gelbe Oberfläche sieht gelb aus, das sie das Blau aus weißem Licht absorbiert, aber Rot und Grün reflektiert. + +Achtung: Dies gilt nur für die Bestrahlung mit weißem Licht. Wird beispielsweise ein gelbes Blatt mit blauem Licht bestrahlt, dann wirkt es schwarz, da das blaue Licht vom gelben Blatt absorbiert wird. + +# Licht \& Reflexion +## Strahlung +Grundfrage: Was ist Licht? +- Teil der elektromagnetischen Strahlung +- ist für das menschliche Auge wahrnehmbar +- Lichtspektrum liegen zwischen 380 nm und 780 nm +- Farbe entspricht der Wellenlänge +- längere Wellenlängen = weniger Photonenenergie +- durch Überlagerungen vieler Frequenzen erscheint das Licht weiß + +Radiometrie: +- Wissenschaft von der Messung elektromagnetischer Strahlung +- Größen sind physikalische Einheiten (ohne Berücksichtigung des menschl. Sehens) + +Photometrie: +- Messverfahren im Wellenlängenbereich des sichtbaren Lichtes (Messung mithilfe eines Photometers) +- lassen sich aus den radiometrischen Größen, bei bekanntem Spektrum bestimmen +- berücksichtigen die wellenlängenabhängige Empfindlichkeit des Auges + +Photon: +- Elementarteilchen der elektromagnetischen Wechselwirkung +- besitzen keine Masse +- Energie und Impuls sind proportional zur Frequenz +- kürzere Wellenlänge = höhere Frequenz = höhere Energie + +Strahlungsenergie (radiant energy): +- durch Strahlung (elektromagnetische Wellen) übertragene Energie +- entspricht dem Produkt von Photonenanzahl und der Energie der Photonen +- Formelzeichen : Q +- Einheit: J (Joule) +- photometrisches Äquivalent: Lichtmenge (luminous energy) + +Strahlungsleistung (auch Strahlungsfluss, engl. radiant flux, radiant power): +- transportierte Strahlungsenergie in einer bestimmten Zeit +- Formelzeichen : $\phi$ +- Einheit: W (Watt) +- Berechnung: $\phi = \frac{Q}{t}$ +- photometrisches Äquivalent: Lichtstrom (luminous flux, luminous power) + +Zusammenhang zwischen Radiometrie und Photometrie:\\ +In der Radiometrie wird sich mit objektiven Messgrößen beschäftigt, in der Photometrie gibt es jeweils eine entsprechende Messgrößen, bei denen die spektrale Empfindlichkeit des menschlichen Auges mit einfließt. +- Beispiel: + - radiometrisch: Strahlungsleistung $\phi_e$ gemessen in Watt W + - photometrisch: Lichtstrom $\phi_v$ gemessen in Lumen lm +- Verknüpfung von Radiometrie und Photometrie erfolgt über das photometrische Strahlungsäquivalent: $K =\frac{\phi_v}{\phi_e}$ +- gibt die Empfindlichkeit des menschlichen Auges an +- radiometrische Größe: Index $_e$ für energetisch +- photometrische Größe: Index $v_$ für visuell +Die radiometrischen Größen gewichtet mit dem photometrischen Strahlungsäquivalent K sind somit die photometrischen Größen. + +Ausbreitung eines Strahls: +- geradlinig von einer Quelle zum Ziel, +- Richtung ändert sich durch Brechung +- an Oberflächen tritt Reflexion und Streuung auf +- eine Strahlungsquelle sendet dabei Strahlen in alle Raumrichtungen unter einem gewissen Raumwinkel aus + +### Raumwinkel +Der Steradiant ist eine Maßeinheit für den Raumwinkel, der von der Mitte M einer Kugel mit Radius r aus gesehen eine Fläche von $r^2$ auf der Kugeloberfläche einnimmt. $\Omega=\frac{Fläche}{Radius^2}=\frac{A}{r^2}sr$ +Eine komplette Kugeloberfläche $A_k$ beträgt allg. $A_k = 4\pi r^2$, entspricht also einem Raumwinkel $\Omega$ von $\frac{A_k}{r^2}= 4\pi r\approx 12,5sr$. Ein Steradiant =1sr entspricht einem Öffnungswinkel $\alpha$ von ca. 65,54° + +### Strahlstärke +- auch Intensität, engl. radiant intensity +- Strahlungsleistung die in eine Raumrichtung mit Raumwinkel $\Omega$ emittiert wird +- Formelzeichen : I +- Berechnung: $I=\frac{\phi}{\Omega}$ +- photometrisches Äquivalent: Lichtstärke (luminous intensity) + +Beispiel: Berechnen Sie die Strahlstärke einer Lampe mit einem Öffnungswinkel von 180° und einer Strahlungsleistung von 20W. +$$\alpha=180°\rightarrow A=2\pi r^2; \phi =20W; \Omega=\frac{A}{r^2}=2\pi ; I_e=\frac{\phi_e}{\Omega}=\frac{20}{2\pi}\approx 3,2 \frac{W}{sr}$$ + +### Räumliche Ausbreitung +Energieübertragung zwischen zwei Flächen: +Eine Fläche $A_r$ strahlt Licht auf eine Fläche $A_i$ ab.\\ +Frage: Wie viel Lichtleistung von einer infinitesimalen abstrahlenden Fläche $A_r$ wird auf einer Fläche $A_i$ empfangen? +- der Abstand zwischen den beiden infinitesimalen Flächen beträgt r +- die Flächen stehen nicht notwendigerweise senkrecht zur Ausbreitungsrichtung des Lichts (gerade Verbindungslinie zwischen den Flächen) +- Wir projizieren daher die abstrahlende und die empfangende Fläche jeweils in Ausbreitungsrichtung. Die projizierten Flächen nennen wir $A'_r$ und $A'_i$. +- Wir betrachten Punktlichtquellen von der abstrahlenden Fläche $A_r$ , welche ihre Strahlungsleistung in den Raumwinkel $\Omega$ abgeben. +- $\Omega$ ist somit die in Abstrahlrichtung reduzierte Fläche $A'_i$ , projiziert auf die Einheitskugel: $\Omega=\frac{A'_i}{r^2}$ + - Die übertragene Energie nimmt quadratisch zu r ab + +### Strahldichte +- engl. radiance +- Strahlstärke welche von einer Sendefläche $A_r$ in eine bestimmte Richtung abgegeben wird +- Formelzeichen : L +- photometrisches Äquivalent: Leuchtdichte (auch Luminanz, engl. luminance) +- Berechnung: $L = \frac{I}{A'_r}=\frac{I}{\cos(\phi_r)*A_r} = \frac{\phi}{\cos(\phi_r)*A_r*\Omega}$ +- $\phi_r$ ist der Winkel zwischen der Normalen n und der Abstrahlrichtung (von der abstrahlenden Fläche $A_r$ zur empfangenden $A_i$) + +Leuchtdichte (Luminanz) als Vorstufe der Helligkeit: +- Strahlungsleistung bewertet mit der spektralen Empfindlichkeitsfunktion des menschlichen Auges für das Hellempfinden +- Das menschliche Auge hat seine maximale Empfindlichkeit, bei einer Wellenlänge von 555 nm (gelbgrün) +- 1 Lumen ist definiert als der Lichtstrom einer 1,464 mW starken 555-nm-Lichtquelle mit 100% Lichtausbeute. + + +### Bestrahlungsstärke +- auch Strahlungsflussdichte, engl. irradiance +- Strahlungsleistung durch die bestrahlte Fläche $A_i$ bzw. Strahlstärke die auf die Empfängerfläche trifft +- Formelzeichen : E +- Berechnung: $E =\frac{\Phi}{A_i}$ +- photometrisches Äquivalent: Beleuchtungsstärke (auch Lichtstromdichte, engl. illuminance) +- erweitert: $E=\frac{\Phi}{A_i}=\frac{L*\cos(\phi_i)*\cos(\phi_r)*A_r}{r^2}$ + +### Zusammenfassung +Radiometrische (physikalische) und Photometrische (unter Berücksichtigung des menschlichen Auges) Größen + +| Symbol | Radiometrie (energetisch $_e$) | Photometrie (visuell $_v$ ) | +| -- | -- | -- | +| $Q$ | Strahlungsenergie $Joule$ | Lichtmenge $lm*s$ | +| $\Phi$ | Strahlungsleistung Watt $W$ | Lichtstrom Lumen $lm$ | +| $I$ | Strahlstärke $\frac{w}{sr}$ | Lichtstärke Candela $cd$ | +| $E$ | Bestrahlungsstärke $\frac{W}{m^2}$ | Beleuchtungsstärke Lux $\frac{lm}{m^2}$ | +| $L$ | Strahldichte $\frac{w}{sr*m^2}$ | Leuchtdichte $\frac{cd}{m^2}$ | + + + +## Reflexion +Nach dem Auftreffen auf einer opaken Oberfläche wird die Strahlung spektral +unterschiedlich stark und geometrisch auf unterschiedliche Weise reflektiert. Es +können 2 Idealfälle der Reflexion unterschieden werden: +- ideal spiegelnde Reflexion (Einfallswinkel = Ausfallswinkel) +- ideal diffuse Reflexion + +Aus den zwei Idealfällen der reflexion werden weitere (gemischte) Fälle abgeleitet: +- spekuläre Reflexion (diffus und gerichtete Reflexion) +- gemischte Reflexion: ideal diffus, gerichtet diffus und ideal spiegelnd + +Bei der Betrachtung der Reflexion ist offensichtlich die Art der Bestrahlung und +insbesondere auch die Richtung der Einstrahlung zu beachten. + + + +### Diffuse Reflexion +![Diffuse Reflexion; Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Diffuse_Reflexion.png) + +Lichtquelle im Unendlichen; Irradiance $E=\frac{A'_i}{A_i}I_{in}=I_{in}\cos(\phi)$ + +Eingestrahlte Strahlstärke I in durch $A'_i$ verteilt sich durch die Projektion auf die größere Fläche $A_i$ Die Bestrahlungsstärke E (Irradiance) ist dadurch proportional zum Vergrößerungsfaktor der Fläche abgeschwächt. + +In Richtung Betrachter reflektierte Strahlstärke $I_{out}$ Aufgrund von Interferenz phasengleicher Lichtstrahlen → Projektion auf Normalenrichtung $\frac{I_{out}}{E_{refl}}=\cos(\phi)$ +- Senkrecht zur Oberfläche: Maximale Kohärenz (Addition) +- Parallel zur Oberfläche: n Keine Kohärenz (Auslöschung) + +![Diffuse Reflexion Addition und Auslöschung; Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Diffuse_Reflexion_2.png) + +Annahme kohärentes Licht: Parallel zur reflektierenden Oberfläche findet sich zu jeder Punktlichtquelle immer eine gleichphasige Punktlichtquelle im Abstand $\frac{\lambda}{2}$ +- Auslöschung parallel zur Fläche, + +![Diffuse Reflexion Betrachter; Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Diffuse_Reflexion_3.png) + +$$\frac{A_r}{A'_r}=\frac{1}{\cos(\phi)} \rightarrow L=\frac{I_{out}}{\cos(\phi)}=I_{refl}$$ +Ein Betrachter mit flachem Blickwinkel sieht Licht aus größerer Fläche $A_r$ durch Kombination dieser Effekte, kürzt sich der Einfluss des Betrachterwinkels $\cos(\phi)$ weg und es bleibt nur der Einfluss des Lichteinfallswinkels übrig: Strahldichte des reflektierten Lichtes: $L=I_{in}*k_d(\lambda)*\cos(\phi)$ + +### Spekuläre Reflexion +Spekuläre (gestreut spiegelnde) Reflexion: +- Speckles (Fleckchen), bzw. (Micro-) Facetten sind einzeln jeweils "ideal" +- spiegelnd: Einfallswinkel $\phi$ = neg. Ausfallswinkel = $-\phi$. +- Die Ausrichtung der Microfacetten weichen von der Gesamtflächennormalen ab. → Statistische Abweichung von der Flächennormalen (z. B. Gauß-Verteilung) +- dadurch Streuung des Lichts (Keule) um den Winkel $\theta$ der idealen Spiegelung herum +- Je größer der Winkel $\theta$ zwischen idealer Spiegelrichtung und Richtung zum Betrachter, desto schwächer ist die Reflexion +- Modellierung meist per $\cos^k(\theta$)$ (Phong-Beleuchtungsmodell) - nicht physikalisch begründet. + +![Spekuläre Reflexion; Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Spekuläre_Reflexion.png) + +Gestreute Spiegelung im Phong Modell mit $L=I*k_s*\cos^k(\theta)$ +- glänzende Oberfläche: großer Exponent k (16,...,128); kleine Streuung $\epsilon$ +- matte Oberfläche: kleiner Exponent k (1,...,2); große Streuung $\epsilon$ + +Energieerhaltung $\rightarrow$ Verhinderung der Abnahme bei großen Exponenten $\rightarrow$ Für die Energieerhaltung wird ein zusätzlicher Normierungsfaktor benötigt: +- physikalisch nicht korrekt: $L=I*k_s*\cos^k(\theta)$ +- gebräuchliche Normierung $\frac{k+2}{2\pi}$ somit: $L=I*k_s*\frac{k+2}{2\pi}*cos^k(\theta)$ + +### Remittierende Flächen +- Wegen der spektralen Unterschiede bei der Reflexion bleiben wir bei den spektralen physikalischen (radiometrischen) Größen! +- Erst im Auge bzw. im Bildsensor erfolgt die Wandlung in die wellenlängenintegralen photometrischen (colorimetrischen) Größe! + +Zunächst ideal diffus remittierende weiße Flächen $(\beta(\lambda) = 1)$: +- Die von den Quellen in die Fläche $dA$ eingetragene Leistung führt zu einer Bestrahlungsstärke $E_{\lambda}$ +- Bei vollständiger Reflexion $\beta(\lambda) = 1$ ist $E_{\lambda} = R_{\lambda}$ (spektrale Radiosity, spezifische spektrale Ausstrahlung). +- Der zugehörige spektrale Strahlungsfluss $d\phi = R_{\lambda} * dA = E_{\lambda} * dA$ wird bei ideal diffusen streuenden Oberflächen gleichmäßig über den Halbraum verteilt, wobei die Strahldichte (Lambertsches Gesetz) konstant ist. + + +## BRDF: Bidirektionale Reflexionsverteilungsfunktion +### Bidirektionale Reflexion +- englisch Bidirectional Reflectance Distribution Function, BRDF +- eine Funktion für das Reflexionsverhalten von Oberflächen eines Materials unter beliebigen Einfallswinkeln +- Ziel: Oberfläche möglichst realistisch und physikalisch korrekt darstellen +- nach gewählter Genauigkeit sehr komplex +- in der Computergrafik wird meist eine vereinfachte Variante gewählt um Rechenzeit zu sparen +- erstmals 1965 definiert (Fred Nicodemus): $\f_r(\omega_i, \omega_r)=\frac{dL_r(\omega_r)}{dE_i(\omega_i)}=\frac{dL_r(\omega_r)}{L_i(\omega_i)\cos(\theta_i)d\omega_i}$ +- Eine BRDF beschreibt wie eine gegebene Oberfläche Licht reflektiert. +- Das Verhältnis von reflektierter Strahldichte (radiance) $L_r$ in eine Richtung $\vec{\omega}_r$ zur einfallenden Bestrahlungsstärke (irradiance) $E_i$ aus einer Richtung $\vec{\omega}_i$ wird "bidirectional reflectance distribution function"(BRDF) genannt. + - $p(\lambda)=\frac{L_r}{E_i}=[\frac{1}{sr}]$ +- Die BRDF (für jeden Punkt x) ist eine 5-dimensionale skalare Funktion: $p(\lambda, \phi_e, \theta_e, \phi_i, \theta_i)$ +- Keine Energie-Einheiten, nur Verhältniszahl! +- Kann durch Messung für verschiedene Materialien bestimmt werden (Messkamera/Normbeleuchtung) +- Eigenschaften der BRDF: + - Reziprozität: $\roh(\lambda)$ ändert sich nicht, wenn Einfalls- und Ausfallsrichtung vertauscht werden (wichtig für Ray-Tracing). + - $\roh(\lambda)$ kann anisotrop sein, d.h. der Anteil des reflektierten Lichtes ändert sich, wenn bei gleicher Einfalls- undAusfallsrichtung die Fläche um die Normale gedreht wird (Textilien, gebürstete Metalle, Metalleffektlacke) + - Superposition gilt, d.h. mehrere Quellen überlagern sich linear. + +Es ist in der Computergrafik üblich, die bidirektionale Reflektivität als Gemisch von ambienten, diffusen und spekularen Komponenten $\roh_d, \roh_s$ aufzufassen und +einen ambienten Anteil $\roh_a$ zu addieren. Für eine Menge Q von Lichtquellen berechnen wir damit die gesamte reflektierte Strahlstärke: $L_r=p_a*E_a+\sum_{1\leq j \leq Q} E_j * (k_d*p_d + k_s*p_s)$ mit $k_d+k_s=1$ und Q= Anzahl der Lichtquellen + +### Rendering-Equation +Für ambiente und gerichtete Lichtquellen aus der Hemisphäre ergibt sich eine spezielle Form der BRDF, die Render-Gleichung (Jim Kajiya 1986): +- eine BRDF mit Integral über alle Lichtquellen (bzw. Hemisphären) +- $L_r=p_a + \int_{Omega} L*(k_d*p_d+k_s*p_s) \omega_i*n d\Omega$ + +![Rendering Equation; Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Rendering_Equation.png) + +### Strahlungsquellenarten +- Ambiente Strahlung: + - es ist keine "eigentliche" Quelle zuordenbar + - stark vereinfachtes Modell für die Streuung der Atmosphäre, für viele "durchmischte" Strahlungsquellen, für indirekte Reflexionen + - Strahlung kommt von allen Seiten "Die Quelle ist überall und nirgends" + - keine Abhängigkeit von Winkeln und Entfernungen + - Beschreibung nur indirekt durch konstante Bestrahlungsstärke (Irradiance) von Flächen möglich + - $E=\frac{\Phi}{A}=E_a$ +- Parallele Strahlung: + - Strahlung ist gerichtet und parallel (kollimiertes Licht, Strahlungsquelle im Unendlichen, Sonnenlicht) + - für derartige Quellen lässt sich kein Ort (aber uneigentlicher Ort, Richtung) angeben + - Wichtig sind die Richtung und die Strahlungsleistung, bezogen auf die senkrecht zur Ausbreitungsrichtung stehende Fläche (spezifische Ausstrahlung oder Radiosity $R_e$) $R=E_q=\frac{\Phi}{A_q}$ + - für die Schattierungsrechnung lässt sich die Bestrahlungsstärke $E_e$ der Oberfläche (Flächenelement dA) berechnen: $E=\frac{\Phi}{A}=\frac{E_q*A_q}{A}=E_q*\cos(\phi) = E_q*V_I^T*n$ +- Ideale Punktlichtquelle: + - für die Punktquelle ist der Ort bekannt und die Strahlstärke in alle Richtungen konstant: $I=\frac{\Phi}{\Omega}=konstant$ + - die Bestrahlungsstärke eines physikalischen vorliegenden, beliebig orientierten Flächenelementes A ergibt sich zu: + - $E=\frac{\Phi}{A}=\frac{I*\Omega}{A}, \Omega=\frac{A}{r^2}*\cos(\phi)*\omega_r \rightarrow E=\frac{I}{r^2}*\cos(\phi)*\omega_r$ + - zum Ausgleich der Adaptionsfähigkeit des menschlichen Auges wird in der Computergrafik oft der folgende Ansatz verwendet: + - $E=\frac{I}{c_1+c_2*|r|+c_3*r^2}*\cos(\phi)*\omega_r$ +- Remittierende Flächen (radiometrische Betrachtung): + - Zur Berechnung der von der reflektierenden Fläche weitergegebenen Strahldichte L sind die weiter oben berechneten Bestrahlungsstärken E für die unterschiedlichen Quellen mit dem Faktor $\frac{\beta(\lambda)}{\pi\omega_r}$ zu bewerten + +| Quelle | Reflexion | Spektale Strahldichte $L(\lambda)$ | +| -- | -- | -- | +| ambient | diffus | $L(\lambda)=\frac{E(\lambda)}{\pi\omega_r}*\beta(\lambda)$ | +| gerichtet | diffus | $L(\lambda)=\frac{E(\lambda)}{\pi\omega_r}*\cos(\phi)*\beta(\lambda)$ | +| punktförmig | diffus | $L(\lambda) = \frac{I(\lambda)}{\pi r^2 }*\cos(\phi)*\beta(\lambda)$ | +| gerichtet diffus | diffus | $L(\lambda)=\frac{I(\lambda)}{\pi r^2 }* \cos^m(\theta)*\cos(\phi)*\beta(\lambda)$ | + + +## Beleuchtungsmodelle +Ein Beleuchtungsmodell ist eine Verfahren in der Computergrafik welches das Verhalten von Licht simuliert. Die Simulation unterscheidet dabei zwischen lokaler und globaler Beleuchtung: +- Lokale Beleuchtungsmodelle: + - simulieren das Verhalten von Licht auf den einzelnen Materialoberflächen + - nur Beleuchtungseffekte welche direkt durch Lichtquellen auf einzelnen Objekt entstehen + - indirekte Beleuchtung bleibt zunächst unberücksichtigt +- Globale Beleuchtungsmodelle: + - simulieren die Ausbreitung von Licht innerhalb der Szene + - dabei wird die Wechselwirkung in der Szene beachtet (Schatttenwurf, Spiegelung, indirekte Beleuchtung) + +### Phong-Modell +- lokales Beleuchtungsmodell (lässt sich durch BRDF beschreiben) +- eignet sich zur Darstellung von glatten, plastikähnlichen Oberflächen +- baut nicht auf physikalischen Grundlagen auf +- widerspricht dem Energieerhaltungssatz +- Reflexion des Lichts = ambienter+ ideal diffuser + ideal spiegelnder Reflexion + +![Phong Modell; Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Phong_Modell.png) + +- Allgemein: $L=I_{out}=I_{ambient}+I_{diffus}+I_{specular}$ +- Ambiente: $I_{ambient}=I_a * k_a$ mit $I_a$ Intensität des Lichtes und $k_a$ Materialkonstante +- Diffus: $I_{diffus}=I_{in}*k_d*\cos(\phi)$ mit $I_{in}$ Lichtstärke der Punktlichtquelle; $k_d$ empirischem Reflexionsfaktor; $\phi$ Winkel zwischen Oberflächennormale und Richtung des einfallenden Lichtstrahls +- Spiegelnd: $I_{specular}=I_{in}*k_s*\frac{n+2}{2\pi}*\cos^n({\theta})$ mit + - $I_{in}$ Lichtstärle des eingallendes Lichtstrahls der Punktlichtquelle + - $k_s$ empirisch bestimmter Reflexionsfaktor + - $\theta$ Winkel zwischen idealer Reflexionsrichtung des Lichtstrahls und Blickrichtung + - $n$ konstante Exponent zur Beschreibung der Oberflächenbeschaffenheit + - $\frac{n+2}{2\pi}$ Normalisierungsfaktor zur Helligkeitsregulierung +- Vollständige Formel: $I_{out}=I_a*k_a+I_{in}*k_d*\cos(\phi)+I_{in}*k_s*\frac{n+2}{2\pi}*\cos^n(\theta)$ + +Unterschiedliche Definitionen sind möglich, z.B. mit mehrere Lichtquellen: +- jeweiligen Komponenten für jede Lichtquelle separat berechnet +- diese werden anschließend aufsummiert + +### Cook-Torrance +- Physik-basierte spekulare Reflexion: +- Microfacetten: Grundidee ähnlich Phong-Modell +- Statistische Abweichung der Microfacetten von der Flächennormalen (z. B. Beckmann-Verteilung) +- Streuung des Lichts (Keule) um den Winkel der idealen Spiegelung herum +- Berücksichtigt auch die gegenseitigen Abschattung (insbesondere bei flachen Lichtstrahlen) +- Vollständig physikbasiertes Modell, keine willkürlichen Reflexionskonstanten +- Aufwendige Berechnung (verschiedene Näherungsformeln existieren) +- Beckmann-Verteilung: $l_{spec}=\frac{exp(-\frac{tan^2(\alpha)}{m^2})}{\pi m^2 cos^4 (\alpha)}$, $\alpha=arccos(N*H)$ + +# Schattierungsverfahren +## Direkte Schattierung +Bisher: +- Zerlegung gekrümmter Flächen in Polygone (meist Drei- oder Vierecke) +- Positionen der (Eck-)Punkte und Normalen im 3D sowie der Punkte im 2D-Bild sind bekannt (per Matrixmultiplikation für Transformationen und Projektion) +- Pixelpositionen für Polygone/Dreiecke im Bild per Scanline-Algorithmus +- lokale Beleuchtungsmodelle für 3D-Punkte (z.B. per Phong-Beleuchtungsmodell) + +Jetzt: Wie kommt Farbe (effizient) in die Pixel? +- Wie oft muss lokales Beleuchtungsmodell bei n Pixeln im Dreieck angewendet werden? + +| Verfahren | Anz. | Idee | +| -- | -- | -- | +| Flat-Shading | 1 | eine Berechnung, dann gleiche Farbe für alle Pixel des Dreiecks/Polygons verwenden | +| Gouraud-Shading | 3 | pro Eckpunkt eine Farbe berechnen, dann lineare Interpolation (pro Dreieck) für jedes Pixel | +| Phong-Shading | n | eine Berechnung pro Pixel, davor aber jeweils lineare Interpolation der Normalen pro Pixel | + +→ Phong-Beleuchtungsmodell in jedem der obigen Shading-Verfahren nutzbar +→ hier nur direkte Schattierung (nur lokal, wo sind die Lichtquellen), d.h. nicht global (wie bei Radiosity & Raytracing) + +### Flat-Shading +Arbeitsweise des Flat-Shadings +- stets nur 1 Farbwert pro (ebener) Fläche, +- Stelle der Berechnung frei wählbar (möglichst repräsentativ), +- repräsentativ wäre z.B.: Punkt (Ort mit Normale) in der Mitte der Fläche +- $\rightarrow$ trivial für Drei- und Vierecke? → für Dreiecke und konvexe Vierecke! + +Auswirkungen +- "flaches" Aussehen und Helligkeitssprünge an den Kanten, das ist: + - schlecht für Fotorealismus, + - gut für abstraktere technische Darstellungen und + - u.U. wichtig für realistische Darstellung kantiger Körper (insbes. wenn pro Eckpunkt nur eine Normale modelliert ist). +- schneller als die anderen Verfahren, +- u.U. genauso gut wie z.B. Phong-Shading, wenn z.B.: + - das Objekt sehr fein modelliert wurde oder + - sehr weit entfernt ist +- $\rightarrow$ d.h. nur ca. 1 Pixel pro Polygon/Dreieck gerendert wird (n==1) + +### Gouraud-Shading +- Gouraud-Shading [H. Gouraud 1971] schattiert Dreiecke (bzw. aus Dreiecken zusammengesetzte Polygone) kontinuierlich, +- beseitigt damit die Diskontinuitäten des Flat-Shadings, +- meist gleiche Normalen pro Vertex, d.h. pro Dreieck wirken oft 3 verschiedene Richtungsvektoren statt nur eine Normale (Dreiecksmitte) wie beim Flat-Shading und +- lineare Interpolation der Schattierung (Intensitäten) im Inneren des Dreiecks aus den 3 Farbwerten der Eckpunkte. +- Es werden "Normalenvektoren" $n_i$ für jeden Eckpunkt $P_i$ des Polygons ermittelt bzw. ausgelesen. +- Die Herleitung der "Normalenvektoren" $n_i$ ist aus der Originaloberfläche (z.B. Zylinder, Kegel, Bèzier-Fläche) oder Nachbarpolygonen möglich. +- Für jeden Eckpunkt: Berechnung der Beleuchtungsintensität $I_i$ (z. B. nach dem Phong-Beleuchtungsmodell). +- Normalen $n_i$ der Eckpunkte werden entweder direkt aus den Flächen (z.B. Regelgeometrien, bei Kugel z.B. Richtung des Radiusvektors) oder aus den Flächennormalen der benachbarten Polygone durch flächengewichtete Mittelung berechnet. +- Die Schattierungsrechnung (RGB-Werte) erfolgt für die Eckpunkte und liefert die reflektierte Leuchtdichte $I_i$ . Zur Erinnerung, das Phong-Beleuchtungsmodell: + - $I_{out}=I_a*k_a+I_{in}*k_d*\cos(\phi)+I_{in}*k_s*\frac{n+2}{2\pi}*\cos^n(\theta)$ + - $\cos(\phi)=V^T_I*n_i$, $cos^n(\theta)=(V^T_r * V_e)^n$ +- Nach Anwendung des Beleuchtungsmodells an den Eckpunkten (auch Vertex-Shading genannt) +- Bei der Rasterkonvertierung wird zwischen den Eckwerte $I_i$ linear interpoliert und damit die Intensität jedes Pixels der Rasterlinie berechnet (Intensität I steht hier für die Leuchtdichte oder für Farbwerte usw.) +- Die Interpolation erfolgt nach dem gleichen arithmetischen Muster wie die Interpolation der x-Werte beim Polygonfüllalgorithmus, bzw. der $1/z$-Werte im z-Buffer-Verfahren (d. h. inkrementell, mit Ganzzahlarithmetik). +- Für farbige Oberflächen werden die Leuchtdichten an den Polygonecken durch RGB-Werte beschrieben und ebenso zwischen den Ecken linear interpoliert. +- Resultat: Kontinuierlich schattierte dreidimensionale Oberflächen + +![Gourad Shading; Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Gourad-Shading.png) + +Artefakte des Gouraud-Shading, bedingt durch die lineare Interpolation: +- Fehlen von gut ausgeprägten Glanzlichtern (verwischt oder verschwunden) +- Mach-Band-Effekt: ((helle) Bänder) Kontrastverstärkung durch das Auge an den Übergängen zwischen Polygonen +- Diese Artefakte werden im Folgenden genauer untersucht. + +#### Fehlende Glanzlichter +Auf Grund der linearen Interpolation von Intensitäten können Glanzlichter, die auf spekulare Reflexion zurückzuführen sind, verloren gehen oder abgeschwächt/verschmiert werden. Das wird umso kritischer, je spitzer die spekulare Reflexion ist (großes n im $\cos^n$- Term). + +Feinere Unterteilung der Oberfläche verbessert Resultat + +![fehlende Glanzlichter; Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Gourad_Glanzlichter.png) + +#### Mach-Band-Effekt +Die lineare Interpolation der Leuchtdichte zwischen den Polygonkanten entlang der Rasterlinie führt zu einem Verlauf, der durch plötzliche Änderungen im Anstieg der Intensität gekennzeichnet ist (nicht stetig differenzierbar). + +Der Mach-Band-Effekt: physiologisches Phänomen (Ernst Mach, 1865) +- Bei Sprüngen in der Helligkeitsänderung (c0-Stetigkeit, c1-Unstetigkeit, typisch für Approximation durch ebene Polygone beim Gouraud-Shading, z.B. Zylinder) stört dieser Effekt u. U. erheblich. +- Gleiche Information benachbarter Rezeptoren wirkt bei der weiteren visuellen Verarbeitung lateral hemmend auf die lokale Lichtempfindung. +- Modellhaft entstehen neben dem eigentlichen Helleindruck auch "Signale", die dem Helligkeitsgradienten (erste Ableitung) und dem Laplacefilter-Output (Laplacian of Gaussian / LoG, zweite Ableitung) entsprechen. +- Die Empfindung wird insgesamt nicht nur durch die Lichtintensität selbst, sondern auch durch die Überlagerung mit ihrer ersten und zweiten räumlichen Ableitung bestimmt. +- Das führt zu einer Verstärkung von Konturen an "Sprungkanten" (c0-Unstetigkeiten, Intensitätssprünge). In der dunklen Fläche zeigt sich eine dunklere, in den hellen Flächen eine hellere Kantenlinie. Dort, wo Konturen vorhanden sind, ist das vorteilhaft (evolutionäre Entwicklung der menschlichen visuellen Wahrnehmung), obwohl Täuschungen damit verbunden sind (photometrischer Eindruck). + +- zunächst Kanten: Liegen eine helle und eine dunkle Fläche nebeneinander, beobachtet man einen dunklen Streifen auf der dunkleren Seite und einen hellen Streifen auf der helleren Seite (Kontrastverstärkung). +- Bei einer Abfolge von Flächen unterschiedlicher Graufärbung, die in sich keine Farbgraduierung haben, beobachten wir entlang der Grenzen machsche Streifen (nach Ernst Mach 1865). Dabei handelt es sich um helle und dunkle Streifen, die den Kontrast zwischen den Flächen verstärken. [Quelle: Wikipedia] + +### Phong-Shading +Phong-Shading [Phong 1975]: +- Lineare Interpolation der Normalenvektoren zwischen den Polygonecken anstelle von Interpolation der Intensitätswerte (bei Grafikkarten/-software als Pixelshader bekannt). +- Exakte Berechnung der $\cos^n$-Funktion im Phong-Beleuchtungsmodell für jedes Pixel : Glanzlichter werden erhalten! +- Keine Diskontinuität der ersten Ableitung: Mach-Band-Effekt wird vermieden! + + +## 3D-Rendering +Soll nur ein konvexes Objekt gerendert werden, dann ist die Entscheidung, welche Flächen zu zeichnen sind, einfach anhand der jeweiligen Normalen möglich.\\ +Annahme: mehrere konvexe Objekte oder auch konkave Objekte sollen gerendert werden. Verdeckungen sind also möglich! +- Korrekte Behandlung von Verdeckungen bedarf spezieller Ansätze/Datenstrukturen (Lösung des Reihenfolgeproblems). +- Rein opake Szenen sind typischerweise wesentlich leichter zu implementieren als (teilweise) transparente (zusätzlich ein Berechnungsproblem). +- Zeichenreihenfolge ist teilweise wichtig (z.B. von hinten nach vorn), +- Algorithmen/Ansätze unterscheiden sich auch in der Granularität/Genauigkeit was auf einmal gezeichnet/sortiert wird: + - Objekte (ganze Objekte nach z-Position sortieren, dann jeweils zeichnen...) + - allg. (d.h. ggfs. überlappende) Polygone: Painters-Algorithmus, + - überlappungsfreie Dreiecke/Polygone: Depth-Sort-Algorithmus, + - Pixel: Z-Buffer-Verfahren (oft auch in Verbindung mit Obj.-Sort.) +- Beliebte Testszene sind sich zyklisch überlappende Dreicke, z.B. + +### Painter’s-Algorithmus +- Gegeben sei eine 3D-Szene, bestehend aus grauen Polygonen mit diffus reflektierender Oberfläche, sowie eine gerichtete Lichtquelle. +- Für jedes Polygon wird die reflektierte Strahldichte L auf Basis des eingestrahlten Lichts (Richtung & Stärke) und der Flächennormale berechnet: + - $I_{out} = L = I_{in}* k_d * \cos(\phi)$ +- Die Polygone werden mittels perspektivischer Kameratransformation (4 x 4 Matrix) in das Kamera-Koordinatensystem (Bildraum) transformiert und nach absteigendem z-Wert (Distanz des Polygonschwerpunkts zum Betrachter) sortiert. +- Die sortierten Polygone werden der Reihe nach (entfernte zuerst) mit dem 2D-Polygonfüllalgorithmus in das Pixelraster der x/y-Bildebene konvertiert. +- Die Pixel für jedes Polygon werden per Overwrite-Modus mit dem Farbwert L (nach obiger Berechnung) im Bildspeicher gespeichert. +- Die Verdeckungsprobleme lösen sich durch die Reihenfolge quasi automatisch. + +Gleichnis: Der Algorithmus arbeitet wie ein Maler, der zuerst den Hintergrund und dann Schritt für Schritt das jeweils weiter vorn liegende Objekt (oder Polygon bzw. Dreieck) zeichnet - und dabei die dahinterliegenden verdeckt. ABER, potentielle Probleme des Painter’s-Algorithmus: selbst bei Dreiecken sind trotzdem falsche Verdeckungen möglich! + +### Depth-Sort-Algorithmus +- Unterteilung in sich nicht überlappende und vollständig überdeckende Teilpolygone +- Ist in der Projektionsebene durch gegenseitigen Schnitt aller Polygone möglich (allerdings blickabhängig – muss in jedem Bild neu berechnet werden!). +- Die sichtbaren Teilpolygone können nun ausgegeben werden: + - Zeichnen der nicht überlappenden Teilpolygone + - Von den sich vollständig überlappenden Teilpolygonen wird nur das vordere gezeichnet. + +![Depth Sorth Algorithmus; Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Depth-Sort-Algorithmus.png) + +- Eine einfache, nicht blickwinkelabhängige Unterteilung tut es in diesem Falle auch! +- Die Teilpolygone sollten dabei möglichst nicht größer sein als der Tiefenunterschied, damit sie in jeder Situation eindeutig sortiert werden können! +- Die 6 Teilpolygone können mittels Painter‘s Algorithmus korrekt sortiert und dargestellt werden + +Anwendungsbereiche des Painter's Algorithmus / Depth-Sort Algorithmus: +- Einfache Szenen, kleine Objekte, die sich in den z-Werten hinreichend unterscheiden. +- Dort, wo keine Hardware-Unterstützung für 3D-Rendering angeboten wird (begrenzter Speicher, keine Z-Buffer Unterstützung). +- Viele 2D-Grafiksystem bieten bereits Polygonfüllverfahren an. +- Ähnliche Vorgehensweise wird auch für das Schattieren von semi-transparenten Flächen notwendig (s. später)! + +Als Sortierverfahren für Echtzeitsysteme eignet sich z.B. "Insertion-Sort": +- Begründung: Von Bild zu Bild ändert sich die Tiefenwerte (und damit die Reihenfolge) der Polygone relativ wenig. Damit sind die Polygone beim nächsten Bild bereits mehr oder weniger vorsortiert (nur wenige Polygone) müssen neu einsortiert werden. Die Komplexität von Insertion-Sort wird bei bereits sortierten Listen linear (O-Notation / best case). +- Folglich tritt beim Painters-Algorithmus der best case sehr häufig ein (außer beim ersten Bild, wo man vom average case ausgehen kann– hier wird die Komplexität quadratisch). + +### Z-Buffer-Verfahren +- Einer der einfachsten "visible surface"-Algorithmen (CATMULL 1974) +- Probleme des Painters-Algorithmus werden überwunden durch zusätzliche Berechnung des z-Wertes für jeden Punkt jedes Polygons und Speicherung des zur Projektionsebene nächstliegenden Farb- und Z-Wertes. +- Dazu ist ein zusätzlicher Speicher (z-Buffer) für jedes Pixel notwendig. +- Es sind weder Vorsortieren von Objekten noch Polygonzerlegung erforderlich (wenn alle Objekte opak sind). + +Initialisierung: Für alle Pixel +- Setze Farbe auf Hintergrundfarbe (z.B. Weiß) +- Setze alle Z -Werte auf $\infty$ (max. ganzzahliger Wert) +- Setze Z min auf Wert der Near-Plane + +Für alle Polygone (im 3D-Kamerakoordinatensystem) +- Rasterumwandlung in der Projektionsebene ($x_p/y_p$ Koordinaten) durch modifizierten 2D-Polygonfüllalgorithmus. Modifiziert heißt: zusätzliche Berechnung des z-Wertes für jedes Pixel +- Anwendung einer Write Pixel ZB-Prozedur: + - Wenn der z-Wert des aktuellen Pixels (im abzuarbeitenden Polygon) kleiner als der bereits abgespeicherte z-Wert ($z_p$) an dieser Position ist, wird im z-Buffer bei $x_p , y_p$ die Farbe sowie $z_p$ ) überschrieben (mit den neuen Werten). + - Sonst: alte Werte im Speicher bleiben erhalten +- Die näher an der Kamera liegen Pixel überschreiben somit die weiter weg liegenden. +- Pixelgenaue Sichtbarkeitsbestimmung und -behandlung der Polygone + +Berechnen der z-Werte durch lineare Interpolation: +- Die Tiefenwerte sind auch nach der Ansichten-Transformation (View-Transformation) zunächst nur für die Eckpunkte gegeben. +- Zunächst erfolgt die lineare Interpolation der z-Werte entlang der Polygonkanten $P_i P_j$ für die y-Position der gerade aktuellen Scanline +- Danach wird mit dem Füllen der Bildzeile (z.B. durch einen konventionellen Polygonfüll-Algorithmus) die Interpolation der z-Werte entsprechend der x-Position in der Scanline (Bildzeile) fortgesetzt (pixelgenaues Befüllen des z-Buffers). + +Berechnung der z-Werte eines Pixels x/y: +- Die y-Koordinate reicht zur Interpolation von $z_A$ und $z_B$ (Strahlensatz). +- Pixel-z-Wert $z_p$ wird äquivalent ermittelt, allerdings die Interpolationskoordinate jetzt x (y = const für die Rasterlinie) +- Die Werte $z_A, z_B, x_A, x_B$, in $z_p$ werden gleichzeitig mit den $x_A$-Werten (Schnitte) von einer Rasterlinie zur nächsten inkrementiert (s. Polygonfüllalgorithmus) +- Die Brüche bleiben in allen Ausdrücken rational. +- Die Ausdrücke für die z-Werte haben identische Form wie die der x-Werte beim Polygonfüllalgorithmus. + +Immer Ganzzahlarithmetik! (ähnlich wie x-Werte im Polygonfüllagorithmus) + +Beispiel: Mögliche Berechnungen eines Tiefenwertes der Pixel\\ +- Als Beispiel dient hier eine Tischplatte (Rechteck, Größe 3m x 1m) in der Perspektive +- Achtung: Eine lineare Interpolation der z-Werte im Bildraum (links) ist nicht wirklich korrekt! (höchstens als Näherung, OK für kleine nahe Flächen) +- $\frac{1}{z}$ kann exakt linear in x- & y-Richtung interpoliert werden (Abbildung rechts). +- Da $z_1$ abnimmt, wenn z zunimmt, muss aber der z-Test invertiert werden! +- positive Auswirkung: Tiefeninfos naher Obj. werden mit höherer z-Genauigkeit gespeichert als weiter von der Kamera entfernte. Statistisch gesehen gibt es damit weniger "z-Fighting“-Effekte (z.B. bei Bewegungen willkürliche Farbwechsel zwischen den Farben von Objekten mit nahezu der selben Tiefeninfo im z-Buffer). + +![Z-Buffer-Beispiel; Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Z-buffer-verfahren.png) + +- Das Ergebnis des Z-Buffer-Verfahrens ist vergleichbar mit dem Painters-Algorithmus. +- Es ist jedoch bei opaken Objekten keine vorgängige Sortierung der Polygone nötig. Sie können in beliebiger Reihenfolge gezeichnet werden. +- Die Interpolation der 1/z-Werte erfolgt im Polygonfüll-Algorithmus durch wenige Ganzzahl-Operationen (wie bei den x-Werten) +- Das Verfahren ist pixelgenau: Es werden auch zyklisch sich überlappende (und sogar räumlich sich durchdringende) Polygone korrekt dargestellt. +- Kaum Mehraufwand gegenüber dem 2D-Polygonfüllalgorithmus! +- Mögliches Problem: Korrekte Berücksichtigung von Transparenzen! + +### Transparenz +Alpha-Blending-Verfahren: +- Annahme: Verwendung eines Z-Buffers +- Mit dem Alpha-Blending-Verfahren kann die transparente Überlagerung zweier Objekte im Bildspeicher wie folgt gelöst werden + - $C_f$ Farbe des Objekts im Vordergrund (kleinster z-Wert), + - $\alpha$ Opazität der Vordergrundfarbe, Wert zwischen 0 und 1 (bzw. 100%), + - $C_b$ Hintergrundfarbe (die im Bildspeicher für das entsprechende Pixel zuletzt eingetragene Farbe) +- Die resultierende Farbe C ergibt sich zu: $C=\alpha*C_f+(1-\alpha)*C_b$ +- Für Alpha-Blending wird der Bildspeicher (mit z-Buffer) um den Opazitätswert $\alpha$ erweitert: + - Speicherbedarf pro Pixel typischerweise mindestens 48 Bit: R + G + B + Z + $\alpha$. + - Bei einer Auflösung des Bildschirms von 1.000.000 Pixel benötigen wir ca. 6MB Speicher. + - z-Wert und $\alpha$-Wert des Vordergrund Objektes werden nach dem Alpha-Blending in den Bildspeicher übernommen! + +![Transparenz Probleme](Assets/Computergrafik_Transparenz-Fehler.png) + +- Reines Z-Buffering (ohne $\alpha$) ignoriert alle Objektepixel, die weiter entfernt sind als vorn liegende Objektpixel (siehe rechts, hier ist die Reihenfolge egal). +- Bei Berücksichtigung von $\alpha$-Werten (Transparenzen) ist die Renderreihenfolge für korrekte Ergebnisse aber sehr wichtig! (siehe Mitte bzw. links) + +- Erläuterung zum Transparenz-Problem: + - Die Formel für $\alpha$-Blending berücksichtigt nur die Überlagerung des aktuellen Objektes mit dem davor existierenden Bildschirminhalt. Wird ein dazwischenliegendes Objekt nachträglich gezeichnet, dann kann die Farbe nicht korrekt bestimmt werden. Dies passiert aber beim Z-Buffering, da die Zeichenreihenfolge der Polygone beliebig ist. +- **Im Beispiel** + - Die opake grüne Kreisscheibe liegt zwischen dem hinteren Objekt (blau) und dem transparenten vorderen Objekt (rot), wird aber als letztes gerendert. → Grün kann Blau nicht mehr verdecken, denn Blau wurde zuvor schon mit Rot verrechnet (ist nun mit "vorderer" z-Koordinate im Z-Buffer hinterlegt). Dort, wo die grüne Kreisscheibe hinter dem transparenten Rot (bzw. dem nun Rot-Blau) liegt wird ein nicht korrekter Blauanteil gezeigt. Auch der weiße Hintergrund kann hinter dem transparenten Rot (insgesamt ein transparentes Rosa) nicht mehr vom Grün verdeckt werden! +- algorithmische Lösung des Problems: + - Zuerst: Darstellung aller opaken Objekte ($\alpha$ = 1) nach dem Z-Buffering (reihenfolgeunabhängig) + - Dann Sortieren aller semitransparenten Polygone nach der Tiefe und Zeichnen nach dem Painters-Algorithmus unter Berücksichtigung des Z-Buffers mittels Alpha-Blending! + - Restfehler: sich zyklisch überlappende oder sich durchdringende semi-transparente Flächen → exakte Behandlung durch die vorn beschriebenen Maßnahmen (Unterteilung der Polygone notwendig!) + +# Globale Beleuchtung +- BRDF: physikbasiertes, lokales Reflektionsmodell (Lichtquelle auf Material) → Funktion von Einfalls-, Betrachterwinkel, Wellenlänge (bzw. -breiche) +- Rendergleichung (Kajiya) = BRDF, Integral über alle Lichtquellen (bzw. Hemisphäre) +- Approximation durch lokales Phong-Beleuchtungsmodell → für "einfache" Materialien und Lichtquellen "korrekt genug" +- direkte (lokale) Schattierungsverfahren (Flat-, Gouraud- und Phong-Shading) +- Was noch fehlt: Interreflektionen zwischen Objekten... + - globale Beleuchtung, d.h. jede Fläche kann als Lichtquelle dienen + +## Ray-Tracing +einfaches Ray-Tracing: Strahlenverfolgung, nicht rekursiv +- Strahlen vom Augpunkt (Ursprung des Kamerakoordinatensystems) durch jedes Pixel des Rasters senden → keine Löcher +- Schnittpunktberechnung mit allen Objekten → Schnittpunkt mit dem größtem z-Wert stammt vom sichtbaren Objekt +- Strahlverfolgung (Anwendung des BRDF-Reziprozitätsprinzips) und Aufsummierung der (Lichtquellen-)Anteile aufgrund von material- und geometrieabhängigen Parametern (ggf. neben Relflektion auch Brechung) → Ergebnis: Helligkeits-/Farbwert pro Pixel +- Bestimmung der diffusen und spekularen Lichtreflexion nach dem Phong-Beleuchtungsmodell +- Bis hier nur einfache, lokale Beleuchtung (keine Spiegelung, Schatten, indirekte Beleuchtung)! → Vorzüge des RT kommen erst bei rekursivem Raytracing zum Tragen! + + +### Rekursiver Ansatz +- Berechnung von Sekundärstrahlen am Auftreffpunkt (Reflexions- und Schattenfühler) +- Annäherung der Interreflektionen (mehrfache Reflexion zwischen den Objekten) durch ideale Spiegelung, d.h. Spiegelung des primären Strahls an $\bar{n}$ im Auftreffpunkt und Erzeugung des sekundären Strahls +- beim Auftreffen des Strahls auf ein weiteres Objekt B Berechnung der diffusen und spekularen Reflexion der jeweiligen Lichtquelle (Schattenfühler, Phong-Modell) sowie Erzeugung eines weiteren Strahls durch ideale Spiegelung +- Addition der Sekundärstrahlen an Objekt B zum Farbwert des Pixel am Objekt A (Anteil bei jeder weiteren Rekursion meistens fallend, da reflektierter Anteil bei jeder Reflexion abgeschwächt wird) → Rekursion kann abgebrochen werden, wenn Beitrag vernachlässigbar! + + +### Brechungseffekte +Transparenz unter Berücksichtigung der Brechung beim Ray-Tracing: Richtung des gebrochenen Strahls berechnet sich aus dem Einfallswinkel zum Normalenvektor sowie den material- und wellenlängenabhängen Brechungsindices. +$$\eta_{e\lambda}*sin(\theta_e) = \eta_{t\lambda}*sin(\theta_t)$$ +Beispiel Luft-Glas: $\eta_{Luft, rot}*sin(\theta_{Luft})=\eta_{Glas,rot}*sin(\theta_{Glas}) \Rightarrow 1.0*sin(30°)=1.5*sin(\theta_{Glas})\rightarrow \theta_{Glas} \approx arcsin(\frac{sin(30°)}{1.5})\approx 20°$ + +![Brechungseffekt; Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Brechungseffekt.png) +Die Farbe im betrachteten Punkt wird nicht durch die Farbe von Hintergrundobjekt B1 (wie im Fall nichtbrechender Transparenz) sondern durch die Farbe von B2 beeinflusst! + +Berechnung des Einheitsvektors $\vec{V}_t(\vec{V}_e,n,\theta_t)$ in Richtung der Brechung: +- An Grenzflächen mit unterschiedlichen Brechungsindizes tritt neben der Transparenz ($\vec{V}_t$) auch Reflexion (Komponente mit der Richtung $\vec{V}_r$) auf. +- $\vec{M}$ ist ein Einheitsvektor (Länge=1) mit der Richtung von $\vec{n}*\cos(\theta_e)-\vec{V}_e$ und +- es gilt: $\vec{M}*sin(\theta_e)=\vec{n}*\cos(\theta_e)-\vec{V}_e \rightarrow \vec{M}=\frac{\vec{n}*\cos(\theta_e)-\vec{V}_e}{\sin(\theta_e)}$ +- Effekte an transparentem Material: + - Simulation brechungsbedingter Verzerrungen wird so möglich (z.B. bei optischen Linsen, Wasser). + - Transparentes und reflektierendes Material erzeugt 2 weiter zu verfolgende Sekundärstrahlen. + + + +### Erweiterungen +Unzulänglichkeiten des einfachen rekursiven Ansatzes: +- Reale Objekte sind eher diffus spekular, d.h. ein ganzes Set von Sekundärstrahlen wäre zu verfolgen. +- Die ideale Spiegelung zur Erzeugung von Sekundärstrahlen ist eine sehr starke Vereinfachung +- Aus der Umkehrbarkeit von Licht- und Beleuchtungsrichtung ließe sich eine Menge von Sekundarstrahlen aus dem Phong-Modell $(\cos^n(\theta)$-Term) ermitteln. +- Aus Aufwandsgründen (rein theoretisch wären unendlich viele Sekundärstrahlen zu berücksichtigen) muss vereinfacht werden, z.B. Monte-Carlo-Ray-Tracing + +**Monte Carlo Ray-Tracing**: +- Reflexion ist selten ideal spekular, meist entsteht ein Bündel von Strahlen +- Ansatz: Verfolgung mehrerer "zufälliger" Sekundärstrahlen, deren Beitrag zum Farbwert des Pixel statistisch gewichtet wird. +- Je gestreuter die Reflexion, um so mehr Sekundärstrahlen sind nötig. Sehr breite Remissionskeulen oder gar diffuse Interreflexionen sind wegen des Aufwandes nicht (bzw. nur schwer) behandelbar. + +Beleuchtungsphänomen Kaustik: +- Das Licht der Lichtquelle werde zuerst spekular, dann diffus reflektiert. Beispiel: Lichtstrahlen, die von Wasserwellen reflektiert auf eine diffuse Wand auftreffen. +- Vom Auge bzw. Pixel ausgehendes Ray Tracing versagt wegen des vorzeitigen Abbruchs der Rekursion am diffus remittierenden Objekt. +- Inverses Ray Tracing [Watt/Watt 1992] : Man erzeugt einen von der Lichtquelle ausgehenden Strahl und reflektiert diesen an glänzenden Oberflächen. Auch Photon Mapping kann hier helfen. +- Die reflektierten Lichtstrahlen wirken als zusätzliche Lichtquellen, die dann zu diffusen Reflexionen führen können. + +Optimierungsmöglichkeiten (einfache Hüllgeometrien, Raumzerlegung, ...): +- Berechnung von achsenparallelen Hüllquadern (Bounding Boxes) oder Hüllkugeln (Bounding Spheres) um Objekte aus mehreren Polygonen. + - Zunächst Test, ob der Strahl die Hülle schneidet und falls ja + - → Schnittpunktberechnung von Strahl mit allen Polygonen in der Hülle + - → zunächst Berechnung des Schnittpunktes mit der jeweiligen Polygonebene + - → danach effizienter Punkt-im-Polygon-Test +- Effiziente Zugriffsstruktur auf die Hüllquader: Bäume für rekursive Zerlegungen des 3D-Raumes (Octrees), Binary-Space-Partition-Trees +- Verwendung von direktem, hardware-unterstützten Rendering (z.B. Gouraud- oder Phong-Shading) anstelle von einfachem, nichtrekursivem Ray-Tracing, nur bei Bedarf Erzeugung von Sekundärstrahlen. +- Verwendung von Hardware mit RTX-Unterstützung + +### Zusammenfassung +Anwendung: +- Erzeugung realistischerer Bilder als bei lokalem Shading, da indirekte (spekuläre) Beleuchtungsphänomene physikalisch (geometr. und radiometr.) viel genauer als bei direkter Schattierung berechnet werden können. +- Ray-Tracing ist aufgrund der hohen Komplexität für interaktive Anwendungen (oft noch) wenig geeignet (hardware- und szenenabhängig), mögliche Lösung: Vorberechnung der Bildsequenzen im Stapel-Betrieb (batch mode) + - Fotorealistisches Visualisieren (Designstudien usw.) + - Computeranimation in Filmen +- Interaktive Programme (CAD, Spiele) verwenden noch eher direktes Rendering mit Texturen (shadow map, environment map) um Schatten, Spiegeleffekte oder Brechung zu simulieren. +- Aufwendige Teiloperation: Geometrischer Schnitt im Raum: + - für jedes Pixel: Berechnung des Schnittes eines Strahles mit potentiell allen Objekten der Szene (einfaches Ray-Tracing, ohne Rekursion) + - z.B. Bildschirm mit 1.000 x 1.000 Pixeln und 1.000 Objekten + - **Rekursives Ray-Tracing** für den ideal spiegelnden Fall: Anzahl der Operationen wächst zusätzlich, d.h. Multiplikation des Aufwandes mit der Anzahl der Reflexionen und Refraktionen und Lichtquellen (Schattenfühler) → für ca. 4 Rekursionsstufen bei 2 Lichtquellen haben wir etwa $4*(2 + 1) = 12$ Millionen Strahlen, was schon bei 1.000 Objekten 12 Milliarden Schnittoperationen bedeutet. + - **Monte-Carlo-Ray-Tracing** für die Approximation diffuser Anteile: Weiteres Anwachsen der Anzahl an erforderlichen Operationen durch zusätzliche Verfolgung sehr vieler Sekundärstrahlen (durchschnittlich 10 pro Reflexion) → Mehrere 100 Millionen bis Milliarden Strahlen (bzw. Billionen Schnittoperationen) + - Durch **effiziente räumliche Suchstrukturen** kann die Anzahl der tatsächlich auszuführenden Schnittoperationen wesentlich reduziert werden. Die Anzahl der Schnitte steigt nicht mehr linear (sondern etwa logarithmisch) mit der Anzahl der Objekte (siehe räumliche Datenstrukturen). Damit ist auch bei großen Szenen nur noch die Anzahl der Strahlen wesentlich → je nach Bildauflösung und Verfahren, mehrere Millionen bis Milliarden Strahlen! +- Eigenschaften des Ray-Tracing-Verfahrens: + - Implementierung ist konzeptionell einfach + einfach parallelisierbar. + - Hohe Komplexität durch Vielzahl der Strahlen, deshalb meistens Beschränkung auf wenige Rekursionen. + - Exponentielle Komplexität bei Monte-Carlo-Ray-Tracing bzw. wenn alle Objekte gleichzeitig transparent (Brechung) und reflektierend sind. +- Resultat: + - RT ist sehr gut geeignet, wenn die spiegelnde Reflexion zwischen Objekten (und/oder die Brechung bei transparenten Objekten) frei von Streuung ist. + - Die diffuse Reflexion zwischen Objekten wird beim Ray-Tracing durch ambiente Terme berücksichtigt. Eine bessere Beschreibung dieser Zusammenhänge ist mit Modellen der Thermodynamik möglich. +- Weitere Ansätze: + - Cone-Tracing - statt eines Strahles wird ein Kegel verwendet, der die Lichtverteilung annähert [Watt/Watt 1992]. + - Radiosity (siehe Abschnitt weiter unten) + - Photon Mapping (nächster Abschnitt) + +## Photon Mapping +- Verfahren von Henrik Wann Jensen 1995 veröffentlicht +- angelehnt an Teichencharakter des Lichts +- 2-stufiges Verfahren +- Quelle: Vorlesung von Zack Waters, Worcester Polytechnic Inst. + +![Photonmapping; Quelle Vorlesung Computergrafik 2020](Assets/Computergrafik_Photonmapping.png) + +1. Phase: Erzeugung der Photon Map + 1. Photonenverteilung in der Szene: Von der Lichtquelle ausgestrahlte Photonen werden zufällig in der Szene gestreut. Wenn ein Photon eine Oberfläche trifft, kann ein Teil der Energie absorbiert, reflektiert oder gebrochen werden. + 2. Speichern der Photonen in der Photon Map Daten enthalten also u.a. Position und Richtung beim Auftreffen sowie Energie für die Farbkanäle R,G,B + - Photon wird in 3D-Suchstruktur (kd-Baum) gespeichert (Irradiance cache) + - Reflektionskoeffizienten als Maß für Reflektionswahrscheinlichkeit (analog Transmissionswahrscheinlichkeit) + - dafür: Energie bleibt nach Reflexion unverändert. Neue Richtung wird statistisch auf Basis der BRDF gewählt. +2. Phase: Aufsammeln der Photonen aus Betrachtersicht (gathering) + - Verwende Ray-Tracing um für den Primärstrahl von der Kamera durch einen Pixel den Schnittpunkt x mit der Szene zu bestimmen. Basierend auf den Informationen aus der Photon Map werden für x folgende Schritte ausgeführt: + 1. Sammle die nächsten N Photonen um x herum auf durch Nächste-Nachbar-Suche in der Photon Map (N = konst., z. B. 10) + 2. S sei die (kleinste) Kugel, welche die N Photonen enthält. + 3. Für alle Photonen: dividiere die Summe der Energie der gesammelten Photonen durch die Fläche von S (→ Irradiance) und multipliziere mit der BRDF angewendet auf das Photon. + 4. Dies ergibt die reflektierte Strahldichte, welche von der Oberfläche (an der Stelle x) in Richtung des Beobachters abgestrahlt wird. + +## Radiosity +Grundprinzip des Radiosity-Verfahrens: +- Ansatz: Erhaltung der Lichtenergie in einer geschlossenen Umgebung +- Die Energierate, die eine Oberfläche verlässt, wird Radiosity (spezifische Ausstrahlung) genannt. +- Die gesamte Energie, die von einer Oberfläche (Patch, Polygon) emittiert oder reflektiert wird, ergibt sich aus Reflexionen oder Absorptionen anderer Oberflächen (Patches, Polygone). +- Es erfolgt keine getrennte Behandlung von Lichtquellen und beleuchteten Flächen, d.h. alle Lichtquellen werden als emittierende Flächen modelliert. +- Da nur diffuse Strahler (Lambertstrahler) betrachtet werden, herrscht Unabhängigkeit der Strahldichte vom Blickwinkel vor. +- Die Lichtinteraktionen werden im 3D-Objektraum (ohne Berücksichtigung der Kamera) berechnet. +- Danach lassen sich beliebig viele Ansichten schnell ermitteln (Ansichtstransformation, perspektivische Projektion, Verdeckungsproblematik, Interpolation). + +Die gesamte von Patch $A_s$ stammende Strahldichte an der Stelle von $dA_r$ ist: $L_r=\beta_r(\lambda)*\int_{A_s}\frac{L_s}{\pi * r^2}*\cos(\theta_s)*\cos(\theta_r)*dA_s$ (s=Sender, r=Reveiver) +![Radiosity; Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Radiosity.png) + +Für das Polygon $A_r$ ist die mittlere Strahldichte zu ermitteln! +$$L_r=\beta_r(\lambda)*\frac{1}{A_r}*\int_{A_r}\int_{A_s}\frac{L_s}{\pi*r^2}*\cos(\theta_s)*\cos(\theta_r)*dA_s*dA_r$$ +Die Geometrieanteile aus dieser Gleichung werden als Formfaktoren bezeichnet (+Sichtbarkeitsfaktor $H_{sr}$). +$$F_{sr}=\frac{1}{A_R}\int_{A_r}\int_{A_s}\frac{\cos(\theta_s)*\cos(\theta_r)}{\pi*r^2}*H_{sr}*dA_s*dA_r, H_{sr}=\begin{cases}1\rightarrow A_s \text{ sichtbar}\\ 0\rightarrow A_s \text{ unsichtbar}\end{cases}$$ +Für Flächen, die klein im Verhältnis zu ihrem Abstand sind, ergibt sich eine Vereinfachung des Formfaktors. In diesem Fall können die Winkel $\theta_s,\theta_r$ und Radius r über den zu integrierenden Flächen als konstant (Mittelwerte) angenommen werden. +$$F_{sr}=A_S \frac{\cos(\theta_s)*cos(\theta_r)}{\pi*r^2}*H_{sr}$$ + +Bei dicht benachbarten Flächen gelten die obigen, vereinfachenden Annahmen u.U. nicht mehr. Es müsste exakt gerechnet oder in diesen Bereichen feiner untergliedert werden. +Wird statt $\beta \lambda \beta$ vereinfachend ein konstanter Remissionsfaktor R (R diff im monochromatischen Fall oder $R_{diff R}, R_{diffG}, R_{diffB}$ für die drei typischen Farbkanäle) eingeführt, so ergibt sich zwischen der Strahldichte $L_r$ der bestrahlten Fläche und der Strahldichte $L_s$ der bestrahlenden Fläche der folgende Zusammenhang: $L_r=R_r*F_sr*L_s$ + +Jedes Patch wird nun als opaker Lambertscher (d.h. ideal diffuser) Emitter und Reflektor betrachtet (d.h. alle Lichtquellen werden genauso wie einfache remittierende Flächen behandelt, allerdings mit emittierendem Strahldichte-Term $L_{emr}$). $L_r=L_{emr}+R_r*\sum_S F_{sr}*L_s$ + +Es ergibt sich schließlich als Gleichungssystem: +$$ \begin{pmatrix} 1-R_1F_{11} & -R_1F_{12} &...$ -R_1F_{1n}\\ 1-R_2F_{21} & -R_2F_{22} &...$ -R_2F_{2n}\\ \vdots & \vdots & \ddots & \vdots \\ 1-R_nF_{n1} & -R_nF_{n2} &...$ -R_nF_{nn}\end{pmatrix}*\begin{pmatrix}L_1\\L_2\\\vdots\\L_n\end{pmatrix} = \begin{pmatrix} L_{em1}\\L_{em2}\\\vdots\\L_{emn}\end{pmatrix}$$ +Das Gleichungssystem ist für jedes Wellenlängenband, das im Beleuchtungsmodell betrachtet wird, zu lösen ($R_r, R_{rR}, R_{rG}, R_{rB}, L_{emr}$ sind im Allgemeinen wellenlängenabhängig). + +### Adaptives Refinement +Adaptives Radiosity-Verfahren: +- vereinfachte Formfaktor-Berechnung ist ungenau bei eng beieinander liegenden Flächenstücken (z. B. in der Nähe von Raumecken), oder bei kontrastreichen Übergängen) +- deshalb adaptive Unterteilung solcher Flächen in feinere Polygone + +Im adaptiven Radiosity-Verfahren werden deshalb große Flächen (insbesondere dort wo Flächen relativ hell sind im Vergleich zur Nachbarfläche → kontrastreiche Übergänge) unterteilt. Die Notwendigkeit wird durch erste Berechnung mit grober Unterteilung geschätzt. + +### Progressive Refinement +- das Radiosity-Verfahren ist sehr aufwendig (Bestimmung aller Formfaktoren, Anwendung des Gauß-Seidel-Verfahrens zum Lösen des Gleichungssystems) +- jedoch viel weniger Samples als Monte-Carlo-Raytracing (1 mal pro Kachel-Paar mal Anzahl Interationen)! +- beim progressive Refinement ist die inkrementelle Approximation des Ergebnisses des exakten Algorithmus durch ein vereinfachtes Verfahren wünschenswert +- ein entsprechender Algorithmus, der die Patches einzeln behandelt, stammt von Cohen, Chen, Wallace und Greenberg +- akkumuliert mehr Energie in jedem Schritt, verletzt Gleichgewicht der Strahlung → Korrektur notwendig: + $L_r^{k+1}=L_{emr} + R_r*\sum_s F_{sr}* L_s^k$ + + +### Radiosity Eigenschaften +- ausschließlich Berücksichtigung der diffusen Reflexion +- blickwinkelunabhängig, direkt im 3D-Raum arbeitend +- realistische Schattenbilder, insbesondere Halbschatten (viele, bzw. flächig ausgedehnte Lichtquellen) +- sehr rechenintensiv, deshalb meist Vorausberechnung einer Szene in 3D +- → Beleuchtungsphänomene wie z.B. indirektes Licht (besonders augenfällig in Innenräumen, Museen, Kirchen, Theaterbühnen usw.) sind mit Radiosity sehr gut/realistisch darstellbar. +- → die Kombination von Radiosity und Ray Tracing (und ggfs. anderen Verfahren/Filtern etc) ermöglicht computergenerierte Szenen mit sehr hohem Grad an Realismus. + +## Zusammenfassung +- BRDF für physikbasierte, lokale Berechnung der Reflexion von Lichtquellen als Funktion von Einfallswinkel und Betrachterwinkel (evtl. wellenlängenabhängig, oder einfach durch RGB) +- Rendergleichung (Kajiya) = BRDF, Integral über alle Lichtquellen (bzw. Hemisphäre) +- für indirekte Beleuchtung / Global Illumination: (verschiedene algorithmische Verfahren unter Verwendung der lokalen Beleuchtung (BRDF) + - (rekursives) Raytracing (einfache Spiegelung, Brechung, Schatten) + - Monte Carlo RT, (gestreute Spiegelung, diffuse Reflexion), Backward Ray Tracing (Kaustik), Photon Mapping → jedoch extrem rechenaufwendig!) + - Radiosity (indirekte diffuse Reflexion – sichtunabhängige Voraus-berechnung in 3D für statische Szenen) +- verschiedene Verfahren können kombiniert werden um die globale Beleuchtungsphänomene effizienter zu berechnen. – z. B. Radiosity + Ray Tracing: Indirekte diffuse Beleuchtung + Spiegelung und Schatten, etc. + +# Texture Mapping +## Bildbasiertes Rendering +### Überblick +- typische Anwendung: Applizieren von 2D-Rasterbildern auf 3D-Modellen + - Beispiele: Hausfassade, Holz-, Marmor-, Steintexturen, Tapeten, Stoffe etc. +- 3D-Objekte mit relativ einfachen Polygonen modelliert. - Details als Texturen, (d.h. als Raster-Bilder) – gelegentlich "Impostor" genannt. +- Texture-Mapping als Erweiterung des einfachen Pattern-Filling (siehe. Polygonfüllalgorithmus) +- als Verallgemeinerung auch Image-based Rendering genannt +- Verwendung unterschiedlicher 3D-Transformationen und Beleuchtungsarten + - Spezielle Effekte! (Reflexionen, Schatten, ..) + +Erzeugung von Texturen: +- "reale" Texturen aus realen rasterisierten/digitalen Fotografien (aus Pixeln = "Picture-Elementen" werden Texel = "Texturelemente") vs. +- "berechnete" Texturen → synthetische Computergrafik-Bilder: + - vorberechnete reguläre Texturen (basieren auf Texeln) vs. + - nach Bedarf erzeugte statistische bzw. prozedurale Texturen (Absamplen von mathematischen Beschreibungen, ggf. beliebig genau) + +Anwendung von Texturen - Grundprinzipien: +- Transformation des Texturraums in den Bildraum der Darstellung: Verwendung unterschiedlicher geometrischer Transformationen (je nach Anwendungszweck) +- Resampling: transformiertes Texturraster wird aufs Bildraster "gerundet" +- Filtern: Verhindern/Abmildern von resampling-basierten Aliasing-Effekten +- Beleuchtung: RGB-Werte der Textur dienen als Materialattribute bei der Beleuchtungsrechnung + +Unterschiedliche Arten des Texturmappings (Transformationsfunktion): +- Parametrisches Mapping: Ein Rasterbild wird auf ein 3D-Polygon aufgebracht, indem man den Eckpunkten (x,y,z) des Polygons 2D-Texturkoordinaten (u,v) explizit zuordnet. + - affines Texturmapping: direkte affine Abbildung der Textur auf projizierte Polygone im Bildraum + - perspektivisches Texturmapping: Zwischenabbildung der Textur in den 3D-Objektraum und perspektivische Projektion in den Bildraum +- Projektives Texturmapping: Verwendung unterschiedlicher Projektionsarten (parallel, perspektivisch, eben, zylindrisch, sphärisch) +- Environment-Mapping: Spiegelung der Textur an der Oberfläche (bzw. Refraktion) mit entsprechender Verzerrung + - Transformation abhängig von Kameraposition! + +### Affines Texturemapping +Durch Zuordnung von 3 Punkten im Bildraster zu den entsprechenden 3 Punkten im Texturraster erhält man ein Gleichungssystem mit 6 Gleichungen und 6 Unbekannten $(a_u , b_u , c_u , a_v , b_v , c_v )$: +- $P_1: u_1=a_u*x_1+b_u*y_1+c_u; v_1=a_v*x_1+b_v*y_1+c_v$ +- $P_2: u_2=a_u*x_2+b_u*y_2+c_u; v_2=a_v*x_2+b_v*y_2+c_v$ +- $P_3: u_3=a_u*x_3+b_u*y_3+c_u; v_3=a_v*x_3+b_v*y_3+c_v$ + +Für jedes Pixel(x,y) im Polygon: Resampling der Textur(u,v) bei der Rasterkonvertierung (Polygonfüllalgorithmus) + +Für jedes Pixel(x,y) finde die Texturkoordinaten(u,v), d.h.: +- Rückwärtstransformation vom Ziel zum Original → keine Löcher im Bild! +- ABER: Texturkoordinaten können übersprungen oder wiederholt werden! +- Störsignale (Aliasing) → Filterung notwendig! + +Affines Mapping der Vertices x,y auf u,v → lineare Interpolation der u/v-Texturkoordinaten zwischen den Vertices für jedes Pixel (ähnlich wie RGB- bzw. Z-Werte im Polygonfüllalgorithmus, durch Ganzzahlarithmetik) + +![Affines Texturmapping; Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Affines-Texturmapping.png) + +Problem: Durch affine 2D-Abbildungen können nur Transformationen wie Rotation, Skalierung, Translation, Scherung in der Bild-Ebene abgebildet werden, aber keine Perspektive! → Abbildungsfehler zwischen den Eckpunkten! (kleine Dreiecke → kleiner Fehler!) + +### Perspektivisches Texture-Mapping +Beispiel: affine 3D-Abbildung der Textur per 4x4-Matrix auf 3D-Modell: +Texturraum → Objektraum: Rotation, Translation, Skalierung (...) dann Objektraum → Bildraum: Projektion (selbe wie bei Geometrieprojektion) + +![Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Perskeptivisches-Texture-Mapping.png) + +entspricht affinem Textur-Mapping mit einem zusätzlichen Zwischenschritt, der Bestimmung der Objektraumkoordinaten: +- Matrix $M_{to}$: Koordinatentransformation vom Texturraum in den 3D- Objektraum (affine Abb.: 3D-Translation, -Rotation, -Skalierung) +- Matrix $M_{oi}$ : Koordinatentransformation vom Objektraum in den Bildraum (Kameratransformation, perspektivische Abbildung) +- Matrix $M_{ti}$: gesamte Koordinatentransformation vom Texturraum direkt in den Bildraum: $M_{ti} = M_{to}*M_{oi}$ +- Matrix $M_{ti}^{−1}$: Inverse Koordinatentransformation vom Bildraum zurück in den Texturraum + +→ 4x4-Matrix für homogene Koordinaten. Perspektivische Abbildung im Bildraum durch Division durch z, für jedes Pixel (wesentlich aufwendiger als lineare Interpolation) + +Vergleich: Perspektivisches / Affines Texture Mapping: +- perspektivisches Textur-Mapping liefert auch bei perspektivischer Ansicht geometrisch korrekte Bilder +- etwas höherer Berechnungsaufwand pro Polygon, da für jedes Polygon zwei Transformationsmatrizen und eine inverse 4x4-Matrix bestimmt werden müssen +- wesentlich höherer Berechnungsaufwand pro Pixel: Matrixmultiplikation plus (floating-point) Division! +- bei affinem Textur-Mapping können hingegen einfach die Texturkoordinaten (u/v) zwischen den Polygonecken linear interpoliert werden: + - ähnlich wie bei anderen Attributen (z. B. x-Koordinate (s. Edge-Scan), r/g/b-Werte (s. Gouraud-Shading), Tiefenwerte (1/z) funktioniert dies inkrementell und mit Ganzzahlarithmetik (als Teil des Polygonfüllalgorithmus) + - je kleiner die Polygone im Bild, desto kleiner der Fehler beim affinen Texturemapping (Ansatz: feinere Unterteilung der Polygone in kleinere Dreiecke → dafür jedoch mehr Polygone!) + +### Textur-Mapping mit Polygon-Schattierung +Eingliederung in die Render Pipeline +- Bestimmung der zum Polygon gehörenden sichtbaren Pixel im Bildraum (Polygonfüllalgorithmus) +- Ermittlung der zur jeder Pixelkoordinate gehörenden Texturkoordinate mit Hilfe der inversen Transformationsmatrix $M_{ti}_{−1}$ +- Ermittlung der Farbe des zu setzenden Pixels aus dem Texturraster (und gegebenenfalls weitere Schattierung aus der Beleuchtungsrechnung) +- Beleuchtungsrechnung, z.B.: Multiplikation der Helligkeit einer beleuchteten diffusen weißen Oberfläche mit den r/g/b-Werten der Textur (Lambert Modell) + + +### Weitere Texturarten +- Texturen mit Transparenz: RGBA-Wert zu jedem Pixel gespeichert, d.h. beim Rendern wird Alpha Blending mit der Hintergrundfarbe angewendet +- Video Texture: zeitlich veränderliche Textur, d.h. dynamische Veränderungen wie z.B. Feuer, Rauch (mit Alpha-Blending über Hintergrund / Billboard) oder Fernseher in der Wohnung mit Programm“ (ohne Alpha-Blending) +- Solid Textures: + - Textur als 3D-Array (u/v/w-Koordinaten, bzw. Voxel) → gespeicherte RGB(A)-Werte pro Voxel + - Abbildung über affine 3D-Transformation xyz auf uvw + - beim Rendern entweder auf Vertices angewendet und dann für Pixel linear interpoliert oder für jedes Pixel einzeln angewendet (Pixelshader) + - Anwendungsbsp.: Schnitt durch Material (z.B. Massivholz, Marmor) oder Volume Rendering (Überlagerung von Schichten) mit Alpha Blending, z.B. Computertomoraphie (CT-Daten) + - ggfs. auch Videotextur als Spezialfall einer Solid Texture: Zeit als 3. Dim. + +### Projektives Textur-Mapping +Berechnung der Texturkoordinaten aus der aktuellen Position der einzelnen Polygone (Analogie: Projektion eines Diapositivs auf ein räumliches Objekt) + +Beispiel: Parallelprojektion mit fixer Position des Projektors zum Objekt +- 2D-Textur (Bsp. Gitter aus Millimeterskalen) +- Parallelprojektion der Textur auf einen Zylinder mit abgeschrägten Endflächen +- Projektion ist relativ zum Objekt definiert, d.h. die Textur bewegt sich mit dem Körper, sofern man diesen bewegt +- markierte Bereiche (1 bzw. 2) haben auf Zylinder stets identische Positionen +- keine explizite Zuordnung von uv-Koordinaten zu Polygoneckpunkten notwendig, weniger Modellieraufwand! + +Anwendungsbeispiele für projektives Textur-Mapping (Parallel- oder Zentralprojektion): +- Darstellung geometrischer Eigenschaften (geometrische Details, parallel, fixe Position des Projektors zum Objekt, senkrecht zur Fläche) +- einfache Darstellung von Parameterlinien (sofern die Textur senkrecht auf die Projektionsebene projiziert wird, parallel, fixiert bezgl. Objekt) +- Simulation eines Lichtkegels (Repräsentation der Leuchtdichteverteilung der Lichtquelle (Lichtfeld) als Rasterbild in einer Textur, zentral, fix in Weltkoordinaten) + +Zylindrisches Textur-Mapping: +- radiale Projektion der Textur-Koordinaten auf eine Zylinderoberfläche +- visueller Effekt für zylinderähnliche Objekte ähnlich zu parametrischem Textur-Mapping, z.B. Etikett auf Flasche, Dose, etc. + +Sphärisches Textur-Mapping: +- Zentralprojektion der Textur-Koordinaten auf eine Kugeloberfläche +- Vorteil des projektiven Texturmappings: Eine explizite Zuordnung der 3D-Punkte zu Texturkoordinaten mit stetiger Fortsetzung der Parametrisierung an den Polygongrenzen entfällt → weniger Modellieraufwand! + +### Environment Mapping +Spezialfall des projektiven Textur-Mapping: +- Simulation der Reflexion der Umgebung an einer reflektierenden Fläche +- Darstellung abhängig von der Position des Betrachters sowie von den Normalen der reflektierenden Fläche +- Textur entspricht der Lichtquelle für die Beleuchtung durch die Umgebung (Environment Map): Sphere Map bzw. Cube Map + +Mapping der Textur auf die spiegelnde Oberfläche: +- Aussenden eines Strahls vom Auge auf einen Punkt der spiegelnden Oberfläche +- Ermittlung der Reflexionsrichtung entsprechend dem Einfallswinkel des Strahl zur Flächennormale +- damit Bestimmung des zu reflektierenden Punktes in der Umgebung, d. h. des entsprechenden Textur-Pixels aus der Environment Map + +Grundannahme beim Environment Mapping: +- relativ große Entfernung der reflektierten Objekte von der spiegelnden Fläche + +Erzeugung einer Cube Map-Textur: +- Aufteilung der Environment Map in sechs Bereiche, die den sechs Flächen eines Würfels um die spiegelnde Fläche herum entsprechen +- Rendern der Umgebung sechs mal mit einem Kamera-Sichtfeld von jeweils 90 Grad aus dem Mittelpunkt des Würfels +- Alternativ: Digitale Aufnahme und Einpassen der sechs Flächen mittels Image Warping in die jeweiligen Zonen der Environment Map +- Strahlverfolgung: Sehstrahl wird an den Eckpunkten des Objekts (entsprechend den Normalen) gespiegelt und dreidimensional mit den 6 Wänden der Cube Map geschnitten. +- Daraus ergibt sich eine Zuordnung von Objektkoordinaten (x/y/z) und Texturkoordinaten (u/v). +- Die Transformation kann wie beim perspektivischen Texturmapping berechnet werden und beim Rasterisieren für die dazwischen liegenden Pixel angewendet werden. +- Effekt ähnlich wie bei Raytracing, jedoch geometrisch angenähert (gespiegelte Objekte sind nur als 2D-Raster-Bild repräsentiert) +- keine aufwändigen Strahl-Objektschnitte (wie beim Raytracing) notwendig (Sehstrahl wird von den dargestellten Dreiecksecken zurückgerechnet!) +- Näherung wird ungenau, wenn das spiegelnde Objekt weit weg ist von der Kameraposition, welche für die Generierung der Cube-Map verwendet wurde +- nur Einfachreflexion +- Cube Maps können dynamisch (durch Offline-Rendering in Texturbuffer) generiert werden. Dadurch auch bewegte gespiegelte Objekte in Echtzeit darstellbar +- Beachte: gespiegeltes Dreieck kann auf zwei oder mehrere Wände der Cube Map fallen. Dies kann durch mehrfaches Mapping und Clipping gelöst werden. + +Environment Mapping [Haeberli/Segal 1993] für Kugel und Torus: +- Unterschiedliche Ausrichtung der Objektoberfläche sorgt für korrekte Verzerrung der spiegelnden Objekte. Die Darstellung der spiegelnden Objekte (Geometrie und Material) steht beim Environment-Mapping im Vordergrund und nicht die korrekte geom. Darstellung gespiegelter Objekte! +- Alle Raumrichtungen werden auf der Kugeloberfläche abgebildet. Je nach Aufnahmegeometrie mehr oder weniger großer blinder Fleck“ hinter der Kugel. + +![Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Environment-Map-Kugel.png) + +Erstellung einer Spherical-Environment-Map-Textur: +- spiegelnde Kugel in der Mitte einer Szene +- Fotografie der Kugel mit einer Kamera sehr großer (unendlicher) Brennweite aus großem (unendlichem) Abstand (parallele Projektionsstrahlen) +- Entstehung einer kreisförmigen Region in der Textur-Map mit den Tangenten jeweils an den Außenkanten +- Texturwerte außerhalb des Kreises werden nicht benötigt +- Wahl der Blickrichtung(-en) wichtig für spätere Anwendung! + +Anwendung einer Spherical Environment Map: +- Zur Bestimmung der Texturkoordinate eines dargestellten Punktes wird zuerst die Normale n an diesem Punkt bestimmt. +- Die Normale n wird auf die x/y- Ebene projiziert. Die Koordinaten des projizierten Normalenvektors entsprechen den Texturkoordinaten in der Sphere Map, welche die an dieser Stelle reflektierte Umgebung zeigt. +- Merke: Die Reflexion ist nicht von der Lage des reflektierenden Punktes abhängig (nur von der Normalenrichtung). + +Environment Map in latitude-/longitude-Koordinaten: +- Spiegelung wird aus Richtung des gespiegelten Strahls in Winkelkoordinaten (lat/long) berechnet +- entweder pro Pixel (Pixel-Shader) oder pro Vertex mit anschließender (linearer) Interpolation pro Pixel +- keine Berücksichtigung der Position des spiegelnden Objekts +- korrekt nur für unendlich entfernte gespiegelte Objekte → geeignet zur Spiegelung weit entfernter Objekte (Landschaften, große Räume auf relativ kleinen Objekten) + + +High-dynamic Range Imaging (HDRI) Env-Maps: +- enthalten "gesamte Dynamik" des Lichts (als Floating Point Farbwerte) + - Wesentlich realistischere Bilder! +- Tone Mapping: berechnete HDRI-Bilder werden anschließend auf die Dynamik des Monitors reduziert +- Refraktion / Brechung mit Environment Maps: + - wie Spiegelung, jedoch Sekundärstrahl aus Sehstrahl über Brechungsindex und Oberflächennormale, statt gespiegelt + - Beispiel: Glas als Polygonflächen mit Rückseite + Normalen (2-fache Brechung!) + Spiegelung als Multi-Pass (Überlagerung zweier Effekte) + - kann im Zusammenhang mit Cube-Maps, Spherical oder Lat/Long Environment Maps angewendet werden + + +## Mip-Mapping +Was? aus Originaltextur Bildung einer Menge jeweils kleinerer Texturen (halbe Kantenlänge) + +Wozu? Vermeidung/Abmilderung von Aliasing-Effekten durch "Vorfilterung" und Anwendung der passend aufgelösten Textur(-en) (1 Pixel ≈ 1 Texel) per bilinearer Filterung oder trilinearer Filterung + +### Sampling-Artefakte +Aliasing-Effekte durch Koordinatentransformation: +- Pixel der Textur und Pixel des dargestellten Bildes weisen (aufgrund der Bildtransformation) im Allgemeinen unterschiedliche Rastergrößen auf. +- simpler Ansatz: Berechnung der transformierten Texturkoordinaten als Floating-Point-Werte und Rundung auf ganze Zahlen +- bei inverser Transformation vom Zielbild zurück zur Textur dann keine Lücken im Bild, aber die Pixel der Textur können ausgelassen oder mehrfach verwendet werden (Bildpixel werden genau einmal angewendet) +- durch das Resampling der Textur auf das resultierende Bildraster entstehen oft Aliasing-Artefakte + +Zwei wesentlich unterschiedliche Situationen: +- Abbildung mehrerer Texturpixel auf ein Bildpixel (Unterabtastung) oder +- Abbildung eines Texturpixels auf mehrere Bildpixel ( Überabtastung) + - Filteroperationen zur Interpolation der Bildpixel-Färbung in jedem Fall notwendig, insbesondere bei der Unterabtastung wird ein vorheriges Tiefpassfiltern und Resampling notwendig! + - Ansonsten Verletzung des Abtasttheorems / Nyquistfrequenz! + +Beispiel perspektivische Verkürzung der Schachbretttextur: +- in Realität eigentlich starke Verkleinerung der Textur bei größerer Entfernung! +- → Moiré Muster - Originaltextur ist an diesen entfernten Stellen im Bild zur Laufzeit nicht mehr erkennbar (Unterabtastung, aus mehreren Texeln, welche "hinter einem Pixel liegen“, wird nur einer ausgwählt) + - Treppenstufen im Nahbereich resultieren aus Überabtastung (mehrere Pixel teilen selben Texel) +- Lösung: Textur muss vorher passend durch Tiefpassfilter in der Auflösung reduziert werden → Aufbau und Anwendung einer Mip-Map +- Ziel der Mip-Map: stets 1 Texel pro Pixel bereitstellen + + +### Aufbau +- In 3D-Szenen können Körper mit der selben Textur vom Betrachter unterschiedlich weit weg sein. → im Bild oft Unterabtastung (Minification) oder Überabtastung (Magnification) und entsprechende Aliasing-Effekte durchs Resampling! +- Ansatz: Vorberechnung derselben Textur für verschiedene Entfernungen + - Stufe 1: volle Auflösung + - Stufe 2: halbe Auflösung in jeder Richtung $(1/2)$ + - ... + - Stufe k: Auflösung $(1/2)^k$ + - Stufe n: niedrigste Auflösung (je 1 Pixel für z.B. R, G und B) +- Speicherbedarf: + - (hypothetische) Annahme: Anordnung im Array (getrennt f. RGB) → Alle niedrigen Auflösungen verbrauchen zusammen nur ein Viertel des Speicherplatzes + - Mip steht für lat. multum in parvo = viel (Information) auf wenig (Speicherplatz) + - niedrige Auflösungsstufen werden durch Filterung aus den höheren berechnet: + - einfach: z.B. Mittelwert aus 4 Pixeln (Box-Filter) oder + - aufwendiger: z.B.: Gaußfilter (siehe Kap. Bildverarb.) + +### Anwendung +- Beispiel: OpenGL-Filteroperationen im Bildraum (zur Laufzeit ausgeführt): + - GL_NEAREST: Annahme des Wertes des nächstliegenden Textur-Pixels + - GL_LINEAR: bilineare Interpolation: gewichteter linearer Durchschnitt aus einem 2x2-Feld der am nächsten liegenden Texturpixel +- Genauere Interpolationsverfahren (z.B. bikubisch) gelten als zu aufwendig für Echtzeitanwendung +- Beispiel für stark vergrößerte Textur: + - Aus der Nähe betrachtet, wird das Texturraster auf dem Bildraster entsprechend skaliert (vergrößert). + - durch Runden der Texturkoordinaten (d.h. ohne Filterung) + - mit bilinearem Filter gewichtete Texturfarbwerte proportional zum Abstand vom gerundeten Koordinatenwert + +### Zusammenfassung +Aufbau der Mip-Map (als Vorverarbeitungsschritt beim Rendering): +- Speicherung der Originaltextur +- rekursive Speicherung der geringer aufgelösten Texturen (je 1/2 Kantenlänge) bis hinunter zu einem einzelnen Pixel + +Vorteile: +- Filter-Operationen können bei Initialisierung der Textur vorausberechnet werden +- nur ein Drittel zusätzlicher Speicherplatzbedarf + +Darstellung mit Mip-Map Texturen (zur Laufzeit) +- Auswahl der passenden Auflösungsstufe k Skalierung berechnet aus der Entfernung zum Betrachter und der perspektivischen Verkürzung (siehe Kameratransf.): $d/z = (1/2)^k \rightarrow k = log_2(z)-log_2(d)$ +- Transformation der Pixel zwischen den Textur-Eckkoordinaten der gewählten Auflösung auf das Polygon im Bildraum +- typ. Verwendung der linearen Filter zur Vermeidung von Aliasing-Effekten durch Trilineare Filterung: zusätzlich zu bilinearem Filteren in einer Mip-Map-Stufe wird linear gewichtet zwischen zwei Mip-Map-Stufen (auf-, bzw. abgerundete Werte von k) interpoliert: z. B. wenn $k = 2.3 \rightarrow 30\% Anteil_{k=3}$ und $70\% Anteil_{k=2}$ + + +### Anti-Aliasing +Anti-Aliasing durch trilineare Filterung: +- Durch die perspektivische Verkürzung wird eine weiter hinten liegende Textur verkleinert und im Vordergrund vergrößert. Bei einer Skalierung kleiner als 1 überspringt die gerundete inverse Texturtransformation Pixel in der Textur (minification). Die im Bildraum gesampelten Texturpixel werden somit "willkürlich" ausgewählt. Dadurch können Treppenstufen und Moiré-Muster entstehen (Aliasing-Effekt: linkes Bild). Durch Mip-Mapping werden an diesen Stellen geringer aufgelöste (gefilterte) Texturen verwendet (Rechtes Bild: Mit Mip-Mapping und tri-linearer Filterung wird ein Anti- Aliasing-Effekt erreicht) +- Vergrößerte Darstellung: Trilinearen Filterung = lineare Filterung zwischen den zwei aufeinander-folgenden (am besten passenden) Mip-Map-Stufen + bilineare Filterung in jeder der beiden Stufen. → Kantenglättung, Tiefpassfilter (Mittelwert / hier Grauwerte) + +![Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Mapping-Anti-Alising.png) + +### Rip-Maps +Anisotrope Filterung: +- z.B. bei flacher Aufsicht ist die Verkleinerung in y-Richtung viel stärker als in x-Richtung! +- Ohne spezielle Maßnahmen für diesen Fall müsste jeweils die Mip-Map-Stufe mit der kleinsten Auflösung verwendet werden, sonst treten wieder Aliasing-Artefakte auf! +- → Dies führt zur unscharfen Texturabbildung. +- Abhilfe: Anisotrope Mip-Maps (= Rip-Maps, Rectangular Mip-Maps) + +Anisotropic Mip-Map (Rip-Map): +- Verschiedene Auflösungsstufen in x- und y-Richtung werden erzeugt, sodass für jede Situation die richtige Auflösung gefunden werden kann ohne beim Resampling das Abtast-theorem zu verletzen. +- Aber: Vierfacher Speicherbedarf gegenüber höchster Auflösung (statt 1,33 - s. MipMap) + + +## Weitere Texturarten +### Bump-Map +- Reliefartige Texturen: Herkömmliche Texturen sehen aus der Distanz zwar akzeptabel aus, von Nahem betrachtet erscheinen sie flach. +- Grund: keine korrekte 3D-Beleuchtung, Abschattung, keine Verdeckung, etc. +- Idee: Verwendung zusätzlicher Texturen, welche Tiefeinformationen beinhalten + +- Bump Map: Offset zur Polygonebene in Richtung der Normale als Grauwert“ der Textur kodiert +- Polygon: als Schnitt mit Normalenrichtung +- Anwendung des Offsets auf Polygonfläche (Drehung): Die Normale wird als Gradient der Bumpmap berechnet. Die Beleuchtung wird daraus wie bei der Normalmap pro Pixel berechnet. +- Ein Offset“ wird nicht berücksichtigt! → Als Konturen nicht erkennbar! + +![Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Bumpmap.png) + +### Normal-Map +- Normal-Map: Normalen Vektor x/y/z als RGB-Wert kodiert +- Polygon: als Schnitt mit Normalenrichtung +- Anwendung der Normal-Map auf Polygonfläche: Die Normale der N-Map modifiziert die Flächennormale (räumliche Drehung). Bei der Beleuchtungsberechnung wird für jedes Pixel die modifizierte Normale verwendet. +- Ein "Offset" wird nicht berücksichtigt! → Als Konturen nicht erkennbar! + +### Parallax-Map +- Parallax Map Tomomichi Kaneko et al. 2001 +- Ausgangsdaten: Bump Map +- Die u/v-Koordinaten der angezeigten Textur werden Entsprechend der Blickrichtung beim Look-up um $\delta u = h · \tan(\phi)$ verschoben. Die daraus resultierende Verzerrung verstärkt den 3D-Effekt, allerding ohne korrekte Berücksichtigung der Verdeckung +- Anwendung des Offsets auf Polygonfläche (Drehung): Anwendung der Bump Map des Offests auf Polygonfläche (räuml. Drehung der Modellkoord.) Die Normale wird als Gradient der Bumpmap berechnet. Die Beleuchtung wird daraus wie bei der Normalmap pro Pixel berechnet. + +### Displacement-Map +- Ausgang: Wiederum Bump Map, jedoch Bestimmen des korrekten Schnitts eines Sehstrahls mit der Bump Map durch iterative Suche des Schnittpunktes +- Finde $u_0$ , sodass $u-u' = h(u') * \tan(\phi)$ mittels Bisektion entlang dem Sehstrahl +- Bei Mehrdeutigkeit: Finde $u_0$ am weitesten weg von $u$ → korrekte Verdeckung +- Silhouetten: Auch u/v-Koordinaten außerhalb der Polygongrenzen müssen berücksichtigt werden! + - aufwendige Shader Programme nötig + +### Zusammenfassung +- DECAL (Abziehbild) RGBA-Werte ohne Berücksichtigung der Beleuchtung (emmisiv, evtl. mit Alpha Wert (A) für transparente Anteile) +- DIFFUSE: RGB-Werte werden als diffuser Farbanteil mit Beleuchtung verrechnet +- Graustufen: Helligkeitsweit wird mit dem diffusen Materialfarben mutlipliziert. +- Specular Map: Wie bei Diffuse Texture Map, jedoch für spekulären Anteil +- Normal Map: Normalisierte Normalenrichtung (als 2farbiges Rasterbild). Dient zur Modulierung der Flächennormalen und wird bei der Beleuchtung berücksichtigt. Farbwerte kommen aus der Materialkonstante des Polygons, oder aus der Diffuse Map (bzw. Specular Map). Ergibt aus der Ferne eine dreidimensionalen (reliefartige) Struktur. +- Bump Map: Statt der Normalen wird eine Erhöhung (in Richtung der Normalen) kodiert (grauwertiges Rasterbild). Die Normalenrichtung wird daraus als Gradient (Differenz zweier benachbarter Pixel) bei der Darstellung abgeleitet. Danach Beleuchtung wie Normal Map. +- Parallax Map: zusätzlich Pixelverschiebung als Funktion der Höhe und Kamerarichtung + +## Shadow Mapping +1. Durchgang: + - Erzeugen der Shadow Map + - Darstellung (mit z-Werten) aus Sicht der Lichtquelle + - Kamera Koordinaten in der Lichtquelle zentriert (Matrix L) + - z-Puffer als Textur speichern +2. Durchgang: + - Kamera Ansicht: View Matrix: V (ebenfalls mit z-Puffer) + - → Um den Schatten zu erzeugen benötigen wir Shader mit Lookup in der Shadow Map-Textur: + - 4x4-Matrix: $M = V^{-1}*L$ + +![Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_ShadowMap.png) + +Shadow map look-up: +- Transformiere jedes Pixel aus dem Kameraraum in den Lichtraum +- $p'=L*V^{-1}*p$ +- Vergleiche transformierte z-Werte $(p'_z)$ mit den z-Werten der Shadow Map $(z_s)$ + - $(p'_z>z_s)$: im Schatten – keine Beleuchtung von der Lichtquelle + - sonst: Punkt ist von der Lichtquelle her sichtbar, wende Beleuchtung in der Schattierung des Pixels an + +### Probleme +Z-fighting beim Schattentest: +- Schattentest $(p_z' <= z_s )$ sollte für beleuchtete Pixel korrekt $(p'_z = z_s)$ ergeben. +- Aufgrund der Rechenungenauigkeit der Fließkomma-Arithmetik wird Gleichheit selten erreicht! +- Beleuchtete Polygone schatten sich teilweise selbst ab. +- Lösung: kleiner Offset im Schattentest: $IF (p'_z <= z_s + Offset...)$ +- durch das Offset wird sichergestellt, dass keine falschen Schatten entstehen + +Uniform Shadow-Map +- Probleme: zu niedrige Auflösung der Shadow Map im Nahbereich, Großteil der Shadow Map ist irrelevant für Kameraansicht + +Perspektive Shadow-Map +- adaptive schiefsymtetrische Projektion; nicht uniforme perspektive Shadow Map + +## Zusammenfassung +- Transformation des Texturraums in den Bildraum der Darstellung: + - Verwendung unterschiedlicher geometrische Transformationen (z. B affin, perspektivisch, Env. Maps, etc.) + - Anwendung immer als inverse Transformation! +- Resampling + Rekonstruktion: Das transformierte Texturraster wird nach der Transformation durch das Bildraster neu abgetastet. +- Filter: Verhindern bzw. Abmildern von Aliasing-Effekten, verursacht durch Resampling. + - Lösung: Tiefpass-Filter vor der Transformation: Mipmapping, Anisotrope Filter. + - Beim Abtasten (Rekonstruktion):Trilineare Filterung in x, y, und k (Mip-Map-Stufe) +- Texturinhalt als Material, Beleuchtung, Geometrie interpretiert + +# Grafik (GPU) Pipeline +- algorithmisches Konzept, sowie Realisierung der Grafikkartenhardware ist vergleichbar mit Fließband +- spezialisierte Arbeitsstationen (Spezialprozessoren) +- jedes geometrische Objekt durchläuft Arbeitsstationen sequenziell +- Arbeitsschritte können dadurch gleichzeitig auf verschiedenen Daten ausgeführt werden + +## Bestandteile +Programm API -> Treiber -> Vertex-Verarbeitung -> Primitivenbehandlung -> Rasterisierung & Interpolation -> Fragment Verarbeitung -> Rasteroperation -> Bildspeicher + +## Allgemeines +- Anwendungsprogramm: + - läuft auf der CPU, + - definiert Daten und Befehlsabfolge, + - greift dazu über das Grafik-API (Application Programming Interface, z. B. OpenGL, Direct3D) auf die Grafikkarte zu +- Treiber: übersetzt die Grafikbefehle des Programms in die Maschinensprache der speziellen Grafikhardware (Graphics Processing Unit / GPU, z.B. von nVidia, AMD oder Intel) +- Befehle und Daten werden über den Bus (z.B. PCI-Express) von der CPU auf die GPU übertragen +- OpenGL-Pipeline: Abarbeitung der Grafikbefehle auf der GPU +- Ausgabe des Bildspeichers auf dem Monitor +- typischer OpenGL "Draw"-Befehl (im Anwendungsprogramm via OpenGL-API aufgerufen) + ```bash + glBegin(GL Polygon); + glVertex3f (1.0, 1.0, 0.0); + glVertex3f (0.0, 1.0, 0.0); + ... + glEnd(); + ``` +- Treiber schickt Daten/Befehle an die GPU (z. B. via PCIe -Bus) +- Funktionsausführung auf der GPU ist dann abhängig vom aktuellen Zustand (OpenGL State Machine bzw. den gewählten Shadern): + - z. B. vorher definierter Primitivtyp (hier GL Polygon), Transformation, Lichtquellen, Interpolationsart (z.B. Gouraud Shading vs. Flat Shading) + +Abarbeitungsreihenfolge auf der GPU: +- Empfangen der Vertices in einer geordneten Sequenz. +- Vertexverarbeitung via Vertex Shader. Jeder Input-Vertex im Datenstrom wird in einen Output-Vertex transformiert und beleuchtet. +- Primitive culling (Verwerfen wenn nicht sichtbar) und clipping (Abschneiden der Polygone am Rand) +- Rasterkonvertierung (Polygon Filling) und Interpolation der Attributwerte (x-Koordinate, 1/z, R, G, B, Texturkoordinaten u/v, ...) +- Die Daten jedes Fragmentes (Pixel/Subpixel) wird mit einem Fragment Shader verarbeitet. Zu jedem Fragment gehört eine Anzahl Attribute. +- Per-Sample Operationen: Blending (Alpha-Blending bei Transparenz), Tiefen- und Stencil- Operationen ... + + +## Vertex-Verarbeitung +- Transformationen: + - Modell-Transformation, Kamera-Transformation (Model View Matrix) → Matrixmultiplikationen → Skalarprodukt +- Beleuchtung (Lighting): + - Lichtquellen, diffuses & spekuläres Material: (Gouraud Shading) Lambert, Phong-Modell → Skalarprodukt +- Skalarprodukte (Gleitkomma-Multiplikationen und Additionen) werden durch viele parallele Prozessoren auf der GPU effizient verarbeitet. + +## Primitive & Primitivenbehandlung +![Primitive; Quelle Computergrafik Vorlesung 2020/21](Assets/Computergrafik-Renderpipeline-primitive.png) + +## Rasterkonvertierung +- Edge Tables bereits erzeugt (Polygonsetup in Primitivenbeh.) +- Rasterkonvertierung/Interpolation entspricht der Scan-Line-Konvertierung (s. Polygonfüllalgoritmus), generiert Pixel (Fragments) +- Interpolation der x-Werte der Kanten (siehe left edge scan /bzw. right edge scan) +- pro Scan Line: inkrementiere x-Wert (left edge, right edge) (OpenGL behandelt nur konvexe Polygone/Dreiecke – d. h. immer 2 Kanten pro Bildzeile!) +- lineare Interpolation weiterer Attribute: + - z (1/z)-Werte, + - RGB-Werte (Gouraud Shading), + - Texturkoordinaten u/v (affines Texturmapping), + - Normalen (Phong Shading) +- sehr wenige Ganzzahloperationen pro Pixel/Bildzeile +- Ausnahmen: z. B. perspektivische Texture Maps (FP-Division!) + + +## Fragment-Verarbeitung +Weiterverarbeitung auf Basis der interpolierten Attribute im Fragment Shader + +Beispiel: Phong-Shading + - Berechnung des Phong-Beleuchtungsmodells auf Basis der vorher linear interpolierten Fragmentnormalen, -position und Materialdaten sowie der Daten der Lichtquellen und Kameraposition + +## Rasteroperationen +- Abschließende Auswahl/Zusammenfassung der berechneten Fragmentdaten (pro Pixel) +- Beispiel: nicht transparente Objekte, Übernahme der Farbwerte mit z-Position, welche am dichtesten an der Kamera ist (z-Buffer) +- Beispiel: + - transparente Objekte (z.B. Glashaus), lineares Blending zwischen schon existierenden Farbwerten und neuesten entsprechend der Transparenz + - z.B. 40% Transparenz (bzw. 60% Opakheit) für rotes Quadrat $\begin{pmatrix} R & G & B \end{pmatrix} = \begin{pmatrix} 0,6*1+0,4*0 & 0,6*0+0,4*0 & 0,6*0+0,4*1 \end{pmatrix} = \begin{pmatrix} 0,6 & 0 & 0,4 \end{pmatrix}$ + + +## Performance +Einfaches Modell zur Bestimmung der Rechenzeit T: +$T = a * \text{Anzahl Vertices} + b * \text{Anzahl Bildpixel}$ (a = Aufwand pro Vertex, b = Aufwand pro Pixel) + +- Grafikkarten geben ihre Performance an in: + - Anzahl Polygone / Sekunde (Polygone mit kleiner Pixelanzahl) + - Anzahl verarbeitete Pixel / Sekunde + - z.B. ca. 100 Millionen Polygone/sec à 10 Pixel / Polygon (mit Texturen, tri-lineare Filterung, etc. mehrere Milliarden Pixel / s (Gouraud Shader) (Angaben: nVidia Geforce 6800 - Jahr 2005) +- Problem der Grafik-Pipeline: Flaschenhals! - Langsamste Operation hält Pipeline auf (bestimmt Durchsatz) → Zwei extreme Situationen: + - Vertex-limited: viele Vertices, kleine Polygone (wenige Pixel), einfache lineare Interpolation der Vertex-Attribute pro Fragment (kleines b ) + - Fill rate limited: anspruchsvolle Fragment-Shader (großes b), weniger dafür große Polygone (viele Pixel) +- Außerdem: Grafikspeicher-Zugriffe sind teuer (Latenz und Bandbreite beachten!) z.B. Auslesen gerenderter Bilder aus dem Grafikspeicher +- Eine für die Grafikkarte angegebene Performance (z. B. 100 Mio Polygone/sec bei G-Force 6800) ist nur unter unrealistisch günstigen Bedingungen zu erreichen. + - d. h. z.B. nicht 100 Mio. unterschiedliche Polygone mit 1 fps (wegen Speicherbandbreite für Vertexzugriffe) + - auch nicht 10.000 Polygone mit 10.000 fps (da Framebuffer-Reset teuer) + - Herstellerangaben gelten nur unter optimalen Bedingungen (z. B. 10 Pixel / projiziertem Polygon)! + - realistisch (verschieden große Polygone) → ca. 1 Mio Polygone mit 10 fps (10 Mio Polygone/s) = 10% der Peak Performance! + +$$\text{Durchsatz (fps)} \approx \text{Konst.} / \text{Polygonanzahl}$$ +- unter realitischem Durchsatz: Begrenzung durch Bildspeicher +- über realisitschem Durchsatz: Begrenzung durch Geometriespeicher + +## Hardware-Architektur + +![GPU Architektur](Assets/Computergrafik_GPU_Hardware.png) + +# Bildverarbeitung +## Operationen auf dem Bildraster +Problem der Vorwärtstransformation: +- Farbwerte sitzen im Zielbild an nicht ganzzahligen Koordinaten, das Ausgabegerät benötigt aber Farbwerte in einem Raster (ganzzahlige Koordinaten) +- durch Runden können Löcher im Bild entstehen, einige Pixel werden u. U. mehrfach belegt + +![Bildraster Skalieren](Assets/Computergrafik_Bildraster_skalieren.png) + +Problemdiskussion: +- 45° - Drehung eines 3x3 Pixel großen Quadrates $\rightarrow$ Den Koodinaten (-1,1) und (1,1) beinhalten 2 Pixel aus dem Original (0,2) ist kein Pixelzugeordnet! +- Runden: führt zu Ausfallartefakten, da bestimmte Zielbildpixel je nach Transformation nicht erreicht werden +- Betrachtung eines Bildes aus 2 Kamerapositionen (Stereo) + - Bild aus verschiedenen Kameraperspektiven betrachtet. + - Beide Kameras sind auf den gleichen Punkt FP gerichtet. + - Die unterschiedlichen Pixel des Quellbildes werden an unterschiedliche Positionen in den beiden Zielbildern (jeweils Kamerabild in Kamerakoordinatensystem) abgebildet (Vorwärtstransformation). + - Störstrukturen bei Skalierung auf jeweils beiden Bildern + +Lösungs-Idee: Inverse Transformation +- inverse Transformation, d.h. indirekte Methode +- da jedes Pixel im Zielbild B an der Position (k, l) Ausgangspunkt der Rechnung ist, bleibt keines unbelegt +- keine Löcher mehr! +- Problem: Auch das Quellbild A ist nur an ganzzahligen Rasterpunkten i,j gegeben. Wie ermittelt man A(x,y) aus den Pixeln A(i,j) im Umfeld von x,y? Wie groß muss das Umfeld sein? → Resamplingproblem (Wiederabtastung) + +Lösungsansatz: Rückwärtstransformation der Pixelkoordinaten +- Inverse Transformation der Koordination vom Zielbild + Sampling im Originalbild +- Es entstehen zwar keine Lücken im Zielbild, aber durch Rundung nichtganzzahliger Pixelkoordinaten auf den nächstenganzzahligen Wert können dennoch Aliasing-Artefakte entstehen: $B(k.l)=A(h^{-1}(k,l)$ + - einzelne Pixel im Originalbild werden öfter gesampelt als andere + - einige Pixel im Originalbild werden ausgelassen! + +![Rücktransformation I](Assets/Computergrafik_Rückwärtstransformation_Pixelkoordinaten.png) + +Rückwärtstransformation der Pixelkoordinaten mit Interpolation benachbarter Pixel: +- Inverse Transformation der Koordination vom Zielbild + Sampling im Originalbild +- bei nicht ganzzahligen Pixelkoordinaten kann man zwischen den benachbarten Pixelwerten im Originalbild interpolieren (RGB-Werte) + - Rekonstruktion eines genaueren Zwischenwertes / Antialiasing +- dadurch werden die scharfen (aber ungenau positionierten Flächengrenzen) zwar unscharf. . . +- aber die wahrgenommenen Grenzen zwischen schwarzen und weißen Flächen können so zwischen den ganzzahligen Pixelwerten positioniert werden +- die empfundene Genauigkeit wird durch Antialiasing sogar erhöht! + +![Rückwärtstransformation II](Assets/Computergrafik_Rückwärtstransformation_Interpolation.png) + +Rückwärtstransformation bei doppelter Auflösung des Zielbildes: +- Vergleich mit exakter Darstellung nur bei doppelter Auflösung möglich + +Verkleinern eines Bildes durch Skalierung +- Inverse Transformation der Koordination vom Zielbild + Sampling im Originalbild + - auch hier entstehen zwar keine Lücken im Zielbild beim Transformieren zusammenhängender Bilder + - aber beim Sampeln im Originalbild entstehen Aliasing-Artefakte: + - z.B. Auslassen jedes zweiten Pixels im Originalbild → Zielbild wird uniform weiß (oder schwarz) +- exakte Lösung wäre nur bei doppelter Auflösung möglich +- jedoch Auflösung im Zielbild begrenzt, gute Näherung muss gefunden werden +- Näherung durch Sampeln und Interpolation mehrerer Nachbarpixel führt zu möglicher Lösung + + +Fazit: +- Vorwärtstransformation: + - gesuchte Farbwerte im Zielbild liegen nicht immer an ganzzahligen Koordinaten + - durch Rundung können Lücken im Zielbild entstehen +- Rückwärtstransformation: + - es entstehen keine Lücken im Zielbild, dennoch können (Sampling) Artefakte (Aliasing) auftreten + - diese Artefakte können durch Interpolation mehrerer Pixel teilweise abmildert werden + + +## Frequenzraum +Um das Thema Sampling und Rekonstruktion und Aliasing-Artefakte besser verstehen zu können und um eine möglichst optimale (und theoretisch begründbare) Lösung zu finden machen wir einen Ausflug in die Signaltheorie und digitale Filter. +Zur Beschreibung der Filtereigenschaften wird der Frequenzraum des Bildes eingeführt. +Def.: Frequenz ist die Wiederholrate eines periodischen Signals. Bei zeitabhängigen Signalen S(t) gibt die Frequenz an, wie oft sich das Signal pro Sekunde wiederholt: $f(Hertz)=\frac{1}{t}$ + +Ein Bild ist im zweidimensionalen Ortsraum definiert: +- Farb-/Helligkeitswert als Funktion des Ortes W(x,y) +- Bei ortsabhängigen Signalen (z.B. Bildmustern) ist mit Frequenz gemeint, nach welcher Distanz (in Pixeln gemessen) sich das Muster im Bild wiederholt. +- Die Umwandlung vom Ortsraum in den Frequenzraum (und umgekehrt) geschieht durch eine Fourier-Transformation. + - damit kann ein Bild im Frequenzraum f definiert werden + - $S(f)$ wird Spektrum genannt + +![Frequenzraum](Assets/Computergrafik_Frequenzraum_Signal.png) + +Beispiel: 2D-Spektrum eines Schachbrettmusters +- Kleinstes auf einem Pixelraster darstellbares Muster hat Durchmesser von 2 Pixel (d.h. 0,5 Wiederholungen pro Pixel) +- Höchste darstellbare Frequenz $f_x = f_y = 0,5 \text{Pixel}^{-1}$ +- Diese Frequenz nennt man Nyquist-Frequenz! + +Bildraster als P-dimensionaler Vektorraum: +- Das diskrete Grauwertbild $F (i* \delta x, j * \delta y )$ habe M Spalten und N Zeilen +- $P = M * N$ (=Anzahl Bildpunkte) ist damit die Dimension des Primärdatenraumes des Bildes +- Wir stellen uns bewusst das Bild aus Punkten zusammengesetzt vor, d.h. + - wir können von $M * N$ Basisbildern der Dimension $M * N$ ausgehen, in denen jeweils nur ein Pixel den Wert 1 (weiß) besitzt (alle anderen Pixel Schwarz = 0) + - diese Basisbilder sind damit alle orthonormal → Wichtungsfaktoren durch inneres Produkt! + - sie ergeben in der grauwertgewichteten Summe das diskrete Bild F + +![Frequenzraum II](Assets/Computergrafik_Frequenzraum_diskretes_Bild.png) + +Vektoroperationen im Bildraum: +- Mit der mathematischen Definition eines Rasterbildes als Vektor in einem hochdimensionalen Vektorraum, lassen sich viele Bildoperationen als Vektoroperatoren elegant darstellen: + - z.B. Skalarprodukte zwischen zwei Bildern (Linearkombination lineare Unabhängigkeit) + - Basistransformation: Ganze Bilder (als Vektoren) dienen als Basis eines transformierten Bildraumes. + - Die neuen Basisvektoren müssen linear unanhängig sein und idealerweise orthonormal zueinander stehen. + - Eine Basistransformation entspricht einer "Drehung" des Vektorraumes um den Nullpunkt. + +### Transformation +Jedes Pixel im gedrehten Raum entspricht einem Bild im Ursprungs-Raum. +Jedes Bild ist eine Linearkombination der Basisvektoren, entspricht also einer gewichteten Addition von Bildern im Ursprungsraum. + +![Transformation](Assets/Computergrafik_Frequenzraum_Transformation.png) + +4 neue Basisvektoren $B_i$ (2 x 2 Pixel), welche unterschiedliche Frequenzen darstellen: + +![Basisvektoren](Assets/Computergrafik_Transformation_Basisvektoren.png) + +(Weiß=+1; Schwarz=-1; Grau=0) + +Die 4 Basisvektoren stehen orthonormal zueinander. Test mittels paarweisen Skalar-produkten: $B_iB_k=\begin{cases}1 \text{ falls } i=k\\ 0 \text{ sonst }\end{cases}$. +Jedes einzelne Pixel aber auch jedes Bild kann als Linearkombination aus 4 Basisvektoren $B_1$ bis $B_4$ konstruiert werden: $P=a*B_1+b*B_2+c*B_3+d*B_4$ +- Gleichungssystem: 4 Gleichungen für die Koeffizienten a,b,c,d +- Berechnung der Frequenzanteile a bis d über Lösung des Gleichungssystems oder Projektion von P auf $B_1$ bis $B_4$ (mittels Skalarprodukt): $a=P*B_1$ +![Basisvektoren II](Assets/Computergrafik_Basisvektor_Linearkombination.png) + +Bsp: $a=P*B_1 = <-1, 1, -1, -1><\frac{1}{2}, \frac{1}{2}, \frac{1}{2}, \frac{1}{2}> = -1*\frac{1}{2}+1*\frac{1}{2}-1*\frac{1}{2}-1*\frac{1}{2} = -1$ + + +### DCT - Discrete Cosinus Transformation +- Spezielle Basistransformation: Cosinus Transformation +- Jedes Pixel im Cosinus Raum entspricht einem Bild mit Cosinus-Funktionen verschiedener Frequenzen oder Phasen (in x- oder y-Richtung) + - Links oben: Frequenz = Null (Durchschnittswert des Bildes) + - Rechts unten: Anteil der höchsten Frequenz +- Der Cosinus Raum bildet ein Orthonormalsystem +- ein Pixelbild im Ursprungsraum lässt sich zusammensetzen als gewichtete Addition von Bildern mit unterschiedlichen Frequenzen → Spektralzerlegung +- Ähnlich funktioniert die Fouriertransformation (Sinus und Cosinustransformation) + +![DCT](Assets/Computergrafik_DCT.png) + +### Fouriertransformation +- Grundidee: jede beliebige periodische Funktion lässt sich darstellen als Summe von $\sin$ und $\cos$ Funktionen unterschiedlicher Frequenzen +- Transformation: verändert eine Funktion nicht, sondern stellt sie nur anders dar +- Transformation ist umkehrbar: somit existiert auch eine inverse Fourier-Transformation +- Hochpassfilter: ausblenden der tiefen Frequenzen im Frequenzraum + ![Hochpassfilter](Assets/Computergrafik_Fourier_Hochpass.png) +- Tiefpassfilter: ausblenden der hohen Frequenzen im Frequenzraum + ![Tiefpassfilter](Assets/Computergrafik_Fourier_Tiefpass.png) + + +### Signalrekonstruktion +- die Abtastfrequenz viel höher als die Signalfrequenz im Original +- Konkret: Die Signalfrequenz liegt unter der halben Abtastfrequenz, der sogenannten Nyquistfrequenz +- Samplingtheorem von Nyquist: + - Signale unterhalb der Nyquistfrequenz der Samples können rekonstruiert werden + - andererseits: Signale oberhalb der Nyquistfrequenz können nicht rekonstruiert werden + - stattdessen entsteht ein völlig fremdes Signal, welches mit dem Original offensichtlich nichts mehr zu tun hat + - Aliasing-Effekt (entsteht z. B. auch bei digitalen Tonaufnahmen von hohen Frequenzen, wenn die Samplingrate für diese Frequenzen zu niedrig ist) + + +### Anitaliasing +- Aliasing bei Bildern entsteht u.a. bei der Kameraaufnahme von diskreten, digitalen Bildern, wenn das Bild in Bezug auf das Abtastraster zu hohe Frequenzen enthält (Verletzung des Abtasttheorems). +- die höchste zulässige Frequenz wird als Nyquistfrequenz bezeichnet + - sie ist gleich der halben Abtastfrequenz:$K_{x,Nyqu}=\frac{1}{2*\delta x}, x = Pixelabstand$ + - zum besseren Verständnis des Grundproblems noch mal drei Beispiele nebeneinander: + ![Beispiel](Assets/Computergrafik_Antialiasing_Nyquist.png) + - Nachträgliches Filtern kann das Aliasing nicht mehr beseitigen. +- Rekonstruktion eines Signals mittels Interpolation durch Erzeugen weiterer Samples zwischen den gemessenen Samples mittels eines Interpolationsalgorithmus (Supersampling) +- z.B. durch polynomiale Interpolation (mehrere Nachbarsamples) + - Dennoch entsteht ein etwas gestörtes Signal (hier nicht harmonische Verzerrung / Modulation) + - → Aliasing-Effekt, allerdings in abgemildertem Umfang + +Bei der eingangs vorgeschlagenen Rückwärtstransformation (vom Zielbild zurück ins Originalbild) ist die Samplingrate durch das Zielbild bestimmt (d.h. ein Sample pro Pixel im Zielbild). +Wir können damit das Aliasing Phänomen besser erklären: Bei der Verkleinerung um ein Faktor 2 ist die Samplingrate im Originalbild nur halb so groß wie die +Nyquistfrequenz des Originalbildes! ($0,25 Pixel^{-1}$ statt $0,5 Pixel^{-1}$). +Beim Sampeln mit zu niedriger Samplingrate (unterhalb der Nyquistfrequenz) kann das Originalbild nicht mehr rekonstruiert werden. Es entstehen Aliasingeffekte: Das Zielbild wird uniform weiß (oder schwarz, wenn Original um ein Pixel verschoben wird). +Der Begriff der Nyquistfrequenz erklärt das bekannte Phänomen und verweist auf mögliche Lösungen. + +Aliasing kann bei der Ausgabe von Graphiken oder Bildinhalten auf Ausgabegeräten entstehen, denn dieser Prozess ist in der Regel mit einer Rasterung (Rasterisation) verbunden. +- Dies betrifft die Computergraphik vielerorts und steht deshalb hier im Mittelpunkt! +- Aliasing entsteht in der Computergraphik insbesondere dann, wenn die Originale in viel höherer Auflösung vorliegen als das Raster des Ausgabegerätes (z.B. hochaufgelöste Bilder, feinste Texturen, aber auch beim Raytracing kleinster Objekte (Strahlverfolgung = Sampling), etc.) +- Aliasing kann auch bei digitalen Fotografien von kleinteiligen (analogen) Mustern entstehen. +- Da sich Aliasing-Artefakte nicht nachträglich beseitigen lassen, kann Anti-Aliasing nicht erst dann ansetzen, wenn das Bild bereits fertig gerendert ist. +- Beachte: Tiefpassfilterung muss deshalb immer vor dem Resampling angewendet werden. + +### Anwendung Tiefpassfilter +Um Bild (durch **Koordinatentransformation**) korrekt rekonstruieren zu können, müssen wir zuerst im Originalbild die hohen Frequenzen, die oberhalb der Nyquistfrequenz des Zielbildes liegen, eliminieren. + +Um Bild (durch **inverse Transformation**) korrekt rekonstruieren zu können müssen wir: +1. Zuerst im Originalbild die hohen Frequenzen, die oberhalb der Samplingrate des Zielbildes transformiert in das Originalbild liegen, eliminieren. +2. Danach Sampling des gefilterten Originalbildes durch inverse Transformation jedes Pixels im Zielbild + +→ Die höchsten Frequenzen des Originalbildes können aufgrund der zu geringen Auflösung im Zielbild ohnehin nicht dargestellt werden. Dieser Ansatz findet die beste Lösung unter den gegebenen Umständen. + +Achtung! Reihenfolge ist wichtig: Wenn man zuerst sampelt und dann das Zielbild filtert, lässt sich u.U. die Originalinformation (wenn dort Frequenzen oberhalb der Nyquistfrequenz enthalten sind) nicht mehr rekonstruieren! + +## Rekonstruktionsfilter +Die oben beschriebene Filterung im Frequenzraum erfordert eine Fouriertransformation des Bildes in den Frequenzraum. Nach Eliminierung der hohen Frequenzen ist die Rücktransformation erforderlich. Dies ist noch sehr aufwendig! + +Das selbe Ergebnis können wir einfacher erreichen, indem wir die Filterfunktion vom Frequenzraum in den Ortsraum transformieren (durch eine inverse Fouriertransformation) und dann direkt im Ortsraum anwenden: +- Box-Filter = ideales Tiefpass-Filter in Frequenzraum; eliminiert alle Frequenzen oberhalb +- Boxfilter im FR = sinc-Funktion im Ortsraum (Fouriertransformierte der Rechtecksf.) $sinc(x)=\frac{sin(x)}{x}$ + +Rekonstruktion von Zwischenpixelwerten durch Interpolation benachbarter Pixel: +- Inverse Transformation der Koordination vom Zielbild + Sampling im Originalbild +- Bei einer Vergrößerung findet hierbei eine Überabtastung statt (d. h. das Signal im Originalbild liegt unter der halben Nyquistfrequenz der Samplingrate des Zielbildes) +- Zur genauen Rekonstruktion von Zwischenwerten kann man interpolieren, d.h. ein gewichtetes Mittel zwischen Werten der benachbarten Pixel im Originalbild berechnen +- Dadurch werden die scharfen (aber ungenau positionierten Flächengrenzen) zwar unscharf... Aber die wahrgenommene Genauigkeit nimmt zu → Antialiasing +- Zur Gewichtung können ebenfalls Filterfunktionen im Ortsraum verwendet werden – Cut-off-Frequenz = Nyquistfrequenz im Originalbild (z. B. lineare Interpolation oder Nearest Neighbor, Sinc Funktion, etc.) + +### Exakte Interpolation +Rekonstruktionsfilter (supersampling) per Sinc-Funktion (Exakte Interpolation): +- Inverse Transformation: $B(k, l) = A(h^{-1} \{k, l\}) = A(x, y )$ +- Interpolationsansatz 1 für das Resampling: + - gewichtete Überlagerung der Abtastwerte aus der lokalen Umgebung des Quellbildes. Die Gewichte werden durch Interpolationsfunktionen festgelegt. Die Interpolations-funktionen bestimmen die Qualität des Zielbildes (Störungen, Artefakte). + - $A(x,y)=\sum_{i=-\infty}^{\infty}\sum_{j=-\infty}^{\infty}A(i,j) * f_{int}(x-i, y-j)$ + - Filterkern $f_{int}$ ist zentriert um das Pixel $A(x, y)$ + - Filter ist selbst auch als Rasterbild definiert + +Anwendung der Filter auf Bildinformationen: +$$G(x,y)=\sum_{m=-size}^{size} \sum_{n=-size}^{size} F(x+m, y+n) * H(m,n)$$ +mit Ausgabebild $G(x,y)$, Eingabebild $F(x+m,y+n)$ und Filterkern $H(m,n)$ + +Beispiel 3x3 Spalttiefpass (Boxfilter im Ortsraum): +- $m=(-1,1), n=(-1,1)$ +- $H=\frac{1}{9} \begin{pmatrix} 1&1&1\\ 1&1&1 \\ 1&1&1 \end{pmatrix}$ +- einfache Mittelwertbildung der Nachbarpixel → unscharfes Bild und hochfrequente Artefakte +- Faltungsoperatoren zur Tiefpassfilterung → Beispiel Rauschunterdrückung + +Beispiel Filterfern: 5x5 Binominalfilter + +$H_{5x5} =\frac{1}{256} * \begin{pmatrix} 1\\4\\6\\4\\1 \end{pmatrix} \begin{pmatrix} 1&4&6&4&1 \end{pmatrix}=\frac{1}{256} \begin{pmatrix} 1&4&6&4&1\\ 4&16&24&16&4\\ 6&24&36&24&6\\ 4&16&24&16&4\\ 1&4&6&4&1 \end{pmatrix}$ + +Interpolatiponsansatz 1 / Methode 1: Exakte Interpolation +- Hinreichend bandbegrenzte Bilder lassen sich theoretisch exakt interpolieren: Multiplikation des Quellbild-spektrum mit Rechtecktiefpass im Frequenzbereich +- Im Ortsbereich führt das auf eine diskrete Faltung mit der sinc-Funktion. +- In der Theorie gibt es keinerlei Störungen / keine Artefakte. +- Praxisproblem: die sinc-Funktion ist unendlich ausgedehnt! + +Sinc-Filter: Das Sinc-Filter ist zwar theoretisch ideal (scharfe Grenze im Frequenzraum) doch gilt dies nur bei gleichmäßiger Abtastung über der Nyquist-Frequenz, was in der Computergrafik meist nicht realisierbar ist. Besonders bei Kanten führt der Sinc-Filter zu starken Ringing-Artefakten. +Die Sinc-Funktion einen unendlichen Träger, sodass zur Berechnung des Farbwerts eines Pixels alle Abtastwerte des Bildes herangezogen werden müssen. Ein einfaches Abschneiden der Sinc-Funktion (Lanczos-Filter) führt zu schlechten Ergebnissen. + +**Box-Filter**: +- Alle Abtastwerte innerhalb eines um das Pixel gelegte Quadrat (meist mit der Kantenlänge von einem Pixelabstand) haben die gleiche Gewichtung: → Mittelwertbildung +- Das Box-Filter liefert im Allgemeinen schlechte Ergebnisse, da seine Fourier-Transformierte eine Sinc-Funktion ist, die den gewünschten Frequenzbereich nur schlecht isoliert + +**Kegel-Filter**: +- Beim Kegel-Filter fällt die Gewichtung mit zunehmender Distanz zum Pixel linear ab. +- Es liefert etwas bessere Ergebnisse als das Box-Filter +- Artefakte sind noch vorhanden, aber deutlich abgeschwächt! + +**Gauß-Filter**: +- Beim Gauß-Filter wird zur Rekonstruktion eine Gauß-Funktion verwendet. Die Fouriertransformierte einer Gauß-Funktion ist wieder eine Gauß-Funktion. +- Dieser Filter führt zu Unschärfe (höhere Frequenzen, auch unterhalb der Nyquistfrequenz werden zu stark abgeschwächt), +- dafür werden aber Aliasing-Effekte sehr gut unterdrückt + +**Mitchell-Netravali-Filter**: +- sind stückweise kubische Filter mit vier Pixel breiten Trägern. +- Sie sind durch zwei freie Parameter änderbar und wurden speziell dafür entworfen, die aus Rekonstruktionsfiltern resultierenden Artefakte zu untersuchen. +- Bei geeigneter Parameterwahl liefern die Filter einen guten Kompromiss zwischen Unschärfe, Anisotropie und Ringing. +- Die Mitchell-Netravali-Filter werden auch als bikubische Filter bezeichnet, z. B. kubische B-Splines, o. Ä. + +### Nearest Neighbour +- Einfache Übernahme des geometrisch nächsten Nachbarn aus dem Quellbild. +- Entspricht der Faltung mit einem Rechteck der Breite$\delta x$ im Ortsbereich, d.h. Multiplikation des periodifizierten Bildspektrums mit einer Sinc-Funktion im Frequenzbereich. +- Ergebnis: Massive Störungen (Artefakte) durch skalierte, z.T. phasengespiegelte Reste von periodifizierten Frequenzanteilen. Verunschärfungen halten sich in Grenzen, da die entsprechende sinc-Funktion bei der Nyquistfrequenz noch nicht wesentlich abgefallen ist. Die unsymmetrische Operation führt zu frequenzabhängigen, örtlichen Verschiebungen. + +### Bilinearer Interpolation +- Entspricht der Faltung mit einem Dreieck der Breite $2*\delta x$ im Ortsbereich, d.h. Multiplikation des periodifizierten Bildspektrums mit einer $sinc^2$-Funktion im Frequenzbereich. +- Reduziertes Aliasing / Artefakte durch schnelleren Abfall der $sinc^2$-Funktion gegenüber sinc, merkliche Verunschärfung durch stärkeren Abfall bei der Nyquistfrequenz. Außermittige Interpolation führt zu frequenzabhängigen örtlichen Verschiebungen (Achtung bei Messanwendungen). + +### Weitere Filter +- Filter zur Hoch- bzw. Bandpassfilterung: +- Anwendung: z.B. Kantenextraktion +- Sobelgradient: $H_{xS} =\begin{pmatrix} 1&0&-1\\ 2&0&-2\\ 1&0&-1\end{pmatrix}, H_{yS}=\begin{pmatrix} 1&2&1\\ 0&0&0\\ -1&-2&-1 \end{pmatrix}$ +- Differenzbildung (Ableitung) → hohe Frequenzen werden verstärkt! +- im Gegensatz dazu sind Tiefpassfilter Integralfilter = gewichtete Summe der Nachbarpixel + +### Zusammenfassung/Kontrollfragen +1. Grundlagen der Bildverarbeitung und Signaltheorie helfen beim Verständnis der Möglichkeiten und Grenzen der Darstellung und Transformation von Bildern. +2. Hohe Frequenz (oberhalb der halben Abtastfrequenz / Nyquistfrequenz) führen zu Artefakten (Aliasing!) – Das Signal lässt sich aus den Samples nicht mehr korrekt rekonstruieren. +3. Hohe Frequenzen müssen daher vor dem Sampling / Resampling herausgefiltert werden! +4. Die Fouriertransformation und die CosinusTransformation sind solche Basistransformationen, welche das Bild in den Frequenzraum / (Phasenraum) transformieren. + +5. Frage: Was verstehen wir unter einer Basistransformation des Bildraumes? Welche Eigenschaften haben die neuen Basisvektoren (notwendigerweise / idealerweise)? +6. Frage: Was versteht man unter einem Tiefpassfilter? (Anwendung im Frequenzraum, bzw. Ortsraum) +7. Frage: Was ist ein Rekonstruktionsfilter? Wo wird es angewendet? Bezug zu Aussage 2? +8. Frage: Welches sind Qualitätsunterschiede von Tiefpass-Filterfuntionen (Sinc, Linear, Gauß, Mitchell-Netravali)? \ No newline at end of file diff --git a/Content Verwertungsmodelle.md b/Content Verwertungsmodelle.md new file mode 100644 index 0000000..08f1682 --- /dev/null +++ b/Content Verwertungsmodelle.md @@ -0,0 +1,1049 @@ +--- +title: Content-Verwertungsmodelle und ihre Umsetzung in mobilen Systemen +vorlesung/quelle: http://www.juergen-nuetzel.de/content_verwertungsmodelle_mobile_umsetzung.html +--- + +# Motivation und Überblick +mobiler Content +- Bücher sind schon länger mobil +- Mobile Musik wurde ab 1979 populär +- Auch die Bilder bewegen sich seit den 1950ern mobil + +Cloud-Computing +- Mobiler Internet-Zugang, Smartphones und Cloud-Dienste (z.B. Amazon AWS) ermöglichen neuartige Anwendungen +- Nutzen von Amazons Cloud-Diensten im Programmierprojekt. Z.B. + - Serverless: https://aws.amazon.com/de/lambda/ + - Amplify: https://aws-amplify.github.io/ + - KI Dienste wie z.B. Bilderkennung: https://aws.amazon.com/de/rekognition/ +- Das Backend einer Social-Media-App wie boombazoo + +Programmierprojekt z.B. mit +- Android Studio + - Native Apps für Android mit Java + ![](Assets/ContentVerwertungsmodelle-android-studio.png) + - [How to Build Your First App in Android Studio 3 Tutorial](https://www.youtube.com/watch?v=UQlDjsfiQ-k) +- Flutter: https://flutter.dev/ + - Native Apps für Android und iOS + ![](Assets/ContentVerwertungsmodelle-Flutter.png) +- React Native https://reactnative.dev/ + - Native Apps für Android, iOS programmiert in JavaScript mit Visual Studio Code + - Einfaches Testen mit [Expo](https://expo.io/) + ![](Assets/ContentVerwertungsmodelle-react-native.png) + +# Mobile Geräte - Smartphones +Überblick +- Mobiles Intelligentes Endgerät + - Festlegungen + - Definitionen +- Eine Historie + - Mobilfunk + - Die Geräte selbst +- Zukunft? + +Mobiles Intelligentes Endgerät +- Mobiles Intelligentes Endgerät = Smartphone? +- Drei Fragen sollen zuerst beantwortet + - Was soll ein sogenanntes Endgerät können? + - Was ist unter "mobil" zu verstehen? + - Was macht ein Endgerät intelligent bzw. smart? + +Was sollte ein Endgerät können? +- Content wiedergeben + ![](Assets/ContentVerwertungsmodelle-content.png) + - $\leftrightarrow$ Mensch-Maschine-Schnittstelle + - $\rightarrow$ Laden/Zuführen des Content bzw. der Content-Daten + +Was sollte ein Endgerät können? +- Elektronische Kommunikation ermöglichen + +Was ist unter mobil zu verstehen? +- Mobile Endgeräte ermöglichen die ... + - mobile Nutzung von Content + - mobile elektronische Kommunikation (nicht in stationärer Form) + - Verarbeitung der Nutzer- und Gerätemobilität +- Was ist nicht mobil? keine mobile Nutzung; tragbar aber nicht mobil nutzbar + +Was macht ein Endgerät intelligent (=smart)? + - enthält ein(en) freiprogrammierbarer Rechner + - hat einen Internet-Zugang + - kann Content erstellen und über das Internet bereitstellen + - kann Content aus dem Internet laden + - kann Content weiterverarbeiten + +## Geschichte des Mobilfunks bis LTE +- Der Anfang 1918 und 1926: Bei der Reichsbahn in Deutschland +- Erste Generation + - A-Netz 1958 (teuer, schwer und in Bereiche unterteilt) + - B-Netz 1972 + - C-Netz 1985 (cellulär) +- GSM ab 1992, 2. Generation (2G), D und E-Netz + - GPRS (General Packet Radio) +- UMTS, 3. Generation (3G) ab ca 2000 +- LTE ab 2010 +- [Geschichte des Mobilfunks](http://www.youtube.com/watch?v=oqFEAAYw9RQ) +- [#kurzerklärt: Was ist 5G?](http://www.youtube.com/watch?v=q4mQUgJzkZE) + +## Historische Geräte - 1. Generation +- A-Netz: A-Netz Funktelefon (Hersteller: Fa. TeKaDe Nürnberg, 1963) +- C-Netz: Autotelefon Motorola CM451 von 1990 + +## 5G Technology +- Milimeter Waves, 30-600GHz + - greater spectrum of communication, less interference + - high frequenzy cannot travel through walls +- Small Cell (Networks) + - more little base stations +- Massive MIMO + - multiple input multiple output + - more ports +- Beamforming + - traffic signaling + - focus stream to user +- Full Duplex + +## Historische Geräte - Meilensteine +- Das erste Handy: Motorola DynaTAC, 1983 (Prototype 1973) +- Das erste GSM Handy für die Massen: Nokia 1011, 10.11.1992 +- Das erste WAP-Handy: Nokia 7110, 1999 +- Das erste App-Handy: iPhone, 2007 + +Weitere Informationen +- [Vintage Mobiles](http://www.gsmhistory.com/vintage-mobiles) +- [Die Meilensteine in der Geschichte der Handys und Mobilfunktelefone](http://www.startmobile.net/die-meilensteine-in-der-geschichte-der-handys-und-mobilfunktelefone/) +- [History of mobile phones](http://en.wikipedia.org/wiki/History_of_mobile_phones) +- [Geschichte der Mobiltelefonie in Deutschland](http://de.wikipedia.org/wiki/Mobilfunk#Geschichte_der_Mobiltelefonie_in_Deutschland) + +## Die nahe Zukunft - Wearables? +- Wear OS by Google + - [Introduction to Wear OS by Google Development](http://www.youtube.com/watch?v=penkgJBJdv4) +- Samsung Gear S3 + - [Samsung Gear S3 im Test](http://www.youtube.com/watch?v=PQCcV8gIi4I) +- Apple Watch 4 mit EKG + - [Hands-On With the ECG Feature for Apple Watch Series 4!](http://www.youtube.com/watch?v=jdRXLES7ajY) + +# Mobile Geräte - Betriebssysteme +## Was ist ein Betriebssystem? +Ein Betriebssystem ist eine Zusammenstellung von Computerprogrammen, die die Systemressourcen eines Computers wie Arbeitsspeicher, Festplatten, Ein- und Ausgabegeräte verwaltet und diese Anwendungsprogrammen zur Verfügung stellt. + +Das Betriebssystem bildet dadurch die Schnittstelle zwischen den Hardwarekomponenten und der Anwendungssoftware des Benutzers. + +- [Andrew S. Tanenbaum: Moderne Betriebssysteme](Andrew S. Tanenbaum: Moderne Betriebssysteme. 3., aktualisierte Auflage, Pearson Studium, ISBN 978-3-8273-7342-7) +- [http://de.wikipedia.org/wiki/Betriebssystem](http://de.wikipedia.org/wiki/Betriebssystem) + +## PDA- und Smartphone-Betriebssysteme +- Android ... (Marktanteil 03/2020 Internet Nutzung weltweit: 72,3%) +- Apple iOS ... (Marktanteil ...: 27,0%) +- Windows 10 Mobile ... (Marktanteil ...: 0,1%) +- BlackBerry OS und BlackBerry 10 ... (Marktanteil ...: 0,01%) +- [Palm OS](http://de.wikipedia.org/wiki/Palm_OS): Betriebssystem für Palm-Handhelds +- Symbian ... +- Sailfish OS: Ex-Nokia-Leute haben [Jolla](http://de.wikipedia.org/wiki/Jolla) gegründet +- [Tizen](http://de.wikipedia.org/wiki/Tizen) : ein freies OS, Samsungs Smartwatches nutzen es +- [Ubuntu Touch](http://de.wikipedia.org/wiki/Ubuntu_Touch): mobile Benutzeroberfläche für Ubuntu +- Kein Betriebssystem: Java Micro Edition (Java ME) ... + +MIDP-Java ME (kein Betriebssystem) +- Überblick + - MIDP (Mobile Information Device Profile) ist ein Profil der Java Micro Edition (Java ME), das speziell auf die Fähigkeiten kleiner Mobilgeräte wie Mobiltelefon oder PDA ausgelegt wurde. Es umfasst daher Funktionen zur Ansteuerung und Abfrage von Einhandtastaturen, Miniaturbildschirmen, flüchtigem und nicht-flüchtigem Speicher im Kilobyte-Bereich etc. + - MIDP-Applikationen heißen MIDlets +- Historie/Versionen: + - MIDP 1.0 (JSR 37) - Approved 19. September 2000 + - MIDP 2.0 (JSR 118) - Approved 20. November 2002 + - MIDP 3.0 (JSR 271) - Approved 9. Dezember 2009 (keine Bedeutung mehr) +- BlackBerry setzte bis Version 7 auf MIDP 2.0 + +## Symbian +- Überblick + - Das Handy-OS Symbian hat seine Ursprünge in der 32-Bit-EPOC-Plattform von Psion; diese wurde in einem 1998 gegründetem Konsortium mit dem Namen Symbian von den Mobilfunkunternehmen Ericsson, Motorola, Nokia und Psion eingesetzt und weiterentwickelt. + - Die Symbian Ltd. wurde später vollständig durch Nokia übernommen und in eine gemeinnützige Organisation, die Symbian Foundation, überführt. Nokia erwarb im Dezember 2008 sämtliche Rechte und übertrug sie an die Symbian Foundation. Diese erklärte Symbian im Februar 2010 zur Open Source-Lösung. + - Die Unterstützung durch Nokia wurde Ende 2012 komplett eingestellt. +- Technik + - Symbian hat vieles mit Desktop-Betriebssystemen gemein, z. B. präemptives Multitasking, Multithreading und Speicherschutz. +- User Interface + - Zuerst AVKON (Serie 60), + - ab Symbian^3 die Qt Oberfläche +- Historie und Geräte (Beispiele) + - Symbian OS v6.0: Nokia 9210 Communicator, 2001 + - Symbian OS v6.1: N-Gage (Nokia Spielekonsole), 2003 + - Symbian OS v7: Nokia Communicator 9500, 2004 + - Symbian OS v8: Nokia N72, 2006 + - Symbian OS v9.1: Nokia N71,N73, N91, 2006 + - Symbian OS v9.2 (Serie 60 3rd Edition): Nokia E90, N95, 2007 + - Symbian OS v9.3: Nokia N78, N96, 2008 + - Symbian OS v9.4 / Symbian^1: Nokia N97, 2009, erste Version der Symbian Plattform und als solche keine eigentliche Veröffentlichung der Symbian Foundation. Beinhaltet das "alte" Symbian OS und S60 5th Edition. Es ist nicht als Open Source verfügbar. + - Symbian^3 / Symbian "Anna": Nokia N8, 2010, Open-Source + - Nokia Belle: Nokia 808 PureView, 2012 + - [http://nokiamuseum.info/](http://nokiamuseum.info/) + +## BlackBerry +- Überblick + - Das Blackberry OS (bis zur fünften Ausgabe bekannt als Blackberry Device Software, auch bekannt als Research In Motion OS) ist ein proprietäres, kostenlos nutzbares (Freeware) Multitasking-Betriebssystem für Smartphones. Es wird von dem Unternehmen Blackberry (ehemals Research In Motion) für dessen Geräte der Marke Blackberry entwickelt. Apps können im zugehörigen Blackberry-World-Store erworben werden. Der Nachfolger von Blackberry OS heißt Blackberry 10. + - Blackberry OS wurde inzwischen durch Blackberry 10 auf QNX-Basis ersetzt. Im August 2013 hat BlackBerry mit dem 9720 noch ein Einsteiger-Smartphone mit BlackBerry OS 7.1 vorgestellt. +- Technik + - Es ist in C++ programmiert und bietet eine Java-Umgebung (J2ME - MIDP) mit speziellen Schnittstellen zum Betrieb von (Dienst-/Anwendungs-)Programmen. Drittentwicklern steht eine spezielle Programmierschnittstelle zur Verfügung. Integraler und bekanntester Bestandteil der Funktionalität sind die E-Mail-Funktionen der Plattform. + - Laut Gartner war es mit **17,5 Prozent Marktanteil im Jahr 2010** eines der bedeutendsten Betriebssysteme für Mobiltelephone. +- Historie und Geräte (Beispiele) + - Das erste Modell der Reihe, der Blackberry 850, 1999 + - [http://en.wikipedia.org/wiki/List_of_BlackBerry_Products](http://en.wikipedia.org/wiki/List_of_BlackBerry_Products) + - [http://en.wikipedia.org/wiki/BlackBerry_OS#1.0](http://en.wikipedia.org/wiki/BlackBerry_OS#1.0) +- BlackBerry 10 + - Das System wurde am 19. Oktober 2011 auf der hauseigenen Entwicklerkonferenz DevCon in San Francisco vorgestellt und basiert zu großen Teilen auf dem Betriebssystem QNX und dessen Microkernel. Blackberry 10 ersetzt das klassische Blackberry OS komplett. Das erste Gerät des Herstellers mit dem neuen Betriebssystem war das Blackberry Z10, 2013 + - Version 10.2 bietet Unterstützung von Android Apps (seit 2014) + - Version 10.3 unterstützt offiziell den Amazon Appstore + - [http://en.wikipedia.org/wiki/BlackBerry_10](http://en.wikipedia.org/wiki/BlackBerry_10) + +## Windows Phone, Windows 10 Mobile +- Windows Phone 7 = Windows CE + - Die Entwicklung von Windows Phone wurde Anfang September 2010 abgeschlossen +- Microsoft Windows Phone 8 bzw. 8.1 + - Im Gegensatz zum Vorgänger Windows Phone 7 basiert es nicht länger auf Windows CE, sondern demselben Windows-NT-Kernel wie Windows 8 und Windows RT. + - Windows Phone 8 wurde am 20. Juni 2012 auf der Windows Phone Summit in San Francisco vorgestellt. + - [http://de.wikipedia.org/wiki/Microsoft_Windows_Phone_8](http://de.wikipedia.org/wiki/Microsoft_Windows_Phone_8) +- Windows 10 Mobile + - Nachfolger von Windows Phone 8.1 + - Wurde stark an die Desktop-Version angelehnt + - Weiterentwicklung wurde 2017 beendet + - **Supportende:** 14. Januar 2020 + - https://de.wikipedia.org/wiki/Microsoft_Windows_10_Mobile + +## iOS +- Überblick und Historie + - iOS (früher iPhone OS oder iPhone Software) ist ein von Apple entwickeltes mobiles Betriebssystem für das iPhone, das iPad, den iPod touch und den Apple TV der 2. und 3. Generation. + - Im Gegensatz zu Apples Konkurrenten wird iOS nur auf eigener Hardware von Apple eingesetzt. iOS basiert auf einem "Mac OS X"-Kern bzw. Darwin-Betriebssystem, welches wiederum auf einen Unix-Kern zurückgeht. + - Das ursprüngliche Betriebssystem wurde am 9. Januar 2007 zusammen mit dem iPhone auf der MacWorld Conference and Expo vorgestellt. Damals bezeichnete Steve Jobs "iOS" noch als ein "Mac OS, welches auf dem iPhone läuft". iPhone OS (iOS) unterstützte zu diesem Zeitpunkt noch keine Apps von externen Entwicklern. + - Am 6. März 2008 veröffentlichte Apple dann das SDK für iOS, um Drittentwicklern die Möglichkeit zu geben, Apps für iOS entwickeln zu können. + - Die damit entwickelten Apps lassen sich ausschließlich im ebenfalls mit iPhone OS 2.0 neu eingeführten App Store veröffentlichen. +- Versionen + - [http://de.wikipedia.org/wiki/Apple_iOS#Versionen](http://de.wikipedia.org/wiki/Apple_iOS#Versionen) +- User Interface / Bedienkonzept + - UI Toolkit ist Cocoa Touch im Unterschied zum OS X's Cocoa. Das UI ist nicht mit OS X kompatibel. + - Das Bedienkonzept von iOS ist möglichst einfach gehalten. Somit beschränkt es sich fast ausschließlich auf den Home-Bildschirm, auch Springboard genannt. iOS wird fast ausschließlich über den Multitouchbildschirm gesteuert, nur das Sperren und Ausschalten des Geräts wird mit dem Lockbutton ausgelöst, und das Beenden von Anwendungen (genannt Apps) mit dem Homebutton. Dieser kann das Gerät ebenso wie der Lockbutton aus dem Standby-Modus aufwecken. iOS ist darauf ausgelegt mit allen anderen Apple-Produkten zusammenzuarbeiten. Es unterstützt Multi-Touch mit bis zu fünf Fingern. Multitouch wird teilweise zur Gestensteuerung verwendet, so lassen sich beispielsweise Apps durch Gesten schließen oder wechseln. + +## Android +- Überblick + - Android ist sowohl ein Betriebssystem als auch eine Software-Plattform für mobile Geräte wie Smartphones, Mobiltelefone, Netbooks und Tablet-Computer, die von der Open Handset Alliance (gegründet von Google) entwickelt wird. Basis ist der Linux-Kernel. Bei Android handelt es sich um freie Software, die quelloffen entwickelt wird. +- Der Anfang + - Im Sommer 2005 kaufte Google das im Herbst 2003 von Andy Rubin gegründete Unternehmen Android. Ursprünglich war Android ausschließlich zur Steuerung von Digitalkameras gedacht. Am 5. November 2007 gab Google bekannt, gemeinsam mit 33 anderen Mitgliedern der Open Handset Alliance ein Mobiltelefon-Betriebssystem namens Android zu entwickeln. Seit dem 21. Oktober 2008 ist Android offiziell verfügbar. + - Als erstes Gerät mit Android als Betriebssystem kam am 22. Oktober 2008 das HTC Dream unter dem Namen T-Mobile G1 in den USA auf den Markt. Dass bereits dieses erste Gerät auf das Global Positioning System (GPS) zugreifen konnte und mit Bewegungssensoren ausgestattet war, gehörte zum Konzept von Android. +- [Oberfläche](http://de.wikipedia.org/wiki/Android_%28Betriebssystem%29#Oberfl.C3.A4che_und_Bedienung) +- Architektur + ![](Assets/ContentVerwertungsmodelle-Android-Architektur.jpg) + Android baute anfangs auf dem Linux-Kernel 2.6 auf, ab Android 4.x auf einen Kernel der 3.x-Serie. Er ist für die Speicherverwaltung und Prozessverwaltung zuständig und stellt die Schnittstelle zum Abspielen von Multimedia und der Netzwerkkommunikation dar. Außerdem bildet er die Hardwareabstraktionsschicht für den Rest der Software und stellt die Gerätetreiber für das System. +- [Versionen](https://de.wikipedia.org/wiki/Liste_von_Android-Versionen) +- Java + - Anwendungen für die Android-Plattform werden in der Regel in Java geschrieben. + - Die Java-Laufzeitumgebung von Android basiert auf der Dalvik Virtual Machine, einer von Google-Mitarbeiter Dan Bornstein entwickelten virtuellen Maschine. Die Dalvik-VM ähnelt funktional der normalen Java-VM, beide führen sogenannten Byte-Code aus. Einer der wesentlichen Unterschiede ist die zugrundeliegende virtuelle Prozessorarchitektur. + - Die Java-VM basiert auf einem Kellerautomaten; Dalvik-VM hingegen ist eine Registermaschine. Durch die sich unterscheidende Prozessorarchitektur sind die Kompilate normaler Java-Compiler nicht für die Dalvik-VM geeignet, dennoch konnte Google auf die bestehenden Java-Entwicklungswerkzeuge zurückgreifen. + - Da das Prozessormodell des Kellerautomaten besonders einfach ist, wird es üblicherweise für die Übersetzerzwischensprache verwendet. Die meisten realen Prozessoren sind heute aber Registermaschinen (x86- und die ARM- Prozessoren). Registerarchitekturen sind oft effizienter. Dalvik nimmt die Umwandlung des Kellerautomatencodes in die Registermaschinencodes schon zur Übersetzungszeit vorweg. Dafür wird das Werkzeug dx (Dalvik Cross-Assembler). + +## Fuchsia von Google +- Im Gegensatz zu Android nicht auf einen Linux-Kernel basierend +- Fuchsia als Echtzeitbetriebssystem basiert auf den Mikrokernel Zircon +- Läuft auf verschiedenen Mobiltelefonen und PCs +- Noch unklar, ob und wann Fuchsia Android ersetzen soll. +- In der Zwischenzeit kann man sich Flutter ansehen: https://flutter.dev/ + - Vergleichbar mit React Native + +## Wear OS +- Wear OS (bis zum 16.3.18 Android Wear) wurde vom Betriebssystem Android abgeleitet und speziell für Smartwatches und andere Wearables entwickelt. +- Es wurde am 18. März 2014 erstmal präsentiert. Laut Hersteller bietet es Google-Now-Funktionen im Gehäuse einer Armbanduhr. + - Mit Google-Now erhält man Karten mit hilfreichen Informationen für den Tagesablauf - und das sogar, bevor man danach sucht + - Seit 2017 ist Android Wear 2.0 verfügbar. + - Seit 2018 unbenannt in "Wear OS by Google" +- https://de.wikipedia.org/wiki/Wear_OS +- Für den Entwickler + - https://developer.android.com/training/wearables + - Tutorial: [http://www.smartwatch.me/t/tutorial-how-to-develop-android-wear-apps-for-](http://www.smartwatch.me/t/tutorial-how-to-develop-android-wear-apps-for-beginners-part-1-setup/684) + +## Weitere Informationen +- [Betriebssystem](http://de.wikipedia.org/wiki/Betriebssystem) +- [PDA- und Smartphone-Betriebssysteme](http://de.wikipedia.org/wiki/Liste_von_Betriebssystemen#PDA-_und_Smartphone-Betriebssysteme) +- [Mobile Information Device Profile](http://en.wikipedia.org/wiki/Mobile_Information_Device_Profile) +- [http://developer.nokia.com/community/wiki/MIDP_2.0](http://developer.nokia.com/community/wiki/MIDP_2.0) +- [Symbian OS](http://de.wikipedia.org/wiki/Symbian-Plattform) +- [BlackBerry OS](http://en.wikipedia.org/wiki/BlackBerry_OS) +- [BlackBerry 10](http://en.wikipedia.org/wiki/BlackBerry_10) +- [Apple iOS](http://de.wikipedia.org/wiki/Apple_iOS) +- [Android](http://de.wikipedia.org/wiki/Android_%28Betriebssystem%29) +- [Wear OS](https://developer.android.com/training/wearables) + +# Apps - Entwurf und Programmierung +Überblick +- Was ist eine App? +- Verschiedene Grundtypen + - Native App, Web-App und hybride App +- User-Interface (UI) Prototype Design +- Unterschiedliche Wege der Programmierung und ausgewählte Entwicklungssysteme + - Native, für ein Betriebssystem angepasst + - Native, für mehrere Betriebssysteme + - Hybride + +## Was ist eine App? +App steht für den englischen Begriff application (bzw. Applikation). Und bezeichnet damit eine Anwendungssoftware (bzw. ein Anwendungsprogramm). Anwendungsprogramme (wie z.B. Textverarbeitung oder Computerspiele) dienen der Lösung von Anwenderproblemen. Anwendungssoftware grenzt sich von Systemsoftware und systemnaher Unterstützungssoftware (wie z.B. Betriebssysteme oder Compiler) ab. +Im Deutschen wird die Abkürzung App seit dem Erscheinen des Apple App Stores (2008) fast ausschließlich mit mobiler App gleichgesetzt, also Anwendungssoftware für Mobilgeräte wie Smartphones und Tablet-Computer. Apple hat diese Kurzform von Application eingeführt. +Sicherlich auch mit bewusster Anspielung auf den Firmennamen Apple. +Inzwischen versucht Microsoft unter Windows 8/10 auch Desktop-Anwendungen als Apps zu bezeichnen. +Hier steht App weiterhin nur für Anwendungssoftware für Mobilgeräte. +[http://de.wikipedia.org/wiki/Anwendungssoftware](http://de.wikipedia.org/wiki/Anwendungssoftware) + + +## Zwei App-Grundtypen +| | Native App | Web-App | Hybrid | +| ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| | Eine App, die speziell für ein einzelnes Betriebssystem ausschließlich mit dem vom Betriebssystem-Anbieter hierfür breitgestellten SDK (System Development Kit) entwickelt wurde. Wird über App-Stores verbreitet und auf dem Endgerät installiert. | Eine Web-App läuft komplett im Browser ab. Eine Web-App wird als Web-Seite vom Web-Server geladen. Neben HTML wird CSS und JavaScript genutzt. | Eine hybride App, ist eine native App, die für die Darstellung der Oberfläche eine Browser-Komponente nutzt. Der größte Teil der App ist in HTML, CSS und JavaScript erstellt. Nativer Code, der über JavaScript der Oberfläche zu gänglich ist, ermöglicht den Zugriff auf native Gerätefunktionen. | +| Vorteile: | Eine native App kann die über das jeweilige Betriebssystems angebotenen Hardware-Ressourcen optimal nutzen. Native Apps können daher sehr performant und Ressourcen-sparend sein. | Da HTML, CSS und JavaScript auf allen Betriebssystemen standardisiert sind, laufen Web-Apps auf allen Systemen. Dies reduziert die Entwicklungskosten. | Als native App, kann die hybride App, alle über das jeweilige Betriebssystems angebotenen Hardware-Ressourcen nutzen. Sie kann über App-Stores verbreitet werden. Die Oberfläche und die Interaktionslogik sind für alle Betriebssysteme gleich. Dies reduziert die Entwicklungskosten. | +| Nachteile: | Native Apps müssen für jedes Betriebssystem getrennt entwickelt werden. Die Entwicklungskosten sind daher sehr hoch. | HTML, CSS und JavaScript müssen vom Browser interpretiert werden. Daher ist die Performanz gering. Der Browser kann nicht auf alle Hardware-Ressourcen (wie z.B. Kamera und Datei-System) zugreifen. Kann nicht über App-Stores verbreitet werden. | HTML, CSS und JavaScript müssen vom Browser interpretiert werden. Daher ist die Performanz/Reaktionszeit der Oberfläche oft zu gering. | + +## User-Interface (UI) Prototype Design +Wireframe / Mock-Up +- Wireframes (Drahtgerüst) oder Mock-Ups (Attrape) werden dazu benutzt, um einen sehr frühen konzeptuellen (nicht funktionsfähigen) Prototypen eines App-Frontends darzustellen. Navigation und Nutzerführung und wesentliche Inhaltsbereiche sollten Teil dieses Skeletts sein. +- Im Gegensatz zu statischen Wireframes ermöglichen dynamische Wireframes die Navigation zwischen den einzelnen Ansichten. +- Beispiele + - [Balsamiq](http://www.balsamiq.com) + - [Proto.io](http://www.proto.io) + - [InVision](http://www.invisionapp.com) + - [Fluid UI](https://www.fluidui.com) + - [UXPin](http://www.uxpin.com) + - [Pencil](http://pencil.evolus.vn/) +- [Wireframing Basics: The Easy Way to Get Started](http://www.youtube.com/watch?v=aqdn7vVKygA) +- [What is a Wireframe?](http://www.youtube.com/watch?v=T0vt3nLZKks) + +## Entwicklungsumgebungen +- IDEs für Apps + - [Xcode von Apple für iOS](https://developer.apple.com/xcode/) + - [Android Studio](https://developer.android.com/studio/) + - [Visual Studio IDE Community 2019 für Windows und Mac](https://visualstudio.microsoft.com) + - [Visual Studio Code (Universal IDE)](https://code.visualstudio.com) +- Cross-Plattform + - [React Native](https://reactnative.dev/) + - [Xamarin](http://www.xamarin.com) + - [Flutter](https://flutter.dev) +- Hybrid + - [Apache Cordova](http://cordova.apache.org/) +- Ganz anders (cool, online grafisch): + - [App Inventor](http://appinventor.mit.edu/explore/get-started) + +## Xcode (Version 11) +IDE von Apple zur Erstellung nativer Apps für sämtliche iOS Geräte. Leider nur für Mac verfügbar. + +Xcode hat inzwischen eine sehr gute Unterstützung bei der Erstellung des UI und der Verknüpfung mit dem Code. + +Xcode ist kostenlos. + +Die Programmierung erfolgt ab Version 6 in Swift. Aktuell in der Version 5. + +[iOS Tutorial: How to make an iPhone App (Xcode 9, Swift 4, iOS 12)](https://www.youtube.com/watch?v=5b91dFhZz0g) + +## Android Studio 3.x +Google hat auf Basis von IntelliJ das Android Studio entwickelt. +Android Studio löste die für Java spezialisierte OpenSource IDE Eclipse ab. + +Das Android SDK beinhaltet auch einen Emulator, der flexibel für verschiedene Geräte angepasst werden kann. + +[How to Build Your First App in Android Studio 3.1.1 Tutorial Hello World!](https://www.youtube.com/watch?v=UQlDjsfiQ-k) + + +## Xamarin +Die Entwickler von Mono (quelloffene Implementierung des .NET Framework) gründeten im Jahr 2011 die Firma Xamarin. Xamarin wurde im Februar 2016 von Microsoft übernommen. Xamarin ist nun Bestandteil von Visual Studio. + +Mit der Programmiersprache C# können Entwickler iOS-, Android- und Windows-Apps schreiben. Der Quellcode kann für alle Plattformen gemeinsam benutzt werden. + +Xamarin Platfrom Mit den Komponenten Xamarin.iOS und Xamarin.Android ist es möglich, native Apps für iOS, Android und Windows in C# entweder mit Xamarin Studio oder Visual Studio zu entwickeln. + +Xamarin.Forms erlaubt portable Bedienelemente zu verwenden (über XAML), welche die eigentlichen Bedienelemente von Android, iOS und Windows Phone aufrufen. + +[https://de.wikipedia.org/wiki/Xamarin] + +[Creating a Simple Xamarin App](http://www.youtube.com/watch?v=gm-RgfdaISU) + +## Visual Studio Community 2019 +(mit Xamarin.forms) + +Visual Studio und Xamarin Studio nutzen das Android SDK, um native Android Apps zu erstellen. Native iOS Apps können mit Xamarin Studio für den Mac oder Visual Studio erstellt werden. Visual Studio benötigt dazu einen Mac (mit Xcode und Xamarin) im lokalen Netzwerk. + +## Apache Cordova +- Apache Cordova (PhoneGap) +- Eine Plattform zur Erstellung von nativen Apps für alle mobilen Betriebssysteme +- Hybride App aus Web-App und nativen Teil +- Web-App Programmierung mit HTML5 +- [Getting Started With Visual Studio Tools For Apache Cordova](https://docs.microsoft.com/en-us/visualstudio/cross-platform/tools-for-cordova/first-steps/build-your-first-app) + +## Cross-Plattform +- React-Native von FB + - Native Apps für Android und iOS + - Native UIs + - Weit verbreitet + - Programmierung in JavaScript + - JavaScript wird in der App ausgeführt. Ermöglicht Hot Code Reloading + - Web-Apps mit React + - Wissen kann genutzt werden, um Web-Apps zu entwickeln +- Flutter von Google + - Native Apps für Android und iOS + - Native UIs + - Noch neu + - Programmierung in Dart + - Just In Time compilation (JIT) ermöglicht Hot Code Reloading + - Wird in ARM bzw. x86 Code übersetzt. Beste Performance. + - Web Apps? Googles Angular ist ganz anders + +## Weitere Informationen +- [Anwendungssoftware (Apps)](http://de.wikipedia.org/wiki/Anwendungssoftware) +- [iOS Human Interface Guidelines](https://developer.apple.com/design/human-interface-guidelines/ios/overview/themes/) +- [Swift](http://de.wikipedia.org/wiki/Swift_%28Programmiersprache%29) +- [Download von Visual Studio Code](https://code.visualstudio.com/download) + + +# Was ist (mobile) Content? +Überblick +- Was ist Content? + - Content-Typen +- Was ist mobiler Content? +- User-generated Content +- Open Data + + +## Was ist Content? +Seit etwa Mitte der 1990er Jahre wird im deutschen Sprachraum im Zusammenhang mit den Neuen Medien und später dem Internet der Anglizismus **Content** (englisch _der Gehalt_ , _der Inhalt_ ) als Synonym für (digitalisierten) Medieninhalt verwendet. + +Medieninhalte (Content) werden von der Infrastruktur eines Mediums (wie z.B. dem Fernsehen) abgegrenzt. Der Content von YouTube ist beispielsweise nicht die Plattform als ganzes, sondern die Gesamtheit der abrufbaren Videos mit ihren Beschreibungen und Nutzerkommentaren. + +Content ist das, was für den Konsumenten einen Wert bzw. Nutzen darstellt. Content ist Information die über ein Medium (den Kanal) übermittelt wird. Das Medium (z.B. das Fernsehen, YouTube ...) stellt ohne den Content keinen Nutzen für den Konsumenten dar. + + +Was passiert mit Content? +- Content wird ... + - produziert, + - gespeichert, + - übertragen + - und konsumiert + +### Content-Typen bzw. Medientypen +Die Daten des Contents werden als Datei gespeichert bzw. als Stream übertragen. Der Internet Media Type, auch MIME-Type (nach der Spezifikation Multipurpose Internet Mail Extensions) oder Content-Type (nach dem Namen des Feldes), klassifiziert die Content-Daten. + +Der Internet Media Type besteht aus zwei Teilen: der Angabe eines Medientyps und der Angabe eines Subtyps. Z.B. image/png Es gibt folgende Medientypen: +- _application_ - für uninterpretierte binäre Daten, Mischformate oder Informationen, die von einem bestimmten Programm verarbeitet werden sollen +- _audio_ - für Audiodaten +- _example_ - Beispiel-Medientyp für Dokumentationen +- _image_ - für Grafiken +- _message_ - für Nachrichten, beispielsweise _message/rfc822_ +- _model_ - für Daten, die mehrdimensionale Strukturen repräsentieren +- _multipart_ - für mehrteilige Daten +- _text_ - für Text +- _video_ - für Videomaterial + +## Was ist mobiler Content? +Mobiler Content kann auf einem mobilen Endgerät mobil genutzt werden. +Content sollte in der Regel für die mobile Nutzung speziell aufbereitet (umgewandelt) werden. Bei Bildern muss möglicherweise die Größe angepasst werden. Nicht jeder Content (z.B. längere Videos oder Spielfilme) ist für mobile Nutzung geeignet. + +## User-generated Content (UGC) +User-generated Content (UGC) ist Content, der nicht vom Anbieter der Plattform, sondern von dessen Nutzern erstellt wird. Konsumenten (Consumer) sind gleichzeitig Produzenten (Producer). +Diese Verbindung wird auch Prosumer genannt. Häufig ist UGC eine Erscheinungsform von Crowdsourcing. Beispiele von UGC sind z.B. Kommentarfunktionen in Blogs, Videoportale wie YouTube oder auch Wikipedia. + +## Open Data +Open Data bedeutet die freie Verfügbar- und Nutzbarkeit von Daten (bzw. Content), typischerweise öffentlicher bzw. staatlicher Einrichtungen. Man geht dabei davon aus, dass durch die freie +Zugänglichmachung, vorteilhafte Entwicklungen wie z.B. Open Government gefördert werden. + +Offene Daten sind sämtliche Datenbestände, die im Interesse der Allgemeinheit der Gesellschaft ohne jedwede Einschränkung zur freien Nutzung, zur Weiterverbreitung und zur freien Weiterverwendung frei zugänglich gemacht werden. Zu denken wäre etwa an Lehrmaterial, Geodaten, Statistiken, Verkehrsinformationen, wissenschaftliche Publikationen, medizinische Forschungsergebnisse oder Hörfunk- und Fernsehsendungen. + +In der Regel verwenden die Anbieter von "Open Data" Lizenzmodelle, die auf Copyright, Patente oder andere proprietäre Rechte weitgehend verzichten. + +[Vorstellung Open Data Portal Österreich](http://www.youtube.com/watch?v=lPIyCIFjZro) + +Open Data Portale +- [Deutschland](https://www.govdata.de/) +- [Deutsche Bahn](http://data.deutschebahn.com/) +- [U.S.A](https://www.data.gov/) + - [APIs](https://www.data.gov/developers/apis) +- [Chicago](https://data.cityofchicago.org/) + - [Crime Map](https://data.cityofchicago.org/Public-Safety/Crimes-Map/dfnk-7re6) +- [GeoNames](http://www.geonames.org/) + +### Weitere Informationen +- [Load resources from a remote URL using React Native](https://reactnative.dev/docs/network) +- [Medieninhalt (Content)](http://de.wikipedia.org/wiki/Medieninhalt) +- [Content](http://en.wikipedia.org/wiki/Content_(media_and_publishing)) +- [What is Content?](http://www.toprankblog.com/2013/03/what-is-content/) +- [Internet Media Type](http://de.wikipedia.org/wiki/Internet_Media_Type) +- [IANA MIME Media Type List](http://www.iana.org/assignments/media-types/media-types.xhtml) +- [User-generated Content](http://de.wikipedia.org/wiki/User-generated_content) +- [Open Data](http://de.wikipedia.org/wiki/Open_Data) +- [Open Data Network](http://opendata-network.org/) + + +# Urheberrecht im Wandel der Zeit +Überblick +- Idee des Urheberrechts +- Geschichte des Urheberrechts +- Fair Use +- Creative Commons + +## Vor dem Urheberrecht +- Bis zur Erfindung des Buchdrucks mit beweglichen Metall-Lettern durch Johannes Gutenberg um 1440 +- Bücher wurden einzeln hergestellt, verkauft und bezahlt +- Schriftsteller, Maler, Bildhauer und Architekten wurden wie Handwerker behandelt +- Sie wurden für Ihre Arbeit entlohnt und hatten darüber hinaus keine weiteren Ansprüche +- Ein Buch durfte zwar nicht gestohlen, wohl aber abgeschrieben werden +- Der Rang eines Künstlers wurde mehr nach seinen handwerklichen Fertigkeiten und nicht nach der Originalität seiner Werke bemessen + +## Schutz der Verleger +- Nach der Erfindung des Buchdrucks wurde es viel einfacher Kopien in großer Anzahl herzustellen. +- Autoren waren schon froh, wenn der Drucker bzw. Verleger auch ihnen etwas dafür zahlte. +- Andere Drucker druckten bald aber die Werke nach, ohne dem Autor etwas zu zahlen. +- Nachdrucker waren gegenüber den Erstdruckern im Vorteil +- Nachdruckern machten oft Fehler beim Nachdruck +- Drucker erbaten von der Obrigkeit Sonderrechte (Privilegien), die das Nachdrucken für eine bestimmte Zeit verboten. +- Die Obrigkeit hatte ein gleiches Interesse (Zensur). Dies gelang in Frankreich mit seiner absolutistischen Struktur besser als in Deutschland. +- Diese Privilegien dienten aber in erster Linie dem Schutz der Verleger zur Sicherung ihres Absatzes + +## Anfänge des Urheberrechts ... +- ... 1710 in England + Im Statute of Anne, wurde das Recht des Autors an seinem Werk erstmals formuliert, das zuvor bei den Verlegern gelegen hatte. [http://www.copyrighthistory.com/anne.html] + Zweck war laut Präambel "the Encouragement of Learning", also die Förderung der Bildung. Dieser Zweck sollte verwirklicht werden, indem das exklusive Druckrecht (right to copy) den jeweiligen Autoren oder den Erwerbern dieses Rechts für die im Gesetz bestimmte Zeiteingeräumt wurde. + Des weiteren sollte die Gelehrten angeregt werden, nützliche Bücher zu verfassen (»Encouragement of Learned Men to Compose and Write useful Books«); + Für neue Werke begrenzte das Gesetz die Schutzfrist auf 14 Jahre. Nach deren Ablauf stand dem lebenden Autor eine Verlängerung um weitere 14 Jahre zu. +- [Urheberrecht im Internet - Erklärfilm](https://www.youtube.com/watch?v=P3hFho5dtC0) +- Deutschland 19. und 20. Jahrhundert + - In Preußen kam es 1837 zu einem entsprechenden Schutz + - Zuerst ein Schutz von 10 Jahren. 1845 auf 30 Jahre nach dem Tod des Autors verlängert. + - 1870 wurde im Norddeutschen Bund ein allgemeiner Urheberrechtsschutz eingeführt, den das Deutsche Reich 1871 übernahm. +- In West-Deutschland wurde am 9. September 1965 das deutsche Urheberrechtsgesetz (UrhG) verkündet. + - Urheberfrist wurde auf 70 Jahre nach dem Tod des Urhebers festgelegt. Damit wurde Deutschland international zu einem Vorreiter im Bezug auf die Verlängerung von Urheberrechtsfristen. Zugleich wurde allerdings auch die Privatkopie wieder legalisiert, die in den 50er Jahren durch Gerichtsentscheidungen entgegen dem damaligen Gesetzeswortlaut aufgehoben wurde. + +## Neue Entwicklungen +- 1996 wurde im Rahmen der Weltorganisation für geistiges Eigentum (WIPO) der WIPO-Urheberrechtsvertrag (WTC) und der WIPO-Vertrag über Darbietungen und Tonträger (WPPT) unterzeichnet. + - Es bildet den Rahmen für die Anpassung der nationalen Urheberrechtsgesetze an die Anforderungen digitaler Netzmedien. + - Das Vervielfältigungsrecht wurde gestärkt, und das Speichern von Werken im Computer wurde ausdrücklich unter diesem Recht subsumiert. + - Recht auf Zugänglichmachung. Die Übertragung und bereits das Anbieten von Werken im Internet ist nur mit Zustimmung der Urheber zulässig. + - Juristischer Schutz technischer Schutzmaßnahmen. Komponenten, deren Zweck es ist, Kopierschutzmechanismen der Rechteinhaber zu umgehen sind verboten. Es ist auch verboten, die Wirkungsweise dieser Komponenten zu beschreiben, so dass sie nachgebaut werden können. Hierdurch wird das Urheberrecht auch zu einem Technologiekontrollrecht. + - Juristischer Schutz von Copyright Management Information. Auch die Veränderung, Fälschung oder Löschung von Informationen, die den Urheber oder den Konsumenten identifizieren oder die erlaubten Nutzungsformen festlegen, sind verboten. +- 1998 in den USA mit dem Digital Millennium Copyright Act umgesetzt +- Die EU setzt den WIPO-Vertrag am 22. Mai 2001 in der Richtlinie 2001/29/EG um +- 2003 folgt Deutschland mit seiner Urheberrechts-Novelle + - "Wirksame technische Maßnahmen zum Schutz eines nach diesem Gesetz geschützten Werkes oder eines anderen nach diesem Gesetz geschützten Schutzgegenstandes dürfen ohne Zustimmung des Rechtsinhabers nicht umgangen werden, ... (Absatz 1 des neu ins Urheberrechtsgesetz aufgenommenen §95a) + - ...Technische Maßnahmen sind wirksam, soweit durch sie die Nutzung eines geschützten Werkes oder eines anderen nach diesem Gesetz geschützten Schutzgegenstandes von dem Rechtsinhaber durch eine Zugangskontrolle, einen Schutzmechanismus wie Verschlüsselung, Verzerrung oder sonstige Umwandlung oder einen Mechanismus zur Kontrolle der Vervielfältigung, die die Erreichung des Schutzziels sicherstellen, unter Kontrolle gehalten wird." +- 2008 der "2. Korb" der Novelle + - Erhalt der Privatkopie, aber: "Wenn für den Nutzer der Tauschbörse offensichtlich ist, dass es sich um ein rechtswidriges Angebot im Internet handelt, darf er keine Privatkopie davon herstellen." + - Es gibt keine Durchsetzung der Privatkopie gegen Kopierschutz + + +## Schranken des Urheberrechts +Schranken des Urheberrechts ist die gesetzliche Bezeichnung für diejenigen Vorschriften des deutschen Urheberrechts, die einen **Ausgleich** zwischen den **Interessen des Urhebers** , dem prinzipiell das ausschließliche Nutzungsrecht eingeräumt ist, und gegenläufigen Interessen (der Nutzer) schaffen sollen. + +Systematisch lassen sich die Schranken in Begrenzungen zugunsten einzelner Nutzer, der Kulturwirtschaft sowie der Allgemeinheit einteilen. Darunter sind beispielsweise die Erlaubnis der Vervielfältigung zu eigenem Gebrauch, die Entlehnungsfreiheit (so z.B. die Zitate) sowie die Gestattung der öffentlichen Wiedergabe im Lehrbetrieb. + +[http://de.wikipedia.org/wiki/Schranken_des_Urheberrechts](http://de.wikipedia.org/wiki/Schranken_des_Urheberrechts) + +## Urheberrechtsreform der Europäischen Union +- [Die Diskussion in Wikipedia](https://de.wikipedia.org/wiki/Urheberrechtsreform_der_Europ%C3%A4ischen_Union) +- [Webschau: EU-Urheberrechtsreform und Artikel 13 - pro und kontra](https://irights.info/webschau/webschau-eu-urheberrechtsreform-und-artikel-13-pro-und-kontra/29417) +- [Rat stimmt für Artikel 13 / Artikel 17 - Wieso stimmen die Agrarminister ab? | RA Christian Solmecke](https://www.youtube.com/watch?v=PBsrFJdyfVo) + +## Urheberrecht versus Copyright +Im Copyright-Law des U.S. Rechtssystems werden im Gegensatz zum kontinentaleuropäischen Urheberrecht, welches Schöpfer und seine ideelle Beziehung zum Werk in den Mittelpunkt stellt, die ökonomischen Aspekte in den Mittelpunkt gestellt. + +Im Gegensatz zum Urheberrecht in Deutschland musste das Copyright bis 1989 in den USA explizit angemeldet werden und erlosch 75 Jahre nach der Eintragung in das zentrale Copyright-Verzeichnis. Inzwischen gilt in den USA für neue Werke ein Schutz bis 70 Jahre nach dem Tod des Urhebers bzw. 95 Jahre für Firmen (Copyright Term Extension Act). Eine Anmeldung des Copyrights bei der Library of Congress ist für den Erwerb des Rechts nach aktueller Gesetzeslage nicht erforderlich, kann aber zum Beispiel bei der Geltendmachung von Schadensersatz vorteilhaft sein. + +## Fair Use +Als Fair Use (deutsch Angemessene Verwendung) bezeichnet man eine Rechtsdoktrin des anglo-amerikanischen Urheberrechts-Systems (z.B. US-amerikanisches Copyright), die bestimmte, nicht autorisierte Nutzungen von geschütztem Material zugesteht, sofern sie der öffentlichen Bildung und der Anregung geistiger Produktionen dienen. + +Die Doktrin erfüllt eine vergleichbare Funktion wie die Schrankenbestimmungen des kontinentaleuropäischen Urheberrechts. + +Im amerikanischen Rechtsraum gestattet Fair Use neben Zitaten etwa auch Parodien auf ein urheberrechtlich geschütztes Werk, aber nicht Satiren. Eine Parodie als solche muss sehr eng mit dem Original verknüpft sein, ansonsten gilt sie als eine nicht erlaubte Satire. + +## Creative Commons +- Hintergrund: Die Werke eines Urhebers sind normalerweise urheberrechtlich geschützt. Der Urheber kann aber entscheiden, dass er Werke anderen Menschen zur Verfügung stellt, ohne dass sie ausdrücklich um Erlaubnis fragen müssen. Dazu veröffentlicht er die Werke mit einem entsprechenden Hinweis, dass er zum Beispiel das Recht zum Kopieren, Verändern und Wiederveröffentlichen jedermann zugesteht. + +- Was ist Creative Commons (CC)? CC (englisch für schöpferisches Gemeingut, Kreativallmende) ist eine gemeinnützige Organisation, die 2001 in den USA (durch Lawrence Lessig) gegründet wurde. Sie veröffentlicht verschiedene Standard-Lizenzverträge, mit denen ein Autor der Öffentlichkeit auf einfache Weise Nutzungsrechte an seinen Werken einräumen kann. + +- Bei der Suche nach einer passenden Lizenz für Weiterverwertung konnte man sich ursprünglich drei Entscheidungsfragen stellen lassen: + - Soll die Nennung des Urhebers vorgeschrieben werden? + - Ist kommerzielle Nutzung erlaubt? + - Sind Veränderungen erlaubt? Wenn ja, nur bei der Verwendung derselben Lizenz? +- Daraus ergaben sich zwölf Lizenzmöglichkeiten. + - Antwortete man mit "nein" auf die erste Frage und auf die zweite und dritte mit "ja", so gibt man sein Werk in die Public Domain. + - Antwortet man auf die dritte Frage stattdessen mit "nur bei Verwendung derselben Lizenz", erhält man etwas Ähnliches zur GPL. + - [Erklärung der CC-Lizenzkombinationen](https://www.youtube.com/watch?v=Qal5LlrffRw) + +### Rechtemodule +| Kürzel | Name des Moduls | Kurzerklärung | +| ------ | --------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- | +| by | Namensnennung (englisch:Attribution) | Der Name des Urhebers muss genannt werden. | +| nc | Nicht kommerziell (Non-Commercial) | Das Werk darf nicht für kommerzielle Zwecke verwendet werden, womit nach EU-Recht auch der Verkauf zum Selbstkostenpreis verboten wird. | +| nd | Keine Bearbeitung ( No Derivatives) | Das Werk darf nicht verändert werden. | +| sa | Weitergabe unter gleichen Bedingungen (Share Alike) | Das Werk muss nach Veränderungen unter der gleichen Lizenz weitergegeben werden. | + +### Weitere Informationen +- [Geschichte der Urheberrechts](http://de.wikipedia.org/wiki/Geschichte_des_Urheberrechts) +- [Statute of Anne](http://de.wikipedia.org/wiki/Statute_of_Anne) +- [Statute of Anne](http://www.copyrighthistory.com/anne.html) +- [http://irights.info/](http://irights.info/) +- [Creative Commons](http://de.wikipedia.org/wiki/Creative_Commons) + + +# Geschäftsmodelle und Cloud-Dienste +Überblick +- Geschäftsmodelle mit Content +- Content-Geschäftsmodelltypen +- Abgrenzung von öffentlichen Gütern +- Wert und Kosten von Content +- Erlösmodelle und Erlösformen +- Cloud-Dienste + +## Geschäftsmodelle mit Content +- Ein Geschäftsmodell beschreibt modellhaft, wie ein Unternehmen Werte auf einem Markt erzielt. +- Ein **Verwertungsmodell** ist ein Geschäftsmodell, für geistiges Eigentum. Content basiert auf geistigem Eigentum. +- Ein Geschäftsmodell wird durch drei Hauptkomponenten charakterisiert: + - Der Architektur von Produkten, Dienstleistungen und Informationsflüssen, welche auch eine Darstellung der beteiligten Wirtschaftsakteure und deren Rollen beinhaltet. + - Den potentiellen Nutzen, den das Unternehmen für die verschiedenen Wirtschaftsakteure bietet. + - Das Erlösmodell, welches aufzeigt, aus welchen Quellen und auf welche Weise sich das Unternehmen finanziert. +- Content-Geschäftsmodelle variieren bei: + - Datei-Download + - Online-Konsum/Streaming + - Peer-to-peer (P2P) und Superdistribution + - Download mit DRM (Verleih, Abo, Pay-per-track) + +## Abgrenzung von öffentlichen Gütern +- Content-Geschäftsmodelle beruhen darauf, dass Rivalität und Ausschließbarkeit bei der Nutzung von Content ermöglicht werden kann. + +||| Ausschließbarkeit | | +| --- | --- | --- | --- | +|| | Ja | Nein +|**Rivalität?**| Ja | Individualgut oder auch privates Gut (z. B. Kleidung, Speiseeis) | Allmendegut oder auch Quasikollektivgut (z. B. Fischbestände der Weltmeere, öffentliche Straßen) +|| Nein | Klubkollektivgut oder auch natürliche Ressource (z. B. Kabelfernsehen, Feuerschutz) | Öffentliches Gut oder auch reines Kollektivgut (z. B. frei zugängliches Wissen, Nationale Verteidigung, Rechtsordnung, Währungssystem) + + +## Wert von Content +Soll ein spezielles Content-Geschäftsmodell erfolgreich sein, muss es die drei verschiedene Wertebegriffe Warenwert, Gebrauchswert und Tauschwert in Einklang bringen und dabei auch das bestehende Wertverständnis der Konsumenten beachten. + +## Kosten für Content +- Stückkostendegression bei Content (Beispiel) + +## Erlösmodelle und Erlösformen +- Die Erlöse für Content bestimmen den Wert und die Nachhaltigkeit eines Geschäftsmodells + +| Direkt |Direkt | Direkt | Indirekt | Indirekt | +| --- | --- | --- | --- | --- | +| Nutzungsabhängig | Nutzungsunabhängig| Nutzungsunabhängig | von Unternehmen | vom Staat | +| | Einmalig | Regelmäßig wiederkehrend | +| Einzeltransaktionen nach Leistungsmenge (Pay-per-use) oder Leistungsdauer (Pay-per-time) | Abschlussgebühren, Lizenzgebühren, Decoder- bzw. App-Kauf | Abonnement, Sonstige Grundgebühren | Werbung, Sponsoring, Kommission / Provisionen / Querfinanz. Sonstige | Subventionen | + +## Einordnung von Cloud-Diensten +| Traditionell | | | Cloud | | | +| ----------------- | ----------------- | ---------------- | ---------------- | ----------- | ---------- | +| **On-Premise** | **Colocation** | **Hosting** | **IaaS^1** | **PaaS^2** | **SaaS^3** | +| Data | Data | Data | Data | Data | Data | +| Application | Application | Application | Application | Application | +| Databases | Databases | Databases | Databases | +| Operating System | Operating System | Operating System | Operating System | +| Virtualization | Virtualization | Virtualization | +| Physical Servers | Physical Servers | +| Network & Storage | Network & Storage | +| Data Center | + +- ^1 IaaS : Infrastructure-as-a-Service, +- ^2 PaaS : Platform-as-a-Service +- ^3 SaaS : Software-as-a-Service + +Was ist Amazon Web Services (AWS)? +- AWS ist der Cloud-Marktführer und technologische Vorreiter +- AWS war zuerst IaaS und dann PaaS +- AWS ist aber auch inzwischen SaaS + +## Der Cloud Markt 2019 +- EC2 von Amazon Web Services (EC2 = Elastic Cloud Compute) +- Virtualisierte Server + - Können in Minuten bereitgestellt werden + - Man kann Server in der genau passenden Größe bekommen +- Flexible Preismodelle + - Man zahlt nur die Zeit, die der Server läuft + - Man zahlt nur die benötigte Hardware + +# Distribution über AppStore und Google-Play +Überblick +- Ohne App Store +- Mit App Store +- App Store Guidelines +- Einreichung bei Apple +- Jailbreak +- Einreichung bei Google Play +- Und bei Microsoft + +## Wie geht es ohne?! +Bevor Apps populär wurden, wurde Software bereits online vertrieben. Software wurde häufig unmittelbar vom Entwickler zum Nutzer der Software vertrieben. Bestellung und Bezahlung ging vom Nutzer direkt an den Entwickler. Entwickler hatten große Freiheiten. Problem für den Software-Nutzer: Bei jedem Entwickler war die Distribution und Bezahlung der Software anders. Es gab keine zentrale Stelle, bei der es alle Software gab. + +## Apple fügt den App Store dazwischen +Apple führt den zentralen App Store ab iOS 2.0 ein. Alle Entwickler müssen ihre Apps hierüber vertreiben. Alle Apps werden von Apple geprüft. Der Entwickler ist sehr eingeschränkt. Der Entwickler erhält 70% des Verkaufspreises. Direktvertrieb nur für zeitlich limitierte Test-Versionen. + +## App Store Guidlines +- Die App muss Apple's App Store Guidelines befolgen, damit sie von Apple angenommen wird. + https://developer.apple.com/app-store/review/guidelines/ +- Was Apple zu Beispiel nicht haben möchte + - We will reject incomplete app bundles and binaries that crash + - Don’t simply copy the latest popular app on the App Store, or make some minor changes to another app’s name or UI and pass it off as your own. + - Your app should include features, content, and UI that elevate it beyond a repackaged website. + - Apps that appear confusingly similar to an existing Apple product, interface, or advertising theme will be rejected + - Apps containing pornographic material, defined by Webster's Dictionary as "explicit descriptions or displays of sexual organs or activities intended to stimulate erotic rather than aesthetic or emotional feelings", will be rejected + +## Einreichung bei Apple im Überblick +- Um eine App über den Apple App Store verbreiten zu können, benötigt der Entwickler einen Apple Developer Account und muss Mitglied im iOS Developer Programm sein. +- Für die Einreichung wird benötigt: + - Eindeutige App ID + - Distribution Certificate & Private Key (im Apple Developer + Center erzeugt) + - Distribution Provisioning Profile + - Optional: Push Notification Certificate + - Icons und Loading Screens +- [How To Submit An App To App Store - Xcode 10](http://www.youtube.com/watch?v=qqtW7YrmSJQ) + +## Test einer iOS App +- Mit der App TestFlight +- https://developer.apple.com/testflight/ + + +## iOS Jailbreak +**Jailbreak** bezeichnet das nicht-autorisierte Entfernen von Nutzungsbeschränkungen bei Geräten der Informationstechnik, deren Hersteller bestimmte Funktionen serienmäßig gesperrt hat. Der Begriff entstand ursprünglich mit Bezug auf die Virtualisierungsumgebung von FreeBSD. Populär wurde er jedoch erst durch den Jailbreak der iOS-Geräte, da Apple ein striktes "Closed World"-Geschäftsmodell verfolgt - was unter anderem bedeutet, dass auf den Geräten ausschließlich Software aus dem firmeneigenen App Store installiert werden kann. + +Bei Geräten mit Linux- oder dem damit verwandten Android-Betriebssystem ist eher der umgangssprachliche Begriff "Rooten" gebräuchlich. +Mittels entsprechender Software wird bei einem Jailbreak das Betriebssystem Apple iOS (bis iOS 7 öffentlich zugänglich) modifiziert, um Zugriff (sogenannte Root-Rechte) auf interne Funktionen sowie das Dateisystem zu erhalten. Im Serienzustand der Geräte ist dieses hingegen nicht möglich. Anschließend wird von den meisten Jailbreaking-Programmen eine Softwareverwaltung (meistens **Cydia** ) aufgespielt, mit welcher beliebige, auch vom Hersteller Apple nicht freigegebene Software installiert werden kann. Da iOS auf dem Unix-artigen Betriebssystem Darwin basiert, erhält der Benutzer mit dem Jailbreak gleichzeitig Administrator-Zugriff auf ein vollwertiges Unix-Betriebssystem. Dieses kann etwa über Kommandozeilen-Tools genutzt werden. + +[http://de.wikipedia.org/wiki/Jailbreak_(iOS)](http://de.wikipedia.org/wiki/Jailbreak_(iOS)) + + +## Einreichung Google Play im Überblick +- Android Apps (*.apk) können auch direkt an die App-Nutzer verteilt werden. Google Play ist nicht der einzige "App Store” für Android Apps. Google Play ist aber bei den meisten Android-Geräten vorinstalliert. +- Registrierung bei der Google Play Developer Console +- Einreichung Google Play im Detail + - Im Detail gibt es einiges zu beachten: + - [How to Upload Android Apps to Google Play Store](http://www.youtube.com/watch?v=GCmXjdp--HM) + +## Und bei Microsoft? +- Microsoft hat sich an Apple orientiert. Auch bei Microsoft geht nichts am Store vorbei: + - https://docs.microsoft.com/de-de/windows/uwp/publish/ + - https://developer.microsoft.com/de-de/store/register + +# Payed-Content und In-App-Payment +Überblick +- Bezahlsysteme +- Bezahlsysteme und Payed-Content +- Abrechnungsmethoden +- Ausgewählte Bezahlsysteme +- Apples App Store ist ein Bezahlsystem +- Apples In-App-Payment +- Consumable und Non-Consumable +- Abonnements (subscription) +- Google Play Billing Library + +## Bezahlsysteme +Bezahlsysteme für Content sind spezialisierte Vermittler und Dienstleister. Sie stehen zwischen Käufer und Content-Anbieter. + +## Bezahlsysteme und Payed-Content +- Bezahlsysteme ermöglichen erst Payed-Content (bezahlten Content) +- Da bei Content die Transaktionshöhe oft sehr gering ist (ein Song für 99 Cent), können Transaktionen beim Bezahlsystem gebündelt werden, um so die Kosten für den Content-Anbieter zu senken. +- Neue Abrechnungsmodelle (z.B. Abonnement) können vom Bezahlsystem angeboten werden. Hierbei werden Transaktionen zyklisch wiederkehrend vom Bezahlsystem veranlasst. +- Der technische Aufwand bei Content-Anbieter kann reduziert werden, da er nicht alle Abrechnungsmodelle und Bezahlverfahren selbst umsetzen muss. +- Der Mangel an Vertrauen in kleine Content-Anbieter könnte zum Problem werden. Durch ein zwischengeschaltetes bekanntes Bezahlsystem können Bedenken der Käufer reduziert werden. + +## Abrechnungsmethoden +- Vorkasse/Überweisung: Bevor der Content-Anbieter den Content ausliefert, muss der Käufer den vollen Betrag überweisen. Diese Abrechnungsmethode bietet dem Händler maximale Sicherheit, da der Kunde eine Überweisung kaum stornieren kann. Diese Methode ist bei Content unüblich, da der Käufer die Banklaufzeiten erst abwarten muss, bevor er den Content erhält. Das Bezahlsystem _Sofortüberweisung_ schaltet sich bei einer Online-Überweisung zwischen Käufer und Käuferbank und kann somit den Content-Anbieter unmittelbar nach der Überweisung mitteilen, dass die Zahlung zu seinem Gunsten erfolgreich war. +- Rechnung: Der Käufer zahlt erst nach Erhalt der Ware. Bei der Abrechnung von Content wird diese Methode nicht eingesetzt. +- Lastschrift: Der Käufer autorisiert den Content-Anbieter bzw. das Bezahlsystem (meist durch Übermittlung der Bankverbindung), den festgelegten Rechnungsbetrag vom Käuferkonto abzubuchen. Aus Sicht des Verbraucherschutzes bietet eine Lastschrift eine ähnliche Sicherheit wie eine Rechnung, da sie vom Käufer nach dem Kauf ohne Angaben von Gründen storniert werden kann. Daher besteht keine Zahlungsgarantie für den Content-Anbieter. Sie gehört allerdings zu den kostengünstigsten Abrechnungsmethoden. +- Kreditkarte: Der Käufer teilt dem Content-Anbieter bzw. Bezahlsystem seine Kreditkartendaten (Nummer, Gültigkeitsdauer) mit, die von diesem zur Abrechnung mit dem zwischengeschalteten Kreditkartenunternehmen benutzt werden. Dieses Verfahren bietet keine Zahlungsgarantie, da ohne Unterschrift keine wirkliche Zahlungsverpflichtung für den Karteninhaber besteht. Die Kreditkartennummer ist auch nicht als ein Geheimnis zwischen Käufer und Kartengesellschaft einzustufen, das den berechtigten Karteninhaber nach außen authentifiziert, da sie auf allen Abrechnungsbelegen gedruckt wird. Dieses Problem wurde durch die Einführung der dreistelligen Kartenprüfnummer entschärft. Diese Prüfnummer erscheint auf keinem Beleg und wird beim Kauf zusätzlich angegeben. +- Inkasso per Telefon bzw. Handy: Hier wird der Rechnungsbetrag über die Telefonrechnung beglichen. Entweder über den Anruf einer Mehrwertnummer oder das Senden einer SMS-Nachricht (sog. Premium-SMS) an eine spezielle Mobilfunknummer. Es fallen nicht nur die normalen Verbindungskosten an, sondern darüber hinaus zusätzliche Entgelte, die die jeweilige Telefongesellschaft an den Content-Anbieter weiterleitet. Bei einer SMS löst bspw. ein bestimmter einzugebender Text eine Aktion aus. Mit dieser SMS wird auch die Handy-Nummer des Kunden übermittelt, an die der Anbieter entweder den Content direkt sendet oder es wird eine SMS mit einem Einmalcode zurückgeschickt. Das Inkasso durch die Telefongesellschaft zählt zu den teuersten Methoden. Dem Content-Anbieter bleiben oft weniger als 50%. +- Freischaltkarten: Vor dem eigentlichen Kauf von Content muss der Kunde zuerst eine Rubbelkarte (Scratchcard) erwerben. Mit der auf dieser Karte freizurubbelnden Buchstaben-Ziffern-Kombination erhält der Käufer Zugriff auf ein anonymes Konto, dessen Stand gleich dem Kaufpreis der Freischaltkarte ist. Durch Eingabe dieser Buchstaben-Ziffern-Kombination autorisiert der Käufer Zahlungen. Dieses Verfahren ist von den Prepaid-Handys her bekannt. Die Freischaltkarte ist nahezu die einzige Möglichkeit, Content vollständig anonym zu bezahlen. + +## Ausgewählte Bezahlsysteme +- Paypal: Mit einem PayPal-Account können Zahlungen anderer PayPal-Nutzer entgegen genommen werden (Peer-to-Peer-Zahlung). Möchte man eine solche Peer-to-Peer-Zahlung innerhalb von PayPal durchführen, so muss man nur die E-Mail-Adresse des Zahlungsempfängers wissen. Im PayPal-System gibt man dann diese Adresse, den Betrag und einen Betreff ein und löst per Klick die Transaktion aus. Der Empfänger wird von PayPal per E-Mail über den Eingang einer Zahlung informiert. +- Click&Buy (gibt es nicht mehr): Im Unterschied zu den kontenbasierten Systemen ist click&buy ein Inkasso/Billing-System, welches auf Content beschränkt ist. Die einzelnen Rechnungsbeträge werden gesammelt und am Monatsende per Lastschrift abgebucht bzw. der Kreditkarte belastet und an die jeweiligen Händler überwiesen. +- Paysafecard: Die Firma Paysafecard vertreibt Freischaltkarten (Rubbelkarten), für Zahlungen im Internet. Das Prinzip ist analog zu den Prepaid-Karten für Mobiltelefone. +- Amazon Payments: Amazon wickelt inzwischen auch für andere Online-Shops Zahlungen ab. Der Käufer nutzt hierbei zur Zahlung seine Daten aus dem Amazon-Account. + +## Apples App Store ist ein Bezahlsystem +- Der App Store ist sein eigenes Bezahlsystem + - Der App Store wurde 2008 aus dem Apple iTunes Music Store abgeleitet. Für die Inbetriebnahme eines iPhones ist ein Account im App Store zwingend notwendig. Da es Musik bei iTunes nie kostenlos gab, hat Apple bei der Anmeldung schon immer die Kreditkartendaten abgefragt. Erst später ermöglichte Apple (wegen der kostenlosen Apps) auch eine Anmeldung ohne Kreditkarte. +- Was bedeutet das für den App-Entwickler? + - Er muss sich nicht um die Abwicklung der Bezahlung kümmern. + - Viele Apple Nutzer vertrauen Apple. Hat der Nutzer einmal ein App bezahlt, ist der Vorgang bei der nächsten App der Gleiche. Unbekannte Entwickler profitieren hiervon. + - Der App-Entwickler erhält 70% des Netto-Verkaufspreises von Apple. Also 58 Cent für eine 99 Cent App. + +## In-App-Payment +- Seit iOS 3.0 ermöglicht Apple allen App-Entwicklern Payed-Content über ihre App zu verkaufen + - Die Entwickler dürfen Content in ihren Apps allerding **nur** über Apple verkaufen. Andernfalls wird die App nicht im App Store angenommen. + - Es ist nicht erlaubt physische Produkte über das In-App-Payment abzurechnen. + - Erotik und anderer von Apple untersagten Inhalte dürfen nicht abgerechnet werden + - Entwickler können einen Content-Shop und einen Content-Player in einer App verbinden + - Entwickler können bestimmte Funktionen ihrer App gegen Bezahlung freischalten lassen + - Entwickler können Online-Dienste und Zugang zu Datenbanken abrechnen lassen + +## Consumable und Non-Consumable +- Consumable Products (verbrauchbar) + Content, der sich verbraucht, wie z.B. VoIP Gesprächsminuten +- Non-Consumable Products (nicht verbrauchbar) + Content, der erhalten bleibt und auf allen Geräten eines Nutzers verfügbar ist. Beispiele sind E-Books, Spiele-Level oder zusätzliche freigeschaltete App-Funktionen. + +| | Non-consumable | Consumable | +| --------------------------------------------- | -------------------- | ---------- | +| Wie oft kann es gekauft werden | einmal | mehrmals | +| Taucht im signierten Beleg des App Stores auf | jedes mal | einmalig | +| Synchronisiert über alle Geräte eines Nutzers | ja, durch das System | nein | +| Kann wiederhergestellt werden | ja | nein | + +## Abonnements (subscription) +- Non-renewable subscription + Erlauben den Verkauf von Dienstleistungen mit einer begrenzten Laufzeit. Z.B. den zeitlich begrenzten Zugang zu einer Datenbank mit historischen Fotos. Die App muss dafür sorgen, dass der Zugang auf allen Geräten eines Nutzers möglich ist. Diese Option kann gut genutzt werden, wenn der Nutzer auf dem Server des Content-Anbieters einen eigenen Acount hat. Ablauf und Dauer des Abo muss die App (bzw. der Server) durchsetzen. +- Auto-renewable subscription + Analog zu non-consumable products sind diese Abos unbegrenzt auf alle Geräten eines Nutzers verfügbar. Es können regelmäßig neue Inhalte (z.B. die tägliche Tageszeitung) geliefert werden, zu denen der Nutzer Zugang erhält, während das Abo aktiv ist. Diese Abos haben ein Ablaufdatum, welches automatisch durch das System verlängert wird, sofern der Nutzer nicht dies ablehnt. + +## Google Play Billing Library +- Der Google-Play-Store hat die Funktionalität, die Apple bietet, ebenfalls zur Verfügung. Dort wird es über die Google Play Billing Library umgesetzt. +- Android-Nutzer sind allerdings von Google nicht wie die Apple-Nutzer von Anfang an zum Bezahlen erzogen worden. Das macht es für Content-Anbieter schwieriger. +- Erst seit Mitte 2013 sind flächendeckend Google-Play- Store Rubbelkarten im Handel verfügbar. Dies ermöglicht es nun auch Jugendlichen, ohne Kreditkarte, Apps und Content bei Google Play zu bezahlen. + +[Use the Google Play Billing Library](https://developer.android.com/google/play/billing) + +## Weitere Informationen +- [Jürgen Nützel: Die informatorischen Aspekte virtueller Güter und Waren (Kapitel 5), Oktober 2006 im Unversitätsverlag Ilmenau,](http://www.juergen-nuetzel.de/habilitation.html) +- [In-App Purchase for Developers](https://developer.apple.com/in-app-purchase/) + + +# Digital Rights Management +Überblick +- Symmetrische Verschlüsselung von Content +- Lizenzen (oder Rechteobjekte) +- Public-Key-Kryptographie +- Zertifikate +- Kryptographische Hash-Funktion +- RSA-Verfahren +- DRM-Referenz-Modell + + +Verschlüsselung von Content +- Content-Daten werden verschlüsselt + - Anbieter verteilt nur verschlüsselte Nutzdaten + - Verschlüsselung und Entschlüsselung mit dem gleichen Schlüssel, z.B. mit AES (Advanced Encryption Standard) + - Schlüssel wird getrennt und geheim übermittelt + +## Symmetrische Verschlüsselung +- Einfacher Algorithmus: Bitweise Addition (XOR) + + - Beispiel: Verschlüsselung + - Content-Daten = 11 = 1011 + - Schlüssel = 9 = 1001 + - Daten = Content XOR Schlüssel = 1011 XOR 1001 = 0010 = 2 + - Beispiel: Entschlüsselung + - Verschl. Content-Daten = 2 = 0010 + - Schlüssel = 9 = 1001 + - Content-Daten = Verschl AND Schlüssel = 0010+1001 = 1011 +- XOR: One-Time-pad, Block Schlüssel + ![](Assets/ContentVerwertungsmodelle-sym-verschlüsselung-xor.png) +- Blockweise Verschlüsselung + - XOR kann in der Praxis nur einmalig (one-time pad) angewendet werden (Klartext-Angriff gelingt) + - Gute symmetrische Verfahren wie AES ermöglichen die wiederholte Anwendung des Schlüssels (Erklärung!) + - Blocklänge und Schlüssellänge z.B. 128 oder 256 Bit + ![](Assets/ContentVerwertungsmodelle-sym-verschlüsselung-block.png) + +## AES - Advanced Encryption Standard +- Standard nach dem Verfahren von Rijndael + - In 2000 Sieger eines Wettbewerbs der NIST + - 128 Bit Blocklänge mit 128, 192 oder 256 Bit Schlüssel + - Realisierung in Hardware und Software sehr schnell + - Je nach Schlüssellänge: 10, 12 oder 14 Runden + - Frei von Patenten und unentgeltlich nutzbar + - Details: https://en.wikipedia.org/wiki/Advanced_Encryption_Standard + +## Kontrolle über den Schlüssel +- Schlüssel wird im Endgerät kontrolliert + - Der DRM-Controller kontrolliert die Verwendung des Schlüssels + - Schlüssel muss vor dem Nutzer verborgen bleiben + - DRM-Controller darf nicht vom Nutzer umprogrammiert werden + ![](Assets/ContentVerwaltungsmodelle-Schlüsselkontrolle.png) + +## Lizenzen (oder Rechteobjekte) +- Lizenzen enthalten den Schlüssel und eine Rechtebeschreibung + - Verschlüsselte Content-Daten sind ohne Lizenz wertlos + - Rechtebeschreibung legt die zulässige Nutzungsart (z.B. abspielen) und Nutzungsdauer (z.B. 3 mal oder in den nächsten 48h) fest + - Verschlüsselte Nutzdaten können und sollen kopiert werden + - Lizenzen sind an das Endgerät gebunden (Weitergabe unmöglich oder wirkungslos) + +## Public-Key-Kryptographie +- Grundprinzip + - Es gibt zwei Schlüssel (=Schlüsselpaar) + - Was mit dem einen verschlüsselt wird kann nur mit dem anderen entschlüsselt werden (=asymmetrisch) + - Der eine Schlüssel heißt öffentlich: Public Key + - Der andere Schlüssel heißt privat: Private Key + +## Anwendungen bei DRM +- Geheime Übertragung des CEK: + - Endgerät fordert von einem Lizenz-Server den passenden Schlüssel für die Content-Daten an. + - Lizenz-Server verschlüsselt den CEK (Content Encryption Key) mit dem öffentlichen Schlüssel des Endgerätes + + +## Geheime Übertragung des CEK +Sequenz-Diagramm +![](Assets/ContentVerwertungsmodelle-CEK-übertragung.png) + +## Allgemeine Anwendungen +- Beispiel: Verschlüsselte E-Mail oder SSL + - Sender einer geheimen E-Mail (z.B.) verschlüsselt diese mit dem öffentlichen Schlüssel des Empfängers + - Da asymmetrische Verfahren langsam sind, wird der Inhalt (Nutzdaten) mit einem schnellen symmetrischen Algorithmus (z.B. AES) verschlüsselt. Der symmetrische Schlüssel wird mit dem öffentlichen Schlüssel des Empfängers verschlüsselt. (=hybrid) +- Digitale Signatur + - Integrität von Nachrichten und Authentizität von Kommunikationspartner muss sichergestellt werden + - Ausgetauschte (nicht verschlüsselte) Dokumente (z.B. Rechte in der Lizenz, oder eine App) dürfen nicht verändert werden + - Beteiligte Kommunikationspartner (z.B. Endgerät und Server) müssen sich über den jeweils anderen sicher sein können + - Einsatz von Zertifikaten (z.B. nach X.509) + - Prinzip vereinfacht: Der Sender überträgt das Dokument doppelt. Einmal unverschlüsselt. Ein zweites mal mit seinem privaten Schlüssel verschlüsselt. + - Besser: Sender verschlüsselt mit seinem privaten Schlüssel nur eine Prüfsumme (Hash-Wert, Details später) des Dokumentes. + +## Authentizität durch Zertifikate +- Wie kann der Lizenz-Server dem Endgerät vertrauen? + - Dem öffentliche Schlüssel alleine darf man noch nicht trauen + - Von einer offiziellen Instanz (CA - Certification Authority) ausgestellte Zertifikate bieten Abhilfe +- Was ist ein Zertifikat (nach X.509)? + - Der öffentliche Schlüssel und + - Ein Datensatz über den Besitzer des Schlüssel + - Beides zusammen wurde von einer CA digital signiert + - Das Zertifikat der CA kann beigefügt sein +- Zertifikatsketten + - Der Aussteller des Zertifikates besitzt ein eigenes Zertifikat + +## Kryptographische Hash-Funktion +- ... wird für die digitale Signatur benötigt + - Wird auch Streuwertfunktion genannt + - Die Hash-Funktion ist eine Funktion, die zu einer Eingabe aus einer (üblicherweise) großen Quellmenge eine Ausgabe aus einer (im Allgemeinen) kleineren Zielmenge (die Hash-Werte, meist eine Teilmenge der natürlichen Zahlen) erzeugt. +- Dabei muss gelten: + - Kollisionsfreiheit + - Es darf nicht effizient möglich sein, zwei Quellelemente mit demselben Hash-Wert zu finden. + - Unumkehrbarkeit + - Zu der Funktion gibt es keine effizient berechenbare Umkehrfunktion, mit der es möglich wäre, für ein gegebenes Zielelement ein passendes Quellelement zu finden + +![](Assets/ContentVerwertungsmodelle-krypto-hash.png) + +## Sicherung der Integrität & Authentizität +- ... der Lizenz durch digitale Signatur + - Mit dem Private Key des Lizenz-Servers wird ein über die Rechte und Schlüssel errechneter Hash-Wert verschlüsselt + ![](Assets/ContentVerwertungsmodelle-lizenz-digitale-signatur.png) + + +## Das RSA-Verfahren +- RSA (Rivest, Shamir, Adleman) +- Idee: Multiplikation ist einfach. Die Umkehrung, die Faktorisierung, ist schwierig +- Nehme zwei etwa gleich lange Primzahlen: $p$ und $q$ (Beispiel: $p=11, q=13$) +- Berechne $n = p*q$ ($n = 143$) +- Berechne $\phi(n) = (p-1)*(q-1)$ ($=120$) +- Wähle $e$ (23) mit $ggT(e,\phi(n)) = 1$ +- Berechne $d$ so, dass $e * d ≡ 1 mod \phi(n)$ gilt, $e * d = k * \phi(n) + 1$ ($d = 47$ mit $k = 9$) + - Public Key: $(n,e) (143, 23)$ + - Private Key: $(n,d) (143, 47)$ + - Verschlüsselung mit Public Key: + - $C = K^e \text{ mod } n$ + - $2 = 723 \text{ mod } 143$ + - Entschlüsselung mit Private Key: + - $K = C^d \text{ mod } n$ + - $7 = 2^{47} \text{ mod } 143$ + - Damit n im praktischen Anwendungsfall nicht in p und q faktorisiert werden kann, muss n aktuell eine 1024 bis 2048 bit lange Zahl sein !! + + +Ein 1024 bit RSA-Schlüsselpaar +- $n = 151117088560515543543583509112099097962003663556607044995537346278481881284114992437661794727300361132467861422736444261887801298612841233509930473048074186874048225374579833810514168500718834144275902347213750223932752522075922296123467024433402797906496071473309891192170853187418104035346071158728163015279$ +- $e = 65537$ (fast immer gleich, damit öffentlich) +- $d = 28437784048962238102491957487823949450926822751173149303904086113989304391061388249899795754639293129785100552765744038968250811233229640247157674658618774782653583162649400546666901513074991074038701463640676643839991675942131621634153560437455148272957188215773487794300919331597374861906548026671091235657$ + + +## Referenz-Modell für DRM-Systeme +- DRM-Referenz-Modell + 1. Download des Contents + 2. Content wird geöffnet + 3. DRM-Controller fordert eine Lizenz an + 4. Lizenz wird geöffnet + 5. Der private Geräteschlüssel wird benötigt + 6. Nutzungszähler werden geprüft und angepasst. Entschlüsselter Content wird decodiert + +![](Assets/ContentVerwertungsmodelle-DRM-Modell.png) + + +## Zusammenfassung +- Content ist symmetrisch verschlüsselt + - Content-Daten sind ohne Schlüssel (CEK) wertlos + - Im unverschlüsselten Teil steht die Adresse des Lizenz-Servers +- Schlüssel wird in der Lizenz transportiert + - Lizenz enthält Rechtebeschreibung + - Rechte werden im DRM-Controller ausgewertet +- Asymmetrische Kryptographie + - Nachrichten (z.B. Rechtebeschreibungen) werden von beiden Seiten signiert + - Zertifikate werden eingesetzt + - Schlüssel (CEK) in der Lizenz wird vom Server mit dem öffentlichen Schlüssel des Endgerätes verschlüsselt + - Der private Endgeräteschlüssel ist der Sicherheitsanker + + +## Weitere Informationen +- [Jürgen Nützel: Die informatorischen Aspekte virtueller Güter und Waren, Oktober 2006 im Unversitätsverlag Ilmenau](http://www.juergen-nuetzel.de/habilitation.html) +- [Jürgen Nützel: Digital Rights Management (Seite 28 - 49), in Die Privatkopie, herausgegeben von Frank Fechner, 2007, Universitätsverlag Ilmenau, ISBN 978-3-939473-06-0](https://www.db-thueringen.de/receive/dbt_mods_00007543) +- [http://de.wikipedia.org/wiki/One-Time-Pad](http://de.wikipedia.org/wiki/One-Time-Pad) +- [http://de.wikipedia.org/wiki/Advanced_Encryption_Standard](http://de.wikipedia.org/wiki/Advanced_Encryption_Standard) +- Reinhard Wobst: Abenteuer Kryptologie. 3. Auflage, Addison-Wesley, München 2003 +- [http://de.wikipedia.org/wiki/Digitale_Signatur](http://de.wikipedia.org/wiki/Digitale_Signatur) +- [The Internet Society: RFC 3280 Internet X.509 Public Key Infrastructure](http://www.ietf.org/rfc/rfc3280.txt) +- [http://de.wikipedia.org/wiki/Digitales_Zertifikat](http://de.wikipedia.org/wiki/Digitales_Zertifikat) +- [http://de.wikipedia.org/wiki/RSA-Kryptosystem](http://de.wikipedia.org/wiki/RSA-Kryptosystem) + + +# Mobile Entrepreneurship +## Unternehmertum +Der Begriff Unternehmertum (engl. **entrepreneurship** , von frz. entreprendre), auch Unternehmergeist, Gründertum, Gründerszene oder Gründerkultur, beschäftigt sich als wirtschaftswissenschaftliche Teildisziplin mit dem Gründungsgeschehen oder der Gründung von neuen Organisationen als Reaktion auf identifizierte Möglichkeiten und als Ausdruck spezifischer Gründerpersönlichkeiten, die ein persönliches Kapitalrisiko tragen. +[Wikipedia](https://de.wikipedia.org/wiki/Unternehmertum) + +## Zielgruppe und Einschränkung +- Zielgruppe: + - Einzelpersonen und Mini-Teams (2-3 Personen) + - Noch keine Unternehmer + - Haben eine erste Version einer App entwickelt +- Einschränkungen + - Kein Ersatz für den eigenen Business-Plan + +## Fragen +- Bin ich ein/e Unternehmer/in? + - Möchte ich Geld verdienen? + - Möchte ich neue Kunden gewinnen? +- Was ist mein Geschäftsmodell? +- Welche Rechtsform? +- Wie komme ich an nötiges Kapital? + +## Geschäftsmodell (Empfehlung) +- Wo kommen 1000 bis 3000 Euro im Monat her? + - Tipp: Wenige, dafür aber zahlungskräftige Kunden! +- Entwickeln Sie zuerst ein B2B-Geschäftsmodell + - B2B: Business-to-Business (Firmen sind Kunden) + - B2C: Business-to-Consumer (Privatpersonen sind Kunden) +- Beispiel für B2B-Geschäftsmodell: + - App: Findet für Allergiker die richtige Zeit zum Joggen + - Mögliche Firmen-Kunden: Krankenkassen, Sportartikel-Hersteller ... + - Entwickeln Sie ein White-Label-Konzept, um Ihre App mehreren Krankenkassen und Herstellern zu "verkaufen" + - Betreiben Sie benötigte Server gegen Gebühr selbst. + + +Rechtsform (wenn es ernst wird) +- Gründen Sie eine Unternehmergesellschaft (UG): + - https://de.wikipedia.org/wiki/Unternehmergesellschaft_(haftungsbeschr%C3%A4nkt) + - Vorstufe einer GmbH + - Bis 3 Gründer sehr einfach. + +Wie komme ich an das nötige Kapital? +- Durststrecke bis zum ersten B2B-Kunden selbst finanzieren +- Crowdfunding oder Crowdinvesting + - Übersicht: https://www.startplatz.de/crowdfunding-plattformen/ + + +# Fragestunde & Konsultation +- Klausur 60 Minuten +- Stoff sind Vorlesungsfolien +- Fragestellung z.B: "Schildern Sie Problem im App Projekt" +- zu MobileEnterpreneurship bisher kaum Fragen +- gerne Fragen zu Digital Rights Management + - PublicKey Kryptographie + - Symmetrische/Asymetrische Kryptographie verstanden haben +- allgemeine Fragen z.B. "was ist Content", Definitionen +- keine Programmieraufgabe, evtl mal Verschlüsselung +- Jahreszahlen/Meilensteine sind nicht relevant, kein stupides Auswendiglernen aber grob Reihenfolge der Entwicklung +- mobile Betriebssysteme kennen (Android, iOS + 2 weitere) +- Urheberrecht kommt vor + CreativeCommons (Rechtemodule) +- aktuelle Bezahlsysteme +- unterschied zertifikat - lizenz diff --git a/Datenbank Implementierungstechniken.md b/Datenbank Implementierungstechniken.md new file mode 100644 index 0000000..1fa44e4 --- /dev/null +++ b/Datenbank Implementierungstechniken.md @@ -0,0 +1,1913 @@ +# Motivation und Grundlagen +## Aufgaben und Komponenten eines DBMS +Prinzipien: Die neun Codd’schen Regeln +1. Integration: einheitliche, nichtredundante Datenverwaltung +2. Operationen: Speichern, Suchen, Ändern +3. Katalog: Zugriffe auf Datenbankbeschreibungen im Data Dictionary +4. Benutzersichten +5. Integritätssicherung: Korrektheit des Datenbankinhalts +6. Datenschutz: Ausschluss unauthorisierter Zugriffe +7. Transaktionen: mehrere DB-Operationen als Funktionseinheit +8. Synchronisation: parallele Transaktionen koordinieren +9. Datensicherung: Wiederherstellung von Daten nach Systemfehlern + +Betrachtete Fragestellung +![](Assets/DBimpl-ebenen.png) + +**Zentrale Komponenten** +- **Anfrageverarbeitung** : Planung, Optimierung und Ausführung deklarativer Anfragen +- **Transaktionsverwaltung** : Koordination und Synchronisation von Transaktionen, Durchführung von Änderungen, Sicherung der ACID-Eigenschaften +- **Speichersystem** : Organisation der Daten im Hauptspeicher und auf dem Externspeicher für effizienten Zugriff und Persistenz + +## Relationale vs. nicht-relationale DBMS +**Relationale DBMS** +- Basis: **Relationenmodell** = Daten in Tabellen strukturiert +- Beziehungen über Werte (= Fremdschlüssel), + Integritätsbedingungen +- **SQL** als standardisierte Anfragesprache +- kommerziell erfolgreichstes Datenmodell: Oracle, IBM DB2, + MS SQL Server, SAP HANA, ... + +| WEINE | WeinID | Name | Farbe | Jahrgang | Weingut | +| ----- | ----------------- | ---- | ----- | ----------- | ------- | +| 1042 | La Rose Grand Cru | Rot | 1998 | Château ... | +| 2168 | Creek Shiraz | Rot | 2003 | Creek | +| 3456 | Zinfandel | Rot | 2004 | Helena | +| 2171 | Pinot Noir | Rot | 2001 | Creek | +| 3478 | Pinot Noir | Rot | 1999 | Helena | +| 4711 | Riesling Reserve | Weiß | 1999 | Müller | +| 4961 | Chardonnay | Weiß | 2002 | Bighorn | + +**Kritik an RDBMS / SQL** +- nicht skalierbar + - Normalisierung von Relationen, viele Integritätsbedingungen zu prüfen + - kann man in RDBMS auch vermeiden! +- starre Tabellen nicht flexibel genug + - schwach typisierte Tabellen (Tupel weichen in den tatsächlich genutzten Attributen ab) + - viele Nullwerte wenn alle potentiellen Attribute definiert + - alternativ Aufspaltung auf viele Tabellen + - Schema-Evolution mit **alter table** unflexibel + - tatsächlich in vielen Anwendungen ein Problem +- Integration von spezifischen Operationen (Graphtraversierung, Datenanalyse-Primitive) mit Stored Procedures zwar möglich führt aber oft zu schwer interpretierbarem Code + +**NoSQL-Systeme** +- Datenmodelle + - KV-Stores + - Wide Column Stores + - Dokumenten-orientierte Datenhaltung + - Graph-Speicher + - ... +- Anfragesprache -> unterschiedliche Ansätze: + - einfache funktionale API + - Programmiermodell für parallele Funktionen + - angelehnt an SQL-Syntax + - ... +- Beispiele + - dokumentenorientierte Datenbanksysteme: MongoDB + - semistrukturierte Dokumente in JSON- bzw. BSON-Format + - Anfragen: CRUD erweitert um dokumentspezifische Suche + - Graph-Datenbanksysteme: Neo4j + - Property Graphen als Datenmodell: Knoten und Kanten mit Eigenschaften + - Anfragesprache Cypher + - Muster der Form "Knoten -> Kante -> Knoten ..." + +## OLTP, OLAP und HTAP +### OLTP vs OLAP +| | Online Transactional Processing (OLTP) | Online Analytical Processing (OLAP) | +| -------------------------- | --------------------------------------------------------------------------------- | ------------------------------------------------------------ | +| | -> Klassische operative Informationssysteme | -> Data Warehouse | +| | Erfassung und Verwaltung von Daten | Analyse im Mittelpunkt = entscheidungsunterstützende Systeme | +| | Verarbeitung unter Verantwortung der jeweiligen Abteilung | Langandauernde Lesetransaktionen auf vielen Datensätzen | +| | Transaktionale Verarbeitung: kurze Lese-/ Schreibzugriffe auf wenigen Datensätzen | Integration, Konsolidierung und Aggregation der Daten | +| | ACID-Eigenschaften | | +| | | +| **Anfragen** | | +| Fokus | Lesen, Schreiben, Modifizieren, Löschen | Lesen, periodisches Hinzufügen | +| Transaktionsdauer und -typ | kurze Lese- / Schreibtransaktionen | langandauernde Lesetransaktionen | +| Anfragestruktur | einfach strukturiert | komplex | +| Datenvolumen einer Anfrage | wenige Datensätze | viele Datensätze | +| Datenmodell | anfrageflexibel | analysebezogen | +| Antwortzeit | msecs ...secs | secs ...min | +| | | +| **Daten** | | +| Datenquellen | meist eine | mehrere | +| Eigenschaften | nicht abgeleitet, zeitaktuell, autonom, dynamisch | abgeleitet / konsolidiert, historisiert, integriert, stabil | +| Datenvolumen | MByte ...GByte | GByte ...TByte ...PByte | +| Zugriffe | Einzeltupelzugriff | Tabellenzugriff (spaltenweise) | + +**OLTP: Beispiel** +```sql +BEGIN ; +SELECT KundenNr INTO KNr +FROM Kunden WHERE email = '...'; +INSERT INTO BESTELLUNG VALUES (KNr, BestNr, 1); +UPDATE Artikel SET Bestand = Bestand-1 +WHERE ArtNr = BestNr; +COMMIT TRANSACTION ; +``` + +**OLAP: Beispiel** +```sql +SELECT DISTINCT ROW Zeit.Dimension AS Jahr, + Produkt.Dimension AS Artikel, + AVG(Fact.Umsatz) AS Umsatzdurchschnitt, + Ort.Dimension AS Verkaufsgebiet +FROM (Produktgruppe INNER JOIN Produkt ON Produktgruppe. + [Gruppen-Nr] = Produkt.[Gruppen-ID]) INNER JOIN + ((((Produkt INNER JOIN [Fact.Umsatz] ON Produkt.[Artikel-Nr] + = [Fact.Umsatz].[Artikel-Nr]) INNER JOIN Order ON + [Fact.Umsatz].[Bestell-Nr]= Order.[Order-ID]) INNER JOIN + Zeit.Dimension ON Orders.[Order-ID] = + Zeit.Dimension.[Order-ID]) INNER JOIN Ort.Dimension ON + Order.[Order-ID] = Ort.Dimension.[Order-ID]) ON + Produktgruppe.[Gruppen-Nr] = Produkt.[Gruppen-ID] +GROUP BY Produkt.Dimension.Gruppenname, Ort.Dimension.Bundesland, +Zeit.Dimension.Jahr; +``` + +### HTAP +- HTAP = Hybrid Transactional and Analytics Processing +- Ziel: schnellere Geschäftsentscheidungen durch "Echtzeit"-Verarbeitung +- OLAP und OLTP auf der gleichen Datenbank: naheliegend aber große technische Herausforderung + - sehr unterschiedliche Workloads (Anfrage- und Lastprofile) + - Transaktionsverwaltung: gegenseitige Beeinflussung von Änderungs- und Leseoperationen reduzieren + - unterschiedliche Datenorganisation (physisch, logisch) +- Herausforderungen + - Analytical (OLAP) und Transactional processing (OLTP) + - verschiedene Zugriffscharakterisiken + - verschiedene Performance-Ziele (Latenz vs. Durchsatz) + - => Unterschiedliche Optimierungen notwendig + +## Disk- vs. Main-Memory-Systeme** +**Traditionelle Annahmen** +- Daten sollen dauerhauft aufbewahrt werden +- Datenbank >> Hauptspeicher +- Disk >> Hauptspeicher +- Hauptspeicher = flüchtiger (volatiler) Speicher +- Disk-IO dominiert Kosten + +**Speicherhierarchie** +![](Assets/DBimpl-speicherhierarchie.png) + +**Eigenschaften von Speichermedien** +| | Primär | Sekundär | Tertiär | +| --------------- | -------- | --------- | ------------ | +| Geschwindigkeit | schnell | langsam | sehr langsam | +| Preis | teuer | preiswert | billig | +| Stabilität | flüchtig | stabil | stabil | +| Größe | klein | groß | sehr groß | +| Granulate | fein | grob | grob | + +**Speichermedien** +- **Primärspeicher** + - Primärspeicher: Cache und Hauptspeicher + - sehr schnell, Zugriff auf Daten fein granular: theoretisch jedes Byte adressierbar (Cachelines) +- **Sekundärspeicher** + - Sekundärspeicher oder Online-Speicher + - meist Plattenspeicher, nicht-flüchtig + - Granularität des Zugriffs gröber: Blöcke, oft 512 Bytes + - Zugriffslücke: Faktor 10^5 langsamerer Zugriff +- **Tertiärspeicher** + - Zur langfristigen Datensicherung (Archivierung) oder kurzfristigen Protokollierung (Journale) + - üblich: optische Platten, Magnetbänder + - "Offline-Speicher" meist Wechselmedium + - Nachteil: Zugriffslücke extrem groß + + +**Transferraten HDD vs. SSD** +![](Assets/DBimpl-Transferrate.png) + +**Konsequenz für disk-basierte Systeme** +- blockbasierter Zugriff mit typischen Blockgrößen ≥ 4 KB +- speziell für Magnetplatten Optimierung auf sequentielle Zugriffe + - Disklayout: Organisation der Daten auf der Disk = fortlaufende Folge von Blöcken + - sequentielles Lesen und Schreiben +- Zugriffslücke zwischen Hauptspeicher und Disk durch Caching verbergen (Lokalität von Zugriffen ausnutzen) + +**Main-Memory-Datenbanken** +- klassische Annahmen nicht mehr zutreffend: + - Systeme mit Hauptspeicher im TB-Bereich verfügbar + - Datenbank kann komplett im Hauptspeicher gehalten werden (muss aber dennoch persistent sein) +- **Main-Memory-** oder **Hauptspeicher-** Datenbanken: Ausnutzung der großen Hauptspeicher und Multicore-Architekturen + - Beispiele: SAP HANA, Oracle TimesTen, SQL Server Hekaton, Hyper, MemSQL, ... + - Besonderheiten: hauptspeicheroptimierte Datenstrukturen (Main-Memory-Scans), Persistenz trotz volatilem Speicher, Datenkompression, Nebenläufigkeitskontrolle + + +## Klassische 5-Schichtenarchitektur +**Fünf-Schichtenarchitektur** +- Architektur für klassische DBMS +- basierend auf Idee von Senko 1973 +- Weiterentwicklung von Härder 1987 +- Umsetzung im Rahmen des IBM-Prototyps _System R_ +- genauere Beschreibung der Transformationskomponenten + - schrittweise Transformation von Anfragen/Änderungen bis hin zu Zugriffen auf Speichermedien + - Definition der Schnittstellen zwischen Komponenten + +**5-Schichtenarchitektur: Funktionen** +![](Assets/DBimpl-5-schichten-funktionen.png) + +**5-Schichtenarchitektur: Objekte** +![](Assets/DBimpl-5-schichten-objekte.png) + +Erläuterungen +- mengenorientierte Schnittstelle **MOS** : + - deklarative Datenmanipulationssprache auf Tabellen und Sichten (etwa SQL) +- durch Datensystem auf satzorientierte Schnittstelle **SOS** umgesetzt: + - navigierender Zugriff auf interner Darstellung der Relationen + - manipulierte Objekte: typisierte Datensätze und interne Relationen sowie logische Zugriffspfade (Indexe) + - Aufgaben des Datensystems: Übersetzung und Optimierung von SQL-Anfragen +- durch Zugriffssystem auf interne Satzschnittstelle **ISS** umgesetzt: + - interne Tupel einheitlich verwalten, ohne Typisierung + - Speicherstrukturen der Zugriffspfade (konkrete Operationen auf B+-Bäumen und Hashtabellen), Mehrbenutzerbetrieb mit Transaktionen +- durch Speichersystem Datenstrukturen und Operationen der ISS auf interne Seiten eines virtuellen linearen Adressraums umsetzen + - Manipulation des Adressraums durch Operationen der Systempufferschnittstelle **SPS** + - Typische Objekte: interne Seiten, Seitenadressen + - Typische Operationen: Freigeben und Bereitstellen von Seiten, Seitenwechselstrategien, Sperrverwaltung, Schreiben des Logs +- durch Pufferverwaltung interne Seiten auf Blöcke der Dateischnittstelle **DS** abbilden + - Umsetzung der DS-Operationen auf Geräteschnittstelle erfolgt durch BS + +## Neue Entwicklungen +Anforderungen aus neuen Anwendungen +- Nicht-Standard-Datenmodelle (siehe NoSQL-Systeme) +- flexibler Umgang mit Datenstrukturen (JSON, Schema on Read, ...) +- beschränkte (Lookups) vs. erweiterte (z.B. Graphoperationen, Datenanalysen) Anfragefunktionalität +- Skalierbarkeit zu Big Data (massiv parallele/verteilte Systeme) +- dynamische Daten / Datenströme +- ... + +**Entwicklungen im Hardware-Bereich** +- Multicore- und Manycore-Prozessoren: 64+ Cores + - Nutzung erfordert Parallelisierungstechniken und Nebenläufigkeitskontrolle +- Memory Wall: Hauptspeicherzugriff als Flaschenhals + - RAM-Zugriff 60 ns, L1-Cache: 4 CPU-Zyklen -> Cache-optimierte Strukturen +- Datenbank-Accelerators + - Hardware-unterstütztes Datenmanagement: FPGA, GPU als Coprozessoren, Highspeed-Netzwerk, SSDs als zusätzliche Cache-Ebene, ... +- Persistenter Memory: nicht-volatiler Speicher + - Instant Restart / Recovery von Main-Memory-Datenbanken + +**Zusammenfassung** +- Datenmanagementfunktionalitäten in vielen Softwaresystemen erforderlich +- nicht auf Implementierung kompletter DBMS beschränkt, sondern für nahezu alle datenintensiven Systeme: auch in Suchmaschinen, Datenanalyseanwendungen, eingebetteten Systemen, Visualisierungssystemen, Steuerungssystemen, Entwicklungsumgebungen, ... +- gemeinsame Aufgaben / Komponenten: Datenorganisation und -verwaltung (Indexstrukturen), Transaktionsverwaltung / Nebenläufigkeitskontrolle / Recovery, Anfrageverarbeitung +- betrifft Datenstrukturen und Algorithmen + +# Speicherstrukturen für Datenbanken +## Speicher- und Sicherungsmedien +Speichermedien +- verschiedene Zwecke: + - Daten zur Verarbeitung bereitstellen + - Daten langfristig speichern (und trotzdem schnell verfügbar halten) + - Daten sehr langfristig und preiswert archivieren unter Inkaufnahme etwas längerer Zugriffszeiten +- Speicherhierarchie: + 1. Extrem schneller Prozessor mit Registern + 2. Sehr schneller Cache-Speicher + 3. Schneller Hauptspeicher + 4. Langsamer Sekundärspeicher mit wahlfreiem Zugriff + 5. Sehr langsamer Nearline-Tertiärspeicher bei dem die Speichermedien automatisch bereitgestellt werden + 6. Extrem langsamer Offline-Tertiärspeicher, bei dem die Speichermedien per Hand bereitgestellt werden + +Zugriffslücke in Zahlen +- Zugriffslücke: Unterschiede in den Zugriffsgeschwindigkeiten auf den verschiedenen Speicherebenen + +| Speicherart | Zugriffszeit | CPU cycles | typische Kapazität | +| ------------------------ | ------------ | ---------- | -------------------------- | +| CacheSpeicher | 6 ns | 12 | 256 KB (L2) bis 32 MB (L3) | +| Hauptspeicher | 60 ns | 120 | 1 GB bis 1.5 TB | +| Zugriffslücke $10^5$ | | | +| Magnetplattenspeicher | 8-12 ms | 16*10^6 | 160 GB bis 4 TB | +| Platten-Farm oder -Array | 12 ms | 24*10^6 | im TB- bis PB-Bereich | + +Typische Merkmale von Sekundärspeicher +| Merkmal | Kapazität | Latenz | Bandbreite | +| --------------- | --------- | ------- | -------------------- | +| 1983 | 30 MB | 48.3 ms | 0.6 MB/s | +| 1994 | 4.3 GB | 12.7 ms | 9 MB/s | +| 2003 | 73.4 GB | 5.7 ms | 86 MB/s | +| 2009 | 2 TB | 5.1 ms | 95 MB/s | +| 2019 SSD (NVMe) | 2 TB | ?? | seq.read 3.500 MB/s | +| | | ?? | seq.write 1.600 MB/s | + +Solid State Disk (SSD) +- basierend auf EEPROMs in NAND- oder NOR-Technologie +- Arrays (=Flash-Block mit ca. 128 KB) von Speicherzellen, entweder ein Bit (SLC) oder 2-4 Bit (MLC) +- MLC sind langsamer und haben verkürzte Lebensdauer +- initial ist jedes Bit auf 1 gesetzt, durch Reprogrammieren auf 0 +- Löschen zurück auf 1 nur für ganzen Block +- Konsequenz: langsames Löschen (Lesen = 25 μs, Löschen = 2 ms), begrenzte Lebensdauer (ca. 100.000 Lösch-Schreib-Zyklen) +- Schnittstelle: SATA oder PCIe (NVMe) + +![](Assets/DBimpl-SSD.png) + +SSDs in DBMS +- klassische, auf sequenzielles Lesen ausgerichtete, Strategien von DBMS nutzen die Stärken von Flash-Speicher nicht aus +- kleinere Blockgrößen lassen sich effizient adressieren, sollten aber ein Vielfaches der Flash-Seiten sein +- wahlfreie Lesezugriffe sind effizienter als auf Magnetplatten, sollten aber auf Größen von ca. 4 bis 16 MB begrenzt werden +- konkurrierende IO-Zugriffe sind bis zu einem gewissen Maße ohne negativen Performanzeinfluss durchführbar + +**Speicherarrays: RAID** +- Kopplung billiger Standardplatten unter einem speziellen Controller zu einem einzigen logischen Laufwerk +- Verteilung der Daten auf die verschiedenen physischen Festplatten übernimmt Controller +- zwei gegensätzliche Ziele: + - Erhöhung der Fehlertoleranz (Ausfallsicherheit, Zuverlässigkeit) durch Redundanz + - Effizienzsteigerung durch Parallelität des Zugriffs + +Erhöhung der Fehlertoleranz +- Nutzung zusätzlicher Platten zur Speicherung von Duplikaten (Spiegeln) der eigentlichen Daten => bei Fehler: Umschalten auf Spiegelplatte +- bestimmte RAID-Levels (1, 0+1) erlauben eine solche Spiegelung +- Alternative: Kontrollinformationen wie Paritätsbits nicht im selben Sektor wie die Originaldaten, sondern auf einer anderen Platte speichern +- RAID-Levels 2 bis 6 stellen durch Paritätsbits oder Error Correcting Codes (ECC) fehlerhafte Daten wieder her +- ein Paritätsbit kann einen Plattenfehler entdecken und bei Kenntnis der fehlerhaften Platte korrigieren + +Erhöhung der Effizienz +- Datenbank auf mehrere Platten verteilen, die parallel angesteuert werden können => Zugriffszeit auf große Datenmengen verringert sich fast linear mit der Anzahl der verfügbaren Platten +- Verteilung: bit-, byte- oder blockweise +- höhere RAID-Levels (ab Level 3) verbinden Fehlerkorrektur und block- oder bitweises Verteilen von Daten +- Unterschiede: + - schnellerer Zugriff auf bestimmte Daten + - höherer Durchsatz für viele parallel anstehende Transaktionen durch eine Lastbalancierung des Gesamtsystems + + +RAID-Levels +![](Assets/DBimpl-Raid-level-1.png) +![](Assets/DBimpl-Raid-level-2.png) + +| Level | Striping blockweise | Striping bitweise | Kopie | Parität | Parität dedizierte Platte | Parität verteilt | Erkennen mehrerer Fehler | +| ----- | ------------------- | ----------------- | ----- | ------- | ------------------------- | ---------------- | ------------------------ | +| 0 | √ | +| 1 | | | √ | +| 0+1 | √ | | √ | +| 2 | | √ | | √ | +| 3 | | √ | | √ | √ | +| 4 | √ | | | √ | √ | +| 5 | √ | | | √ | | √ | +| 6 | √ | | | √ | | | √ | + +**Sicherungsmedien: Tertiärspeicher** +- weniger oft benutzte Teile der Datenbank, die eventuell sehr großen Umfang haben (Text, Multimedia) "billiger" speichern als auf Magnetplatten +- aktuell benutzte Datenbestände zusätzlich sichern (archivieren) +- Tertiärspeicher: Medium austauschbar + - offline: Medien manuell wechseln (optische Platten, Bänder) + - nearline: Medien automatisch wechseln (_Jukeboxes_, _Bandroboter_) + +Langzeitarchivierung +- Lebensdauer, Teilaspekte: +- physische Haltbarkeit des Mediums garantiert die Unversehrtheit der Daten: + - 10 Jahre für Magnetbänder, + - 30 Jahre für optische Platten, + - Papier??? +- Vorhandensein von Geräten und Treibern garantiert die Lesbarkeit von Daten: + - Geräte für Lochkarten oder 8-Zoll-Disketten? +- zur Verfügung stehende Metadaten garantieren die Interpretierbarkeit von Daten +- Vorhandensein von Programmen, die auf den Daten arbeiten können, garantieren die Wiederverwendbarkeit von Daten + + +## Struktur des Hintergrundspeichers +Verwaltung des Hintergrundspeichers +- Abstraktion von Speicherungs- oder Sicherungsmediums +- Modell: Folge von Blöcken + ![](Assets/DBimpl-5-schichten-funktionen.png) +- Alternativen: + - jede Relation oder jeder Zugriffspfad in genau einer Betriebssystem-Datei + - ein oder mehrere BS-Dateien, DBS verwaltet Relationen und Zugriffspfade selbst innerhalb dieser Dateien + - DBS steuert selbst Magnetplatte an und arbeitet mit den Blöcken in ihrer Ursprungsform ( _raw device_ ) +- Warum nicht immer BS-Dateiverwaltung? + - Betriebssystemunabhängigkeit + - In 32-Bit-Betriebssystemen: Dateigröße 4 GB maximal + - BS-Dateien auf maximal einem Medium + - betriebssystemseitige Pufferverwaltung von Blöcken des Sekundärspeichers im Hauptspeicher genügt nicht den Anforderungen des Datenbanksystems + +Blöcke und Seiten +- Zuordnung der physischen Blöcke zu Seiten +- meist mit festen Faktoren: 1, 2, 4 oder 8 Blöcke einer Spur auf eine Seite +- hier: "ein Block — eine Seite" +- höhere Schichten des DBS adressieren über Seitennummer + +Dienste des Dateisystems +- Allokation oder Deallokation von Speicherplatz +- Holen oder Speichern von Seiteninhalten +- Allokation möglichst so, dass logisch aufeinanderfolgende Datenbereiche (etwa einer Relation) auch möglichst in aufeinanderfolgenden Blöcken der Platte gespeichert werden +- Nach vielen Update-Operationen: Reorganisationsmethoden +- Freispeicherverwaltung: doppelt verkettete Liste von Seiten + +Abbildung der Datenstrukturen +- Abbildung der konzeptuellen Ebene auf interne Datenstrukturen +- Unterstützung durch Metadaten (im Data Dictionary, etwa das interne Schema) + +| Konz. Ebene | Interne Ebene | Dateisystem/Platte | +| ---------------- | --------------- | ------------------ | +| Relationen -> | Log. Dateien -> | Phys. Dateien | +| Tupel -> | Datensätze -> | Seiten/Blöcke | +| Attributwerte -> | Felder -> | Bytes | + +- Beispiel: jede Relation in je einer logischen Datei, diese insgesamt in einer einzigen physischen Datei + + +## Seiten, Sätze und Adressierung +### Seite +- Block: + - kleinste adressierbare Einheit auf Externspeicher + - Zuordnung zu Seiten im Hauptspeicher +- Aufbau von Seiten + - Header + - Informationen über Vorgänger- und Nachfolger-Seite + - eventuell auch Nummer der Seite selbst + - Informationen über Typ der Sätze + - freier Platz + - Datensätze + - unbelegte Bytes + +Seitenorganisation +- Organisation der Seiten: doppelt verkettete Liste +- freie Seiten in Freispeicherverwaltung +![](Assets/DBimpl-seitenorganisation.png) + +Seite: Adressierung der Datensätze +- adressierbare Einheiten + - Zylinder + - Spuren + - Sektoren + - Blöcke oder Seiten + - Datensätze in Blöcken oder Seiten + - Datenfelder in Datensätzen +- Beispiel: Adresse eines Satzes durch Seitennummer und Offset (relative Adresse in Bytes vom Seitenanfang) + +Seitenzugriff als Flaschenhals +- Maß für die Geschwindigkeit von Datenbankoperationen: Anzahl der Seitenzugriffe auf dem Sekundärspeicher (wegen Zugriffslücke) +- Faustregel: Geschwindigkeit des Zugriffs ⇐ Qualität des Zugriffspfades ⇐ Anzahl der benötigten Seitenzugriffe +- Hauptspeicheroperationen nicht beliebig vernachlässigbar + + +Einpassen von Datensätzen auf Blöcke +- Datensätze (eventuell variabler Länge) in die aus einer fest vorgegebenen Anzahl von Bytes bestehenden Blöcke einpassen: Blocken +- Blocken abhängig von variabler oder fester Feldlänge der Datenfelder + - Datensätze mit variabler Satzlänge: höherer Verwaltungsaufwand beim Lesen und Schreiben, Satzlänge immer wieder neu ermitteln + - Datensätze mit fester Satzlänge: höherer Speicheraufwand + +Verschiedene Satztypen +![](Assets/DBimpl-satztypen.png) + +Sätze fester Länge +- SQL: Datentypen fester und variabler Länge + - _char(n)_ Zeichenkette der festen Länge _n_ + - _varchar(n)_ Zeichenkette variabler Länge mit der Maximallänge _n_ +- Aufbau der Datensätze, falls alle Datenfelder feste Länge: + 1. Verwaltungsblock mit Typ eines Satzes (wenn unterschiedliche Satztypen auf einer Seite möglich) und Löschbit + 2. Freiraum zur Justierung des Offset + 3. Nutzdaten des Datensatzes + +Sätze variabler Länge +- im Verwaltungsblock nötig: Satzlänge _l_, um die Länge des Nutzdaten-Bereichs _d_ zu kennen + ![](Assets/DBimpl-variable-länge-1.png) +- Strategie a) + ![](Assets/DBimpl-variable-länge-2.png) +- Strategie b) + ![](Assets/DBimpl-variable-länge-3.png) + +Speicherung von Sätzen variabler Länge +- Strategie a): Jedes Datenfeld variabler Länge $A_i$ beginnt mit einem _Längenzeiger $al_i$, der angibt, wie lang das folgende Datenfeld ist +- Strategie b): Am Beginn des Satzes wird nach dem Satz-Längenzeiger _l_ und der Anzahl der Attribute ein Zeigerfeld $ap_1 ,..., ap_n$ für alle variabel langen Datenfelder eingerichtet +- Vorteil Strategie b): leichtere Navigation innerhalb des Satzes (auch für Sätze in Seiten => TID) + +Anwendung variabel langer Datenfelder +- "Wiederholgruppen": Liste von Werten des gleichen Datentyps + - Zeichenketten variabler Länge wie _varchar(n)_ sind Wiederholgruppe mit _char_ als Basisdatentyp, mathematisch also die Kleene’sche Hülle $(char)∗$ + - Mengen- oder listenwertige Attributwerte, die im Datensatz selbst denormalisiert gespeichert werden sollen (Speicherung als geschachtelte Relation oder Cluster-Speicherung), bei einer Liste von _integer_ -Werten wäre dies $(integer)∗$ + - Adressfeld für eine Indexdatei, die zu einem Attributwert auf mehrere Datensätze zeigt (Sekundärindex), also $(pointer)∗$ + +Blockungstechniken: Nichtspannsätze +- jeder Datensatz in maximal einem Block + ![](Assets/DBimpl-nichtspannsätze.png) +- Standardfall (außer bei BLOBs oder CLOBs) + +Blockungstechniken: Spannsätze +- Spannsätze: Datensatz eventuell in mehreren Blöcken + ![](Assets/DBimpl-spannsätze.png) + +Adressierungstechniken +![](Assets/Dbimpl-adressierungstechniken.png) + +Adressierung: TID-Konzept +- Tupel-Identifier (TID) ist Datensatz-Adresse bestehend aus Seitennummer und Offset +- Offset verweist innerhalb der Seite bei einem Offset-Wert von _i_ auf den _i_ -ten Eintrag in einer Liste von Tupelzeigern (Satzverzeichnis), die am Anfang der Seite stehen +- Jeder Tupel-Zeiger enthält Offsetwert +- Verschiebung auf der Seite: sämtliche Verweise von außen bleiben unverändert +- Verschiebungen auf eine andere Seite: statt altem Datensatz neuer TID-Zeiger +- diese zweistufige Referenz aus Effizienzgründen nicht wünschenswert: Reorganisation in regelmäßigen Abständen + + +TID-Konzept: einstufige Referenz +![](Assets/DBimpl-tid-einstufig.png) + +TID-Konzept: zweistufige Referenz +![](Assets/DBimpl-tid-zweistufig.png) + +## Alternative Speichermodelle +- bisher klassisches N-äres Speichermodell (NSM), auch "row store" +- Vorteile: + - gesamter Datensatz kann mit einem Seitenzugriff gelesen werden + - leichte Änderbarkeit einzelner Attributwerte +- Nachteil: + - werden nur wenige Attributwerte benötigt, müssen trotzdem immer alle Attributwerte gelesen werden -> unnötiger IO-Aufwand +- Alternativen: spaltenorientierte Speichermodelle + - Zerlegung einer _n_ -stelligen Relation in eine Menge von Projektionen (z.B. binäre Relation) + - Identifikation (und Rekonstruktion) über eine Schlüsselspalte oder Position + +Spaltenorientierte Datenorganisation +![](Assets/DBimpl-spaltenorientierte-db.png) + +Alternative Speichermodelle: DSM +- Decomposition Storage Model (DSM) -> column stores + - alle Werte einer Spalte (Attribut) werden hintereinander gespeichert + - Adressierung über Position + ![](Assets/DBimpl-dsm.png) +- Kompression einfach möglich (z.B. Run length encoding) +- effizientere Scanoperationen (Feldoperationen -> bessere Cache-Nutzung) +- jedoch: Updateoperationen sind komplexer, Lesen aller Spalten aufwendiger +- Einsatz bei leseoptimierten Datenbanken + +Ein Full-Table-Scan in NSM +- Im NSM-Modell stehen alle Tupel einer Tabelle sequenziell hintereinander auf einer Datenbankseite. + ![](Assets/Dbimpl-full-table-scan-nsm.png) + +Ein "Full-Table-Scan" in DSM +- Im DSM-Modell stehen alle Werte eines Attributs sequenziell hintereinander auf einer Datenbankseite. + ![](Assets/DBimpl-full-table-scan-dsm.png) +- Alle Daten, die für den "l_shipdate Scan" geladen werden sind +auch dafür relevant. + +Alternative Speichermodelle: PAX +- Partition Attributes Across (PAX) als Kompromiss + - NSM: alle Spalten eines Satzes auf der gleichen Seite + - DSM: vertikale Partitionierung, Miniseiten für jeweils eine Spalte + ![](Assets/DBimpl-PAX.png) + +## Main-Memory-Strukturen +Speicherstrukturen für Main-Memory-Datenbanken +- Vermeidung der seiten-basierten Indirektion (über Seitenadresse, Puffer) +- Hauptspeicherzugriffe als neuer Bottleneck ("Memory Wall") +- Cache-freundliche Datenstruktur: Hauptspeicherzugriffe tatsächlich nicht byteweise, sondern in Cachelines (64 Bytes) +- Speicherlayout: Row Store vs. Column Store - abhängig vom Workload (Reduzierung der Cache Misses) +- ggf. Partitionierung für Multicore-Systeme +- Kompression der Daten zur Reduktion des Speicherbedarfs +- Persistenz weiterhin notwendig, z.B. über Logging +- Bsp.: In-Memory-Datenstruktur für relationale Column Stores + - pro Spalte = Feld von Attributwerten + - Kompression der Attributwerte (siehe Kapitel 8) + - ggf. Strukturierung in Segmemten (Chunks) für bessere Speicherverwaltung, NUMA-Effekte + + +## Speicherorganisation in konkreten DBMS +Oracle: Datenbankstruktur + ![](Assets/DBimpl-oracle-dbstruktur.png) + +Oracle: Blöcke + ![](Assets/Dbimpl-oracle-blöcke.png) + +Oracle: Aufbau von Datensätzen + ![](Assets/DBimpl-oracle-datensatz.png) +- Kettadresse für _Row Chaining_ : Verteilung und Verkettung zu großer Datensätze (> 255 Spalten) über mehrere Blöcke +- row id = (data object identifier, data file identifier, block identifier, row identifier) + +Zusammenfassung +- Speicherhierarchie und Zugriffslücke +- Speicher- und Sicherungsmedien +- Hintergrundspeicher: Blockmodell +- Einpassen von Sätzen in Seiten +- Satzadressierung: TID-Konzept + +# Caching und Pufferverwaltung +## Aufgaben +Aufgaben der Pufferverwaltung +- Puffer: ausgezeichneter Bereich des Hauptspeichers +- in Pufferrahmen gegliedert, jeder Pufferrahmen kann Seite der Platte aufnehmen +- Aufgaben: + - Pufferverwaltung muss angeforderte Seiten im Puffer suchen => effizienteSuchverfahren + - parallele Datenbanktransaktionen: geschickte Speicherzuteilung im Puffer + - Puffer gefüllt: adäquate Seitenersetzungsstrategien + - Unterschiede zwischen einem Betriebssystem-Puffer und _einem Datenbank-Puffer_ + - spezielle Anwendung der Pufferverwaltung: Schattenspeicherkonzept +![](Assets/DBimpl-pufferverwaltung.png) + +Mangelnde Eignung des BS-Puffers +- Natürlicher Verbund von Relationen $a$ und $b$ (zugehörige Folge von Seiten: _Ai_ bzw. _Bj_ ) +- Implementierung: _Nested-Loop_ + ![](Assets/DBimpl-bs-puffer.png) +- Ablauf + - FIFO: $A_1$ verdrängt, da älteste Seite im Puffer + - LRU: $A_1$ verdrängt, da diese Seite nur im ersten Schritt beim Auslesen des ersten Vergleichstupels benötigt wurde +- Problem + - im nächsten Schritt wird das zweite Tupel von $A_1$ benötigt + - weiteres "Aufschaukeln": um $A_1$ laden zu können, muss $B_1$ entfernt werden (im nächsten Schritt benötigt) usw. + +## Suche von Seiten und Speicherzuteilung +Suchen einer Seite +- Direkte Suche: + - ohne Hilfsmittel linear im Puffer suchen +- Indirekte Suche: + - Suche nur noch auf einer kleineren Hilfsstruktur + - _unsortierte und sortierte Tabelle_ : alle Seiten im Puffer vermerkt + - _verkettete Liste_ : schnelleres sortiertes Einfügen möglich + - _Hashtabelle_ : bei geschickt gewählter Hashfunktion günstigster Such- und Änderungsaufwand + + +Speicherzuteilung im Puffer +- bei mehreren parallel anstehenden Transaktionen + - Lokale Strategien: Jeder Transaktion bestimmte disjunkte Pufferteile verfügbar machen (Größe statisch vor Ablauf der Transaktionen oder dynamisch zur Programmlaufzeit entscheiden) + - Globale Strategien: Zugriffsverhalten aller Transaktionen insgesamt bestimmt Speicherzuteilung (gemeinsam von mehreren Transaktionen referenzierte Seiten können so besser berücksichtigt werden) + - Seitentypbezogene Strategien: Partition des Puffers: Pufferrahmen für Datenseiten, Zugriffspfadseiten, Data-Dictionary-Seiten, usw. - eigene Ersetzungstrategien für die jeweiligen Teile möglich + +## Seitenersetzungsstrategien +- Speichersystem fordert Seite $E_2$ an, die nicht im Puffer vorhanden ist +- Sämtliche Pufferrahmen sind belegt +- vor dem Laden von _E_ 2 Pufferrahmen freimachen +- nach den unten beschriebenen Strategien Seite aussuchen +- Ist Seite in der Zwischenzeit im Puffer verändert worden, so wird sie nun auf Platte zurückgeschrieben +- Ist Seite seit Einlagerung in den Puffer nur gelesen worden, so kann sie überschrieben werden (verdrängt) + +![](Assets/DBimpl-Seitenersetzung.png) + +Seitenersetzung in DBMS +- Fixieren von Seiten (Pin oder Fix): + - Fixieren von Seiten im Puffer verhindert das Verdrängen + - speziell für Seiten, die in Kürze wieder benötigt werden +- Freigeben von Seiten (Unpin oder Unfix): + - Freigeben zum Verdrängen + - speziell für Seiten, die nicht mehr benötigt werden +- Zurückschreiben einer Seite: + - Auslösen des Zurückschreibens für geänderte Seiten bei Transaktionsende + +Seitenersetzung: Verfahren +- grundsätzliches Vorgehen beim Laden einer Seite: + - Demand-paging-Verfahren: genau eine Seite im Puffer durch angeforderte Seite ersetzen + - Prepaging-Verfahren: neben der angeforderten Seite auch weitere Seiten in den Puffer einlesen, die eventuell in der Zukunft benötigt werden (z.B. bei BLOBs sinnvoll) +- Ersetzen einer Seite im Puffer: + - optimale Strategie: Welche Seite hat maximale Distanz zu ihrem nächsten Gebrauch? (nicht realisierbar, zukünftiges Referenzverhalten nicht vorhersehbar) -> Realisierbare Verfahren besitzen keine Kenntnisse über das zukünftige Referenzverhalten + - Zufallsstrategie: jeder Seite gleiche Wiederbenutzungswahrscheinlichkeit zuordnen + +![](Assets/DBimpl-Seitenersetzung-2.png) + +Fehlseitenrate +$$F=1-p(\frac{1-F_{kalt}}{p_{DB}}) * 100%$$ +- $p$: Puffergröße +- $p_{DB}$: Puffergröße, die gesamte Datenbank umfasst +- $F_{kalt}$: Fehlseitenrate beim Kaltstart (d.h. leerer Puffer) -> Verhältnis von Anzahl der in den Puffer geladenen Seiten zur Anzahl der Referenzierungen + +- Gute, realisierbare Verfahren sollen vergangenes Referenzverhalten auf Seiten nutzen, um Erwartungswerte für Wiederbenutzung schätzen zu können + - besser als Zufallsstrategie + - Annäherung an optimale Strategie + + +Merkmale gängiger Strategien +- Alter der Seite im Puffer: + - Alter einer Seite nach Einlagerung (die globale Strategie (G)) + - Alter einer Seite nach dem letztem Referenzzeitpunkt (die Strategie des jüngsten Verhaltens (J)) + - Alter einer Seite wird nicht berücksichtigt (-) +- Anzahl der Referenzen auf Seite im Puffer: + - Anzahl aller Referenzen auf eine Seite (die globale Strategie (G)) + - Anzahl nur der letzten Referenzen auf eine Seite (die Strategie des jüngsten Verhaltens (J)) + - Anzahl der Referenzen wird nicht berücksichtigt (-) + + +Gängige Strategien +![](Assets/DBimpl-seitenwechsel-strategie.png) + +Klassifikation gängiger Strategien +| Verfahren | Prinzip | Alter | Anzahl | +| -------------------------------- | ------------------------------------------------------------------- | ----- | +| FIFO | älteste Seite ersetzt | G | - | +| LFU (least fre-quently used) | Seite mit geringster Häufigkeit ersetzen | - | G | +| LRU (least recently used) | Seite ersetzen, die am längsten nicht referenziert wurde (System R) | J | J | +| DGCLOCK (dyn. generalized clock) | Protokollierung der Ersetzungshäufigkeiten wichtiger Seiten | G | JG | +| LRD (least reference density) | Ersetzung der Seite mit geringster Referenzdichte | JG | G | + +Beispiel +- Folge von Seitenanforderungen #1, #2 ... +- Puffer der Größe 6 + ![](Assets/DBimpl-beispiel-seitenwechsel.png) +- Ablauf mit + - FIFO ... + - LFU ... + +### LRU: Least Recently Used +- Idee: Seite im Puffer ersetzen, die am längsten nicht mehr referenziert wurde +- Implementierung: + - Liste oder Stack von Seiten + - Puffer-Hit bewegt Seite zur MRU-Position (Most Recently Used) + - Seite am Ende wird verdrängt + ![](Assets/DBimpl-seitenersetzung-lru.png) +- Varianten: + - durch Interpretation der Pin-Operation: Least Recently Referenced bzw. Least Recently Unfixed + - durch Berücksichtigung der letzten $k$ Referenzierungen (d.h. auch Häufigkeit): LRU-K + +LRU: Probleme +- Lock Contention in Multitasking-Umgebungen + - Zugriff auf LRU-Liste/Stack und Bewegung der Seite erfordert exklusiven Zugriff auf Datenstruktur + - aufwendige Operation +- berücksichtigt nur Alter jedoch nicht Häufigkeit + - oft gelesene Seiten mit langen Pausen zwischen den Zugriffen werden nicht adäquat berücksichtigt +- "Zerstörung" des Puffers durch Scan-Operator + - Seiten werden nur einmalig gelesen, verdrängen jedoch andere (ältere) Seiten + + +Lock Contention bei der Pufferverwaltung +![](Assets/DBimpl-lock-contention.png) +- Sperren = Latches: leichtgewichtige (wenige CPU-Instruktionen) Objekte für kurzzeitige Sperren + +Approximierende Verfahren +- Idee: + - Vereinfachung der benötigten Datenstruktur durch Approximation + - Effektivität (Trefferrate) vs. Skalierbarkeit (Anzahl der Threads) +- CLOCK: Approximation der Historie durch Bit-Schieberegister der Länge $k$ + - $k= 0$: FIFO + - $k\rightarrow\infty$: LRU + - typisch: $k = 1$ + +### CLOCK +- Seite mit Benutzt-Bit; bei Referenzierung auf "1" setzen +- bei Seitenfehler: + - zyklische Suche + - Seite mit "0" verdrängen + - sonst Setzen auf "0" + ![](Assets/DBimpl-seitenersetzung-clock.png) + +### GCLOCK +- Verbesserung: Benutzt-Bit durch Referenzzähler _RC_ ersetzen; Dekrementierung bei Suche +- weitere Verbesserungen: + - Initialisierung des Referenzzählers + - Inkrementierung des Zählers + - seitentypspezifische Maßnahmen (für Typ _i_ : Seitengewicht $E_i$ bei Erstreferenzierung, $W_i$ bei weiterer Referenzierung) + - Altern +- Varianten: Seite _j_ von Typ _i_ + - $GCLOCK(V1): RC_j := E_i ; RC_j := RC_j + W_i$ + - $GCLOCK(V2): RC_j := E_i ; RC_j := W_i$ (speziell für $W_i\geq E_i$) + +### DGCLOCK +- weitere Verbesserung: globaler Zähler $GC$ und Normierung der aktuellen Referenzzähler $RC$ + 1. Initialisierung: $RC_j := GC$ + 2. Referenzierung von Seite $j : GC := GC + 1 ; RC_j := RC_j + GC$ + 3. bei Überschreiten $GC > MIN : \forall j : RC_j := RC_j / C$ + +### ARC +- Adaptive Replacement Cache: neues Verfahren, das Nachteile von LRU vermeidet +- Prinzip: + - Puffergröße _c_ + - Pufferverzeichnis für 2 _c_ Seiten: _c_ Pufferseiten + _c_ History-Seiten + - Liste _L_ 1 : "recency" = kurzfristiger Nutzen-> Seiten, die kürzlich einmal gelesen wurden + - Liste _L_ 2 : "frequency" = langfristiger Nutzen -> Seiten, die kürzlich mehrmals gelesen wurden +- Ausgangspunkt: einfache Verdrängungsstrategie DBL(2 _c_ ) + - Ersetze die LRU-Seite in $L_1$, wenn $|L_1| = c$ , sonst ersetze LRU-Seite in $L_2$ + - Ziel: Größenausgleich zwischen $L_1$ und $L_2$ + - Zugriff Seite $p$: wenn Treffer -> $p$ wird MRU in $L_2$ , sonst in $L_1$ + +Von DBL(2c) zu ARC +![](Assets/DBimpl-DBL-to-arc.png) +- Parameter $p$ mit $0\leq p \leq c$ + - $T_1$ enthält $p$ Seiten, $T_2$ enthält $c-p$ Seiten +- Wahl von $p$? + +ARC: Algorithmus +- Seitenanforderungen: $x_1,x_2 ,..., x_t ,...$ +- $p = 0, T_1 , B_1 , T_2 ,B_2$ sind initial leer + - Fall 1: $x_t \in T_1 \cup T_2$ /* Puffer-Hit */ + - Bewege $x_t$ zu MRU von $T_2$ + - Fall 2: $x_t \in B_1$ + - Anpassung: $p = min\{ p +\delta_1,c\}$ mit $\delta_1 = \begin{cases} 1\quad\text{ wenn } |B_1|\geq |B_2| \\ \frac{|B_2|}{|B_1|} \quad\text{ sonst}\end{cases}$ + - $REPLACE(x_t,p)$ + - Bewege $x_t$ von $B_1$ zu MRU von $T_2$ + - Fall 3: $x_t \in B_2$ + - Anpassung: $p = max\{ p - \delta_2, 0 \}$ mit $\delta_2 = \begin{cases} 1\quad\text{ wenn } |B_2|\geq |B_1| \\ \frac{|B_1|}{|B_2|} \quad\text{ sonst}\end{cases}$ + - $REPLACE(x_t,p)$ + - Bewege $x_t$ von $B_2$ zu MRU von $T_2$ + - Fall 4: $x_t \not\in T_1 \cup B_1 \cup T_2 \cup B_2$ + - 4.A: $|L_1| = c$ + - Wenn $|T_1|p$ oder ($x_t\in B_2$ und $|T_1|=p$) + Lösche LRU-Seite in $T_1$ und bewege sie zu MRU in $B_1$ + else + Lösche LRU-Seite in $T_2$ und bewege sie zu MRU in $B_2$ + endif + +ARC: Beispiel +1. erstmalige Anforderung der Seiten $#1$ und $#2$: Aufnahme in + ![](Assets/DBimpl-arc-bsp-1.png) +2. nächsten Referenzierung von $#1$: Übernahme in $T_2$-Liste + ![](Assets/DBimpl-arc-bsp-2.png) +3. Seitenanforderungen $#3$, $#4$, $#1$; mit $#2$ wird diese in $T_2$ bewegt; Platz für Seite $#5$: + ![](Assets/DBimpl-arc-bsp-3.png) +4. Beantwortung der Seitenanforderungen $#1$ und $#2$ aus $T_2$ +5. neu angeforderten Seiten $#5$ und $#6$ in $T_1$ + ![](Assets/DBimpl-arc-bsp-4.png) +6. Seitenanforderung $#7$: Verdrängen von $#4$ aus $T_1$ in $B_1$ + ![](Assets/DBimpl-arc-bsp-5.png) + +ARC: Eigenschaften +- kontinuierliche Anpassung von Parameter $p$ + - Lernraten $\delta_1$ und $\delta_2$ + - "Investieren in Liste mit dem meisten Profit" +- Berücksichtigung von Alter und Häufigkeit + - durch zwei Listen $L_1$ und $L_2$ +- Scan-Resistenz + - einmalig gelesene Seiten nur in $L_1$, niemals in $L_2$ +- Vermeidung von Lock Contention durch approximierende Varianten (CAR, CART, ...) + +## Fazit +- Pufferverwaltungsstrategie mit großem Einfluss auf Performance +- in kommerziellen Systemen meist LRU mit Variationen +- besondere Behandlung von Full-Table-Scans +- weiterer Einflussfaktor: Puffergröße +- Indikator: Trefferrate (engl. _hit ratio_ ) + $$hit\_ratio = \frac{\text{Anz. log. Zugriffe} - \text{Anz. phys. Zugriffe}}{\text{Anz. log. Zugriffe}}$$ +- 5-Minuten-Regel (Gray, Putzolu 1997): + Daten, die in den nächsten 5 Min. wieder referenziert werden, sollten im Hauptspeicher gehalten werden + +# Indexierung von Daten +## Klassifikation der Speichertechniken +Einordnung in 5-Schichten-Architektur +- **Speichersystem** fordert über Systempufferschnittstelle Seiten an +- interpretiert diese als interne Datensätze +- interne Realisierung der logischen Datensätze mit Hilfe von Zeigern, speziellen Indexeinträgen und weiteren Hilfsstrukturen +- Zugriffssystem abstrahiert von der konkreten Realisierung + +Klassifikation der Speichertechniken +- Kriterien für Zugriffsstrukturen oder Zugriffsverfahren: + - organisiert interne Relation selbst (Dateiorganisationsform) oder zusätzliche Zugriffsmöglichkeit auf bestehende interne Relation (Zugriffspfad) + - Art der Zuordnung von gegebenen Attributwerten zu Datensatz-Adressen: Schlüsselvergleich = Zuordnung von Schlüsselwert zu Adresse über Hilfsstruktur; Schlüsseltransformation = Berechnung der Adresse aus Schlüsselwert (z.B. über Hashfunktion) + - Arten von Anfragen, die durch Dateiorganisationsformen und Zugriffspfade effizient unterstützt werden können +![](Assets/DBimpl-speichertechniken-klassifikation.png) + +Dünn- vs. dichtbesetzter Index +- dünnbesetzter Index: nicht für jeden Zugriffsattributwert $k$ ein Eintrag in Indexdatei sondern z.B. nur für _Seitenanführer_ einer sortierten Relation +- dichtbesetzter Index: für jeden Datensatz der internen Relation ein Eintrag in Indexdatei + +Geclusterter vs. nicht-geclusterter Index +- geclusterter Index: in der gleichen Form sortiert wie interne Relation +- nicht-geclusterter Index: anders organisiert als interne Relation +- Primärindex oft dünnbesetzt und geclustert +- jeder dünnbesetzte Index ist auch geclusterter Index, aber nicht umgekehrt +- Sekundärindex kann nur dichtbesetzter, nicht-geclusterter Index sein (auch: invertierte Datei) +![](Assets/Dbimpl-cluster-vs-nicht-cluster.png) + +Statische vs. dynamische Struktur +- statische Zugriffsstruktur: optimal nur bei bestimmter (fester) Anzahl von verwaltenden Datensätzen +- dynamische Zugriffsstruktur: unabhängig von der Anzahl der Datensätze optimal + - dynamische Adresstransformationsverfahren verändern dynamisch Bildbereich der Transformation + - dynamische Indexverfahren verändern dynamisch Anzahl der Indexstufen => in DBS üblich + +Klassifikation +![](Assets/DBimpl-zugriff-klassifikation.png) + + +## Statische Verfahren +- Heap, indexsequenziell, indiziert-nichtsequenziell +- oft grundlegende Speichertechnik in RDBS +- direkte Organisationsformen: keine Hilfsstruktur, keine Adressberechnung (Heap, sequenziell) +- statische Indexverfahren für Primärindex und Sekundärindex + + +Statische Verfahren: Überblick +![](Assets/DBimpl-statische-verfahren.png) + +### Heap +Organisation +- völlig unsortiert speichern +- physische Reihenfolge der Datensätze ist zeitliche Reihenfolge der Aufnahme von Datensätzen + | | | | | + | ---- | ----- | ---------- | --- | -------- | + | 8832 | Max | Mustermann | ... | 9.1.2003 | + | 5588 | Beta | Alpha | ... | 7.3.1978 | + | 4711 | Gamma | Delta | ... | 2.5.1945 | + +Operationen +- insert: Zugriff auf letzte Seite der Datei. Genügend freier Platz => Satz anhängen. Sonst nächste freie Seite holen +- delete: lookup, dann Löschbit auf 0 gesetzt +- lookup: sequenzielles Durchsuchen der Gesamtdatei, maximaler Aufwand (Heap-Datei meist zusammen mit Sekundärindex eingesetzt; oder für sehr kleine Relationen) +- Komplexitäten: + - Neuaufnahme von Daten $O(1)$ + - Suchen $O(n)$ + +### Sequenzielle Speicherung +- sortiertes Speichern der Datensätze + | | | | | + | ---- | ----- | ---------- | --- | -------- | + | 4711 | Gamma | Delta | ... | 2.5.1945 | + | 5588 | Beta | Alpha | ... | 7.3.1978 | + | 8832 | Max | Mustermann | ... | 9.1.2003 | + +Sequenzielle Datei: Operationen +- insert: Seite suchen, Datensatz einsortieren => beim Anlegen oder sequenziellen Füllen einer Datei jede Seite nur bis zu gewissem Grad (etwa 66%) füllen +- delete: Aufwand bleibt +- Folgende Dateiorganisationsformen: + - schnelleres lookup + - mehr Platzbedarf (durch Hilfsstrukturen wie Indexdateien) + - mehr Zeitbedarf bei insert und delete +- klassische Indexform: indexsequenzielle Dateiorganisation + +## Indexsequenzielle Dateiorganisation +- Kombination von sequenzieller Hauptdatei und Indexdatei: indexsequenzielle Dateiorganisationsform +- Indexdatei kann geclusterter, dünnbesetzter Index sein +- mindestens zweistufiger Baum + - Blattebene ist Hauptdatei (Datensätze) + - jede andere Stufe ist Indexdatei +![](Assets/DBimpl-indexsequentiell.png) + +Aufbau der Indexdatei +- Datensätze in Indexdatei: _(Primärschlüsselwert, Seitennummer)_ zu jeder Seite der Hauptdatei genau ein Index-Datensatz in Indexdatei +- Problem: "Wurzel" des Baumes bei einem einstufigen Index nicht nur eine Seite +![](Assets/DBimpl-indexsequentiell-2.png) + + +Mehrstufiger Index +- Optional: Indexdatei wieder indexsequenziell verwalten +- Idealerweise: Index höchster Stufe nur noch eine Seite +![](Assets/DBimpl-indexsequentiell-3.png) + +lookup bei indexsequenziellen Dateien +- lookup-Operation sucht Datensatz zum Zugriffsattributwert _w_ +- Indexdatei sequenziell durchlaufen, dabei $(v_1,s)$ im Index gesucht mit $v_1\leq w$: + - $(v_1,s)$ ist letzter Satz der Indexdatei, dann kann Datensatz zu _w_ höchstens auf dieser Seite gespeichert sein (wenn er existiert) + - nächster Satz $(v_2,s′)$ im Index hat $v_2 > w$ , also muss Datensatz zu _w_, wenn vorhanden, auf Seite _s_ gespeichert sein +- $(v_1,s)$ überdeckt Zugriffsattributwert _w_ + +insert bei indexsequenziellen Dateien +- insert: zunächst mit lookup Seite finden +- Falls Platz, Satz sortiert in gefundener Seite speichern; Index anpassen, falls neuer Satz der erste Satz in der Seite +- Falls kein Platz, neue Seite von Freispeicherverwaltung holen; Sätze der "zu vollen" Seite gleichmäßig auf alte und neue Seite verteilen; für neue Seite Indexeintrag anlegen +- Alternativ neuen Datensatz auf Überlaufseite zur gefundenen Seite + +delete bei indexsequenziellen Dateien +- delete: zunächst mit lookup Seite finden +- Satz auf Seite löschen (Löschbit auf 0) +- erster Satz auf Seite: Index anpassen +- Falls Seite nach Löschen leer: Index anpassen, Seite an Freispeicherverwaltung zurück + +Probleme indexsequenzieller Dateien +- stark wachsende Dateien: Zahl der linear verketteten Indexseiten wächst; automatische Anpassung der Stufenanzahl nicht vorgesehen +- stark schrumpfende Dateien: nur zögernde Verringerung der Index- und Hauptdatei-Seiten +- unausgeglichene Seiten in der Hauptdatei (unnötig hoher Speicherplatzbedarf, zu lange Zugriffszeit) + + +Indiziert-nichtsequenzieller Zugriffspfad +- zur Unterstützung von Sekundärschlüsseln +- mehrere Zugriffpfade dieser Form pro Datei möglich +- einstufig oder mehrstufig: höhere Indexstufen wieder indexsequenziell organisiert + +Aufbau der Indexdatei +- Sekundärindex, dichtbesetzter und nicht-geclusteter Index +- zu jedem Satz der Hauptdatei Satz $(w,s)$ in der Indexdatei +- _w_ Sekundärschlüsselwert, _s_ zugeordnete Seite + - entweder für ein _w_ mehrere Sätze in die Indexdatei aufnehmen + - oder für ein _w_ Liste von Adresse in der Hauptdatei angeben +![](Assets/Dbimpl-nichtsequentieller-index.png) + +Operationen +- lookup: _w_ kann mehrfach auftreten, Überdeckungstechnik nicht benötigt +- insert: Anpassen der Indexdateien +- delete: Indexeintrag entfernen + +Probleme statischer Verfahren +- unzureichende Anpassung an wachsende/schrumpfende Datenmengen +- schlechte Ausnutzung von Speicher nach Seitensplits +- Bevorzugung bestimmter Attribute (Schlüssel) +- daher in den folgenden Kapiteln: + - bessere Datenstrukturen zur Schlüsselsuche als zusätzlicher Zugriffspfad = Approximation einer Funktion Schlüssel -> Speicheradresse, z.B. über Baumverfahren + - Erweiterung von Hashverfahren um Anpassung des Bildbereichs = dynamische Hashverfahren + - Behandlung von zusammengesetzten Schlüsseln = multidimensionale Zugriffsverfahren, z.B. multidimensionale Bäume oder raumfüllende Kurven + +# Baumbasierte Indexstrukturen +## Baumverfahren +- Stufenanzahl dynamisch verändern +- wichtigste Baumverfahren: B-Bäume und ihre Varianten +- B-Baum-Varianten sind noch "allgegenwärtiger" in heutigen Datenbanksystemen als SQL +- SQL nur in der relationalen und objektrelationalen Datenbanktechnologie verbreitet; B-Bäume überall als Grundtechnik eingesetzt + +Baumverfahren: Überblick +![](Assets/DBimpl-Baumverfahren.png) + +## B-Bäume +- Ausgangspunkt: ausgeglichener, balancierter Suchbaum +- Ausgeglichen oder balanciert: alle Pfade von der Wurzel zu den Blättern des Baumes gleich lang +- Hauptspeicher-Implementierungsstruktur: binäre Suchbäume, beispielsweise AVL-Bäume von Adelson-Velskii und Landis +- Datenbankbereich: Knoten der Suchbäume zugeschnitten auf Seitenstruktur des Datenbanksystems +- mehrere Zugriffsattributwerte auf einer Seite +- Mehrwegebäume + +Prinzip des B-Baumes +- B-Baum von Bayer (B für balanciert, breit, buschig, Bayer, NICHT: binär) +- dynamischer, balancierter Indexbaum, bei dem jeder Indexeintrag auf eine Seite der Hauptdatei zeigt +- Mehrwegebaum völlig ausgeglichen, wenn + 1. alle Wege von Wurzel bis zu Blättern gleich lang + 2. jeder Knoten gleich viele Indexeinträge +- vollständiges Ausgleichen zu teuer, deshalb B-Baum-Kriterium: + Jede Seite außer der Wurzelseite enthält zwischen $m$ und $2m$ Einträge. + +Definition B-Baum +- Ordnung eines B-Baumes ist minimale Anzahl der Einträge auf den Indexseiten außer der Wurzelseite +- Bsp.: B-Baum der Ordnung 8 fasst auf jeder inneren Indexseite zwischen 8 und 16 Einträgen +- Def.: Ein Indexbaum ist ein B-Baum der Ordnung $m$ , wenn er die folgenden Eigenschaften erfüllt: + 1. Jede Seite enthält höchstens $2m$ Elemente. + 2. Jede Seite, außer der Wurzelseite, enthält mindestens $m$ Elemente. + 3. Jede Seite ist entweder eine Blattseite ohne Nachfolger oder hat $i+1$ Nachfolger, falls $i$ die Anzahl ihrer Elemente ist. + 4. Alle Blattseiten liegen auf der gleichen Stufe. + +Eigenschaften des B-Baumes +- $n$ Datensätze in der Hauptdatei => in $log_m(n)$ Seitenzugriffen von der Wurzel zum Blatt +- Durch Balancierungskriterium wird Eigenschaft nahe an der vollständigen Ausgeglichenheit erreicht (1. Kriterium vollständig erfüllt, 2. Kriterium näherungsweise) +- Kriterium garantiert 50% Speicherplatzausnutzung +- einfache, schnelle Algorithmen zum Suchen, Einfügen und Löschen von Datensätzen (Komplexität von $O(log_m(n))$) + +Suchen in B-Bäumen +- lookup wie in statischen Indexverfahren +- Startend auf Wurzelseite Eintrag im B-Baum ermitteln, der den gesuchten Zugriffsattributwert $w$ überdeckt => Zeiger verfolgen, Seite nächster Stufe laden +- Suchen: 38, 20, 6 +- ![](Assets/DBimpl-b-baum-lookup.png) + +Einfügen in B-Bäumen +- Einfügen eines Wertes _w_ + - mit lookup entsprechende Blattseite suchen + - passende Seite $n<2m$ Elemente, _w_ einsortieren + - passende Seite $n=2m$ Elemente, neue Seite erzeugen, + - ersten _m_ Werte auf Originalseite + - letzten _m_ Werte auf neue Seite + - mittleres Element auf entsprechende Indexseite nach oben + - eventuell dieser Prozess rekursiv bis zur Wurzel + +Einfügen in einen B-Baum: Beispiel +![](Assets/DBimpl-b-baum-beispiel.png) +![](Assets/DBimpl-b-baum-beispiel-2.png) + +Löschen in B-Bäumen +- bei weniger als $m$ Elementen auf Seite: Unterlauf +- Löschen eines Wertes $w$ : Bsp.: 24; 28, 38, 35 + - mit lookup entsprechende Seite suchen + - $w$ auf Blattseite gespeichert => Wert löschen, eventuell Unterlauf behandeln + - $w$ nicht auf Blattseite gespeichert => Wert löschen, durch lexikographisch nächstkleineres Element von einer Blattseite ersetzen, eventuell auf Blattseite => Unterlauf +- Unterlaufbehandlung + - Ausgleichen mit der benachbarten Seite (benachbarte Seite $n$ Elemente mit $n>m$) + - oder Zusammenlegen zweier Seiten zu einer (Nachbarseite $n=m$ Elemente), das "mittlere" Element von Indexseite darüber dazu, auf Indexseite eventuell => Unterlauf +- Einfügen des Elementes 22; Löschen von 22 + ![](Assets/DBimpl-b-baum-beispiel-3.png) + +Komplexität der Operationen +- Aufwand beim Einfügen, Suchen und Löschen im B-Baum immer $O(log_m(n))$ Operationen +- entspricht genau der "Höhe" des Baumes +- Konkret: Seiten der Größe 4 KB, Zugriffsattributwert 32 Bytes, 8-Byte-Zeiger: zwischen 50 und 100 Indexeinträge pro Seite; Ordnung dieses B-Baumes 50 +- 1.000.000 Datensätze: $log_{50}(1000000) = 4$ Seitenzugriffe im schlechtesten Fall +- Wurzelseite jedes B-Baumes normalerweise im Puffer: 3 Seitenzugriffe + +## B+-Baum +Varianten +- B+-Bäume: nur Blattebene enthält Daten -> Baum ist hohl +- B∗-Bäume: Aufteilen von Seiten vermeiden durch "Shuffle" +- Präfix-B-Bäume: Zeichenketten als Zugriffsattributwerte, nur Präfix indexieren + +B+-Baum: Motivation +- B-Baum: Wie/wo werden Nicht-Schlüsseldaten (Tupel, TIDs) gespeichert? + - Zusammen mit Schlüsseln in allen Knoten? + - Problem beim Traversieren des Baumes, z.B. bei Bereichsanfragen + ![](Assets/DBimpl-b+-baum-traversieren.png) + +B+-Baum +- in der Praxis am häufigsten eingesetzte Variante des B-Baumes: + - effizientere Änderungsoperationen, insb. Löschen + - Verringerung der Baumhöhe +- Änderungen gegenüber B-Baum + - in inneren Knoten nur noch Zugriffsattributwert und Zeiger auf nachfolgenden Seite der nächsten Stufe; nur Blattknoten enthalten neben Zugriffsattributwert die Daten (Datensätze bzw. Verweise auf Datensätze in der Hauptdatei) + - Knoten der Blattebene sind untereinander verkettet für effiziente Unterstützung von Bereichsanfragen + +B+-Baum: Aufbau +![](Assets/Dbimpl-b+-baum-aufbau.png) + +Ordnung; Operationen +- Ordnung für B+-Baum: $(x,y), x$ Mindestbelegung der Indexseiten, $y$ Mindestbelegung der Blattseiten +- delete gegenüber B-Baum effizienter ("Ausleihen" eines Elementes von der Blattseite entfällt) +- Zugriffsattributwerte in inneren Knoten können sogar stehenbleiben +- häufig als Primärindex eingesetzt +- B+-Baum ist dynamische, mehrstufige, indexsequenziellen Datei + +B+-Baum: Blattebene mit Verweisen +![](Assets/DBimpl-b+-baum-blattebenen.png) + +B+-Baum: Datenstrukturen +```cpp +BPlusBranchNode =record of + nkeys: int; + ptrs: array[0 .. nkeys ] of PageNum; + keys: array[1 .. nkeys ]of KeyType; + level: int; +/* Level= 1 zeigt an, dass die ptrs auf Blätter zeigen */ +end; +``` +```cpp +BPlusLeafNode = record of + nkeys: int; + keys: array[1 .. nkeys ]of KeyType; + payload: array[1 .. nkeys ]of LoadType ; /* Daten bzw. TIDs */ + nextleaf: PageNum; +end; +``` + +Operationen im B+-Baum +- lookup: wie im B-Baum jedoch immer bis zur Blattebene +- $search(u,o)$: Lookup für unteren Wert $u$ , Traversieren auf der Blattebene bis zum oberen Wert $o$ +- $insert$: ähnlich zum B-Baum + - im Fall des Split bei Überlaufbehandlung wird nur ein Separatorschlüssel im Elternknoten eingefügt + - z.B. Kopie des kleinsten Schlüsselwertes des "rechten" Kindknotens oder geeigneter Wert zwischen beiden Knoten +- $delete$: ähnlich zum B-Baum, jedoch + - Löschen der Daten zunächst nur auf Blattebene + - bei Unterlauf: entweder Ausgleich mit Nachbarknoten oder Vereinigen mit Nachbarknoten; ggf. Anpassen (Ausgleich) oder Löschen (Vereinigen) des Separatorschlüssels + - alternativ: Unterlauf akzeptieren und durch spätere inserts oder Reorganisation auflösen + +Weitere Entwurfsentscheidungen für B+-Baum +- Schlüsselsuche im Knoten: sequenzielle Suche vs. binäre Suche vs. Interpolation Search +- Knotengröße: Maximieren der Anzahl der Vergleiche (Knotennutzen) pro I/O-Zeiteinheit + +| Seitengröße (KB) | Sätze/Seite | Knotennutzen | I/O-Zeit (ms) | Nutzen/Zeit | +| ---------------- | ----------- | ------------ | ------------- | ----------- | +| 4 | 143 | ≈7 | 5,020 | 1,427 | +| 16 | 573 | ≈ 9 | 5,080 | 1,804 | +| 64 | 2.294 | ≈ 11 | 5,320 | 2,098 | +| 128 | 4.588 | ≈ 12 | 5,640 | 2,157 | +| 256 | 9.175 | ≈ 13 | 6,280 | 2,096 | +| 1024 | 36.700 | ≈ 15 | 10,120 | 1,498 | +| 4096 | 146.801 | ≈ 17 | 25,480 | 0,674 | +[Literatur](G. Graefe: Modern B-Tree Techniques, Foundations and Trends in Databases, 2010) + +- Konsistenzprüfung während der Traversierung + - mögliche Inkonsistenzen durch Speicherfehler, konkurrierende Änderungen + Implementierungsfehler, ... +- Cache-Optimierung: Knotenstruktur, Kompression (Präfix-/Suffix Truncation) +- Pointer Swizzling: zur Ersetzung der logischen Seitennummern durch physische Adressen +- Knotengröße: bei großen Puffern kann großer Teil der inneren Knoten im Puffer gehalten werden -> größere Knoten (im MB-Bereich) sinnvoll +- Verzögern des Splits bei Überlaufbehandlung: Ausgleichen mit Nachbarknoten soweit möglich; verbessert Auslastung der Knoten +- zusätzliche Verweise zwischen Knoten + - z.B. zwischen inneren Knoten der gleichen Ebene, zu Elternknoten, etc. + - ermöglichen Konsistenzchecks, aber erschweren Sperren für Nebenläufigkeitskontrolle + +## Weitere Varianten +Präfix-B-Baum +- B-Baum über Zeichenkettenattribut + - lange Schlüssel in inneren Knoten -> hoher Speicherplatzbedarf + - vollständige Schlüssel eigentlich nicht notwendig, da nur "Wegweiser" +- Idee: Verwaltung von Trennwerten -> Präfix-B-Baum + - in inneren Knoten nur Trennwerte, die lexikographisch zwischen den Werten liegen + - möglichst kurze Trennwerte, z.B. kürzester eindeutiger Präfix + ![](Assets/DBimpl-präfix-b-baum.png) + - aber: Beispiel "Vandenberg" und "Vandenbergh" + +Mehr-Attribut-B-Baum +- B-Baum ist eindimensionale Struktur, jedoch können mehrere Attribute als kompositer Schlüssel indexiert werden + `create index NameIdx on KUNDE(Name, Vorname)` +- allerdings: Attribute werden bei partial-match-Anfragen nicht gleich behandelt! +- Alternative: raumfüllende Kurven -> multidimensionale Indexstrukturen + ![](Assets/Dbimpl-mehr-attribut-b-baum.png) + +## Optimierungen für moderne Hardware +Optimierungspotential +- Verbesserung der Cache-Trefferrate + - Organisation der Datenstruktur entsprechend Cacheline (Größe, Anordnung der Daten) + - In-Place-Update im Hauptspeicher -> Cache-Invalidierung: verändertes Update Handling + - Pointer Swizzling +- Berücksichtigung der Storage-Eigenschaften + - SSD vs. HDD + - Bevorzugung sequentieller Schreiboperationen + - spezielle Berücksichtigung für Main-Memory-Indexe +- Synchronisation in Multicore-Umgebungen + - Lock/Latch-freie Operationen + + +CSB+-Baum +- =Cache Sensitive B+ Tree (Rao, Ross: Making B+-Trees Cache Conscious in Main Memory, SIGMOD 2000) +- "Cache-Freundlichkeit" durch + 1. Platzsparen im Knoten -> mehr relevante Daten im Cache + 2. Eliminieren von Zeigern für 1. und Reduzierung von Zeigerarithmetik +- Ansatz: veränderte Struktur der inneren Knoten + - Zeiger auf ersten Kindknoten + - alle Kindknoten eines Knotens sind in einem zusammenhängenden Speicherbereich (Knotengruppe) allokiert und werden über einenOffsetadressiert + ![](Assets/DBimpl-csb-baum.png) + +Bw-Baum +- = Buzzword Tree (Levandoski, Lomet, Sengupta: The Bw-Tree: A B-tree for New Hardware Platforms, ICDE 2013) +- Ziele: Cache-Freundlichkeit, Multicore-CPUs, Flash-Speichereigenschaften +- Techniken + - überwiegend Latch-freie Operationen, stattdessen atomare CAS-Instruktionen + - spezifische Struktur-Modifikationsoperationen: Folge von atomaren Modifikationen, Blink-ähnliche Struktur + - Delta-Updates und Log Structured Storage (LSS) + - Änderungen an Seiten/Knoten werden nicht direkt ausgeführt, sondern in Delta-Records pro Knoten erfasst + - keine Synchronisation für Zugriff auf Seiten notwendig + - Seite kann auch nach Änderung im Cache verbleiben + - Seiten + Delta Records werden periodisch konsolidiert + - Log Structured Storage -> später! + - Mapping-Tabelle: logische Seitennummern in + - (a) Offset im Flash-Speicher + - (b) Zeiger im Hauptspeicher + +## LSM-Baum +- = Log Structured Merge Tree (O’Neil, Cheng, Gawlick, O’Neil: The log-structured merge-tree (LSM-tree). Acta Informatica. 33 (4): 351-385, 1996) +- Ziel: höherer Schreibdurchsatz durch Eliminierung verstreuter In-Place-Updates +- Einsatz in diversen NoSQL-Systemen: HBase, Cassandra, BigTable, LevelDB, RocksDB, ... +- Grundidee + - Batches von Schreiboperationen werden sequentiell in Indexdateien gespeichert, d.h. Sortieren vor Schreiben auf Externspeicher (Log Structured) + - Neue Updates werden in neuen Indexdateien gespeichert + - Indexdateien werden periodisch zusammengefügt (Merge) + - Leseoperationen müssen alle Indexdateien konsultieren +![](Assets/DBimpl-LSM-baum.png) + +LSM-Baum: Realisierung +- Main-Memory-Baum $C_0$ als Puffer, sortiert nach Schlüsseln, z.B. als AVL- oder RB-Baum + - bei Erreichen eines gegebenen Füllgrads -> Herausschreiben auf Disk (siehe unten) + - ergänzt um Write Ahead Logging auf Disk für Wiederherstellung nach Systemfehler +- mehrere Append-only, disk-basierte Indexe $C_1, C_2,...,$ ebenfalls sortiert nach Schlüssel (z.B. als B-Baum) + - effiziente Unterstützung von Scans (Schlüsselsuche) + - Merge in einem Schritt +- Aktualität der Indexe: $C_0,C_1,...,C_n$ + +LSM-Baum: Verdichtung +- wenn bestimmte Anzahl von Dateien erzeugt wurden (z.B. 5 Dateien je 100 Datensätze), werden diese in eine Datei gemischt (1 Datei mit 500 Sätzen) +- sobald 5 Dateien mit 500 Sätzen vorliegen, dann Mischen in eine Datei +- usw. +- Nachteil: große Anzahl von Dateien, die alle durchsucht werden müssen + +LSM-Baum: Ebenenweise Verdichtung +1. pro Ebene wird eine bestimmte Zahl von Dateien verwaltet, partitioniert nach Schlüsseln (keine Überlappung der Schlüssel) -> Suche nur in einer Datei notwendig +2. Ausnahme: erste Ebene (Überlappung erlaubt) +3. Mischen der Dateien jeweils in die nächsthöhere Ebene: Auswahl einer Datei und Aufteilen der Sätze -> Platz für neue Daten schaffen + +LSM-Baum: Lesezugriffe +- grundsätzlich: Verbesserung der Schreibperformance zulasten der Leseperformance + - Suche in allen Indexen $C_0,C_1,...,C_n$ notwendig +- Vermeiden unnötiger Lesevorgänge durch Bloom-Filter pro Index oder pro Run + - (probabilistische) Datenstruktur zum Feststellen, ob Objekt in einer Menge enthalten ist + - Bit-Feld: Objekt wird über $k$ Hashfunktionen auf $k$ Bits abgebildet, die auf 1 gesetzt werden + - Prüfen auf Enthaltensein: Hashfunktionen anwenden -> Wenn alle $k$ Bits $= 1$, dann ist Objekt enthalten + - aber falsch-positive Werte möglich! + - können ebenfalls durch Mischen kombiniert werden + - [Quelle](Bloom: Space/Time Trade-offs in Hash Coding with Allowable Errors. CACM, 13(7):422-426, 1970) + +## Zusammenfassung +- B+-Baum als "Arbeitspferd" für Indexing +- Standardoperationen: Suche, Einfügen, Löschen +- noch nicht betrachtet: Nebenläufigkeitskontrolle und Wiederherstellung im Fehlerfall +- diverse Varianten und Optimierungen +- LSM-Baum für schreibintensive Workloads + +# Hashing +## Hashing +- Zugriff über Adressberechnung aus Schlüssel +- linearer Adressraum der Grösse $n$ + - Adressierung in einem Array +- Ziel: direkter Zugriff in $O(1)$ statt logarithmisch wie bei Bäumen + +Hashverfahren +- Schlüsseltransformation und Überlaufbehandlung +- DB-Technik: + - Disk-basiert: Bildbereich entspricht Seiten-Adressraum + - Hauptspeicher: Adresse in einem Array (Hauptspeicheradresse plus Offset) +- Dynamik: dynamische Hashfunktionen oder Re-Hashen + +Grundprinzipien +- Basis-Hashfunktion: $h(k)= k mod m$ + - $m$ oft Primzahl da besseres Verhalten bei Kollisionen + - oder $m=2^k$ aufgrund einfacher Berechnungen +- Überlauf-Behandlung + - Überlaufseiten als verkettete Liste + - lineares Sondieren + - quadratisches Sondieren + - doppeltes Hashen + - ... + +Hashverfahren für blockorientierte Datenhaltung +![](Assets/Dbimpl-hashverfahren.png) + +Operationen und Zeitkomplexität +- lookup, modify, insert, delete +- lookup benötigt maximal $1+ #B(h(w))$ Seitenzugriffe +- $#B(h(w))$ Anzahl der Seiten (inklusive der Überlaufseiten) des Buckets für Hash-Wert $h(w)$ +- Untere Schranke 2 (Zugriff auf Hashverzeichnis plus Zugriff auf erste Seite) + +Statisches Hashen: Probleme +- mangelnde Dynamik +- Vergrößerung des Bildbereichs erfordert komplettes Neu-Hashen +- Wahl der Hashfunktion entscheidend; + - Bsp.: Hash-Index aus 100 Buckets, Studenten über 6-stellige MATRNR (wird fortlaufend vergeben) hashen + - ersten beiden Stellen: Datensätze auf wenigen Seiten quasi sequenziell abgespeichert + - letzten beiden Stellen: verteilen die Datensätze gleichmäßig auf alle Seiten +- Sortiertes Ausgeben einer Relation nicht unterstützt + +## Hash-Funktionen +- klassisch, etwa Divisions-Rest-Methode + $h() = x mod m$ +- zusammengesetzt, etwa $h(k)= h_2 (h_1 (k))$ (siehe später Spriralhashen) +- ordnungserhaltend + $k_1 < k_2 => ( h(k_1) = h(k_2) \vee h(k_1) < h(k_2))$ +- dynamisch (siehe später) +- mehrdimensional (siehe später) +- materialisiert (etwa Dictionary Encoding, siehe später) + +Ordnungserhaltenes Hashen +- Schlüsselwerte werden als 8-Bit-Integer-Werte ohne Vorzeichen kodiert und sind gleichmässig im Bereich $0...2^8-1$ verteilt. +- Die Extraktion der ersten drei Bits ergibt eine ordnungserhaltende Hashfunktion für den Bereich $0...2^3-1$. +- Sind die Schlüsselwerte nicht gleichverteilt, etwa weil es sich um fortlaufend vergebene Nummern handelt, ist das Ergebnis zwar weiterhin ordnungserhaltend, aber die Hash-Tabelle ist sehr ungleichmäßig gefüllt. + +## Hardware-sensitives Hashen +Neue Hardware und Hash-Funktionen +- Beobachtung: Hashen mit klassischem Sondieren ungünstig für neue Hardware + - schwer parallelisierbar + - Clustern von Werten verletzt Nähe der Werte (bei Cache Lines) +- Varianten versuchen beide Punkte anzugehen + - Cuckoo-Hashing + - optimiertes lineares Sondieren + - Hopscotch-Hashing + - Robin-Hood-Hashing + +Cuckoo-Hashen +- Kuckucks-Hashen +- soll Parallelität erhöhen im Vergleich zu linearem Sondieren +- Idee: Zwei Tabellen mit zwei Hash-Funktionen + - im Fall einer Kollision in einer Tabelle wird in der zweiten Tabelle gesucht + - ist dort der Platz belegt, wird der dortige Eintrag verdrängt in die jeweils andere Tabelle + - _Kuckuck wirft Ei aus dem Nest_ + - dies wird solange gemacht bis ein freier Platz gefunden wird +- Beispiel + - zwei einfache Hash-Funktionen, die jeweils die letzte beziehungsweise vorletzte Dezimalstelle einer Zahl extrahieren + $h_1(k) = k mod 10$ + $h_2(k) = (k/10) mod 10$ + - Bei einer Suche muss immer in beiden Tabellen nachgeschaut werden, also $T_1[h_1(k)] = k\vee T_2[h_2(k)] = k$. + - Wir fügen die Zahlen $433, 129$ und $555$ in die Tabelle $T_1$ ein. Beim Einfügen von $783$ ist der Platz in Tabelle $T_1$ belegt, so dass diese Zahl in $T_2$ gespeichert werden muss. Wird nun mit $103$ eine weitere Zahl eingefügt, die mit $433$ unter $h_1$ kollidiert, ist dies mit $h_2$ weiterhin möglich. + +Cuckoo Beispiel +- Ergebnis des Einfügens von 433, 129 , 555 , 783 , 103 +| | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | +| ----- | --- | --- | --- | --- | --- | --- | --- | --- | --- | +| $T_1$ | | | | 433 | | 555 | | | | 129 | +| $T_2$ | 103 | | | | | | | | 783 | +- Wird nun die Zahl $889$ eingefügt, so sind beide möglichen Positionen belegt. $889$ kann in $T_1$ die dort stehende Zahl $129$ verdrängen, die in $T_2$ an der Position $T_2[2]$ gespeichert werden kann. +| | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | +| ----- | --- | --- | --- | --- | --- | --- | --- | --- | --- | +| $T_1$ | | | | 433 | | 555 | | | | 129 | +| $T_2$ | 103 | | 129 | | | | | | 783 | +- Wird nun $789$ eingefügt, sind wiederum beide Positionen belegt. Das Verdrängen von $889$ aus $T_1$ würde zu einem kaskadierenden Verdrängen führen: $889$ würde in $T_2$ dann $783$ verdrängen, das wiederum $433$ in $T_1$ verdrängen würde. Dies würde gehen da $433$ an der Stelle $T_2[3]$ Platz hätte +| | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | +| ----- | --- | --- | --- | --- | --- | --- | --- | --- | --- | +| $T_1$ | | | | 783 | | 555 | | | | 129 | +| $T_2$ | 103 | | 129 | 433 | | | | | 783 | + +Weitere Prinzipien der Optimierung +- Lokalität von Datenzugriffen verringert die Wahrscheinlichkeit von Cache Misses +- Blockung von Daten kann an die Grösse von Cache-Lines (64 Bytes) angepasst werden, und erhöht den Durchsatz +- Parallelisierung für SIMD basierend auf einer Vektorisierung der Daten kann insbesondere SIMD-basierte Co-Prozessoren gut ausnutzen, aber greift auch bei MICs + +Optimiertes lineares Sondieren +- Lineares Sondieren ist gut geeignet, um den Sondierungsvorgang auf Vektoren zu parallelisieren + - Suchschlüssel kann in einen Vektor der Länge $n$ an alle Positionen kopiert werden + - beginnend ab derem initialen Sondierungspunkt $h(k)$ können dann Vektoren jeweils mit Vektoren aus der Hash-Tabelle verglichen werden, also zuerst mit + $H[h)k),...,h(k)+n - 1]$, dann mit $H[h(k) + n,...,h(k) + 2n-1 ]$, etc. + - Vergleich kann parallel erfolgen; muss sowohl auf Vorhandensein von $k$ als auch auf Existenz einer leeren Position prüfen + +Hopscotch-Hashen +- Hopscotch: _Himmel und Hölle_ beziehungsweise _wild herumhopsen_ +- Begrenzung des Sondierungsraum auf eine (konstante) Länge +- Idee: + - beim Einfügen erfolgt die Suche (parallel) in der festen Nachbarschaft + - wird Schlüssel $k$ nicht gefunden und existiert kein freier Slot in der festen Nachbarschaft, dann wird versucht, $k$ mit einem anderen Schlüssel aus der festen Nachbarschaft zu tauschen + - dafür wird die nächste freie Stelle gesucht; von dieser wird rückwärts in Richtung $h(k)$ gesucht und jeder Eintrag $k′$ untersucht + - wenn die aktuelle freie Stelle noch in der festen Nachbarschaft von $k′$ liegt, wird getauscht: $k′$ springt auf die freie Stelle + +Robin-Hood-Hashen +- Robin-Hood: _Nimm von den Reichen gib es den Armen_ +- Basisidee: in der Situation, dass beim Sondieren für $k$ ein Platz bereits mit einem Element $k′$ besetzt ist, wird der nächste Sondierungsschritt mit demjenigen Element weitergeführt, das die kleinere Distanz zum eigentlichen Hash-Wert $h(k)$ bzw. $h(k′)$ hat + +## Dynamische Hash-Verfahren +Lineares Hashen +- Folge von Hash-Funktionen, die wie folgt charakterisiert sind: + - $h_i$: dom(Primärschlüssel) ->$\{0,..., 2^i \times N\}$ ist eine Folge von Hash-Funktionen mit $i\in\{0,1,2,...\}$ und $N$ als Anfangsgröße des Hash-Verzeichnisses + - Wert von $i$ wird auch als Level der Hash-Funktion bezeichnet + - $dom(Primärschlüssel)$ wird im folgenden als $dom(Prim)$ abgekürzt +- Für diese Hash-Funktionen gelten die folgenden Bedingungen: + - $h_{i+1}(w) = h_i(w)$ für etwa die Hälfte aller $w\in dom(Prim)$ + - $h_{i+1}(w) = h_i(w) + 2^i\times N$ für die andere Hälfte + - Bedingungen sind zum Beispiel erfüllt, wenn $h_i(w)$ als $w mod(2^i\times N)$ gewählt wird + - Darstellung durch Bit-Strings, Hinzunahme eines Bits verdoppelt Bildbereich + +Prinzip lineares Hashen +- für ein $w$ höchstens zwei Hash-Funktionen zuständig, deren Level nur um 1 differiert, Entscheidung zwischen diesen beiden durch Split-Zeiger + - $sp$ Split-Zeiger (gibt an, welche Seite als nächstes geteilt wird) + - $lv$ Level (gibt an, welche Hash-Funktionen benutzt werden) +- Aus Split-Zeiger und Level läßt sich die Gesamtanzahl $Anz$ der belegten Seiten wie folgt berechnen: + - $Anz = 2^{lv} + sp$ +- Beide Werte werden am Anfang mit 0 initialisiert. +![](Assets/DBimpl-lineares-hashen.png) + +Lookup +- $$s := h_{lv}(w)$; +- if $s < sp$ +- then $s := h_{lv + 1}(w)$; +- zuerst Hash-Wert mit der "kleineren" Hash-Funktion bestimmen +- liegt dieser unter dem Wert des Split-Zeigers => größere Hash-Funktion verwenden + +Splitten einer Seite +1. Die Sätze der Seite (Bucket), auf die $sp$ zeigt, werden mittels $h_{lv+1}$ neu verteilt (ca. die Hälfte der Sätze wird auf Seite (Bucket) unter Hash-Nummer $2^{lv}*N +sp$ verschoben) +2. Der Split-Zeiger wird weitergesetzt: $sp:=sp +1;$ +3. Nach Abarbeiten eines Levels wird wieder bei Seite 0 begonnen; der Level wird um 1 erhöht: + +``` +if sp = 2^{lv} * N then + begin + lv := lv + 1 ; + sp := 0 + end; +``` +![](DBimpl-hashing-split.png) + + +Problem lineares Hashen +![](Assets/DBimpl-lineares-hashing-problem.png) + +Erweiterbares Hashen +- Problem: Split erfolgt an fester Position, nicht dort wo Seiten überlaufen +- Idee: binärer Trie zum Zugriff auf Indexseiten +- Blätter unterschiedlicher Tiefe + - Indexseiten haben Tiefenwert + - Split erfolgt bei Überlauf +- aber: Speicherung nicht als Trie, sondern als Array + - entspricht vollständigem Trie mit maximaler Tiefe + - "shared" Seiten als Blätter + - Array der Grösse 2 _d_ für maximale Tiefe _d_ + - erfordert nun nur einen Speicherzugriff! + - bei Überlauf: Indexgrösse muss möglicherweise verdoppelt werden! +- Ausgangslage: + - Einfügen von 00111111 würde Überlauf bei erreichter maximaler Tiefe erzeugen + ![](Assets/DBimpl-erweiterbares-hashing.png) + - Verdopplung der Indexgrösse + ![](Assets/DBimpl-erweiterbares-hashing-2.png) + - nun möglich: Split der Seite + ![](Assets/DBimpl-erweiterbares-hashing-3.png) + +Variante: Array als Trie gespeichert +![](Assets/DBimpl-trie.png) + +Spiral-Hashen +- Problem: zyklisch erhöhte Wahrscheinlichkeit des Splittens +- Lösung: unterschiedliche Dichte der Hashwerte + - Interpretation der Bit-Strings als binäre Nachkommadarstellung einer Zahl zwischen $0.0$ und $1.0$ + - Funktion von $[0.0,1.0] -> [0.0,1.0]$ so dass Dichte gleichmässig verteilter Werte nahe $1.0$ doppelt so gross ist wie nahe $0.0$ +- Umverteilung mittels Exponentialfunktion +- Funktion $exp(n)$ $exp(n) = 2^n - 1$ erfüllt die Bedingungen +- insbesondere gilt $2^0 - 1 = 0$ und $2^1 - 1 = 1$ +- Hashfunktion exhash + $exhash(k) = exp(h(k)) = 2^{h(k)} - 1$ +- Wirkung der verwendeten Hashfunktion im Intervall $0.0$ bis $1.0$ + | $n$ | $2^n-1$ | + | ----- | ----------- | + | $0.0$ | $0.0$ | + | $0.1$ | $0.0717735$ | + | $0.2$ | $0.1486984$ | + | $0.3$ | $0.2311444$ | + | $0.4$ | $0.3195079$ | + | $0.5$ | $0.4142136$ | + | $0.6$ | $0.5157166$ | + | $0.7$ | $0.6245048$ | + | $0.8$ | $0.7411011$ | + | $0.9$ | $0.866066$ | + | $1.0$ | $1.0$ | +- Spiralförmiges Ausbreiten + - Ausgangslage: 4 Seiten der Tiefe 2 + ![](Assets/DBimpl-spiral-hashing.png) +- Spiralförmiges Ausbreiten + - Split der Seite mit der höchsten Dichte + - Ergebnis: 5 Seiten, davon 3 der Tiefe 2 und 2 der Tiefe 3 + ![](Assets/DBimpl-spiral-hashing-2.png) + +## Grid-File +Grid-Files +- bekannteste und von der Technik her attraktive mehrdimensionale Dateiorganisationsform +- eigene Kategorie: Elemente der Schlüsseltransformation wie bei Hashverfahren und Indexdateien wie bei Baumverfahren kombiniert + - deshalb hier bei Hash-Verfahren betrachtet + +Grid-File: Zielsetzungen +- Prinzip der 2 Plattenzugriffe: Jeder Datensatz soll bei einer _exact-match_ -Anfrage in 2 Zugriffen erreichbar sein +- Zerlegung des Datenraums in Quader: _n_ -dimensionale Quader bilden die Suchregionen im Grid-File +- Prinzip der Nachbarschaftserhaltung: Ähnliche Objekte sollten auf der gleichen Seite gespeichert werden +- Symmetrische Behandlung aller Raum-Dimensionen: _partial-match_ -Anfragen ermöglicht +- Dynamische Anpassung der Grid-Struktur beim Löschen und Einfügen + +Prinzip der zwei Plattenzugriffe +- bei exact-match + 1. gesuchtes $k$ -Tupel auf Intervalle der Skalen abbilden; als Kombination der ermittelten Intervalle werden Indexwerte errechnet; Skalen im Hauptspeicher => noch kein Plattenzugriff + 2. über errechnete Indexwerte Zugriff auf das _Grid-Directory_ ; dort Adressen der Datensatz-Seiten gespeichert; erster _Plattenzugriff_. + 3. Der Datensatz-Zugriff: zweiter _Plattenzugriff_. + +Aufbau eines Grid-Files +![](Assets/DBimpl-grid-files.png) +- Grid: $k$ eindimensionale Felder (Skalen), jede Skala repräsentiert Attribut +- _Skalen_ bestehen aus Partition der zugeordneten Wertebereiche in Intervalle +- Grid-Directory besteht aus Grid-Zellen, die den Datenraum in Quader zerlegen +- Grid-Zellen bilden eine Grid-Region, der genau eine Datensatz-Seite zugeordnet wird +- Grid-Region: $k$-dimensionales, konvexes (Regionen sind paarweise disjunkt) + +Operationen +- Zu Anfang: Zelle = Region = eine Datensatz-Seite +- Seitenüberlauf: + - Seite wird geteilt + - falls zugehörige Gridregion aus nur einer Gridzelle besteht, muss ein Intervall auf einer Skala in zwei Intervalle unterteilt werden + - besteht Region aus mehreren Zellen, so werden diese Zellen in einzelne Regionen zerlegt +- Seitenunterlauf: + - Zwei Regionen zu einer zusammenfassen, falls das Ergebnis eine neue, konvexe Region ergibt + +Beispiel +- Start-Grid-File + ![](Assets/DBimpl-grid-start.png) + - Datensätze einfügen: $(45,D),(2,B),(87,S),(75,M),(55,K),(3,Y),(15,D),(25,K),(48,F)$ + - jede Seite des Grid-Files fasst bis zu drei Datensätze +- Eingefügt: $(45, D), (2, B), (87, S)$ + ![](Assets/DBimpl-grid-beispiel-1.png) +- Einfügen von $(75, M)$ erzwingt Split + ![](Assets/Dbimpl-grid-beispiel-2.png) +- Eingefügt: $(55, K)$ + ![](Assets/Dbimpl-grid-beispiel-3.png) +- Einfügen von $(3, Y)$ erzwingt wiederum einen Split + ![](Assets/Dbimpl-grid-beispiel-4.png) +- Eingefügt: (15, D), (25, K), + ![](Assets/DBimpl-grid-beispiel-5.png) +- Einfügen von (48, F) erzwingt wiederum einen Split + ![](Assets/DBimpl-grid-beispiel-6.png) + + +Buddy-System +- Beschriebenes Verfahren: Buddy-System (Zwillings-System) +- Die im gleichen Schritt entstandenen Zellen können zu Regionen zusammengefasst werden; Keine andere Zusammenfassung von Zellen ist im Buddy-System erlaubt +- Unflexibel beim Löschen: nur Zusammenfassungen von Regionen erlaubt, die vorher als Zwillinge entstanden waren +- Beispiel: $(15,D)$ löschen: Seiten 1 und 4 zusammenfassen; $(87,S)$ löschen, Seite 2 zwar unterbelegt, kann aber mit keiner anderen Seite zusammengefasst werden + +# Weitere Indexstrukturen +## Bitmap-Indexe +Bitmap-Indexe +- Idee: _Bit-Vektor_ zur Kodierung der Tupel-Attributwert-Zuordnung +- Vergleich mit baumbasierten Indexstrukturen: + - vermeidet degenerierte B-Bäume + - unempfindlicher gegenüber höherer Zahl von Attributen + - einfachere Unterstützung von Anfragen, in denen nur einige (der indexierten) Attribute beschränkt werden + - dafür aber i.allg. höhere Aktualisierungskosten + - beispielsweise in Data Warehouses wegen des überwiegend lesenden Zugriffs unproblematisch + +Bitmap-Index: Realisierung +- Prinzip: Ersetzung der TIDs (rowid) für einen Schlüsselwert im $b$ +-Baum durch Bitvektor +- Knotenaufbau: $|B: 0 1001 0...0 1 | F: 1 01 000... 10 | O: 000 101 ...00 |$ +- Vorteil: geringerer Speicherbedarf + - Beispiel: 150.000 Tupel, 3 verschiedene Schlüsselwerte, 4 Byte für TID + - B+-Baum: 600 KB + - Bitmap: $3*18750 Byte =56KB$ +- Nachteil: Aktualisierungsaufwand +- Definition in Oracle + ```sql + CREATE BITMAP INDEX bestellstatus_idx ON bestellung(status); + ``` +- Speicherung in komprimierter Form + +Standard-Bitmap-Index +- jedes Attribut wird getrennt abgespeichert +- für jede Ausprägung eines Attributs wird ein + Bitmap-Vektor angelegt: + - für jedes Tupel steht ein Bit, dieses wird auf 1 gesetzt, wenn das indexierte Attribut in dem Tupel den Referenzwert dieses Bitmap-Vektors enthält + - die Anzahl der entstehenden Bitmap-Vektoren pro Dimension entspricht der Anzahl der unterschiedlichen Werte, die für das Attribut vorkommen +- Beispiel: Attribut Geschlecht + - 2 Wertausprägungen (m/w) + - 2 Bitmap-Vektoren + | PersId | Name | Geschlecht | Bitmap-w | Bitmap-m | + | --- | --- | --- | --- | --- | + 007 |James Bond |M |0 |1 + 008 |Amelie Lux |W |1 |0 + 010 |Harald Schmidt |M |0 |1 + 011 |Heike Drechsler |W |1 |0 +- Selektion von Tupeln kann nun durch entsprechende Verknüpfung von Bitmap-Vektoren erfolgen +- Beispiel: Bitmap-Index über Attribute Geschlecht und Geburtsmonat + - (d.h. 2 Bitmap-Vektoren B-w und B-m für Geschlecht und 12 Bitmap-Vektoren B-1, ..., B-12 für die Monate, wenn alle Monate vorkommen) +- Anfrage: "alle im März geborenen Frauen" + - Berechnung: $B-w \wedge B-3$ (bitweise konjunktiv verknüpft) + - Ergebnis: alle Tupel, an deren Position im Bitmap-Vektor des Ergebnis eine 1 steht + +Mehrkomponenten-Bitmap-Index +- bei Standard-Bitmap-Indexe entstehen für Attribute mit vielen Ausprägungen sehr viele Bitmap-Vektoren +- $$-Mehrkomponenten-Bitmap-Indexe erlauben $n*m$ mögliche Werte durch $n+m$ Bitmap-Vektoren zu + indexieren +- jeder Wert $x(0\leq x\leq n*m-1)$ kann durch zwei Werte $y$ und $z$ repräsentiert werden: + $x=n*y+z$ mit $0\leq y\leq m-1$ und $0\leq z\leq n-1$ + - dann nur noch maximal $m$ Bitmap-Vektoren für $y$ und $n$ Bitmap-Vektoren für $z$ + - Speicheraufwand reduziert sich von $n*m$ auf $n+m$ + - dafür müssen für eine Punktanfrage aber 2 Bitmap-Vektoren gelesen werden +- Beispiel: Zweikomponenten-Bitmap-Index + - Für $M= 0 ..11$ etwa $x= 4*y + z$ + - y-Werte: $B-2-1, B-1-1, B-0-1$ + - z-Werte: $B-3-0, B-2-0, B-1-0, B-0-0$ + | x| y | || z ||||| + | --- | --- | --- | --- | --- | --- | --- | --- | + | M | B-2-1 | B-1-1 | B-0-1| B-3-0| B-2-0| B-1-0| B-0-0 + |5| 0 |1 |0 |0 |0 |1 |0 + |3| 0 |0 |1 |1 |0 |0 |0 + |0| 0 |0 |1 |0 |0 |0 |1 + |11| 1| 0 |0| 1 |0| 0 |0 + +Beispiel: Postleitzahlen +- Kodierung von Postleitzahlen +- Werte 00000 bis 99999 +- direkte Umsetzung: 100.000 Spalten +- Zweikomponenten-Bitmap-Index (erste 2 Ziffern + 3 letzte Ziffern): 1.100 Spalten +- Fünf Komponenten: 50 Spalten + - geeignet für Bereichsanfragen "PLZ 39***" +- Binärkodiert (bis $2^17$): 34 Spalten + - nur für Punktanfragen! +- Bemerkung: Kodierung zur Basis 3 ergibt sogar nur 33 Spalten... + +## Indexierung von Texten +Indexierung von Texten +- bisher vorgestellte Verfahren unterstützen prinzipiell auch die Indexierung von Zeichenketten +- Probleme bereitet folgendes: + - unterschiedliche Längen der Zeichenketten als Suchschlüssel + - bei Sätzen: Zugriff auf einzelne Wörter bevorzugt + - Ähnlichkeiten u.a. über gemeinsame Präfixe und Editierabstand + +Digital- und Präfixbäume +- B-Bäume: Problem bei zu indexierenden Zeichenketten +- Lösung: Digital- oder Präfixbäume +- Digitalbäume indexieren (fest) die Buchstaben des zugrundeliegenden Alphabets +- können dafür unausgeglichen werden +- Beispiele: Tries, Patricia-Bäume +- Präfixbäume indexieren Präfix der Zeichenketten + +Tries +- von "Information Retrieval", aber wie try gesprochen + - Abgrenzung vom _tree_ für allgemeine Suchbäume + ![](Assets/DBimpl-tries.png) +- Knoten eines Tries + ![](Assets/Dbimpl-tries-knoten.png) + - Probleme: lange gemeinsame Teilworte, nicht vorhandenen Buchstaben und Buchstabenkombinationen, möglicherweise leere Knoten, sehr unausgeglichene Bäume + +Patricia-Bäume +- Tries: Probleme bei Teilekennzahlen, Pfadnamen, URLs (lange gemeinsame Teilworte) +- Lösung: Practical Algorithm To Retrieve Information Coded In Alphanumeric (Patricia) +- Prinzip: Überspringen von Teilworten +- Problem: Datenbanksprache bei Suchbegriff _Triebwerksperre_ + +Patricia-Baum und Trie im Vergleich +![](Assets/Dbimpl-trie-vs-patricia.png) +- übersprungene Teilworte zusätzlich speichern: Präfix-Bäume + + +Präfix-Bäume +- Patricia-Baum plus Abspeicherung der übersprungenen Präfixe + ![](Assets/DBimpl-präfix-baum.png) + +Invertierte Listen +- indizierte Worte (Zeichenketten) bilden eine lexikographisch sortierte Liste +- einzelner Eintrag besteht aus einem _Wort_ und einer Liste von Dokument-Identifikatoren derjenigen Dokumente, in denen das Wort vorkommt +- zusätzlich können weitere Informationen für die Wort-Dokument-Kombination abgespeichert werden: + - Position des (ersten Auftretens des) Wortes im Text + - Häufigkeit des Wortes im Text + +Invertierte Listen + ![](Assets/DBimpl-invertierte-liste.png) + +## Mehrdimensionale Speichertechniken +Mehrdimensionale Speichertechniken +- bisher: eindimensional (keine partial-match-Anfragen, nur lineare Ordnung) +- jetzt: mehrdimensional (auch partial-match-Anfragen, Positionierung im mehrdimensionalen Datenraum) +- $k$ Dimensionen = $k$ Attribute können gleichberechtigt unterstützt werden +- dieser Abschnitt + - mehrdimensionaler B-Baum + - mehrdimensionales Hashverfahren + +## Mehrdimensionale Baumverfahren +Mehrdimensionale Baumverfahren +- KdB-Baum ist B+-Baum, bei dem Indexseiten als binäre Bäume mit Zugriffsattributen, Zugriffsattributwerten und Zeigern realisiert werden +- Varianten von $k$ -dimensionalen Indexbäumen: + - _kd-Baum_ von Bentley und Friedman: für Hauptspeicheralgorithmen entwickelte, mehrdimensionale Grundstruktur (binärer Baum) + - _KDB-Baum_ von Robinson: Kombination kd-Baum und B-Baum ( $k$ -dimensionaler Indexbaum bekommt höheren Verzweigungsgrad) + - _KdB-Baum_ von Kuchen: Verbesserung des Robinson-Vorschlags, wird hier behandelt +- KdB-Baum kann Primär- und mehrere Sekundärschlüssel gleichzeitig unterstützen +- macht als Dateiorganisationsform zusätzliche Sekundärindexe überflüssig + +Definition KdB-Baum +- Idee: auf jeder Indexseite einen Teilbaum darstellen, der nach mehreren Attributen hintereinander verzweigt + - _KdB-Baum vom Typ_ ( $b$ , $t$ ) besteht aus + - inneren Knoten (Bereichsseiten) die einen _kd-Baum_ mit maximal $b$ internen Knoten enthalten + - Blättern (Satzseiten) die bis zu $t$ Tupel der gespeicherten Relation speichern können + - Bereichsseiten: _kd-Baum_ enthalten mit Schnittelementen und zwei Zeigern + - Schnittelement enthält Zugriffsattribut und Zugriffsattributwert; + - linker Zeiger: kleinere Zugriffsattributwerte; + - rechter Zeiger: größere Zugriffsattributwerte + +Beispiel +![](Assets/Dbimpl-kdb-baum-beispiel.png) + +KdB-Baum: Struktur +- Bereichsseiten + - Anzahl der Schnitt- und Adressenelemente der Seite + - Zeiger auf Wurzel des in der Seite enthaltenen kd-Baumes + - Schnitt- und Adressenelemente. +- Schnittelement + - Zugriffsattribut + - Zugriffsattributwert + - zwei Zeiger auf Nachfolgerknoten des kd-Baumes dieser Seite (können Schnitt- oder Adressenelemente sein) +- Adressenelemente: Adresse eines Nachfolgers der Bereichsseite im KdB-Baum (Bereichs- oder Satzseite) + +KdB-Baum: Operationen +- Komplexität $lookup$, $insert$ und $delete$ bei exact-match $O(log n)$ +- bei partial-match besser als $O(n)$ +- bei $t$ von $k$ Attributen in der Anfrage spezifiziert: Zugriffskomplexität von $O(n^{1-t/k})$ + +KdB-Baum: Trennattribute +- Reihenfolge der Trennattribute + - entweder zyklisch festgelegt + - oder Selektivitäten einbeziehen: Zugriffsattribut mit hoher Selektivität sollte früher und häufiger als Schnittelement eingesetzt werden +- Trennattributwert: aufgrund von Informationen über Verteilung von Attributwerten eine geeignete "Mitte" eines aufzutrennenden Attributwertebereichs ermitteln + + +KdB-Baum: Brickwall +![](Assets/DBimpl-kdb-baum-brickwall.png) + +## Mehrdimensionales Hashen +Mehrdimensionales Hashen +- Idee: Bit Interleaving +- abwechselnd von verschiedenen Zugriffsattributwerten die Bits der Adresse berechnen +- Beispiel: zwei Dimensionen + | | *0*0 | *0*1 | *1*0| *1*1| + | --- | --- | --- | --- | --- | + 0*0*| 0000 |0001 |0100 |0101 + 0*1*| 0010 |0011 |0110 |0111 + 1*0*| 1000 |1001 |1100 |1101 + 1*1*| 1010 |1011 |1110 |1111 + +MDH von Kuchen +- MDH baut auf linearem Hashen auf +- Hash-Werte sind Bitfolgen, von denen jeweils ein Anfangsstück als aktueller Hashwert dient +- je ein Bitstring pro beteiligtem Attribut berechnen +- Anfangsstücke nun nach dem Prinzip des Bit-Interleaving zyklisch abarbeiten +- Hashwert reihum aus den Bits der Einzelwerte zusammensetzen + +MDH formal +- mehrdimensionaler Wert $x := (x_1,..., x_k)\in D = D_1\times ...\times D_k$ +- Folge von mit _i_ indizierten Hashfunktionen konstruieren +- _i_-te Hashfunktion $h_i(x)$ wird mittels Kompositionsfunktion $\bar{h}_i$ aus den jeweiligen $i$ -ten Anfangsstücken der lokalen Hash-Werte $h_{i_j}(x_j)$ zusammengesetzt: $h_i(x)=\bar{h}_i(h_{i_1}(x_1),...,h_{i_k}(x_k))$ +- lokale Hashfunktionen $h_{i_j}$ ergeben jeweils Bitvektor der Länge $z_{i_j} +1$:$h_{i_j} : D_j\rightarrow \{0,..., z_{i_j}\}, j\in\{1 ,..., k\}$ +- $z_{i_j}$ sollten möglichst gleich groß sein, um die Dimensionen gleichmäßig zu berücksichtigen +- Kompositionsfunktion $\bar{h}_i$ setzt lokale Bitvektoren zu einem Bitvektor der Länge $i$ zusammen: $\bar{h}_i:\{0,...,z_{i1}\times ...\times\{0,..., z_{i_k}\}\rightarrow\{0,...,2^{i+1}-1\}$ +- ausgeglichene Länge der $z_{i_j}$ wird durch folgende Festlegung bestimmt, die Längen zyklisch bei jedem Erweiterungsschritt an einer Stelle erhöht: + $$z_{i_j} = \begin{cases} 2^{\lfloor \frac{i}{k}\rfloor +1} -1 \quad\text{ für } j-1\leq (i mod k)\\ 2^{\lfloor \frac{i}{k}\rfloor} -1 \quad\text{ für } j-1 > (i mod k) \end{cases}$$ +- Kompositionsfunktion: + $$\bar{h}_i(x)=\sum_{r=0}^i (\frac{(x_{(r mod k)+1} mod 2^{\lfloor \frac{r}{k}\rfloor +1}) - (x_{(r mod k)+1} mod 2^{\lfloor \frac{r}{k}\rfloor})}{2^{\lfloor \frac{r}{k}\rfloor})}) 2^r$$ + +MDH Veranschaulichung +![](Assets/DBimpl-mdh-veranschaulichung.png) +- verdeutlicht Komposition der Hashfunktion $h_i$ für drei Dimensionen und den Wert $i=7$ +- graphisch unterlegte Teile der Bitstrings entsprechen den Werten $h_{7_1}(x_1),h_{7_2}(x_2)$ und $h_{7_3}(x_3)$ +- beim Schritt auf $i=8$ würde ein weiteres Bit von $x_2$ (genauer: von $h_{8_2}(x_2)$) verwendet + +MDH Komplexität +- Exact-Match-Anfragen: $O(1)$ +- Partial-Match-Anfragen, bei $t$ von $k$ Attributen festgelegt, Aufwand $O(n^{1-\frac{t}{k}})$ +- ergibt sich aus der Zahl der Seiten, wenn bestimmte Bits "unknown" +- Spezialfälle: $O(1)$ für $t=k$, $O(n)$ für $t=0$ + +## Geometrische Zugriffsstrukturen +Geometrische Zugriffsstrukturen +- große Mengen geometrischer Objekte ($> 10^6$) +- Eigenschaften geometrischer Objekte + - Geometrie (etwa Polygonzug) + - zur Unterstützung bei Anfragen: zusätzlich $d$-dimensionales umschreibendes Rechteck (bounding + box) + - nichtgeometrische Attribute +- Anwendungsszenarien: Geoinformationssysteme (Katasterdaten, Karten), CAx-Anwendungen (etwa VLSI + Entwurf), ... +- Zugriff primär über Geometriedaten: Suchfenster (Bildschirmausschnitt), Zugriff auf benachbarte Objekte + +Typische Operationen +- exakte Suche + - Vorgabe: exakte geometrische Suchdaten + - Ergebnis: maximal ein Objekt +- Bereichsanfrage für vorgegebenes $n$-dimensionales Fenster + - Suchfenster: $d$-dimensionales Rechteck (entspricht mehrdimensionalem Intervall) + - Ergebnis sind alle geometrischen Objekte, die das Suchfenster schneiden + - Ergebnisgröße parameterabhängig +- Einfügen von geometrischen Objekten + - wünschenswert ohne globale Reorganisation! +- Löschen von geometrischen Objekten + - wünschenswert ohne globale Reorganisation! + +Nachbarschaftserhaltende Suchbäume +- Aufteilung des geometrischen Bereichs in Regionen +- benachbarte Objekte wenn möglich der selben Region zuordnen +- falls dieses nicht geht, diese auf benachbarte Regionen aufteilen +- Baumstruktur entsteht durch Verfeinerung von Regionen in benachbarte Teilregionen +- Speicherung von Objekten erfolgt in den Blattregionen +- Freiheitsgrade + - Form der Regionen + - vollständige Partitionierung oder Überlappung durch die Regionen + - eindeutige Zuordnung von Objekten zu Regionen oder Mehrfachzuordnung + - Speicherung und Zugriff über Originalgeometrie oder über abgeleitete Geometrie für Objekte + - Grad des Baumes & Organisationsform + +Mehrstufige Bearbeitung geom. Anfragen +![](Assets/DBimpl-mehrstufige-geom-bearbeitung.png) + +Geom. Baumstruktur: BSP-Baum +- Binary Space Partitioning: schrittweises binäres Teilen des Datenraums +![](Assets/DBimpl-bsp-partition.png) + +Realisierungsvarianten +| Alternative | Baumstrukturen | | | +| --- | --- | --- | --- | +| | BSP-Baum | R-Baum | R+-Baum | +Regionenform | konvexe Polygone |Rechtecke| Rechtecke| +Teilregionen |vollständig |unvollständig |unvollständig| +Überlappung |nein |ja |nein| +ausgeglichen |nein |ja |ja| + +R-Bäume +- R-Baum: Verallgemeinerung des B-Baum-Prinzips auf mehrere Dimensionen + - Baumwurzel entspricht einem Rechteck, das alle geometrischen Objekte umfasst + - Geo-Objekte werden durch ihre umschließenden Rechtecke repräsentiert + - Aufteilung in Regionen erfolgt in nichtdisjunkte Rechtecke + - Jedes Geo-Objekt ist eindeutig einem Blatt zugeordnet +- Regionenaufteilung durch Rechtecke im R-Baum + ![](Assets/DBimpl-r-baum.png) +- Baumstruktur für R-Baum + ![](Assets/DBimpl-r-baum-struktur.png) + +Probleme mit R-Bäumen +- gegebenes Rechteck kann von vielen Regionen überlappt werden, es ist aber genau in einer Region gespeichert +- auch Punktanfragen können eine Suche in sehr vielen Rechteckregionen bedeuten +- Ineffizient bei exakter Suche (exakte Suche auch bei Einfügen und Löschen notwendig!) +- Probleme beim Einfügen + - Einfügen erfordert oft Vergrößern von Regionen (aufwärts propagiert) + +Vergrößern beim Einfügen +![](Assets/DBimpl-r-baum-vergrößern.png) + +R+-Bäume +- R+-Bäume: Aufteilung in Teilregionen disjunkt +- Jedem gespeicherten Punkt des geometrischen Bereichs ist eindeutig ein Blatt zugeordnet +- In jeder Baumebene ist einem Punkt ebenfalls maximal ein Rechteck zugeordnet -> eindeutiger Pfad von der Wurzel zum speichernden Blatt +- ‘Clipping’ von Geo-Objekten notwendig! + ![](Assets/DBimpl-r+-baum.png) + ![](Assets/DBimpl-r+-baum-struktur.png) + +Probleme mit R+-Bäumen +- Objekte müssen in mehreren Rechteckregionen gespeichert werden (clipping) - erhöhter Speicher- & Modifikationsaufwand +- Einfügen von Objekten erfordert möglicherweise Modifikation mehrerer Rechteckregionen + ![](Assets/DBimpl-r+-baum-problem.png) +- Einfügen kann in bestimmten Situationen unvermeidbar zu Regionenaufteilungen führen + ![](Assets/Dbimpl-r+-baum-problem-2.png) +- Regionenmodifikationen haben Konsequenzen sowohl in Richtung Blätter als auch in Richtung Wurzel +- obere Grenze für Einträge in Blattknoten kann nicht mehr garantiert werden + +Rechteckspeicherung durch Punktdatenstrukturen +- Probleme bei ausgedehnten Geometrien -> Entartung +- Nutzung "robuster" mehrdimensionaler Indexstrukturen (z.B. Grid-File) durch Abbildung von Rechtecken auf Punkte möglich? + +Punktdatenstrukturen +- Rechteckspeicherung durch Punktdatenstrukturen + - Transformation von ausgedehnten Objekten (mehrdimensionale Rechtecke) in Punktdaten + - Transformation bildet $d$-dimensionale Rechtecke auf Punkte im $2d$-dimensionalen Raum $R^{2d}$ ab + - $d$-dimensionale Rechteck: $r=[l_1, r_1]\times ...\times [l_d, r_d]$ +- Eckentransformation + $p_r = (l_1, r_1,..., l_d, r_d) \in R^{2d}$ + pro Intervall als Koordinaten: obere Schranke, untere Schranke +- Mittentransformation $p_r =(\frac{l_1+r_1}{2}, \frac{r_1-l_1}{2},...,\frac{l_d+l_r}{2},\frac{r_d-l_d}{2})\in\mathbb{R}^{2d}$ + pro Intervall als Koordinaten: Mittelpunkt, halbe Breite + +Eckentransformation +![](Assets/DBimpl-eckentransformation.png) + +Mittentransformation +![](Assets/DBimpl-mittentransformation.png) + +Suchfenster +![](Assets/DBimpl-suchfenster.png) + +Grid-File-Degeneration +![](Assets/Dbimpl-grid-file-degeneration.png) + +## Approximierende Verfahren +Approximierende Verfahren +- insbesondere für hochdimensionale Daten +- pro Tupel einen approximierenden Bit-Code mit nur wenigen Bits pro Dimensionen + - beispielsweise ein Grid mit jeweils $2^k$ Bit pro Dimension + - ordnungserhaltend wenn die Bits geeignet gewählt werden + - adressiert werden die Zellen in denen ein Punkt liegt + - Nutzung zur Nachbarschaftssuche in hochdimensionalen Räumen +- VA-File von Weber et al. + - ersetzt Durchlauf über alle Punkte durch Durchlauf über alle Approximationswerte zur Vorauswahl von Kandidaten + +VA-File +![](Assets/DBimpl-va-file.png) + +Zusammenfassung +- Bitmap-Indexe +- Digital- und Präfixbäume +- Mehrdimensionale Verfahren +- Geometrische Zugriffsstrukturen diff --git a/Datenbanksysteme.md b/Datenbanksysteme.md new file mode 100644 index 0000000..0c2e445 --- /dev/null +++ b/Datenbanksysteme.md @@ -0,0 +1,2318 @@ +--- +title: Datenbanksysteme +date: Wintersemester 20/21 +author: Robert Jeutter +--- + +# Was sind Datenbanken - Grundlegende Konzepte +## Überblick +- Daten = logisch gruppierte Informationseinheiten +- Bank = Sicherheit vor Verlust, Dienstleistung für mehrere Kunden, (langfristige) Aufbewahrung + +Ohne Datenbanken: +- jedes Anwendungssystem verwaltet seine eigenen Daten +- Daten sind (redundant) mehrfach gespeichert +- Probleme + - Verschwenden von Speicherplatz + - "vergessen" von Änderungen + - keine zentrale "genormte" Datenerhaltung +- größere Mengen von Daten nicht effizient verarbeitet +- mehrere Benutzer können nicht parallel auf den gleichen Daten arbeiten, ohne sich zu stören +- Anwendungsprogrammierer/Benutzer können Anwendungen nicht programmieren/benutzen ohne ... zu kennen (keine Datenunabhängigkeit) + - interne Dartstellung der Daten + - Speichermedien oder Rechner +- Datenschutz und Datensicherheit + +### Datenintegration durch Datenbanksystem +Anwendungen greifen über Datenbankmanagementsystem auf Datenbank zu. + +Datenbankmanagementsystem (DBMS): Software zur Verwaltung von Datenbanken + +Datenbank (DB): strukturierter, von DBMS verwalteter Datenbestand + +Datenbanksystem (DBS) = DBMS + DB + +## Architekturen +die neun Codd'schen Regeln +1. Integration: einheitliche, nichtredundante Datenverwaltung +2. Operationen: Speichern, Suchen, Ändern +3. Katalog: Zugriffe auf Datenbankbeschreibungen im Data Dictionary +4. Benutzersichten +5. Integritätssicherung: Korrektheit des Datenbankinhalts +6. Datenschutz: Ausschluss unauthorisierter Zugriffe +7. Transaktionen: mehrere DB-Operationen als Funktionseinheit +8. Synchronisation: parallele Transaktionen koordinieren +9. Datensicherung: Wiederherstellung von Daten nach Systemfehlern + +Ziele: +- Trennung von Modellierungssicht und interner Speicherung +- Portierbarkeit +- Tuning vereinfachen +- standardisierte Schnittstellen + +Schemata: +- Konzeptuelles Schema (Ergebnis der Dateidefinition) +- Internes Schema (Festlegung der Dateiorganisation und Zugriffspfade = Index) +- Externes Schema (Ergebnis der Sichtdefinition) +- Anwendungsprogramm (Ergebnis der Anwendungsprogrammierung) + +- Trennung Schema-Instanz + - Schema: Metadaten, Datenbeschreibung + - Instanz: Anwenderdaten, Datenbankzustand + +Datenunabhängigkeit: +- Stabilität der Benutzerschnittstelle gegen Änderungen +- physisch: Änderung der Dateiorganisation und Zugriffspfade haben keinen Einfluss auf das konzeptuelle Schema +- logisch: Änderung am konzeptuellen und gewissen externen Schemata haben keine Auswirkungen auf andere externe Schemata und Anwendungsprogramme + +Aufteilung der Funktionalitäten einer Anwendung +- Präsentation und Benutzerinteraktion +- Anwendungslogik („Business“-Logik) +- Datenmanagementfunktionen (Speichern, Anfragen, ...). + +Architektur von Datenbankanwendungen typischerweise auf Basis des Client-Server-Modells (Server=Datenbanksystem). + +### 3 Schichten Architektur (ANSI-SPARC-Architektur) +Klassifizierung der Komponenten +- Definitionskomponenten: Datendefinition, Dateiorganisation, Sichtdefinition +- Programmierkomponenten: DB-Programmierung mit eingebetteten DB-Operationen +- Benutzerkomponenten: Anwendungsprogramme, Anfrage und Update interaktiv +- Transformationskomponenten: Optimierer, Auswertung, Plattenzugriffssteuerung +- Data Dictionary (Datenwörterbuch): Aufnahme der Daten aus Definitionskomponenten, Versorgung der anderen Komponenten + +### 5 Schichten Architektur +Verfeinerung der Transformation +- Datensystem: Übersetzung, Zugriffspfadwahl +- Zugriffssystem: Logische Zugriffspfade, Schemakatalog, Sortierung, Transaktionsverwaltung +- Speichersystem Speicherungsstrukturen, Zugriffspfadverwaltung, Sperrverwaltung, Logging, Recovery +- Pufferverwaltung: Systempufferverwaltung, Seitenersetzung, Seitenzuordnung +- Betriebssystem: Externspeicherverwaltung, Speicherzuordnung + +## Einsatzgebiete +- Klassische Einsatzgebiete: + - viele Objekte (15000 Bücher, 300 Benutzer, 100 Ausleihvorgänge pro Woche, ...) + - wenige Objekttypen (BUCH, BENUTZER, AUSLEIHUNG) + - etwa Buchhaltungssysteme, Auftragserfassungssysteme, Bibliothekssysteme, ... +- Aktuelle Anwendungen: E-Commerce, entscheidungsunterstützende Systeme (Data Warehouses, OLAP), NASA’s Earth Observation System (Petabyte-Datenbanken), Data Mining + +Datenbankgrößen: +- eBay Data Warehouse: 10PB + - Teradata DBMS, 72 Knoten, 10.000 Nutzer, + - mehrere Millionen Anfragen/Tag +- WalMart Data Warehouse: 2,5PB + - Teradata DBMS, NCR MPP-Hardware; + - Produktinfos (Verkäufe etc.) von 2.900 Märkten; + - 50.000 Anfragen/Woche +- Facebook: 400TB + - x.000 MySQL-Server + - Hadoop/Hive, 610 Knoten, 15 TB/Tag +- US Library of Congress 10-20TB + - nicht digitalisiert + +## Historisches +- Wissensbanksysteme + - Daten in Tabellenstrukturen + - Stark deklarative DML, integrierte Datenbankprogrammiersprache +- Objektorientierte Datenbanksysteme + - Daten in komplexeren Objektstrukturen (Trennung Objekt und seine Daten) + - Deklarative oder navigierende DML + - Oft integrierte Datenbankprogrammiersprache + - Oft keine vollständige Ebenentrennung + +- Neue Hardwarearchitekturen + - Multicore-Prozessoren, Hauptspeicher im TB-Bereich: In-Memory-Datenbanksysteme (z.B. SAP HANA) +- Unterstützung für spezielle Anwendungen + - Cloud-Datenbanken: Hosting von Datenbanken, Skalierbare Datenmanagementlösungen (Amazon RDS, Microsoft Azure) +• Datenstromverarbeitung: Online-Verarbeitung von Live-Daten, z.B. Börseninfos, Sensordaten, RFID-Daten, ...(StreamBase, MS StreamInsight, IBM Infosphere Streams) + - Big Data: Umgang mit Datenmengen im PB-Bereich durch hochskalierbare, parallele Verarbeitung, Datenanalyse (Hadoop, Hive, Google Spanner & F1, ...) +- NoSQL-Datenbanken („Not only SQL“): + - nicht-relationale Datenbanken, flexibles Schema (dokumentenzentriert) + - „leichtgewichtig“ durch Weglassen von SQL-Funktionalitäten wie Transaktionen, mächtige deklarative Anfragesprachen mit Verbunden etc. + - Beispiele: CouchDB, MongoDB, Cassandra, ... + + +# Relationale Datenbanken - Daten als Tabellen +## Relationen für tabellarische Daten +Konzeptuell: Datenbank = Menge von Tabellen (= Relationen) + +- „Tabellenkopf“: Relationenschema +- Eine Zeile der Tabelle: Tupel; Menge aller Einträge: Relation +- Eine Spaltenüberschrift: Attribut +- Ein Eintrag: Attributwert + +Integritätsbedingungen: Schlüssel +- Attribute einer Spalte identifizieren eindeutig gespeicherte Tupel: Schlüsseleigenschaft +- auch Attributkombinationen können Schlüssel sein! +- Schlüssel können durch Unterstreichen gekennzeichnet werden +- Schlüssel einer Tabelle können in einer anderen (oder derselben!) Tabelle als eindeutige Verweise genutzt werden: + - Fremdschlüssel, referenzielle Integrität +- ein Fremdschlüssel ist ein Schlüssel in einer „fremden“ Tabelle + +## SQL-Datendefinition +### CREATE table +Wirkung dieses Kommandos ist sowohl +- die Ablage des Relationenschemas im Data Dictionary, als auch +- die Vorbereitung einer „leeren Basisrelation“ in der Datenbank + +### DROP table +komplettes Löschen einer Tabelle (Inhalt und Eintrag im Data +Dictionary) + +### Mögliche Wertebereiche in SQL +- integer (oder auch integer4, int), +- smallint (oder auch integer2), +- float(p) (oder auch kurz float), +- decimal(p,q) und numeric(p,q) mit jeweils q Nachkommastellen, +- character(n) (oder kurz char(n), bei n = 1 auch char) für Zeichenketten (Strings) fester Länge n, +- character varying(n) (oder kurz varchar(n) für Strings variabler Länge bis zur Maximallänge n, +- bit(n) oder bit varying(n) analog für Bitfolgen, und +- date, time bzw. datetime für Datums-, Zeit- und kombinierte Datums-Zeit-Angaben + +Beispiel: +```sql +create table WEINE ( + WeinID int, + Name varchar(20) not null, + Farbe varchar(10), + Jahrgang int, + Weingut varchar(20), + primary key(WeinID), + foreign key(Weingut) references ERZEUGER(Weingut)) +``` +- primary key kennzeichnet Spalte als Schlüsselattribut +- foreign key kennzeichnet Spalte als Fremdschlüssel +- not null schließt in bestimmten Spalten Nullwerte als Attributwerte aus +- null repräsentiert die Bedeutung „Wert unbekannt“, „Wert nicht anwendbar“ oder „Wert existiert nicht“, gehört aber zu keinem Wertebereich +- null kann in allen Spalten auftauchen, außer in Schlüsselattributen und den mit not null gekennzeichneten + + +## Grundoperationen: Die Relationenalgebra +- Anfrageoperationen auf Tabellen + - Basisoperationen auf Tabellen, die die Berechnung von neuen Ergebnistabellen aus gespeicherten Datenbanktabellen erlauben + - Operationen werden zur sogenannten Relationenalgebra zusammengefasst + - Mathematik: Algebra ist definiert durch Wertebereich sowie darauf definierten Operationen + - für Datenbankanfragen entsprechen die Inhalte der Datenbank den Werten, Operationen sind dagegen Funktionen zum Berechnen der Anfrageergebnisse + - Anfrageoperationen sind beliebig kombinierbar und bilden eine Algebra zum „Rechnen mit Tabellen“ – die Relationenalgebra + +- Selektion $\sigma$: Auswahl von Zeilen einer Tabelle anhand eines Selektionsprädikats +- Projektion $\pi$: Auswahl von Spalten durch Angabe einer Attributliste + - Die Projektion entfernt doppelte Tupel +- Verbund $\bowtie$ (engl. join): verknüpft Tabellen über gleichbenannte Spalten, indem er jeweils zwei Tupel verschmilzt, falls sie dort gleiche Werte aufweisen + - Tupel, die keinen Partner finden (dangling tuples), werden eliminiert +- Umbenennung $\beta$: Anpassung von Attributnamen mittels Umbenennung +- Vereinigung $r_1 \cup r_2$ von zwei Relationen $r_1$ und $r_2$: + - Gesamtheit der beiden Tupelmengen + - Attributmengen beider Relationen müssen identisch sein +- Differenz $r_1 − r_2$ eliminiert die Tupel aus der ersten Relation, die auch in der zweiten Relation vorkommen +- Durchschnitt $r_1 \cap r_2$: ergibt die Tupel, die in beiden Relationen gemeinsam vorkommen + + +## SQL als Anfragesprache +```sql +SELECT farbe FROM weine WHERE Jahrgang = 2002 +``` +- SQL hat Multimengensemantik — Duplikate in Tabellen werden in SQL nicht automatisch unterdrückt! + - Mengensemantik durch distinct +- Verknüpfung von Tabellen + - Kreuzprodukt: `` select * from Weine, Erzeuger`` + - Verbund: `` select * from Weine natural join Erzeuger`` + - Verbund mit Bedingung: `` select * from Weine, Erzeuger where Weine.Weingut = Erzeuger.Weingut`` +- Kombination von Bedingungen +- Vereinigung in SQL explizit mit union + +## Änderungsoperationen in SQL +- insert: Einfügen eines oder mehrerer Tupel in eine Basisrelation oder Sicht + - `` INSERT INTO table (attribut) VALUE (ausdruck) `` + - optionale Attributliste ermöglicht das Einfügen von unvollständigen Tupeln + - nicht alle Attribute angegeben ⇝ Wert des fehlenden Attribut Land wird null +- update: Ändern von einem oder mehreren Tupel in einer Basisrelation oder Sicht + - `` UPDATE relation SET attribut=ausdruck `` +- delete: Löschen eines oder mehrerer Tupel aus einer Basisrelation oder Sicht + - `` DELETE FROM table WHERE id=123 `` + - Löschoperationen können zur Verletzung von Integritätsbedingungen führen! + +Lokale und globale Integritätsbedingungen müssen bei Änderungsoperationen automatisch vom System überprüft werden + + +# Datenbankentwurf im ER-Modell +## Datenbankmodelle +> **Datenbankmodell**: Ein Datenbankmodell ist ein System von Konzepten zur Beschreibung von Datenbanken. Es legt Syntax und Semantik von Datenbankbeschreibungen für ein Datenbanksystem fest. + +Datenbankbeschreibungen = Datenbankschemata + +1. statische Eigenschaften + 1. Objekte + 2. Beziehungen + - inklusive der Standard-Datentypen, die Daten über die Beziehungen und Objekte darstellen können, +2. dynamische Eigenschaften wie + 1. Operationen + 2. Beziehungen zwischen Operationen, +1. Integritätsbedingungen an + 1. Objekte + 2. Operationen + +Datenbankmodelle im Überblick +- HM: hierarchisches Modell, NWM: Netzwerkmodell, RM: Relationenmodell +- NF 2 : Modell der geschachtelten (Non-First-Normal-Form = NF 2 ) Relationen, eNF 2 : erweitertes NF 2 -Modell +- ER: Entity-Relationship-Modell, SDM: semantische Datenmodelle +- OODM / C++: objektorientierte Datenmodelle auf Basis objektorientierter Programmiersprachen wie C++, + - OEM: objektorientierte Entwurfsmodelle (etwa UML), + - ORDM: objektrelationale Datenmodelle + +## ER Modell +- **Entity**: Objekt der realen oder der Vorstellungswelt, über das Informationen zu speichern sind, z.B. Produkte (Wein, Katalog), Winzer oder Kritiker; aber auch Informationen über Ereignisse, wie z.B. Bestellungen +- **Relationship**: beschreibt eine Beziehung zwischen Entities, z.B. ein Kunde bestellt einen Wein oder ein Wein wird von einem Winzer angeboten +- **Attribut**: repräsentiert eine Eigenschaft von Entities oder Beziehungen, z.B. Name eines Kunden, Farbe eines Weines oder Datum einer Bestellung + - Attribute modellieren Eigenschaften von Entities oder auch Beziehungen + - alle Entities eines Entity-Typs haben dieselben Arten von Eigenschaften; Attribute werden somit für Entity-Typen deklariert +- **Werte**: primitive Datenelemente, die direkt darstellbar sind + - Wertemengen sind beschrieben durch Datentypen, die neben einer Wertemenge auch die Grundoperationen auf diesen Werten charakterisieren + - ER-Modell: vorgegebene Standard-Datentypen, etwa die ganzen Zahlen int, die Zeichenketten string, Datumswerte date etc. + - jeder Datentyp stellt Wertebereich mit Operationen und Prädikaten dar +- **Entities** sind die in einer Datenbank zu repräsentierenden Informationseinheiten + - im Gegensatz zu Werten nicht direkt darstellbar, sondern nur über ihre Eigenschaften beobachtbar + - Entities sind eingeteilt in Entity-Typen, etwa $E_1 , E_2,...$ +- **Schlüsselattribute**: Teilmenge der gesamten Attribute eines Entity-Typs $E(A_1,... , A_m)$ + - in jedem Datenbankzustand identifizieren die aktuellen Werte der Schlüsselattribute eindeutig Instanzen des Entity-Typs E + - bei mehreren möglichen Schlüsselkandidaten: Auswahl eines Primärschlüssels +- **Beziehungstypen**: Beziehungen zwischen Entities werden zu Beziehungstypen zusammengefasst + - Beziehungen können ebenfalls Attribute besitzen + + +Merkmale von Beziehungen +- Stelligkeit oder Grad: + - Anzahl der beteiligten Entity-Typen + - häufig: binär + - Beispiel: Lieferant liefert Produkt +- Kardinalität oder Funktionalität: + - Anzahl der eingehenden Instanzen eines Entity-Typs + - Formen: 1:1, 1:n, m:n + - stellt Integritätsbedingung dar + - Beispiel: maximal 5 Produkte pro Bestellung + +- 1:1 Beziehung + - jedem Entity $e_1$ vom Entity-Typ $E_1$ ist maximal ein Entity $e_2$ aus $E_2$ zugeordnet und umgekehrt + - Bsp: Prospekt *beschreibt* Produkt +- 1:N Beziehung + - jedem Entity $e_1$ aus $E_1$ sind beliebig viele Entities $E_2$ zugeordnet, aber zu jedem Entity $e_2$ gibt es maximal ein $e_1$ aus $E_1$ + - Bsp: Lieferant *liefert* Produkte, Mutter *hat* Kinder +- N:1 Beziehung + - invers zu 1:N, auf funktionale Beziehung +- M:N Bezeihung + - keine Restriktionen + - Bsp: Bestellung *umfasst* Produkte + +[min,max]-Notation +- schränkt die möglichen Teilnahmen von Instanzen der beteiligten Entity-Typen an der Beziehung ein, indem ein minimaler und ein maximaler Wert vorgegeben wird +- Spezielle Wertangabe für $max_i$ ist ∗ + +Kardinalitätsangaben +- [0, ∗] legt keine Einschränkung fest (default) +- $R(E_1 [0, 1], E_2 )$ entspricht einer (partiellen) funktionalen Beziehung $R : E_1 \rightarrow E_2$ , da jede Instanz aus $E_1$ maximal einer Instanz aus $E_2$ zugeordnet ist +- totale funktionale Beziehung wird durch $R(E_1 [1, 1], E_2 )$ modelliert +- Beispiele: + - partielle funktionale Beziehung: $lagert_in(Produkt[0,1],Fach[0,3])$ + - totale funktionale Beziehung: $liefert(Lieferant[0,*],Produkt[1,1])$ + +## Weitere Konzepte im ER Modell +- abhängiger Entity-Typ: Identifikation über funktionale Beziehungen (Bsp x "gehört zu" y) +- Spezialisierungs-/Generalisierungsbeziehung oder auch *IST*-Beziehung + - E1 *IST* E2 + - entspricht semantisch einer injektiven funktionalen Beziehung + - Attribute des Entity-Typs E2 treffen auch auf E1 zu: "vererbte" Attribute + - nicht nur Atrributsdeklarationen vererben sich, sondern auch jeweils die aktuellen Werte für eine Instanz + - Kardinalitätsangabe immer: $IST(E_1[1,1], E_2[0,1])$ + - Jede Instanz von E1 nimmt genau einmal an der Ist-Beziehung teil, während Instanzen des Obertyps E2 nicht teilnehmen müssen + +Die Konzepte im Überblick: +| **Begriff** | **Informale Bedeutung** | +| -- | -- | +| Entity | zu repräsentierende Informationseinheit | +| Entity Typ | Gruppierung von Entitys mit gleichen Eigenschaften | +| Beziehungstyp | Gruppierung von Beziehungen zwischen Entitys | +| Attribut | datenwertige Eigenschaft eines Entitys oder einer Beziehung | +| Schlüssel | identifizierende Eigenschaft von Entitys | +| Kardinalitäten | Einschränkung von Beziehungstypen bezüglich der mehrfachen Teilnahme von Entitys an der Beziehung | +| Stelligkeit | Anzahl der an einem Beziehungstyp beteiligten Entity Typen | +| funktionale Beziehungen | Beziehungstyp mit Funktionseigenschaften | +| abhängige Entitys | Entitys, die nur abhängig von anderen Entitys existieren können | +| IST Beziehung | Spezialisierung von Entity Typen | +| Optionalität | Attribute oder Funktionale Beziehungen als partielle Funktionen | + + +# Datenbankentwurf +## Phasen des Datenbankentwurfs +- Datenerhaltung für mehrere Anwendungssysteme und mehrere Jahre +- Anforderungen an Entwurf: + - Anwendungsdaten jeder Anwendung sollen aus Daten der Datenbank ableitbar sein (mögl effizient) + - nur "vernünftige" Daten sollen gespeichert werden + - nicht-redundante Speicherung + +### Phasenmodell +Anforderungsanalyse $\leftrightarrow$ Konzeptioneller Entwurf $\leftrightarrow$ Verteilungsentwurf $\leftrightarrow$ Logischer Entwurf $\leftrightarrow$ Datendefinition $\leftrightarrow$ Physischer Entwurf $\leftrightarrow$ Implementierung & Wartung + +### Anforderungsanalyse +- Vorgehensweise: Sammeln des Informationsbedarfs in den Fachabteilungen +- Ergebnis: + - informale Beschreibung des Fachproblems (Texte, Tabellen, Formblätter,...) + - Trennen der Informationen über Daten (Datenanalyse) von den Informationen über Funktionen (Funktionsanalyse) +- "Klassischer" Entwurf: nur Datenanalyse und Folgeschritte +- Funktionsentwurf: siehe Methoden des Software Engineering + +### Konzeptioneller Entwurf +- erste Formale Beschreibung des Fachproblems +- Sprachmittel: semantisches Datenmodell +- Vorgehensweise: + - Modellierung von Sichen z.B. für verschiedene Fachabteilungen + - Analyse der vorliegenden Sichten in Bezug auf Konflikte + - Integration der Sichten in ein Gesamtschema +- Phasen: + - Sichtentwurf + - Sichtanalyse + - Sichtintegration +- Ergebnis: konzeptionelles Gesamtschema (z.B. ER Schema) + +#### weiteres Vorgehen beim Entwurf +- ER-Modellierung von verschiedenen Sichten auf Gesamtinformation, z.B. für verschiedene Fachabteilungen eines Unternehmens -> konzeptueller Entwurf +- Verteilungsentwurf bei verteilter Speicherung +- Abbildung auf konkretes Implementierungsmodell -> logischer Entwurf +- Datendefinition, Implementierung und Wartung -> physischer Entwurf + +#### Sichtintegration +- Analyse der vorliegenden Sichten in Bezug auf Konflikte +- Integration der Sichten in ein Gesamtschema + +#### Integrationskonflikte +- Namenskonflikte: Homonyme/Synonyme +- Typkonflikte: verschiedene Strukturen für das gleiche Element +- Wertebereichskonflikte: verschiedene Wertebereiche für ein Element +- Bedingungskonflikte: z.B. verschiedene Schlüssel für ein Element +- Strukturkonflikte: gleicher Sachverhalt durch unterschiedliche Konstrukte ausgedrückt + +### Verteilungsentwurf +- sollen Daten auf mehreren Rechnern verteilt vorliegen, muss Art und Weise der verteilten Speicherung festgelegt werden + - horizontale Verteilung z.B. Kunden 1-1000 und Kunden 10001-20000 + - vertikale Verteilung z.B. Adresse in DB1, Konto in DB2 + +### Logischer Entwurf +- Sprachmittel: Datenmodell des ausgewählten "Realisierungs"DBMS +- Vorgehensweise + 1. (automatische) Transformation des konzeptionellen Schemas z.B. ER -> relationales Modell + 2. Verbesserung des relationalen Schemas anhand von Gütekriterien +- Ergebnis: logisches Schema + +### Datendefinition +- Umsetzung des logischen Schemas in ein konkretes Schema +- Sprachmittel: DDL und DML eines DBMS + - Datenbankdeklaration in der DDL des DBMS + - Realisierung der Integritätssicherung + - Definition der Benutzersichten + +### Physischer Entwurf +- Ergänzen des physischen Entwurfs um Zugriffsunterstützung bzgl Effizienzverbesserung, z.B. Definition von Indexen +- Index: + - Zugriffspfad: Datenstruktur für zusätzlichen, schlüsselbasierten Zugriff auf Tupel + - meist als B*-Baum realisiert +- Sprachmittel: Speicherstruktursprache SSL + +Indexe in SQL, z.B.: ```create index WeinIdx on WEINE (Name)``` + +Notwendigkeit für Zugriffspfade: +- Beispiel: Tabelle mit 100GB Daten, Festplattentransferrate ca 50MB/s +- Operation: Suchen eines Tupels (Selektion) +- Implementierung: sequentielles Durchsuchen +- Aufwand: 102.500/50 = 2048 sec ~ 34 Minuten + +### Implementierung & Wartung +- Wartung +- weitere Optimierung der physischen Ebene +- Anpassung an neue Anforderungen und Systemplattformen +- Portierung auf neue Datenbankmanagementsysteme +- etc + + +## Kapazitätserhaltende Abbildungen +Umsetzung des konzeptionellen Schemas +- Umsetzung auf logisches Schema +- Erhaltung der Informationskapazität +- Kapazitäts**erhöhende** Abbildung: Abbildung auf R mit genau einem Schlüssel K ( K={{A},{B}} ) +- Kapazitäts**vermindernde** Abbildung: Relationsschema mit einem Schlüssel +- Kapazitäts**erhaltende** Abbildung: kapazitätserhaltend mit Schlüssel beider Entity Typen im Relationsschema als neuer Schlüssel + +## ER-auf-RM Abbildung +### ER Abbildung auf Relationen +- Entity-Typen und Beziehungstypen: jeweils auf Relationenschemata +- Attribute: Attribute des Relationenschemas, Schlüssel werden übernommen +- Kardinalitäten der Beziehungen: durch Wahl der Schlüssel bei den zugehörigen Relationenschemata ausgedrückt +- in einigen Fällen: Verschmelzen der Relationenschemata von Entity- und Beziehungstypen +- zwischen den verbleibenden Relationenschemata diverse Fremdschlüsselbedingungen einführen + +### Abbildung von Beziehungstypen +- neues Relationenschema mit allen Attributen des Beziehungstyps, zusätzlich Übernahme aller Primärschlüssel der beteiligten Entity-Typen +- Festlegung der Schlüssel: + - m:n-Beziehung: beide Primärschlüssel zusammen werden Schlüssel im neuen Relationenschema + - 1:n-Beziehung: Primärschlüssel der n-Seite (bei der funktionalen Notation die Seite ohne Pfeilspitze) wird Schlüssel im neuen Relationenschema + - 1:1-Beziehung: beide Primärschlüssel werden je ein Schlüssel im neuen Relationenschema, der Primärschlüssel wird dann aus diesen Schlüsseln gewählt +- optionale Beziehungen ([0,1] oder [0,n]) werden nicht verschmolzen +- bei Kardinalitäten [1,1] oder [1,n] (zwingende Beziehungen) Verschmelzung möglich: + - 1:n-Beziehung: das Entity-Relationenschema der n-Seite kann in das Relationenschema der Beziehung integriert werden + - 1:1-Beziehung: beide Entity-Relationenschemata können in das Relationenschema der Beziehung integriert werden + +## Übersicht über Transformationen +| ER Konzept | wird abgebildet auf relationales Konzept | +| -- | -- | +| Entity Typ $E_i$ | Relationsenschema $R_i$ | +| Attribute von $E_i$ | Attribute von $R_i$ | +| Primärschlüssel $P_i$ | Primärschlüssel $P_i$ | +| Beziehungstyp | Relationenschema, Attribute $P_1,P_2$ | +| dessen Attribute | weitere Attribute | +| 1:n | $P_2$ wird Primärschlüssel der Beziehung | +| 1:1 | $P_1$ und $P_2$ werden Schlüssel der Beziehung | +| m:n | $P_1 \cup P_2$ wird Primärschlüssel der Beziehung | +| IST Beziehung | $R_1$ erhält zusätzlichen Schlüssel $P_2$ | + +# Relationaler Entwurf +## Zielmodell des logischen Entwurfs + +Begriffe des Relationenmodells +| Begriff | Informale Bedeutung | +| -- | -- | +| Attribut | Spalte einer Tabelle | +| Wertebereich | mögliche Werte eines Attributs (auch Domäne) | +| Attributwert | Element eines Wertebereichs | +| Relationenschema | Menge von Attributen | +| Relation | Menge von Zeilen einer Tabelle | +| Tupel | Zeile einer Tabelle | +| Datenbankschema | Menge von Relationenschemata | +| Datenbank | Menge von Relationen (Basisrelationen) | +| Schlüssel | minimale Menge von Attributen, deren Werte ein Tupel einer Tabelle eindeutig identifizieren | +| Primärschlüssel | ein beim Datenbankentwurf ausgezeichneter Schlüssel | +| Fremdschlüssel | Attributmenge, die in einer anderen Relation Schlüssel ist | +| Fremdschlüsselbedingung | alle Attributwerte des Fremdschlüssels tauchen in der anderen Relation als Werte des Schlüssels auf | + +Formalisierung Relationenmodell +- Attribute und Domänen + - $U$ nichtleere, endliche Menge: Universum + - $A\in U$: Attribut + - $D = {D_1,..., D_m}$ Menge endlicher, nichtleerer Mengen: jedes $D_i$: Wertebereich oder Domäne + - total definierte Funktion $dom:U \rightarrow D$ + - $dom(A)$: Domäne von A + - $w \in dom(A)$: Attributwert für A +- Relationenschemata und Relationen + - $R\subseteq U$: Relationenschema + - Relation $r$ über $R = {A_1,..., A_n}$ (kurz: $r(R)$) ist endliche Menge von Abbildungen $t:R \rightarrow \bigcup_{i=1}^{m} D_i$, Tupel genannt + - Es gilt $t(A) \in dom(A)$ ($t(A)$ Restriktion von $t$ auf $A \in R$) + - für $X\subseteq R$ analog $t(X)$ X-Wert von $t$ + - Menge aller Relationen über $R: REL(R) := {r | r(R)}$ +- Datenbankschema und Datenbank + - Menge von Relationenschemata $S := {R_1,..., R_p }:$ Datenbankschema + - Datenbank über $S$: Menge von Relationen $d:={r_1,..., r_p}$, wobei $r_i (R_i)$ + - Datenbank $d$ über $S: d(S)$ + - Relation $r\in d$: Basisrelation + +Integritätsbedingung +- Identifizierende Attributmenge $K:= {B_1,..., B_k } \subseteq R: \forall t_1, t_2 \in r [t_1 \not = t_2 \Rightarrow \exists B \in K: t_1(B) \not = t_2(B)]$ +- Schlüssel: ist minimale identifizierende Attributmenge +- Primattribut: Element eines Schlüssels +- Primärschlüssel: ausgezeichneter Schlüssel +- Oberschlüssel oder Superkey: jede Obermenge eines Schlüssels (= identifizierende Attributmenge) +- Fremdschlüssel: $X(R_1)\rightarrow Y(R_2)$ + + +## Relationaler DB-Entwurf +**Redundanzen** in Basisrelationen sind aus mehreren Gründen unerwünscht: +- Redundante Informationen belegen unnötigen Speicherplatz +- Änderungsoperationen auf Basisrelationen mit Redundanzen nur schwer korrekt umsetzbar: + - wenn eine Information redundant vorkommt, muss eine Änderung diese Information in allen ihren Vorkommen verändern + - mit normalen relationalen Änderungsoperationen und den in + - relationalen Systemen vorkommenden lokalen + - Integritätsbedingungen (Schlüsseln) nur schwer realisierbar + +Funktionale Abhängigkeit zwischen Attributemengen X und Y +> Wenn in jedem Tupel der Relation der Attributwert unter den X-Komponenten den Attributwert unter den Y-Komponenten festlegt. +- Unterscheiden sich zwei Tupel in den X-Attributen nicht, so haben sie auch gleiche Werte für alle Y-Attribute +- Notation für funktionale Abhängigkeit (FD, von functional dependency): X → Y + +> Ziel des Datenbankentwurfs: alle gegebenen funktionalen Abhängigkeiten in Schlüsselabhängigkeiten umformen, ohne dabei semantische Information zu verlieren + +## Normalformen +Schemaeigenschaften +- Relationenschemata, Schlüssel und Fremdschlüssel so wählen, dass + 1. alle Anwendungsdaten aus den Basisrelationen hergeleitet werden können, + 2. nur semantisch sinnvolle und konsistente Anwendungsdaten dargestellt werden können und + 3. die Anwendungsdaten möglichst nicht-redundant dargestellt werden. +- Hier: Forderung 3 + - Redundanzen innerhalb einer Relation: Normalformen + - globale Redundanzen: Minimalität + +Normalformen +- legen Eigenschaften von Relationenschemata fest +- verbieten bestimmte Kombinationen von funktionalen Abhängigkeiten in Relationen +- sollen Redundanzen und Anomalien vermeiden + +1. Erste Normalform + - erlaubt nur atomare Attribute in den Relationenschemata, d.h. als Attributwerte sind Elemente von Standard-Datentypen wie integer oder string erlaubt, aber keine Konstruktoren wie array oder set +2. Zweite Normalform + - Zweite Normalform eliminiert derartige partielle Abhängigkeiten bei Nichtschlüsselattributen + - partielle Abhängigkeit liegt vor, wenn ein Attribut funktional schon von einem Teil des Schlüssels abhängt + - Beispielrelation in 2 NF + - R1(Name, Weingut, Preis) + - R2(Name, Farbe) + - R3(Weingut, Anbaugebiet, Region) +3. Dritte Normalform + - eliminiert (zusätzlich) transitive Abhängigkeiten + - etwa Weingut $\rightarrow$ Anbaugebiet und Anbaugebiet $\rightarrow$ Region in Relation + - man beachte: 3 NF betrachtet nur Nicht-Schlüsselattribute als Endpunkt transitiver Abhängigkeiten + - Beispielrelation in 3NF, transitive Abhängigkeit in R3, d.h. R3 verletzt 3NF + - R3_1(Weingut, Anbaugebiet) + - R3_2(Anbaugebiet, Region) + +> Dritte Normalform: +> - $A \in R$ heißt transitiv abhängig von X bezüglich F genau dann, wenn es ein $Y\subseteq R$ gibt mit $X \rightarrow Y, Y \not\rightarrow X, Y \rightarrow A, A \not\in XY$ +> - erweitertes Relationenschema $R=(R, \bf{K})$ ist in 3 NF bezüglich F genau dann, wenn $\not\exists A \in R$: +> - A ist Nicht-Primattribut in R +> - $\wedge A$ transitiv abhängig von einem $K\in \bf{K}$ bezüglich $F_i$. +> - Nicht-Primattribut: A ist in keinem Schlüssel von R enthalten + +> Boyce-Kodd-Normalform (Verschärfung der 3NF): Eliminierung transitiver Abhängigkeiten auch zwischen Primattributen +- $\not\exists A \in R$: A transitiv abhängig von einem $K\in\bf{K}$ bezüglich F + +Minimalität +- Global Redundanzen vermeiden +- andere Kriterien (wie Normalformen) mit möglichst wenig Schemata erreichen +- Beispiel: Attributmenge ABC, FD-Menge ${A \rightarrow B, B \rightarrow C}$ + +Übersicht +| Kennung | Schemaeigenschaft | Kurzcharakteristik | +| -- | -- | -- | +| | 1 NF | nur atomare Attribute | +| | 2 NF | keine partielle Abhängigkeit eines Nicht-Primattributes von einem Schlüssel | +| S1 | 3 NF | keine transitive Abhängigkeit eines Nicht-Primattributs von einem Schlüssel | +| | BCNF | keine transitive Abhängigkei eines Attributes von einem Schlüssel | +| S2 | Minimalität | minimale Anzahl von Relationsschemata, die die anderen Eigenschaften erfüllt | + +## Transformationseigenschaften +- bei einer Zerlegung einer Relation in mehrere Relationen ist darauf zu achten, dass + 1. nur semantisch sinvolle und konsistente Anwendungsdaten dargestellt (Abhängigkeitstreue) und + 2. alle Anwendungsdaten aus den Basisrelationen hergeleitet werden können (Verbundtreue) +- Abhänggikeitstreue (Kennung T1) + - alle gegebenen Abhängigkeiten sind durch Schlüssel repräsentiert + - eine Menge von Abhängigkeiten kann äquivalent in eine zweite Menge von Abhängigkeiten transformiert werden + - spezieller: in die Menge der Schlüsselabhängigkeiten, da diese vom Datenbanksystem effizient überprüft werden kann + - die Menge der Abhängigkeiten soll äquivalent zu der Menge der Schlüsselbedingungen im resultierenden Datenbankschema sein + - Äquivalenz sichert zu, dass mit den Schlüsselabhängigkeiten semantisch genau die gleichen Integritätsbedingungen ausgedrückt werden wie mit den funktionalen oder anderen Abhängigkeiten vorher + - S charakterisiert vollständig F (oder: ist abhängigkeitstreu bezüglich F) genau dann, wenn $F\equiv \{K\rightarrow R | (R,\bf{K})\in S, K\in\bf{K}\}$ +- Verbundtreue (Kennung T2) + - Originalrelationen können durch den Verbund der Basisrelationen wiedergewonnen werden + - zur Erfüllung des Kriteriums der Normalformen müssen Relationenschemata teilweise in kleinere Relationenschemata zerlegt werden + - für Beschränkung auf „sinnvolle“ Zerlegungen gilt Forderung, dass die Originalrelation wieder aus den zerlegten Relationen mit dem natürlichen Verbund zurückgewonnen werden kann + - Zerlegung des Relationenschemas $R = ABC$ in $R_1 = AB$ und $R_2 = BC$ + - Dekomposition bei Vorliegen der Abhängigkeiten $F = \{A \rightarrow B, C \rightarrow B\}$ ist nicht verbundtreu + - dagegen bei Vorliegen von $F′ = \{A \rightarrow B, B \rightarrow C\}$ verbundtreu + +> Verbundtreue: Die Dekomposition einer Attributmenge $X$ in $X_1,..., X_p$ mit $X = \bigcup_{i=1}^p X_i$ heißt verbundtreu ($\pi \bowtie$-treu, lossless) bezüglich einer Menge von Abhängigkeiten F über X genau dann, wenn $\forall r \in SAT_X(F) : \pi_{X_1}(r) \bowtie ··· \bowtie \pi_{X_p}(r) = r$ gilt. + +## Weitere Abhängigkeiten +- Mehrwertige Abhängigkeit (kurz: MVD) + - innerhalb einer Relation r wird einem Attributwert von X eine Menge von Y-Werten zugeordnet, unabhängig von den Werten der restlichen Attribute $\rightarrow$ Vierte Normalform + - Folge der 1NF: Mehrwertige Abhängigkeiten erzeugen Redundanz + - eine (oder mehrere) Gruppe von Attributwerten ist von einem Schlüssel bestimmt, unabhängig von anderen Attributen + - Resultat: Redundanz durch Bildung aller Kombinationen + - wünschenswerte Schemaeigenschaft bei Vorliegen von MVDs: vierte Normalform + - fordert die Beseitigung derartiger Redundanzen: keine zwei MVDs zwischen Attributen einer Relation + - Elimination der rechten Seite einer der beiden mehrwertigen Abhängigkeiten, + - linke Seite mit dieser rechten Seite in neue Relation kopiert +- Verbundabhängigkeit (kurz: JD) + - R kann ohne Informationsverlust in $R_1,..., R_p$ aufgetrennt werden: $\bowtie [R_1,..., R_p]$ +- Inklusionsabhängigkeit (kurz: IND) + - auf der rechten Seite einer Fremdschlüsselabhängigkeit nicht unbedingt der Primärschlüssel einer Relation + +> Vierte Normalform: erweitertes Relationenschema $R = (R, \bf{K})$ ist in vierter Normalform (4NF) bezüglich M genau dann, wenn für alle $X\rightarrow\rightarrow Y \in M^+$ gilt: $X\rightarrow\rightarrow Y$ ist trivial oder $X\supseteq K$ für ein $K\in\bf{K}$ + + +# Relationale Theorie +## Rechnen mit FDs +- gilt für f über R $SAT_R(F)\subseteq SAT_R(f)$, dann impliziert F die FD f (kurz: $F|= f$) +- Hüllenbildung: Ermittlung aller funktionalen Abhängigkeiten, die aus einer gegebenen FD_Menge abgeleitet werden können +- Hülle: $F_R^+ := \{ f | (f \text{ FD über R} ) \wedge F |= f\}$ + +Ableitungsregel: +- F1: Reflexivität $X\supseteq Y \Rightarrow X\rightarrow Y$ +- F2: Augumentation $\{X\rightarrow Y\}\Rightarrow XZ\rightarrow YZ, \text{ sowie } XZ\rightarrow Y$ +- F3: Transitivität $\{ X\rightarrow Y,Y\rightarrow Z\}\Rightarrow X\rightarrow Y$ +- F4: Dekomposition $\{X\rightarrow YZ\} \Rightarrow X\rightarrow Y$ +- F5: Vereinigung $\{X\rightarrow Y, X\rightarrow Z\}\Rightarrow X\rightarrow YZ$ +- F6: Pseudotransitivität $\{X\rightarrow Y, WY\rightarrow Z\}\Rightarrow WX\rightarrow Z$ + +F1-F3 bekannt als Armstrong-Axiome (sound, complete) +- gültig (sound): Regeln leiten keine FDs ab, die logisch nicht impliziert +- vollständig (complete): alle implizierten FDs werden abgeleitet +- unabhängig (independent) oder auch bzgl. ⊆ minimal: keine Regel kann weggelassen werden + +Alternative Regelmenge +- B-Axiome oder RAP-Regeln + - R Reflexivität $\{\}\Rightarrow X\rightarrow X$ + - A Akkumulation $\{X\rightarrow YZ, Z\rightarrow AW\}\Rightarrow X\rightarrow YZA$ + - P Projektivität $\{X\rightarrow YZ\}\Rightarrow X\rightarrow Y$ +- Regelmenge ist vollständig, da Armstrong-Axiome daraus abgeleitet werden können + +> Membership Problem: Kann eine bestimmte FD $X\rightarrow Y$ aus der vorgegebenen Menge F abgeleitet werden, d.h. wird sie von F impliziert? $X\rightarrow Y \in F^+$ +- Hülle einer Attributmenge X bzgl. F ist $X^+_F := \{A | X\rightarrow A \in F^+\}$ +- Membership-Problem kann durch das modifizierte Problem $Y\subseteq X_F^+$ in linearer Zeit gelöst werden + +Überdeckungen +- F heißt äquivalent zu G; oder +- F Überdeckung von G; kurz: $F\equiv G$ falls $F^+=G^+$ +- verschiedene Formen von Überdeckung: nicht-redundant, reduziert, minimal, ringförmig + +Reduktionsoperationen +- Ziel: Entfernen überflüssiger Attribute auf linker bzw. rechter Seite von FDs +- Linksreduktion: entfernt unwesentliche Attribute auf der linken Seite einer FD +- Rechtsreduktion: entsprechend auf der rechten Seite +- erw. Relationenschema $R = (R, K)$, FD-Menge F über R, A ist ein Attribut aus R und $X\rightarrow Y$ eine FD aus F +> Unwesentliche Attribute +> A heißt unwesentlich in $X\rightarrow Y$ bzgl. F, wenn +>- $X=AZ,Z\not= X \Rightarrow (F-\{X\rightarrow Y\})\cup \{Z\rightarrow Y\} \equiv F$ oder +>- $Y=AW, W\not=Y\Rightarrow (F-\{X\rightarrow Y\})\cup \{X\rightarrow W\} \equiv F$ +- A kann also aus der FD $X\rightarrow Y$ entfernt werden, ohne dass sich die Hülle von F ändert +- FD $X\rightarrow Y$ heißt linksreduziert, wenn kein Attribut in X unwesentlich ist +- FD $X\rightarrow Y$ heißt rechtsreduziert, wenn kein Attribut in Y unwesentlich ist + +Minimale Überdeckung +- Eine minimale Überdeckung ist eine Überdeckung, die eine minimale Anzahl von FDs enthält +- Auswahl der kleinsten aller nicht-redundanten Überdeckungen +- FD-Menge F heißt minimal gdw. $\forall F' [F'\equiv \Rightarrow |F|\leq |F'|]$ +- Bestimmung etwa durch reduzierte Überdeckung mit anschließender Äquivalenzklassenbildung (später) + +Äquivalenzklassen +- FDs mit äquivalenten linken Seiten werden zu einer Äquivalenzklasse zusammengefasst +- FDs $X_1 \rightarrow Y_1$ und $X_2\rightarrow Y_2$ liegen in einer Äquivalenzklasse, wenn $X_1\rightarrow X_2$ und $X_2\rightarrow X_1$ gelten +- In einigen Fällen können nun zwei solche FDs in einer Äquivalenzklasse zu einer FD $X\rightarrow Y_1 Y_2$ zusammengefasst werden +- Da die FDs einer Äquivalenzklasse in die Form $X_1\rightarrow X_2, X_2\rightarrow X_3,..., X_n\rightarrow X_1, X_1\rightarrow Y$ überführt werden können, nennt man eine Überdeckung dieser Form eine ringförmige Überdeckung +- linke Seiten sind äquivalent, wenn sie sich gegenseitig funktional bestimmen + + +## Mehr zu Normalformen +- partielle Abhängigkeit liegt vor, wenn ein Attribut funktional schon von einem Teil des Schlüssels abhängt +- Hinweis: partiell abhängiges Attribut stören nur, wenn es kein Primattribut ist +- 2NF formal: erweitertes Relationenschema $R = (R, K)$, FD-Menge F über R + +> Zweite Normalform +> - Y hängt partiell von X bzgl. F ab, wenn die FD $X\rightarrow Y$ nicht linksreduziert ist +> - Y hängt voll von X ab, wenn die FD $X\rightarrow Y$ linksreduziert ist +> - R ist in 2NF, wenn R in 1NF ist und jedes Nicht-Primattribut von R voll von jedem Schlüssel von R abhäng + +## Entwurfsverfahren +Ziele: +- Universum $U$ und FD-Menge F gegeben +- lokal erweitertes Datenbankschema $S=\{(R_1, K_1),...,(R_p, K_p)\}$ berechnen mit + - T1: S charakterisiert vollständig F + - S1: S ist in 3NF bezüglich F + - T2: Dekomosition von $U$ in $R_1,...,R_p$ ist verbundtreu bezüglich F + - S2: Minimalität, d.h. $\not\exists S':S'$ erfüllt T1,S1,T2 und $|S'|<|S|$ + +Dekomposition: +- Geg.: initiales Universalrelationenschema $R = (U, K(F))$ mit allen Attributen und einer von erfassten FDs F über R implizierten Schlüsselmenge + - Attributmenge U und eine FD-Menge F + - suche alle $K\rightarrow U$ mit K minimal, für die $K\rightarrow U \in F^+$ gilt $(K(F))$ +- Ges.: Zerlegung in $D = \{R_1, R_2,... \}$ von 3NF-Relationenschemata +- Beispiel: + - initiales Relationenschema $R=ABC$ + - funktionale Abhängigkeiten $F=\{A\rightarrow B, B\rightarrow C\}$ + - Schlüssel $K=A$ +- Bewertung + - Vorteile: 3NF, Verbundtreue + - Nachteile: restliche Kriterien nicht, reihenfolgeabhängig, NP-vollständig (Schlüsselsuche) + +Details zum Syntheseverfahren +- Prinzip: Synthese formt Original-FD-Menge F in resultierende Menge von Schlüsselabhängigkeiten G so um, dass $F\equiv G$ gilt +- „Abhängigkeitstreue“ im Verfahren verankert +- 3NF und Minimalität wird auch erreicht, reihenfolgeunabhängig +- Zeitkomplexität: quadratisch + +Syntheseverfahren für Relationenschema R mit FDs F +- Ges.: verlustfreie und abhängigkeitstreue Zerlegung in $R_1,... R_n$, wobei alle $R_i$ in 3NF sind +- Bilde Äquivalentklassen $C_i$ von FD aus $\hat{F}$ mit gleichen oder äquivalenten linken Seiten, d.h. $C_i=\{X_i\rightarrow A_{i1},X_i\rightarrow A_{i2},...\}$. Bilde zu jeder Äquivalenzklasse $C_i$ ein Schema der Form $R_{Ci}=\{X_i\cup \{A_{i1}\}\cup \{A_{i2}\}\cup ... \}$. Falls keines der Schemata $R_{Ci}$ enthält einen Schlüssel von R, erzeuge weiteres Relationenschema $R_K$ mit Attributen aus R, die Schlüssel bilden +- Beispiel + - FD-Menge $F=\{A\rightarrow B, AB\rightarrow C, A\rightarrow C, B\rightarrow A, C\rightarrow E\}$ + - minimale Überdeckung $\hat{F}=\{A\rightarrow B,B\rightarrow C, B\rightarrow A, C\rightarrow E\}$ + - Zusammenfassung zu Äquivalenzklassen $C_1=\{A\rightarrow B,B\rightarrow C, B\rightarrow A\}, C_2=\{C\rightarrow E\}$ + - Syntheseergebnis: $(ABC,\{\{A\},\{B\}\}),(CE,\{C\})$ + +Erreichung der Verbundtreue +- Erreichen der Verbundtreue durch einfachen „Trick“: + - Erweitern der Original-FD-Menge F um $U\rightarrow \delta$ um Dummy-Attribut $\delta$ + - $\delta$ wird nach Synthese entfernt +- Beispiel: $\{A\rightarrow B, C\rightarrow E\}$ + - Syntheseergebnis $(AB, \{A\}), (CE, \{C\})$ ist nicht verbundtreu, da Universalschlüssel in keinem Schema enthalten ist + - Dummy-FD $ABCE\rightarrow \delta$; reduziert auf $AC\rightarrow\delta$ + - liefert drittes Relationenschema $(AC,\{AC\})$ + + +# Die relationale Anfragesprache SQL +## Aufbau von SQL-Anfragen +- `select` + - Projektionsliste + - Festlegung der Projektionsattribute + - arithmetische Operationen und Aggregatfunktionen + - Attribute der hinter from stehenden Relationen, optional mit Präfix, der Relationennamen oder Namen der Tupelvariablen angibt + - arithmetische Ausdrücke über Attributen dieser Relationen und passenden Konstanten + - Aggregatfunktionen über Attributen dieser Relationen + - Spezialfall der Projektionsliste: * ,liefert alle Attribute der Relation(en) aus dem from-Teil + - distinct eliminiert Duplikate +- `from` + - zu verwendende Relationen, evtl. Umbenennungen + - einfachste Form; hinter jedem Relationennamen kann optional eine Tupelvariable stehen +- `where` + - Selektions-, Verbundbedingungen + - Geschachtelte Anfragen (wieder ein SFW-Block) + +### Verbunde +- bei mehr als einer Relation wird das kartesische Produkt gebildet: + `select * from WEINE, ERZEUGER` +- alle Kombinationen werden ausgegeben! +- Einführung von Tupelvariablen erlaubt mehrfachen Zugriff auf eine Relation: + `select * from WEINE w1, WEINE w2` + - Spalten lauten dann: + `w1.WeinID, w1.Name, w1.Farbe, w1.Jahrgang, w1.Weingut, w2.WeinID, w2.Name, w2.Farbe, w2.Jahrgang, w2.Weingut` +- Natürlicher Verbund in SQL92 + `select * from WEINE, ERZEUGER where WEINE.Weingut = ERZEUGER.Weingut` +- Verbund mit "join"; kennen mehrere explizite Verbundoperatoren (engl. join); als Abkürzung für die ausführliche Anfrage mit Kreuzprodukt aufzufassen + `select * from WEINE natural join ERZEUGER` + - Verbund mit beliebigem Prädikat: `select * from WEINE join ERZEUGER on WEINE.Weingut = ERZEUGER.Weingut` + - Gleichverbund mit using: `select * from WEINE join ERZEUGER using (Weingut)` +- Kreuzprodukt `select * from WEINE, ERZEUGER` +- als cross join `select * from WEINE cross join ERZEUGER` +- "Zwischenrelationen" aus SQL-Operationen oder einem SFW-Block können über Tupelvariablen mit Namen versehen werden + `select Ergebnis.Weingut from (WEINE natural join ERZEUGER) as Ergebnis` +- Präfixe für Eindeutigkeit `select Name, Jahrgang, ERZEUGER.Weingut from WEINE natural join ERZEUGER` +- bei der Verwendung von Tupelvariablen, kann der Name einer Tupelvariablen zur Qualifizierung eines Attributs benutzt werden: + `select w1.Name, w2.Weingut from WEINE w1, WEINE w2` + +### Selektionen +- where Klausel: `select ...from ... where bedingung` + - Formen der Bedingung: + - Vergleich eines Attributs mit einer Konstanten: `attribut θ konstante` + - mögliche Vergleichssymbole θ abhängig vom Wertebereich; etwa =, <>, >, <, >= sowie <=. + - Vergleich zwischen zwei Attributen mit kompatiblen Wertebereichen: `attribut1 θ attribut2` + - logische Konnektoren or, and und not +- Verbundbedingung + - Verbundbedingung hat die Form: `relation1.attribut = relation2.attribut` + - Beispiel: `select Name, Jahrgang, ERZEUGER.Weingut from WEINE, ERZEUGER where WEINE.Weingut = ERZEUGER.Weingut` +- Bereichsselektion + - `attrib between konstante_1 and konstante_2` + - ist Abkürzung für `attrib ≥ konstante_1 and attrib ≤ konstante_2` + - schränkt damit Attributwerte auf das abgeschlossene Intervall $[konstante_1 , konstante_2 ]$ ein + - Beispiel: `select * from WEINE where Jahrgang between 2000 and 2005` +- Ungewissheitsselektion + - Notation `attribut like spezialkonstante` + - Mustererkennung in Strings (Suche nach mehreren Teilzeichenketten) + - Spezialkonstante kann die Sondersymbole `%` und `_` beinhalten + - `%` steht für kein oder beliebig viele Zeichen + - `_` steht für genau ein Zeichen + - Beispiel: `select * from WEINE where Name like 'La Rose%'` + +### Mengenoperationen +Mengenoperationen erfordern kompatible Wertebereiche für Paare korrespondierender Attribute: +- beide Wertebereiche sind gleich oder +- beide sind auf character basierende Wertebereiche (unabhängig von der Länge der Strings) oder +- beide sind numerische Wertebereiche (unabhängig von dem genauen Typ) wie integer oder float +- Ergebnisschema := Schema der „linken“ Relation +```sql +select A, B, C from R1 +union +select A, C, D from R2 +``` + +- Vereinigung, Durchschnitt und Differenz als union, intersect und except +- orthogonal einsetzbar: +- `select * from (select Weingut from ERZEUGER except select Weingut from WEINE)` +- äquivalent zu `select * from ERZEUGER except corresponding WEINE` +- über corresponding by-Klausel: Angabe der Attributliste, über die Mengenoperation ausgeführt wird +- `select * from ERZEUGER except corresponding by (Weingut) WEINE` +- bei Vereinigung: Defaultfall ist Duplikateliminierung (union distinct); ohne Duplikateliminierung durch union all + +### Geschachtelte Anfragen +Schachtelung von Anfragen +- für Vergleiche mit Wertemengen notwendig: +- Standardvergleiche in Verbindung mit den Quantoren all ($\forall$) oder any ($\exists$) +- spezielle Prädikate für den Zugriff auf Mengen, in und exists +- in-Prädikat und geschachtelte Anfragen + - Notation: `attribut in ( SFW-block )` + - Beispiel: `select Name from WEINE where Weingut in (select Weingut from ERZEUGER where Region = 'Bordeaux')` + - Auswertung von geschachtelten Anfragen + 1. Auswertung der inneren Anfrage zu den Weingütern aus Bordeaux + 2. Einsetzen des Ergebnisses als Menge von Konstanten in die äußere Anfrage hinter in + 3. Auswertung der modifizierten Anfrage + `select Name from WEINE where Weingut in ( 'Château La Rose', 'Château La Pointe')` + - interne Auswertung: Umformung in einen Verbund + `select Name from WEINE natural join ERZEUGER where Region = 'Bordeaux'` +- Negation des in-Prädikats + - Simulation des Differenzoperators $^π Weingut^{(ERZEUGER)}- ^π Weingut^{(WEINE)}$ durch SQL-Anfrage + `select Weingut from ERZEUGER where Weingut not in ( select Weingut from WEINE )` + + +### Mächtigkeit des SQL-Kerns +| Relationenalgebra | SQL | +| -- | -- | +| Projektion | select distinct | +| Selektion | where ohne Schachtelung | +| Verbund | from, where\\ from mit join oder natural join | +| Umbenennung | from mit Tupelvariable; as | +| Differenz | where mit Schachtelung\\ except corresponding | +| Durchschnitt | where mit Schachtelung\\ intersect corresponding | +| Vereinigung | union corresponding | + +## Erweiterungen des SFW-Blocks +Erweiterungen des SFW-Blocks +- innerhalb der from-Klausel weitere Verbundoperationen (äußerer Verbund), +- innerhalb der where-Klausel weitere Arten von Bedingungen und Bedingungen mit Quantoren, +- innerhalb der select-Klausel die Anwendung von skalaren Operationen und Aggregatfunktionen, +- zusätzliche Klauseln group by und having +- rekursive Anfragen + +### Skalare Ausdrücke +Umbenennung von Spalten: `ausdruck as neuer-name` +- skalare Operationen auf + - numerischen Wertebereichen: etwa +, −, ∗ und /, + - Strings: Operationen wie char_length (aktuelle Länge eines Strings), die Konkatenation ∥ und die Operation substring (Suchen einer Teilzeichenkette an bestimmten Positionen des Strings), + - Datumstypen und Zeitintervallen: Operationen wie current_date (aktuelles Datum), current_time (aktuelle Zeit), +, − und ∗ +- bedingte Ausdrücke +- Typkonvertierung +- skalare Ausdrücke können mehrere Attribute umfassen +- Anwendung ist tupelweise: pro Eingabetupel entsteht ein Ergebnistupel +- Ausgabe der Namen aller Grand Cru-Weine + `select substring(Name from 1 for (char_length(Name) - position('Grand Cru' in Name))) from WEINE where Name like '%Grand Cru'` +- Annahme: zusätzliches Attribut HerstDatum in WEINE + `alter table WEINE add column HerstDatum date update WEINE set HerstDatum = date '2004-08-13' where Name = 'Zinfandel'` + - Anfrage: + `select Name, year(current_date - HerstDatum) as Alter from WEINE` + +### Bedingte Ausdrücke +- case-Anweisung: Ausgabe eines Wertes in Abhängigkeit von der Auswertung eines Prädikats + `case when prädikat_1 then ausdruck_1 ... when prädikat_n−1 then ausdruck_n−1 [ else ausdruck_n ] end` +- Einsatz in select- und where-Klausel + `select case when Farbe = 'Rot' then 'Rotwein' when Farbe = 'Weiß' then 'Weißwein' else 'Sonstiges' end as Weinart, Name from WEINE` + +### Typkonvertierung +- explizite Konvertierung des Typs von Ausdrücken + `cast(ausdruck as typname)` +- Beispiel: int-Werte als Zeichenkette für Konkatenationsoperator + `select cast(Jahrgang as varchar) || 'er ' || Name as Bezeichnung from WEINE` + +### Quantoren und Mengenvergleiche +- Quantoren: all, any, some und exists +- Notation + `attribut θ { all | any | some } ( select attribut from ...where ...)` +- all: where-Bedingung wird erfüllt, wenn für alle Tupel des inneren SFW-Blocks der θ-Vergleich mit attribut true wird +- any bzw. some: where-Bedingung wird erfüllt, wenn der θ-Vergleich mit mindestens einem Tupel des inneren SFW-Blocks true wird +- Bestimmung des ältesten Weines + `select * from WEINE where Jahrgang <= all ( select Jahrgang from WEINE)` +- alle Weingüter, die Rotweine produzieren + `select * from ERZEUGER where Weingut = any ( select Weingut from WEINE where Farbe = 'Rot')` + +### Vergleich von Wertemengen +- Test auf Gleichheit zweier Mengen allein mit Quantoren nicht möglich +- Beispiel: „Gib alle Erzeuger aus, die sowohl Rot- als auch Weißweine produzieren.“ +- falsche Anfrage `select Weingut from WEINE where Farbe = 'Rot' and Farbe = 'Weiß'` +- richtige Anfrage `select w1.Weingut from WEINE w1, WEINE w2 where w1.Weingut = w2.Weingut and w1.Farbe = 'Rot' and w2.Farbe = 'Weiß'` + +### Das exists/not exists-Prädikat +- einfache Form der Schachtelung + `exists ( SFW-block )` +- liefert true, wenn das Ergebnis der inneren Anfrage nicht leer ist +- speziell bei verzahnt geschachtelten (korrelierte) Anfragen sinnvoll + - in der inneren Anfrage wird Relationen- oder Tupelvariablen-Name aus dem from-Teil der äußeren Anfrage verwendet + +### Verzahnt geschachtelte Anfragen +Weingüter mit 1999er Rotwein +```sql +select * from ERZEUGER +where 1999 in ( +select Jahrgang from WEINE +where Farbe='Rot' and +WEINE.Weingut = ERZEUGER.Weingut) +``` +konzeptionelle Auswertung +1. Untersuchung des ersten ERZEUGER-Tupels in der äußeren Anfrage (Creek) und Einsetzen in innere Anfrage +2. Auswertung der inneren Anfrage +3. Weiter bei 1. mit zweitem Tupel ... + +## Aggregatfunktionen und Gruppierungen +- Aggregatfunktionen berechnen neue Werte für eine gesamte Spalte, etwa die Summe oder den Durchschnitt der Werte einer Spalte +- Beispiel: Ermittlung des Durchschnittspreises aller Artikel oder des Gesamtumsatzes über alle verkauften Produkte +- bei zusätzlicher Anwendung von Gruppierung: Berechnung der Funktionen pro Gruppe, z.B. der Durchschnittspreis pro Warengruppe oder der Gesamtumsatz pro Kunde +- Aggregatfunktionen in Standard-SQL: + - count: berechnet Anzahl der Werte einer Spalte oder alternativ (im Spezialfall count(∗)) die Anzahl der Tupel einer Relation + - sum: berechnet die Summe der Werte einer Spalte (nur bei numerischen Wertebereichen) + - avg: berechnet den arithmetischen Mittelwert der Werte einer Spalte (nur bei numerischen Wertebereichen) + - max bzw. min: berechnen den größten bzw. kleinsten Wert einer Spalte +- Argumente einer Aggregatfunktion: + - ein Attribut der durch die from-Klausel spezifizierten Relation, + - ein gültiger skalarer Ausdruck oder + - im Falle der count-Funktion auch das Symbol ∗ +- vor dem Argument (außer im Fall von count(∗)) optional auch die Schlüsselwörter distinct oder all + - distinct: vor Anwendung der Aggregatfunktion werden doppelte Werte aus der Menge von Werten, auf die die Funktion angewendet wird + - all: Duplikate gehen mit in die Berechnung ein (Default-Voreinstellung) + - Nullwerte werden in jedem Fall vor Anwendung der Funktion aus der Wertemenge eliminiert (außer im Fall von count(∗)) +- Beispiel: Anzahl der Weine: + `select count(*) as Anzahl from WEINE` +- Beispiel: Anzahl der verschiedenen Weinregionen: + `select count(distinct Region) from ERZEUGER` +- Weine, die älter als der Durchschnitt sind: + `select Name, Jahrgang from WEINE where Jahrgang < ( select avg(Jahrgang) from WEINE)` +- Schachtelung von Aggregatfunktionen nicht erlaubt + `select f 1 (f 2 (A)) as Ergebnis from R ...` -- (falsch!); + mögliche Formulierung: `select f 1 (Temp) as Ergebnis from ( select f 2 (A) as Temp from R ...)` + +- Aggregatfunktionen in where-Klausel + - Aggregatfunktionen liefern nur einen Wert ⇝ Einsatz in Konstanten-Selektionen der where-Klausel möglich + - alle Weingüter, die nur einen Wein liefern: + `select * from ERZEUGER e where 1 = ( select count(*) from WEINE w where w.Weingut = e.Weingut )` + +- group by und having + - Notation + - select ... + - from ... + - [where ...] + - [group by attributliste ] + - [having bedingung ] + - Beispiel + - Regionen mit mehr als einem Wein + `select Region, count(*) as Anzahl from ERZEUGER natural join WEINE group by Region having count(*) > 1` + +### Äußere Verbunde +- outer join übernimmt alle Tupel beider Operanden (Langfassung: full outer join) +- left outer join bzw. right outer join übernimmt alle Tupel des linken bzw. des rechten Operanden +- äußerer natürlicher Verbund jeweils mit Schlüsselwort natural, also z.B. natural left outer join + +### Sortierung +order by attributliste + +select w1.Name, count(*) as Rang +from WEINE w1, WEINE w2 +where w1.Jahrgang <= w2.Jahrgang +group by w1.Name, w1.WeinID +having count(*) <= 4 +order by Rang + +### Nullwerte +- skalare Ausdrücke: Ergebnis null, sobald Nullwert in die Berechnung eingeht +- in allen Aggregatfunktionen bis auf count(∗) werden Nullwerte vor Anwendung der Funktion entfernt +- fast alle Vergleiche mit Nullwert ergeben Wahrheitswert unknown (statt true oder false) +- Ausnahme: is null ergibt true, is not null ergibt false +- Boolesche Ausdrücke basieren dann auf dreiwertiger Logik +- Null-Selektion wählt Tupel aus, die bei einem bestimmten Attribut Nullwerte enthalten + - Notation `attribut is null` + + +## Rekursion +- Anwendung: Bill of Material-Anfragen, Berechnung der transitiven Hülle (Flugverbindungen etc.) +- Formulierung über erweiterte with recursive-Anfrage + - Notation + ```sql + with recursive rekursive-tabelle as ( + anfrage-ausdruck -- rekursiver Teil + ) + [traversierungsklausel] [zyklusklausel] + anfrage-ausdruck -- nicht rekursiver Teil + ``` +- Sicherheit (= Endlichkeit der Berechnung) ist wichtige Anforderung an Anfragesprache + - Behandlung in SQL + - Begrenzung der Rekursionstiefe + - Zyklenerkennung + +# Grundlagen von Anfragen: Algebra & Kalkül +## Kriterien für Anfragesprachen +- bisher: Relationenschemata mit Basisrelationen, die in der Datenbank gespeichert sind +- jetzt: „abgeleitete“ Relationenschemata mit virtuellen Relationen, die aus den Basisrelationen berechnet werden (Basisrelationen bleiben unverändert) + +Begriffe +- Anfrage: Folge von Operationen, die aus den Basisrelationen eine Ergebnisrelation berechnet + - Ergebnisrelation interaktiv auf dem Bildschirm anzeigen oder + - per Programm weiterverarbeiten („Einbettung“) +- Sicht: Folge von Operationen, die unter einem Sichtnamen langfristig abgespeichert wird und unter diesem Namen wieder aufgerufen werden kann; ergibt eine Sichtrelation +- Snapshot: Ergebnisrelation einer Anfrage, die unter einem Snapshot-Namen abgelegt wird, aber nie ein zweites Mal (mit geänderten Basisrelationen) berechnet wird (etwa Jahresbilanzen) + +Kriterien für Anfragesprachen +- Ad-Hoc-Formulierung: Benutzer soll eine Anfrage formulieren können, ohne ein vollständiges Programm schreiben zu müssen +- Deskriptivität: Benutzer soll formulieren „Was will ich haben?“ und nicht „Wie komme ich an das, was ich haben will?“ +- Mengenorientiertheit: jede Operation soll auf Mengen von Daten gleichzeitig arbeiten, nicht navigierend nur auf einzelnen Elementen („one-tuple-at-a-time“) +- Abgeschlossenheit: Ergebnis ist wieder eine Relation und kann wieder als Eingabe für die nächste Anfrage verwendet werden +- Adäquatheit: alle Konstrukte des zugrundeliegenden Datenmodells werden unterstützt +- Orthogonalität: Sprachkonstrukte sind in ähnlichen Situationen auch ähnlich anwendbar +- Optimierbarkeit: Sprache besteht aus wenigen Operationen, für die es Optimierungsregeln gibt +- Effizienz: jede Operation ist effizient ausführbar (im Relationenmodell hat jede Operation eine Komplexität ≤ O(n 2 ), n Anzahl der Tupel einer Relation). +- Sicherheit: keine Anfrage, die syntaktisch korrekt ist, darf in eine Endlosschleife geraten oder ein unendliches Ergebnis liefern +- Eingeschränktheit: (folgt aus Sicherheit, Optimierbarkeit, Effizienz) Anfragesprache darf keine komplette Programmiersprache sein +- Vollständigkeit: Sprache muss mindestens die Anfragen einer Standardsprache ausdrücken können + +## Anfragealgebren +- Mathematik: Algebra definiert durch Wertebereich und auf diesem definierte Operatoren +- für Datenbankanfragen: Inhalte der Datenbank sind Werte, und Operatoren definieren Funktionen zum Berechnen von Anfrageergebnissen + - Relationenalgebra + - Algebra-Erweiterungen + +Relationenalgebra +- Spalten ausblenden: Projektion π +- Zeilen heraussuchen: Selektion σ +- Tabellen verknüpfen: Verbund (Join) ⋊ +- Tabellen vereinigen: Vereinigung ∪ +- Tabellen voneinander abziehen: Differenz − +- Spalten umbenennen: Umbenennung β (wichtig für ⋊ und ∪, −) + +Projektion +- Syntax $\pi_{Attributmenge}(Relation)$ +- Semantik $\pi_X (r) := \{t(X) | t \in r\}$ + - für r(R) und X ⊆ R Attributmenge in R +- Eigenschaft für Y ⊆ X ⊆ R + - $\pi_Y (\pi_X (r)) = \pi_Y (r)$ +- Achtung: π entfernt Duplikate (Mengensemantik) + +Selektion +- Syntax $\sigma_{Bedingung} (Relation)$ +- Semantik (für A ∈ R) $\sigma_{A=a}(r) := \{t \in r | t(A) = a\}$ +- Konstantenselektion $Attribut θ Konstante$ + - boolesches Prädikat θ ist = oder$\not=$, bei linear geordneten Wertebereichen auch ≤, <, ≥ oder > +- Attributselektion $Attribut1 θ Attribut2$ +- logische Verknüpfung mehrerer Konstanten- oder Attribut-Selektionen mit ∧, ∨ oder ¬ +- Eigenschaften + - Kommutativität $\sigma_{A=a}(\sigma_{B=b} (r)) = \sigma_{B=b} (\sigma_{A=a} (r))$ + - falls $A\in X, X \subseteq R: \pi_X(\sigma_{A=a} (r)) = \sigma_{A=a} (\pi_{X} (r))$ + - Distributivität bzgl. ∪, ∩, − $\sigma_{A=a} (r \cup s) = \sigma_{A=a} (r) \cup \sigma_{A=a} (s)$ +- Verbund + - Syntax des (natürlichen) Verbundes (engl.: natural join) $Relation1 \bowtie Relation2$ + - Semantik $r_1 \bowtie r_2 := {t | t(R_1\cup R_2 ) \vee [\forall i \in \{1, 2\}\exists t_i ∈ r_i : t_i = t(R_i )]}$ + - Verbund verknüpft Tabellen über gleichbenannten Spalten bei gleichen Attributwerten + - Schema für $r(R) \bowtie r(S)$ ist Vereinigung der Attributmengen $RS = R \cup S$ + - aus $R_1 \cap R_2 = \{\}$ folgt $r_1\bowtie r_2 = r_1 \times r_2$ + - Kommutativität: r 1 ⋊ r 2 = r 2 ⋊ r 1 + - Assoziativität: (r 1 ⋊ r 2 ) ⋊ ⋉ r 3 = r 1 ⋉ (r 2 ⋊ r 3 ) + - daher erlaubt: $\bowtie_{i=1}^p r_i$ +- Umbenennung + - Syntax $\beta_{neu\leftarrow alt} (Relation)$ + - Semantik $\beta_{B\leftarrow A} (r) := \{t' | \exists t \in r : t' (R - A) = t(R - A) \vee t'(B) = t(A)\}$ + - ändert Attributnamen von alt in neu +- Berechnung des Kreuzproduktes + - natürlicher Verbund entartet zum Kreuzprodukt, wenn keine gemeinsamen Attribute existieren + - Erzwingen durch Umbenennung + - Kreuzprodukt + Selektion simuliert natürlichen Verbund + +Unabhängigkeit und Vollständigkeit +- Minimale Relationenalgebra: Ω = π, σ, ⋊, β, ∪ und − +- unabhängig: kein Operator kann weggelassen werden ohne Vollständigkeit zu verlieren +- andere unabhängige Menge: ⋉ und β durch × ersetzen +- Relationale Vollständigkeit: jede andere Menge von Operationen genauso mächtig wie Ω +- strenge relationale Vollständigkeit: zu jedem Ausdruck mit Operatoren aus Ω gibt es einen Ausdruck auch mit der anderen Menge von Operationen + +## Erweiterungen der Relationenalgebra +Verbundvarianten +- Gleichverbund (engl. equi-join): Gleichheitsbedingung über explizit angegebene und evtl. verschiedene Attribute + - $r(R) \bowtie_{C=D} r(S)$ +- Theta-Verbund (engl. θ-join): beliebige Verbundbedingung + - $r(R) \bowtie_{C>D} r(S)$ +- Semi-Verbund: nur Attribute eines Operanden erscheinen im Ergebnis + - $r(L) \bowtie r(R) = \pi_L (r(L) \bowtie r(R))$ +- äußere Verbunde (engl. outer join) + - voller äußerer Verbund übernimmt alle Tupel beider Operanden + - linker äußerer Verbund übernimmt alle Tupel des linken Operanden + - rechter äußerer Verbund übernimmt alle Tupel des rechten Operanden + +Problem: Quantoren +- Allquantor in Relationenalgebra ausdrücken, obwohl in Selektionsbedingungen nicht erlaubt +- Division (kann aus Ω hergeleitet werden) + +> Division: Die ganzzahlige Division ist in dem Sinne die Inverse zur Multiplikation, indem sie als Ergebnis die größte Zahl liefert, für die die Multiplikation mit dem Divisor kleiner ist als der Dividend. +Analog gilt: $r = r_1 / r_2$ ist die größte Relation, für die $r \bowtie r_2 \subseteq r_1$ ist. + +Gruppierungsoperator γ +- erweitert Attributschema von r(R) um neue Attribute, die mit den Funktionsanwendungen $f_1 (x_1 ), f_2 (x_2 ),..., f_n (x_n )$ korrespondieren +- Anwendung der Funktionen $f_i (x_i)$ auf die Teilmenge derjenigen Tupel von $r(R)$ die gleiche Attributwerte für die Attribute A haben + +## Anfragekalküle +- Kalkül: eine formale logische Sprache zur Formulierung von Aussagen +- Ziel: Einsatz eines derartigen Kalküls zur Formulierung von Datenbank-Anfragen +- Logikbasierter Ansatz: + - Datenbankinhalte entsprechen Belegungen von Prädikaten einer Logik + - Anfragen abgeleiteten Prädikaten + +Ein allgemeiner Kalkül +- Motivation: mathematische Notation $\{x^2 | x \in\N \vee x^3 > 0 \vee x^3 < 1000\}$ +- Anfrage hat die Form $\{f(\bar{x}) | p(\bar{x})\}$ + - x bezeichnet Menge von freien Variablen $x = \{x_1:D_1,...,x_n:D_n\}$ + - Funktion f bezeichnet Ergebnisfunktion über $\bar{x}$ + - p Selektionsprädikat über freien Variablen $\bar{x}$ +- Ergebnisbestimmung einer Anfrage + - Bestimme aller Belegungen der freien Variablen in x, für die das Prädikat p wahr wird. + - Wende Funktion f auf die durch diese Belegungen gegebenen Werte an. +- Unter welchen Umständen liefern Kalkülanfragen endliche Ergebnisse? → Sicherheit von Anfragen + +Relationale Kalküle +- Bereichskalkül: Variablen nehmen Werte elementarer Datentypen (Bereiche) an + - Terme: + - Konstanten, etwa 42 oder 'MZ-4' + - Variablen zu Datentypen, etwa x Datentypangabe erfolgt in der Regel implizit und wird nicht explizit deklariert! + - Funktionsanwendung $f(t_1,...,t_n )$: Funktion f, Terme $t_i$ , etwa $plus(12, x)$ bzw. in Infixnotation $12 + x$ + - Atomare Formeln: + - Prädikatanwendung $\Theta(t_1,...,t_n ), \Theta\in\{<, >, \leq, \geq, \not = , =,...\}$ + - Datentypprädikat, Terme $t_i$ + - Zweistellige Prädikate wie üblich in Infix-Notation. + - Beispiele: $x = y$, $42 > x$ oder $3 + 7 = 11$. + - Prädikatanwendungen für Datenbankprädikate, notiert als $R(t_1,...,t_n)$ für einen Relationennamen R + - Voraussetzung: n muss die Stelligkeit der Relation R sein und alle $t_i4 müssen vom passenden Typ sein + - Beispiel: `ERZEUGER(x, ’Hessen’, z)` + - Formeln wie üblich $\vee, \wedge, \neg, \forall, \exists$ + - Anfragen: $\{x_1,..., x_n | \phi(x_1,..., x_n )\}$ + - $\phi$ ist Formel über den in der Ergebnisliste aufgeführten Variablen $x_1$ bis $x_n$ + - Ergebnis ist eine Menge von Tupeln + - Tupelkonstruktion erfolgt implizit aus den Werten der Variablen in der Ergebnisliste +- Basiskalkül + - Einschränkung des Bereichskalküls: + - Wertebereich: ganze Zahlen + - Datentypprädikate werden wie bei der Relationenalgebra auf Gleichheit und elementare Vergleichsoperatoren eingeschränkt + - Funktionsanwendungen sind nicht erlaubt; nur Konstanten dürfen neben Bereichsvariablen als Terme verwendet werden +- Tupelkalkül: Variablen variieren über Tupelwerte (entsprechend den Zeilen einer Relation) + - Grundlage von SFW-Anfragen in SQL + - Variablen sind tupelwertig + - Beispiel: $\{w | w\in WEINE \vee w.Farbe = 'Rot'\}$ + +Motivation: Die Sprache QBE +- „Query by Example“ +- Anfragen in QBE: Einträge in Tabellengerüsten +- Intuition: Beispieleinträge in Tabellen +- Vorläufer verschiedener tabellenbasierter Anfrageschnittstellen kommerzieller Systeme +- basiert auf logischem Kalkül mit Bereichsvariablen + +> Semantisch sichere Anfragen: Anfragen, die für jeden Datenbankzustand $\sigma(R)$ ein endliches Ergebnis liefern + +> Semantische Sicherheit Semantische Sicherheit ist im Allgemeinen nicht entscheidbar! + +> Syntaktische Sicherheit: Jede freie Variable $x_i$ muss überall in $\phi(x_1,...)$ durch positives Auftreten $x_i = t$ oder $R(. . . , x_i , . . . )$ an endliche Bereiche gebunden werden. +- Syntaktisch sichere Anfragen: Anfragen, die syntaktischen Einschränkungen unterliegen, um die semantische Sicherheit zu erzwingen. +- Bindung an endliche Bereiche muss für die ganze Bedingung gelten, also insbesondere für alle Zweige einer Disjunktion + +## Eigenschaften des Bereichskalküls +- Ausdrucksfähigkeit des Bereichskalküls: Bereichskalkül ist streng relational vollständig, d.h. zu jedem Term τ der Relationenalgebra gibt es einen äquivalenten (sicheren) Ausdruck η des Bereichskalküls. + +# Transaktionen, Integrität und Trigger +## Grundbegriffe +Integritätsbedingung (engl. integrity constraint oder assertion): Bedingung für die „Zulässigkeit“ oder „Korrektheit“ + +1. Typintegrität + - SQL erlaubt Angabe von Wertebereichen zu Attributen + - Erlauben oder Verbieten von Nullwerten +2. Schlüsselintegrität + - Angabe eines Schlüssels für eine Relation +3. Referentielle Integrität + - die Angabe von Fremdschlüsseln + +## Transaktionsbegriff +Beispiel: +- Platzreservierung für Flüge gleichzeitig aus vielen Reisebüros → Platz könnte mehrfach verkauft werden, wenn mehrere Reisebüros den Platz als verfügbar identifizieren +- überschneidende Kontooperationen einer Bank +- statistische Datenbankoperationen → Ergebnisse sind verfälscht, wenn während der Berechnung Daten geändert werden + +> Transaktion: Eine Transaktion ist eine Folge von Operationen (Aktionen), die die Datenbank von einem konsistenten Zustand in einen konsistenten, eventuell veränderten, Zustand überführt, wobei das ACID-Prinzip eingehalten werden muss. +- Aspekte: + - Semantische Integrität: Korrekter (konsistenter) DB-Zustand nach Ende der Transaktion + - Ablaufintegrität: Fehler durch "gleichzeitigen" Zugriff mehrerer Benutzer auf dieselben Daten vermeiden + +ACID-Eigenschaften +- Atomicity (Atomarität): Transaktion wird entweder ganz oder gar nicht ausgeführt +- Consistency (Konsistenz oder auch Integritätserhaltung): Datenbank ist vor Beginn und nach Beendigung einer Transaktion jeweils in einem konsistenten Zustand +- Isolation (Isolation): Nutzer, der mit einer Datenbank arbeitet, sollte den Eindruck haben, dass er mit dieser Datenbank alleine arbeitet +- Durability (Dauerhaftigkeit / Persistenz): nach erfolgreichem Abschluss einer Transaktion muss das Ergebnis dieser Transaktion „dauerhaft“ in der Datenbank gespeichert werden + +Kommandos einer Transaktionssprache +- Beginn einer Transaktion: Begin-of-Transaction-Kommando BOT (in SQL implizit!) +- commit: die Transaktion soll erfolgreich beendet werden +- abort: die Transaktion soll abgebrochen werden + +Vereinfachtes Modell für Transaktion +- Repräsentation von Datenbankänderungen einer Transaktion + - `read(A,x)`: weise den Wert des DB-Objektes A der Variablen x zu + - `write(x, A)`: speichere den Wert der Variablen x im DB-Objekt A +- Beispiel einer Transaktion T: + - `read(A, x); x := x − 200; write(x, A);` + - `read(B, y); y := y + 100; write(y, B);` +- Ausführungsvarianten für zwei Transaktionen T_1 , T_2 : + - seriell, etwa T_1 vor T_2 + - „gemischt“, etwa abwechselnd Schritte von T_1 und T_2 +- Probleme im Mehrbenutzerbetrieb + - Inkonsistentes Lesen: Nonrepeatable Read + - Variablen/Speicher ändert sich durch fertigstellen anderer Transaktionen während des Ablaufs + - Abhängigkeiten von nicht freigegebenen Daten: Dirty Read + - T_1 ändert X + - T_2 liest X und rechnet damit + - T_1 bricht ab und setzt änderung zurück + - Ergebnis von T_2 ist damit falsch + - Das Phantom-Problem + - durch `insert` ändert sich `select` ergebnis; nachfolgende rechnungen auf vorherigen abruf sind falsch + - Verlorengegangenes Ändern: Lost Update + - updates gehen verloren, wenn gleiche Variablen gleicheitig beschrieben werden (oder kurz nacheinander) + +> Serialisierbarkeit: Eine verschränkte Ausführung mehrerer Transaktionen heißt serialisierbar, wenn ihr Effekt identisch zum Effekt einer (beliebig gewählten) seriellen Ausführung dieser Transaktionen ist. +- Schedule: "Ablaufplan" für Transaktion, bestehend aus Abfolge von Transaktionsoperationen + +## Transaktionen in SQL +Aufweichung von ACID in SQL: Isolationsebenen +```sql +set transaction + [ { read only | read write }, ] + [isolation level + { read uncommitted | + read committed | + repeatable read | + serializable }, ] + [ diagnostics size ...] +``` +Standardeinstellung: +```sql +set transaction read write, + isolation level serializable +``` + +Bedeutung der Isolationsebenen +- **read uncommitted** + - schwächste Stufe: Zugriff auf nicht geschriebene Daten, nur für read only Transaktionen + - statistische und ähnliche Transaktionen (ungefährer Überblick, nicht korrekte Werte) + - keine Sperren → effizient ausführbar, keine anderen Transaktionen werden behindert +- **read committed**: nur Lesen endgültig geschriebener Werte, aber nonrepeatable read möglich +- **repeatable read**: kein nonrepeatable read, aber Phantomproblem kann auftreten +- **serializable**: garantierte Serialisierbarkeit + + +## Integritätsbedingungen in SQL +- **not null**: Nullwerte verboten +- **default**: Angabe von Default-Werten +- **check** ( search-condition ): + - Attributspezifische Bedingung (in der Regel Ein-Tupel-Integritätsbedingung) + - Festlegung weitere lokale Integritätsbedingungen innerhalb der zu definierenden Wertebereiche, Attribute und Relationenschemata + - Beispiel: + ```sql + create table WEINE ( + WeinID int primary key, + Name varchar(20) not null, + Jahr int check(Jahr between 1980 and 2010), + ... + ) + ``` +- **primary key**: Angabe eines Primärschlüssel +- **foreign key** ( Attribut(e) ) **references** Tabelle( Attribut(e) ): Angabe der referentiellen Integrität +- **create domain**: Festlegung eines benutzerdefinierten Wertebereichs + - Beispiel: + ```sql + create domain WeinFarbe varchar(4) + default 'Rot' + check (value in ('Rot', 'Weiß', 'Rose')) + + create table WEINE ( WeinID int primary key, Name varchar(20) not null, Farbe WeinFarbe, ...) + ``` + +Erhaltung der referentiellen Integrität +- Überprüfung der Fremdschlüsselbedingungen nach Datenbankänderungen +- Überprüfungsmodi von Bedingungen + - `on update | delete`: Angabe eines Auslöseereignisses, das die Überprüfung der Bedingung anstößt + - `cascade | set null | set default | no action`: Kaskadierung: Behandlung einiger Integritätsverletzungen pflanzt sich über mehrere Stufen fort, z.B. Löschen als Reaktion auf Verletzung der referentieller Integrität + - `deferred | immediate` legt Überprüfungszeitpunkt für eine Bedingung fest + - `deferred`: Zurückstellen an das Ende der Transaktion + - `immediate`: sofortige Prüfung bei jeder relevanten Datenbankänderung + - Beispiel: `... foreign key (Weingut) references ERZEUGER (Weingut) on delete cascade` + +Die assertion-Klausel +- Assertion: Prädikat, das eine Bedingung ausdrückt, die von der Datenbank immer erfüllt sein muss +- Syntax (SQL:2003) `create assertion name check ( prädikat )` + +## Trigger +- Trigger: Anweisung/Prozedur, die bei Eintreten eines bestimmten Ereignisses automatisch vom DBMS ausgeführt wird +- Anwendung: + - Erzwingen von Integritätsbedingungen („Implementierung“ von Integritätsregeln) + - Auditing von DB-Aktionen + - Propagierung von DB-Änderungen +- Definition: + ```sql + create trigger ... + after Operation + Anweisungen + ``` +- Beispiel: Einfügen von neuen Aufträgen + ```sql + create trigger Auftragszählung+ + on insertion of Auftrag A: + update Kunde + set AnzAufträge = AnzAufträge + 1 + where KName = new A.KName + + create trigger Auftragszählung- + on deletion ...: + update ...- 1 ... + ``` +- Spezifikation von + - Ereignis und Bedingung für Aktivierung des Triggers + - Aktion(en) zur Ausführung +- Syntax in SQL:2003 festgelegt + ```sql + create trigger Name + after | before Ereignis + on Relation + [ when Bedingung ] + begin atomic SQL-Anweisungen end + ``` +- verfügbar in den meisten kommerziellen Systemen (aber mit anderer Syntax) +- Weitere Angaben bei Triggern + - **for each row** bzw. **for each statement**: Aktivierung des Triggers für jede Einzeländerungen einer mengenwertigen Änderung oder nur einmal für die gesamte Änderung + - **before** bzw. **after**: Aktivierung vor oder nach der Änderung + - **referencing new as** bzw. **referencing old as**: Binden einer Tupelvariable an die neu eingefügten bzw. gerade gelöschten („alten“) Tupel einer Relation ⇝ Tupel der Differenzrelationen + +Integritätssicherung durch Trigger +1. Bestimme Objekt $o_i$ , für das die Bedingung $\phi$ überwacht werden soll + - i.d.R. mehrere $o_i$ betrachten, wenn Bedingung relationsübergreifend ist + - Kandidaten für $o_i$ sind Tupel der Relationsnamen, die in $\phi$ auftauchen +2. Bestimme die elementaren Datenbankänderungen $u_{ij}$ auf Objekten $o_i$ , die $\phi$ verletzen können + - Regeln: z.B. Existenzforderungen beim Löschen und Ändern prüfen, jedoch nicht beim Einfügen etc. +3. Bestimme je nach Anwendung die Reaktion $r_i$ auf Integritätsverletzung + - Rücksetzen der Transaktion (rollback) + - korrigierende Datenbankänderungen +4. Formuliere folgende Trigger: + `create trigger t-phi-ij after u ij on o i when ¬φ begin r i end` +5. Wenn möglich, vereinfache entstandenen Trigger + +Trigger in Oracle: Arten +- Prädikat zur Einschränkung (when) +- Zugriff auf altes (:old.col) bzw. neues (:new.col) Tupel + - für delete: nur (:old.col) + - für insert: nur (:new.col) + - in when-Klausel nur (new.col) bzw. (old.col) +- Transaktionsabbruch durch raise_application_error(code, message) +- Unterscheidung der Art der DML-Anweisung + - `if deleting then ... end if;` + - `if updating then ... end if;` + - `if inserting then ... end if;` + +## Schemaevolution +- Änderung eines Datenbankschemas durch neue/veränderte Anforderungen + - Hinzufügen oder Löschen von Tabellen, Spalten, Integritätsbedingungen + - Umbenennen oder Datentypänderungen +- erfordert oft auch Anpassung/Übertragung der vorhandenen Datenbank ⇝ Datenbankmigration +- leider nur eingeschränkte Unterstützung durch DB-Werkzeuge (DDL + Export/Import der Daten) + +- SQL-DDL zum Löschen von Tabellen + - Löschen von Tabellendefinitionen (beachte Unterschied zu delete) + `drop table relationenname [ restrict | cascade ]` + - cascade: erzwingt Löschen aller Sichten und Integritätsbedingungen, die zu dieser Basisrelation gehören + - restrict (Defaultfall): das drop-Kommando wird zurückgewiesen, falls noch solche Sichten und Integritätsbedingungen existieren +- SQL-DDL zur Änderung von Tabellen + - `alter table relationenname modifikation` + - **add column spaltendefinition** fügt eine neue Spalte hinzu; alle bereits in der Tabelle existierenden Tupel erhalten als Wert der neuen Spalte den angegebenen Defaultwert bzw. den null-Wert + - **drop column spaltenname** löscht die angegebene Spalte (inkl. restrict- bzw. cascade) + - **alter column spaltenname set default defaultwert** verändert Defaultwert der Spalte +- Änderung von Integritätsbedingungen + - nachträgliches Hinzufügen/Löschen von Tabellenbedingungen über **alter table** + - Vergabe von Namen für Bedingungen über constraint bed-name-Klausel + ```sql + alter table WEINE + add constraint WeinBed_Eindeutig + unique (Name, Weingut) + ``` + - Löschen über Namen `alter table WEINE drop constraint WeinBed_Eindeutig` + +# Sichten und Zugriffskontrolle +## Sichtenkonzept +> Sichten: virtuelle Relationen (bzw virtuelle Datenbankobjekte in anderen Datenmodellen) (englisch view) +- Sichten sind externe DB-Schemata folgend der 3-Ebenen-Schemaarchitektur + - Sichtdefinition + - Relationenschema (implizit oder explizit) + - Berechnungsvorschrift für virtuelle Relation, etwa SQL-Anfrage +- Vorteile + - Vereinfachung von Anfragen für den Benutzer der Datenbank, etwa indem oft benötigte Teilanfragen als Sicht realisiert werden + - Möglichkeit der Strukturierung der Datenbankbeschreibung, zugeschnitten auf Benutzerklassen + - logische Datenunabhängigkeit ermöglicht Stabilität der Schnittstelle für Anwendungen gegenüber Änderungen der Datenbankstruktur + - Beschränkung von Zugriffen auf eine Datenbank im Zusammenhang mit der Zugriffskontrolle +- Probleme + - automatische Anfragetransformation + - Durchführung von Änderungen auf Sichten +- Definition von Sichten in SQL + ```sql + create view SichtName [ SchemaDeklaration ] + as SQLAnfrage + [ with check option ] + ``` +- Beispiel: alle Rotweine aus Bordeaux + ```sql + create view Rotweine as + select Name, Jahrgang, WEINE.Weingut + from WEINE natural join ERZEUGER + where Farbe = 'Rot' and Region = 'Bordeaux' + ``` + +## Änderungen auf Sichten +Kriterien für Änderungen auf Sichten +- Effektkonformität: Benutzer sieht Effekt als wäre die Änderung auf der Sichtrelation direkt ausgeführt worden +- Minimalität: Basisdatenbank sollte nur minimal geändert werden, um den erwähnten Effekt zu erhalten +- Konsistenzerhaltung: Änderung einer Sicht darf zu keinen Integritätsverletzungen der Basisdatenbank führen +- Respektierung des Datenschutzes: Wird die Sicht aus Datenschutzgründen eingeführt, darf der bewusst ausgeblendete Teil der Basisdatenbank von Änderungen der Sicht nicht betroffen werden + +Projektionssicht: $WNW:=\pi_{WeinID, Name, Weingut}(WEINE)$ +- in sql mit create view Anweisung + `create view WNW as select WeinID, Name, Weingut from WEINE` +- Änderungsanweisung für die Sicht WNW: + `insert into WNW values (3333, 'Dornfelder', 'Müller')` + - Problem der Konsistenzerhaltung falls Farbe oder Jahrgang als not null deklariert! + +Selektionssichten: $WJ:=\sigma_{Jahrgang>2000}(\pi_{WeinID, Jahrgang}(WEINE))$ + ```sql + create view WJ as + select WeinID, Jahrgang + from WEINE + where Jahrgang > 2000 + ``` + +Kontrolle der Tupelmigration +```sql +create view WJ as +select WeinID, Jahrgang +from WEINE +where Jahrgang > 2000 +with check option +``` + +Verbundsichten $WE := WEINE \bowtie ERZEUGER$ +- In SQL: + ```sql + create view WE as + select WeinID, Name, Farbe, Jahrgang, + WEINE.Weingut, Anbaugebiet, Region + from WEINE, ERZEUGER + where WEINE.Weingut = ERZEUGER.Weingut + ``` +- Änderungsoperationen hier in der Regel nicht eindeutig übersetzbar: + `insert into WE values (3333, 'Dornfelder', 'Rot', 2002, 'Helena', 'Barossa Valley', 'Südaustralien')` +- Änderung wird transformiert zu + `insert into WEINE values (3333, 'Dornfelder', 'Rot', 2002, 'Helena')` +- plus Änderung auf ERZEUGER ! + +Aggregierungssichten + ```sql + create view FM (Farbe, MinJahrgang) as + select Farbe, min(Jahrgang) + from WEINE + group by Farbe + ``` +- Folgende Änderung ist nicht eindeutig umsetzbar: + ```sql + update FM + set MinJahrgang = 1993 + where Farbe = 'Rot' + ``` + +Klassifikation der Problembereiche +1. Verletzung der Schemadefinition (z.B. Einfügen von Nullwerten bei Projektionssichten) +2. Datenschutz: Seiteneffekte auf nicht-sichtbaren Teil der Datenbank vermeiden (Tupelmigration, Selektionssichten) +3. nicht immer eindeutige Transformation: Auswahlproblem +4. Aggregierungssichten (u.a.): keine sinnvolle Transformation möglich +5. elementare Sichtänderung soll genau einer atomaren Änderung auf Basisrelation entsprechen: 1:1-Beziehung zwischen Sichttupeln und Tupeln der Basisrelation (kein Herausprojizieren von Schlüsseln) + +SQL-92-Standard +- Integritätsverletzende Sichtänderungen nicht erlaubt +- datenschutzverletzende Sichtänderungen: Benutzerkontrolle (with check option) +- Sichten mit nicht-eindeutiger Transformation: Sicht nicht änderbar (SQL-92 restriktiver als notwendig) + +Einschränkungen für Sichtänderungen +- änderbar nur Selektions- und Projektionssichten (Verbund und Mengenoperationen nicht erlaubt) +- 1:1-Zuordnung von Sichttupeln zu Basistupeln: kein distinct in Projektionssichten +- Arithmetik und Aggregatfunktionen im select-Teil sind verboten +- genau eine Referenz auf einen Relationsnamen im from-Teil erlaubt (auch kein Selbstverbund) +- keine Unteranfragen mit „Selbstbezug“ im where-Teil erlaubt (Relationsname im obersten SFW-Block nicht in from-Teilen von Unteranfragen verwenden) +- group by und having verboten +- seit SQL:2003 Aufhebung einiger Einschränkungen, insbesondere + - updates auf union all-Sichten (ohne Duplikateliminierung) + - Inserts in Verbundsichten mit Primär-/Fremdschlüsselbeziehungen (mit einigen Einschränkungen) + - Updates auf Verbundsichten mit Cursor + +Alternative: Sichtänderungen mit Instead-of-Triggern +- Definition von Triggern auf Sichten zur anwendungsspezifischen Propagierung der Änderungen auf die Basistabellen +```sql +create view V_WEINERZEUGER as + select * from WEINE natural join ERZEUGER; +create trigger V_WEINERZEUGER_Insert + instead of insert on V_WEINERZEUGER +referencing new as N +for each row +begin + insert into WEINE values (:N.WeinID, :N.Name, + :N.Farbe, :N.Jahrgang, :N.Weingut); +end; +``` + +Auswertung von Anfragen an Sichten +- select: Sichtattribute evtl. umbenennen bzw. durch Berechnungsterm ersetzen +- from: Namen der Originalrelationen +- konjunktive Verknüpfung der where-Klauseln von Sichtdefinition und Anfrage (evtl. Umbenennungen) +- Vorsicht bei Aggregationssichten! + - having versus where + - keine geschachtelten Aggregationen in SQL + +## Rechtevergabe +- Zugriffsrechte (AutorisierungsID, DB-Ausschnitt, Operation) +- AutorisierungsID ist interne Kennung eines „Datenbankbenutzers“ +- Datenbank-Ausschnitte: Relationen und Sichten +- DB-Operationen: Lesen, Einfügen, Ändern, Löschen + +```sql +grant Rechte +on Tabelle +to BenutzerListe +[with grant option] +``` +- In Rechte-Liste: all bzw. Langform all privileges oder Liste aus select, insert, update, delete +- Hinter on: Relationen- oder Sichtname +- Hinter to: Autorisierungsidentifikatoren (auch public, group) +- spezielles Recht: Recht auf die Weitergabe von Rechten (with grant option) + +Autorisierung für public: „Jeder Benutzer kann seine Aufträge sehen und neue Aufträge einfügen (aber nicht löschen!).“ +```sql +create view MeineAufträge as +select * +from AUFTRAG +where KName = user; +grant select, insert +on MeineAufträge +to public; +``` + +Zurücknahme von Rechten +```sql +revoke Rechte +on Tabelle +from BenutzerListe +[restrict | cascade ] +``` +- restrict: Falls Recht bereits an Dritte weitergegeben: Abbruch von revoke +- cascade: Rücknahme des Rechts mittels revoke an alle Benutzer propagiert, die es von diesem Benutzer mit grant erhalten haben + + +## Privacy-Aspekte +> Privacy (Privatsphäre): das Recht jedes Einzelnen auf einen geschützten privaten Raum, der von anderen nur in definierten Ausnahmefällen verletzt werden darf +- elektronische Autobahn-Mautsysteme: Überwachung von Fahrzeugen +- Kreditkartenaktivitäten und diverse Payback- bzw. Rabattkarten: Kaufverhalten von Kunden +- Mobilfunksysteme: Bewegungsprofile der Nutzer +- RFID-Technologie: etwa im Einzelhandel Kaufverhalten, Warenflüsse, etc. + +Statistische Datenbanken +- Datenbanken, in denen die Einzeleinträge dem Datenschutz unterliegen, aber statistische Informationen allen Benutzern zugänglich sind +- statistische Information = aggregierte Daten (Durchschnittseinkommen etc.) +- Problem: Gewinnung von Einzelinformationen durch indirekte Anfragen + - Abhilfe: keine Anfragen, die weniger als n Tupel selektieren + - Abhilfe: statistische Anfragen nicht erlauben, die paarweise einen Durchschnitt von mehr als m vorgegebenen Tupeln betreffen +> Sind nur Ergebnisse von Aggregatfunktionen erlaubt, dann benötigt eine Person 1 + (n − 2)/m Anfragen, um einen einzelnen Attributwert zu ermitteln + +> k-Anonymität: ein bestimmter Sachverhalt kann nicht zwischen einer vorgegebenen Anzahl k von Tupeln unterschieden werden +- für viele Zwecke (klinische Studien etc.) werden auch Detaildaten (Mikrodaten) benötigt + - weitere Zuordnungen (Namen etc.) etwa durch Verbund mit anderen Daten möglich? + - Lösung: Data Swapping (??) + - Vertauschen von Attributwerten einzelner Tupel + - statistische Analysen noch gültig? + - eine Anfrage nach einer beliebigen Kombination von Alter, Geschlecht, Familienstand und Postleitzahl liefert entweder eine leere Relation oder mindestens k Tupel +- Ansätze + - Generalisierung: Attributwerte durch allgemeinere Werte ersetzen, die einer Generalisierungshierarchie entnommen sind + - die Verallgemeinerung des Alters einer Person zu Altersklassen: $\{35, 39\} \rightarrow 30-40$ + - Weglassen von Stellen bei Postleitzahlen: $\{ 39106, 39114 \}\rightarrow 39***$ + - Unterdrücken von Tupeln: Löschen von Tupeln, welche die k-Anonymität verletzen und damit identifizierbar sind + +# NoSQL Datenbanken +## Motivation für NoSQL +- NoSQL = Not only SQL +- im Umfeld vieler aktueller Buzzwords + - NoSQL + - Big Data + - BASE + - ... +- oft einfach als Etikett einer Neuentwicklung eines DBMS pauschal vergeben + +Was ist NoSQL? +- SQL - No! + - SQL-Datenbanken sind zu komplex, nicht skalierbar, ... + - man braucht was einfacheres! +- Not only SQL + - SQL-Datenbanken haben zu wenig (oder die falsche) Funktionalität + - Operationen auf Graphen, Data Mining Operatoren, ... +- New SQL + - SQL-Datenbanken sind (software-technisch) in die Jahre gekommen + - eine neue Generation von DBMS muss her (ohne die etablierten Vorteile von SQL zu ignorieren) + +Kritik an RDBMS / SQL +- nicht skalierbar + - Normalisierung von Relationen, viele Integritätsbedingungen zu prüfen + - kann man in RDBMS auch vermeiden! +- starre Tabellen nicht flexibel genug + - schwach typisierte Tabellen (Tupel weichen in den tatsächlich genutzten Attributen ab) + - viele Nullwerte wenn alle potentiellen Attribute definiert + - alternativ Aufspaltung auf viele Tabellen + - Schema-Evolution mit alter table skaliert bei Big Data nicht + - tatsächlich in vielen Anwendungen ein Problem +- Integration von spezifischen Operationen (Graphtraversierung, Data-Mining-Primitive) mit Stored Procedures zwar möglich führt aber oft zu schwer interpretierbarem Code + + +## Datenmodelle für NoSQL +Datenmodelle für NoSQL +- KV-Stores +- Wide Column Stores +- Dokumenten-orientierte Datenhaltung +- Graph-Speicher +- ... + +Anfragesprachen für NoSQL +- unterschiedliche Ansätze: +- einfache funktionale API +- Programmiermodell für parallele Funktionen +- angelehnt an SQL-Syntax +- ... + +## KV-Stores und Wide Column +Datenmodell: Key-Value-Stores +- Key-Value-Store: binäre Relationen, bestehend aus + - einem Zugriffsschlüssel (dem Key) und + - den Nutzdaten (dem Value) +- Nutzdaten + - binäre Daten ohne Einschränkung, + - Dateien oder Dokumente, → Document Databases + - oder schwachstrukturierte Tupel → Wide Column Store +- Anfragen an KV-Stores + - einfache API + ```sql + store.put(key, value) + value = store.get(key) + store.delete(key) + ``` + - aufgesetzte höherer Sprache angelehnt an SQL + - Map-Reduce: Framework zur Programmierung paralleler Datenaggregation auf KV-Stores +- Beispielsysteme für KV-Stores + - Amazon DynamoDB + - Riak + +Datenmodell: Wide Column +- Basisidee: KV-Store mit schwachstrukturiertem Tupel als Value +- Value = Liste von Attributname-Attributwert-Paaren + - schwache Typisierung für Attributwerte (auch Wiederholgruppen) +- nicht alle Einträge haben die selben Attributnamen + - offene Tupel + - Hinzufügen eines neuen Attributs unproblematisch + - Nullwerte aus SQL ersetzt durch fehlende Einträge +- Beispiel in DynamoDB +- Anfragen bei Wide Column + - CRUD: Create, Read, Update und Delete + - in DynamoDB + - *PutItem* fügt einen neuen Datensatz mit der gegebenen Attribut-Wert-Liste ein bzw. ersetzt einen existierenden Datensatz mit gleichem Schlüssel. + - *GetItem*-Operation liest alle Felder eines über einen Primärschlüssel identifizierten Datensatzes. + - *Scan* erlaubt einen Lauf über alle Datensätze mit Angabe von Filterkriterien. + - Aufruf über HTTP oder aus Programmiersprachen heraus + + +## Document Stores +Datenmodell: dokumentenorientierte Speicherung +- Basisidee: KV-Store mit (hierarchisch) strukturiertem Dokument als Value +- strukturiertes Dokument: + - JSON-Format: geschachtelte Wide Column-Daten + - XML (eher unüblich auf KV-Stores) +- Anfragen bei dokumentenorientierter Speicherung + - CRUD erweitert um dokumentspezifische Suche + - Beispiele (MongoDB mit BSON statt JSON) `db.kritiker.find({Name: "Bond"})` +- Beispielsysteme für dokumentenorientierte Speicherung + - MongoDB + - CouchDB + +## Graph Stores +Graph-Datenmodelle: Grundlagen +- spezielle Form der Datenrepräsentation = Graphen, insb. Beziehungen zwischen Objekten +- Anwendungsgebiete: + - Transportnetze + - Networking: Email-Verkehr, Mobilfunk-Nutzer + - Soziale Netzwerke: Eigenschaften, Communities + - Web: Verlinkte Dokumente + - Chemie: Struktur chemischer Komponenten + - Bioinformatik: Proteinstrukturen, metabolische Pathways, Genexpressionen +- Graph $G = (V, E)$ + - $V$: Menge der Knoten (vertices) + - $E \subseteq V \times V$: Menge der Kanten (edges) + - Kanten können mit Gewicht versehen werden +- Adjazenzmatrix + - Repräsentation von Graphen durch Matrix (Knoten als Zeilen und Spalten) + - ungerichteter Graph: symmetrische Matrix + - ungewichteter Graph: Zellen nur 0 oder 1 +- Knotengrad + - Eigenschaft eines Knotens: Anzahl der verbundenen Knoten + - bei gerichteren Graphen: Unterscheidung in Eingangs- und Ausgangsgrad +- Traversierung + - Tiefensuche (DFS): zunächst rekursiv alle Kindknoten besuchen bevor alle Geschwisterknoten besucht werden + - Bestimmung der Zusammenhangskomponente + - Wegsuche um Labyrinth + - Breitensuche (BFS): zunächst alle Geschwisterknoten besuchen bevor die Kindknoten besucht werden + - Bestimmung des kürzesten Weges + +Subjekt-Prädikat-Objekt-Modell: RDF +- Sprache zur Repräsentation von Informationen über (Web)-Ressourcen +- Ziel: automatisierte Verarbeitung +- zentraler Bestandteil von Semantic Web, Linked (Open) Data +- Repräsentation von Daten, aber auch Wissensrepräsentation (z.B. Ontologie) + +Ontologien +- Ontologie = formale Spezifikation einer Konzeptualisierung, d.h. einer Repräsentation von Begriffen (Konzepten) und deren Beziehungen +- Anwendung: Annotation von Daten, semantische Suche + +RDF: Graphen & Tripel + - Graph = Menge von Tripeln, die Aussagen über Web-Ressourcen repräsentieren + - Identifikation der Web-Ressourcen über Uniform Resource Identifier (URI) + - Tripel: subjekt prädikat objekt . + - Beispiel ` \ ` und ` "Pinot Noir".` + - Subjekt: URI-Referenz, d.h. Ressource, auf die sich die Aussage bezieht + - Prädikat: Eigenschaft, ebenfalls in Form einer URI-Referenz + - Objekt: Wert der Eigenschaft als Literal (Konstante) oder URI- Referenz +- abkürzende Notation für Namensräume über Präfixe: + ```sql + prefix wo: + prefix weine: + weine:2171 wo:name "Pinot Noir". + ``` +- Komplexe Graphen + - mehrere Aussagen zum gleichen Subjekt + - Objekte nicht nur Literale sondern selbst Objekte (URI) + ```sql + weine:2171 wo:name "Pinot Noir". + weine:2171 wo:farbe "Rot". + weine:2171 wo:jahrgang "1999". + weine:2171 wo:erzeuger werzeuger:567 . + ``` +- Repräsentation, Schema und Vokabulare + - Repräsentation von RDF-Daten: N-Tripel, RDF/XML + - RDF Schema: + - objektorientierte Spezifikationssprache + - erweitert RDF um Typsystem: Definition von Klassen und Klassenhierarchien mit Eigenschaften, Ressourcen als Instanzen von Klassen + - RDF Schema ist selbst RDF-Spezifikation + - Beispiel RDF Schema + ```sql + Wein rdf:type rdfs:Class . + Schaumwein rdf:type rdfs:Class . + Schaumwein rdfs:subClassOf Wein . + Name rdf:type rdf:Property . + Jahrgang rdf:type rdf:Property . + Jahrgang rdfs:domain Wein . + Jahrgang rdfs:range xsd:integer . + ``` + - für komplexere Ontologien: OWL (Web Ontology Language) + - Vokabular: vordefinierte Klassen und Eigenschaften + - Bsp: Dublin Core (Metadaten für Dokumente), FOAF (Soziale Netze), ... + - wichtig z.B. für Linked Open Data + +SPARQL als RDF-Anfragesprache +- SPARQL Protocol And RDF Query Language: Anfragesprache für RDF +- W3C-Recommendation +- unterschiedliche Implementierungen möglich: + - Aufsatz für SQL-Backends (z.B. DB2, Oracle) + - Triple Stores (RDF-Datenbank) + - SPARQL-Endpoints +- syntaktisch an SQL angelehnt, aber Unterstützung für Graph-Anfragen +- SPARQL-Elemente + - Grundelemente: select-where-Block und Tripelmuster `?wein wo:name ?name .` + - Auswertung: finden aller Belegungen (Bindung) für Variable (?name) bei Übereinstimmung mit nicht-variablen Teilen + ```sql + wo:name "Pinot Noir". + wo:name "Creek Shiraz". + wo:name "Chardonnay". + ``` +- SPARQL: Basic Graph Pattern + - Graphmuster (BGP = Basic Graph Pattern): Kombination von Tripelmustern über gemeinsame Variablen + ```sql + ?wein wo:name ?name . + ?wein wo:farbe ?farbe . + ?wein wo:erzeuger ?erzeuger . + ?erzeuger wo:weingut ?ename . + ``` + - Einsatz in SPARQL-Anfragen im where-Teil + ```sql + select ?wein ?name ?farbe ?ename + where { ?wein wo:name ?name . + ?wein wo:farbe ?farbe . + ?wein wo:erzeuger ?erzeuger . + ?erzeuger wo:weingut ?ename . } + ``` +- SPARQL: Weitere Elemente + - filter: Filterbedingungen für Bindungen + - optional: optionale Muster – erfordern nicht zwingend ein Matching + ```sql + prefix wo: + select ?name + where { ?wein wo:name ?name . } + optional { ?wein wo:jahrgang ?jahrgang } . + filter ( bound(?jahrgang) && ?jahrgang < 2010 ) + ``` +- Property-Graph-Modell + - Knoten und (gerichtete) Kanten mit Eigenschaften (Properties) + - nicht streng typisiert, d.h. Eigenschaften als Name-Wert-Paare + - Unterstützung in diversen Graph-Datenbanksystemen: neo4j, Microsoft Azure Cosmos DB, OrientDB, Amazon, Neptune, ... + - Property-Graph-Modell in Neo4j + - Elemente: Nodes, Relationships, Properties, Labels + - Properties = Key-Value-Paare: Key (=String), Value (=Java-Datentypen + Felder) + - Nodes mit Labels (≈ Klassenname) + - Relationships: sind gerichtet, mit Namen und ggf. Properties + - Anfragen auf Graphen + - keine Standardsprache + - aber wiederkehrende Grundelemente + - Graph Matching: Knoten, Kanten, Pfade (siehe BGP in SPARQL) + - Filter für Knoten- und Kanteneigenschaften + - Konstruktion neuer Graphen + - Anfragen in Cypher + - Basis: Muster der Form „Knoten → Kante → Knoten ...“ `(von)-[:relationship]->(nach)` + - Beschränkung über Label und Properties `(e:ERZEUGER)-[:LIEGT_IN]->(a:ANBAUGEBIET {gebiet: 'Napa Valley' } )` + - Klauseln + - match: Beispielmuster für Matching + - return: Festlegung der Rückgabedaten (Projektion) + - where: Filterbedingung für „gematchte“ Daten + - create: Erzeugen von Knoten oder Beziehungen + - set: Ändern von Property-Werten + +Zusammenfassung +- NoSQL als Oberbegriff für diverse Datenbanktechniken +- große Bandbreite: von einfachen KV-Stores bis zu Graphdatenbanken +- höhere Skalierbarkeit / Performance gegenüber SQL-DBMS meist durch Einschränkungen erkauft +- Abschwächung von ACID-Eigenschaften +- begrenzte Anfragefunktionalität +- Nicht-Standard bzw. proprietäre Schnittstellen + +# Anwendungsprogrammierung +Lernziele: +- Wissen zu Konzepten und Schnittstellen zum Zugriff auf SQL-Datenbanken aus Programmiersprachen heraus +- Verständnis prozeduraler Schnittstellen am Beispiel von JDBC +- Kenntnisse zu Embedded SQL und prozeduralen SQL-Erweiterungen +- Grundverständnis objektrelationaler Abbildungen + +## Programmiersprachenanbindung +Kopplungsarten: +- prozedurale oder CALL-Schnittstellen (call level interface) + - Beispiele: SQL/CLI, ODBC, JDBC, ... +- Einbettung einer DB-Sprache in Programmiersprachen + - statische Einbettung: Vorübersetzer-Prinzip ⇝ SQL-Anweisungen zur Übersetzungszeit festgelegt + - Beispiele: Embedded SQL, SQLJ + - dynamische Einbettung ⇝ Konstruktion von SQL-Anweisungen zur Laufzeit +- Spracherweiterungen und neue Sprachentwicklungen + - Beispiele: SQL/PSM, PL/SQL, Transact-SQL, PL/pgSQL +- Cursor-Konzept + - Cursor: Iterator über Liste von Tupeln (Anfrageergebnis) + +## JDBC +- Datenbankzugriffsschnittstelle für Java +- abstrakte, datenbankneutrale Schnittstelle +- vergleichbar mit ODBC +- Low-Level-API: direkte Nutzung von SQL +- Java-Package java.sql + - DriverManager: Einstiegspunkt, Laden von Treibern + - Connection: Datenbankverbindung + - Statement: Ausführung von Anweisungen über eine Verbindung + - ResultSet: verwaltet Ergebnisse einer Anfrage, Zugriff auf einzelne Spalten + +![JDBC Struktur](Assets/Datenbanksysteme_JDBC_Struktur.png) + +![JDBC Treiber](Assets/Datenbanksysteme_JDBC_Treiberkonzept.png) + +### Ablauf +1. Aufbau einer Verbindung zur Datenbank + - Angabe der Verbindungsinformationen + - Auswahl und Laden des Treibers +2. Senden einer SQL-Anweisung + - Definition der Anweisung + - Belegung von Parametern +3. Verarbeiten der Anfrageergebnisse + - Navigation über Ergebnisrelation + - Zugriff auf Spalten + +### Verbindungsaufbau +1. Treiber laden `Class.forName("com.company.DBDriver");` +2. Verbindung herstellen + ```java + String url = "jdbc:subprotocol:datasource"; + Connection con = DriverManager.getConnection + (url, "scott", "tiger"); + ``` + +JDBC-URL spezifiziert +- Datenquelle/Datenbank +- Verbindungsmechanismus (Protokoll, Server und Port) + +### Anfrageausführung +1. Anweisungsobjekt (Statement) erzeugen `Statement stmt = con.createStatement();` +2. Anweisung ausführen + ```java + String query = "select Name, Jahrgang from WEINE"; + ResultSet rSet = stmt.executeQuery(query); + ``` + +Klasse java.sql.Statement +- Ausführung von Anfragen (SELECT) mit executeQuery +- Ausführung von Änderungsanweisungen (DELETE, INSERT, UPDATE) mit executeUpdate + +### Ergebnisverarbeitung +1. Navigation über Ergebnismenge (Cursor-Prinzip) + ```java + while (rSet.next()) { + // Verarbeitung der einzelnen Tupel + ... + } + ``` +2. Zugriff auf Spaltenwerte über getType-Methoden + - über Spaltenindex `String wName = rSet.getString(1);` + - über Spaltenname `String wName = rSet.getString("Name");` + +### Fehlerbehandlung +- Fehlerbehandlung mittels Exception-Mechanismus +- SQLException für alle SQL- und DBMS-Fehler +```java +try { + // Aufruf von JDBC-Methoden + ... +} catch (SQLException exc) { + System.out.println("SQLException: " + + exc.getMessage()); +} +``` + +### Änderungsoperationen +- DDL- und DML-Operationen mittels executeUpdate +- liefert Anzahl der betroffenen Zeilen (für DML-Operationen) +```java +Statement stmt = con.createStatement(); +int rows = stmt.executeUpdate( + "update WEINE set Preis = Preis * 1.1 " + + "where Jahrgang < 2000"); +``` + +### Transaktionssteuerung +- Methoden von Connection + - commit () + - rollback () +- Auto-Commit-Modus + - implizites Commit nach jeder Anweisung + - Transaktion besteht nur aus einer Anweisung + - Umschalten mittels setAutoCommit (boolean) + +## SQLJ +### Embedded SQL für Java +- Einbettung von SQL-Anweisungen in Java-Quelltext +- Vorübersetzung des erweiterten Quelltextes in echten Java-Code durch Translator sqlj +- Überprüfung der SQL-Anweisungen + - korrekte Syntax + - Übereinstimmung der Anweisungen mit DB-Schema + - Typkompatibilität der für Datenaustausch genutzten Variablen +- Nutzung von JDBC-Treibern +![SQLJ Prinzip](Assets/Datenbanksysteme_SQLJ_Prinzip.png) + +Anweisungen +- Kennzeichnung durch #sql Deklarationen +- Klassendefinitionen für Iteratoren +- SQL-Anweisungen: Anfragen, DML- und DDL-Anweisungen `#sql { SQL-Operation };` +- Beispiel: `#sql { insert into ERZEUGER (Weingut, Region) values ( 'Wairau Hills', 'Marlborough') };` + +Host-Variablen +- Variablen einer Host-Sprache (hier Java), die in SQL-Anweisungen auftreten können +- Verwendung: Austausch von Daten zwischen Host-Sprache und SQL +- Kennzeichnung durch ":variable" +- Beispiel: + ```java + String name; + int weinID = 4711; + #sql { select Name into :name + from WEINE where WeinID = :weinID }; + System.out.println("Wein = " + name); + ``` +- Nullwerte: Indikatorvariable `":variable:indvar"` + +### Iteratoren +1. Deklaration des Iterators `#sql public iterator WeinIter(String Name, String Weingut, int Jahrgang);` +2. Definition des Iteratorobjektes `WeinIter iter;` +3. Ausführung der Anweisung `#sql iter = { select Name, Weingut, Jahrgang from WEINE };` +4. Navigation + ```java + while (iter.next()) { + System.out.println(iter.Name() + " " iter.Weingut()); + } + ``` + +Dynamic SQL: SQL-Statements als zur Laufzeit konstruierte Strings +```java +exec sql begin declare section; + AnfrageString char(256) varying; +exec sql end declare section; +exec sql declare AnfrageObjekt statement; +AnfrageString = 'delete from WEINE where WeinID = 4711'; +... +exec sql prepare AnfrageObjekt from :AnfrageString; +exec sql execute AnfrageObjekt; +``` + +## LINQ +Language Integrated Query (LINQ) +- Einbettung einer DB-Sprache (SQL) in eine Programmiersprache (C#) +- spezielle Klassenmethoden + ```java + IEnumerable res = weine + .Where(w => w.Farbe == "Rot") + .Select(w => new { w.Name }); + ``` +- eigene Sprachkonstrukte (ab C# 3.0) + ```java + IEnumerable res = from w in weine + where w.Farbe == "Rot" + select new { w.Name }; + ``` + +## Objekt-relationales Mapping +- Einsatz von + - relationalen Backends (SQL-DBMS) + - objektrelationalen Anwendungen, Applikationsservern, Middleware, ... +- Implementierung von „Geschäftslogik“ in Form von Objekten (Kunde, Bestellung, Vorgang, ...) + - z.B. als Java Bean, CORBA-Objekt +- erfordert: Abbildung Klasse ↔ Relation +- Aspekte: + - konzeptionelle Abbildung + - Laufzeitunterstützung +- Technologien/Produkte: JDO, Hibernate, ADO.NET Entity Framework... + +![ORM Prinzip](Assets/Datenbanksysteme_ORM_Prinzip.png) + +Klassen und Tabellen +- OO: Klasse definiert Eigenschaften von Objekten (Intension) + umfasst Menge aller Objekte (Extension) +- RM: Relation umfasst alle Tupel, Relationenschema beschreibt Struktur +- naheliegend: Klasse = Tabelle +- aber: Normalisierung zerlegt Relationen! + - 1 Klasse = 1 Tabelle + - 1 Klasse = n Tabellen + - n Klassen = 1 Tabelle +- Beispiel ![Klassen und Tabellen Beispiel](Assets/Datenbanksysteme_Tabellenbeispiel.png) + +Beziehungen +- eingebetteter Fremdschlüssel in der Relation der Klasse, d.h. der Identifikator des assoziierten Objektes wird als Fremdschlüssel in zusätzlichen Spalten gespeichert +- Fremdschlüsseltabellen: die Beziehungsinstanz wird als Tupel mit den Schlüsseln der beteiligten Objekte repräsentiert +- Abbildung der in Beziehung stehenden Klassen auf eine einzelne Tabelle: Verletzung der Normalformen +- konkrete Abbildung + - 1:1-Beziehungen: eingebettete Fremdschlüssel + - 1:n-Beziehungen: eingebettete Fremdschlüssel oder Fremdschlüsseltabellen + - Beziehungen mit Attributen: Fremdschlüsseltabellen + - m:n-Beziehungen: Fremdschlüsseltabellen + - Drei- und mehrstellige Beziehungen: Fremdschlüsseltabellen +- ![Beziehungen](Assets/Datenbanksysteme_Beziehungen.png) + +Hibernate +- Java-Framework für objekt-relationales Mapping +- Idee: Abbildung von Java-Objekten auf Tupel einer relationalen Datenbank +- Prinzip: Java-Klasse + Abbildungsvorschrift ⇝ SQL-Tabelle +- keine expliziten SQL-Anweisungen nötig! +- Unterstützung der Navigation über Beziehungen (automatisches Nachladen der referenzierten Objekte) +- Anfragen über eigene Sprache (HQL bzw. QBC/QBE) +- Beispiel + ```java + public class Wein { + private int id; + private String name; + private String farbe; + private int jahr; + private String weingut; + + public void setName(String n) { name = n; } + public String getName() { return name; } + public void setFarbe(String f) { farbe = f; } + public String getFarbe() { return farbe; } + public void setJahr(int j) { jahr = j; } + public int getJahr() { return jahr; } + ... + } + ``` +- Deklaration der Abbildung in einer XML-Mapping-Datei +- Abbildungsvorschrift wird zur Systemlaufzeit interpretiert + ```xml + + + + + + + + + + + + ``` + +Objekterzeugung +```java +Transaction tx = null; + +Wein wein = new Wein(); +wein.setName("Pinot Noir"); +wein.setFarbe("Rot"); +wein.setJahr(1999); +wein.setWeingut("Helena"); + +try { + tx = session.beginTransaction(); + session.save(wein); + tx.commit(); +} catch (HibernateException exc) { + if (tx != null) tx.rollback(); +} +``` + +Anfragen +- Anfragen über Hibernate-eigene Anfragesprache HQL +- Formulierung auf dem konzeptuellen Schema (Java-Klassen) +- Select-Klausel nicht benötigt (Ergebnisse sind immer Objekte) +- Beispiel + ```java + Query query = session.createQuery("from Wein where Farbe = 'Rot'"); + Iterator iter = query.iterate(); + while (iter.hasNext()) { + Wein wein = (Wein) iter.next(); + ... + } + ``` + +## Prozedurale SQL-Erweiterungen: SQL/PSM +- SQL-Standard für prozedurale Erweiterungen +- PSM: Persistent Stored Modules + - gespeicherte Module aus Prozeduren und Funktionen + - Einzelroutinen + - Einbindung externer Routinen (implementiert in C, Java, ...) + - syntaktische Konstrukte für Schleifen, Bedingungen etc. + - Basis für Methodenimplementierung für objektrelationale Konzepte + +Vorteile gespeicherter Prozeduren +- bewährtes Strukturierungsmittel +- Angabe der Funktionen und Prozeduren erfolgt in der Datenbanksprache selbst; daher nur vom DBMS abhängig +- Optimierung durch DBMS möglich +- Ausführung der Prozeduren erfolgt vollständig unter Kontrolle des DBMS +- zentrale Kontrolle der Prozeduren ermöglicht eine redundanzfreie Darstellung relevanter Aspekte der Anwendungsfunktionalität +- Konzepte und Mechanismen der Rechtevergabe des DBMS können auf Prozeduren erweitert werden +- Prozeduren können in der Integritätssicherung verwendet werden (etwa als Aktionsteil von Triggern) + +Variablendeklaration +- Variablen vor Gebrauch deklarieren +- Angabe von Bezeichner und Datentyp +- optional mit Initialwert +```java +declare Preis float; +declare Name varchar(50); +declare Menge int default 0; +``` + +### Ablaufkontrolle +- Zuweisung `set var = 42;` +- Bedingte Verzweigungen + ```java + if Bedingung then Anweisungen + [ else Anweisungen ] end if; + ``` +- Schleifen + ```java + loop Anweisungen end loop; + while Bedingung do + Anweisungen end while; + repeat Anweisungen + until Bedingung end repeat; + ``` +- Schleifen mit Cursor + ```java + for SchleifenVariable as CursorName cursor for + CursorDeklaration + do + Anweisungen + end for; + ``` + +Ablaufkontrolle Beispiel: +```java +declare wliste varchar(500) default ' '; +declare pos integer default 0; + +for w as WeinCurs cursor for + select Name from WEINE where Weingut = 'Helena' +do + if pos > 0 then + set wliste = wliste || ',' || w.Name; + else + set wliste = w.Name; + end if; + set pos = pos + 1; +end for; +``` + +### Ausnahmebehandlung +- Auslösen einer Ausnahme (Condition) `signal ConditionName;` +- Deklarieren von Ausnahmen + ```java + declare fehlendes_weingut condition; + declare ungueltige_region + condition for sqlstate value '40123'; + ``` +- Ausnahmebehandlung + ```java + begin + declare exit handler for ConditionName + begin + -- Anweisungen zur Ausnahmebehandlung + end + -- Anweisungen, die Ausnahmen auslösen können + end + ``` + +### Funktionen +- Funktionsdefinition + ```java + create function geschmack (rz int) + returns varchar(20) + begin + return case + when rz <= 9 then 'Trocken' + when rz > 9 and rz <= 18 then 'Halbtrocken' + when rz > 18 and rz <= 45 then 'Lieblich' + else 'Süß' + end + end + ``` +- Aufruf innerhalb einer Anfrage + ```java + select Name, Weingut, geschmack(Restzucker) from WEINE + where Farbe = 'Rot' and geschmack(Restzucker) = 'Trocken' + ``` +- Nutzung außerhalb von Anfragen `set wein_geschmack = geschmack (12);` + +### Prozeduren +- Prozedurdefinition +```java +create procedure weinliste (in erz varchar(30), + out wliste varchar(500)) +begin + declare pos integer default 0; + for w as WeinCurs cursor for + select Name from WEINE where Weingut = erz + do + -- siehe Beispiel von Folie 12-40 + end for; +end; end; +``` + +Nutzung über call-Anweisung +```java +declare wliste varchar(500); +call weinliste ('Helena', wliste); +``` + +Zugriffscharakteristik +- Eigenschaften von Prozeduren, die Anfrageausführung und -optimierung beeinflussen + - **deterministic**: Routine liefert für gleiche Parameter gleiche Ergebnisse + - **no sql**: Routine enthält keine SQL-Anweisungen + - **contains sql**:Routine enthält SQL-Anweisungen (Standard für SQL-Routinen) + - **reads sql data**: Routine führt SQL-Anfragen (select-Anweisungen) aus + - **modifies sql data**: Routine, die DML-Anweisungen (insert, update, delete) enthält + +## Zusammenfassung +- Verbindung zwischen SQL und imperativen Sprachen +- Call-Level-Schnittstelle vs. Embedded SQL +- objektrelationales Mapping +- SQL/PSM: imperative Erweiterungen von SQL → Implementierung von Funktionen und Prozeduren \ No newline at end of file diff --git a/Einführung in die Neurowissenschaften.md b/Einführung in die Neurowissenschaften.md new file mode 100644 index 0000000..8fa161e --- /dev/null +++ b/Einführung in die Neurowissenschaften.md @@ -0,0 +1,864 @@ +Einführung in die Neurowissenschaft + +> Hinweis: Die Vorlesungsunterlagen dieses Seminars enthält insbesondere Bilder von Dritten, deren Copyright nicht beachtet wurde. Diese wurden entfernt. Vielen Dank für den Hinweis. Dadurch ist diese Zusammenfassung unvollständig und spiegelt nicht die Vorlesung wieder! +> Hilfreich: Für diese Vorlesung gibt es einen Fragenkatalog, der das notwendige Wissen wiederspiegelt. + + +Gliederung +1. Einführung +2. Mikroanatomische und physiologische Grundlagen +3. Aufbau des Zentralnervensystems Gehirn +4. Aufbau des Zentralnervensystems Rückenmark +5. Neurologische Erkrankungen und Hirnschäden +6. Sensomotorische Systeme +7. Visuelles System +8. Audiotorisches und vestibuläres System +9. Olfaktorisches, gustatorisches und neurohomronelles System +10. Neuroendokrinologisches und neurohormonelles System +11. Autonomes Nervensytem, Hunger/essen, Schlaf/zirkadiane Rythmen +12. Kognitive Funktionen: Gedächtnis/Emotionen +13. Kognitive Funktionen: Sprache +14. Psychatrische Störungen + + +# Einführung +## Was ist Neurowissenschaft? +Die Neurowissenschaft untersucht den Aufbau , die Funktion sowie die phylogenetische und ontogenetische Entwicklung des Nervensystems auf systemischer, zellulärer und molekularer Ebene. Damit sind die strukturellen Grundlagen und die physiologischen Mechanismen aller Leistungen des Nervensystems, einschließlich höherer kognitiver Funktionen, Gegenstand dieser Wissenschaft. + +Neurowissenschaft / die Neurowissenschaften +- Neuroanatomie: untersucht Struktur auf allen Ebenen +- Neurophysiologie: untersucht Funktion auf allen Ebenen +- Neurologie: untersucht Erkrankungen des Nervensystems +- Biopsychologie: untersucht biologische Basis psychologischer Prozesse + +(Das ist eine der möglichen Einteilungen!) +## Beziehung zu anderen Lehrveranstaltungen +- Anatomie & Physiologie + - Allgemeine biologische Grundlagen + - Berührungspunkte besonders beim endokrinologischen System, Bewegungsapparat und Verdauungssystem +- Neurobiologische Informationsverarbeitung + - Neuronen: Funktionsweise/Aufbau + - Neuronale Schaltkreise + - Neuronale Modelle +- Neuroinformatik + - Neuronale Modelle +- Bildgebung, Messtechnik + - Messung von neurobiologischen Signalen + +## Das Nervensystem im Gesamtorganismus +- Das Nervensystem ist ein Organsystem der höheren Tiere +- Es realisiert eine Grundeigenschaft des Lebens: die Reizbarkeit +- Information aus der Umwelt und aus dem Organismus wird verarbeitet und in Verhalten umgesetzt. + +## Das Nervensystem im Gesamtorganismus +- Das Nervensystem interagiert eng mit allen anderen Organsystemen +- Eine besondere Rolle spielt das Hormonsystem (endokrines System) +- ![](Assets/Neurowissenschaften-Nervensystem-gesamt.png) + +## Gliederung des Nervensystems +Zentrales Nervensystem (Gehirn und Rückenmark) +- $\leftrightarrow$ Peripheres Nervensystem + - $\leftrightarrow$ Senso-motorisches Nervensystem (Afferenzen und Efferenzen) + - $\leftrightarrow$ Umwelt + - $\leftrightarrow$ Autonomes Nervensystem (Afferenzen, symp. u. parasymp. Efferenzen) + - $\leftrightarrow$ Andere Organsysteme + +## Sensomotorisches Nervensystem +- Efferenzen - vom ZNS zu Muskeln und Drüsen +- Afferenzen - von Sinnesrezeptoren zum ZNS + +## Zellen +Neuronen (Nervenzellen) +- Azevedo et al. J. Comp. Neurol. 2009 + - im Hirn: $86*10^6$ + - im Cortex: $16*10^9$ +- Zellkörper mit Dendriten (Fortsätzen) $\rightarrow$ Integration von Information +- Axon/ Neurit (Nervenfaser) $\rightarrow$ Weiterleitung von Information +- Synapse $\rightarrow$ Übertragung von Information (elektrisch und chemisch) + +Glia (im Hirn Anzahl etwa gleich der Anzahl der Neuronen) +- Informationsverarbeitung und -weiterleitung, zusammen mit Neuronen +- Stütz-und Transportfunktion +- Stoffwechselfunktion, Versorgung der Neuronen +- Abwehr-und Immunfunktion +- Bildung von Markscheiden (Isolation der Axone) + +## Gewebe +Peripheres Nervensystem +- Ganglien, Plexus (Neuron. Zellkörper + Glia) +- Nerven (Nervenfasern + Glia) + +# Mikroanatomische und physiologische Grundlagen +## Zellen +- $75...100*10^{12}$ im Körper: Protoplasma, umgeben von Zellmembran +- Zusammenschluss zu Geweben und Organen + +1. Nucleolus +2. Zellkern + - enthält Erbinformation +3. Ribosomen + - Exprimierung der Erbinformation (Proteinsynthese) +4. Vesikel + - Speicherung und Transport von Substanzen (z.B. Proteine oder Neurotransmitter) +5. raues endoplasmatisches Reticulum + - vielfältige Aufgaben: Proteinsynthese, Ca-Speicherung, Enzym/Hormon-Bildung +6. Golgi-Apparat +7. Mikrotubuli +8. glattes endoplasmatisches Retikulum + - vielfältige Aufgaben: Proteinsynthese, Ca-Speicherung, Enzym/Hormon-Bildung +9. Mitochondrien + - erzeugen Energie (ADP $\rightarrow$ ATP) +10. Lysosom + - Aufspaltung von Polymeren (,,Verdauung'') +11. Zytosol + - Zellflüssigkeit +12. Peroxisom +13. Zentriolen + +## Zellen im Nervensystem +- Nervengewebe + - besteht aus Neuronen und Glia +- Neuronen + - erregbare Zellen + - verbunden durch Nervenfasern + - Kommunikation über Synapsen + - Informationstransfer elektrisch und chemisch + - Hirn: $86*10^9$ + - Cortex: $16*10^9$ + - Azevedo et al. J. Comp. Neurol. 2009; abweichend in Birbaumer/Schmidt +- Glia + - Stützung/Ernährung/Homöostase + - Bildung von Myelinscheiden + - Beiträge zur Informationsverarbeitung + - Hirn: $86*10^9$ + - Cortex: $61*10^9$ + +## Neuronen +### grundsätzlicher Aufbau +- Synapsen: Kontaktstellen zwischen Neuronen und anderen Neuronen oder Muskel/Drüsenzellen +- Zellmembran: Semipermeable Membran um das Neuron (Lipid-Doppelschicht - guter elektrischer Isolator) +- Axonshügel: Kegelförmiger Übergang zwischen Zellkörper und Axon +- Dendriten: Kurze, vom Zellkörper ausgehende Fortsätze, an denen die meiste synaptischen Impulsübertragungen von anderen Neuronen ankommen +- Axon: Langer dünner Fortsatz, der Information vom Neuron fortleitet +- Myelin: Lipidreiche Substanz, die viele Axone umgibt +- Ranviersche Schnürringe: Einschnürungen zwischen myelinisierten Abschnitten des Axons.Synapsen: Kontaktstellen zwischen Neuronen und anderen Neuronen oder Muskel/Drüsenzellen + +### morphologische Vielfalt +- Soma: $\oslash 5-100 \mu m$ +- Dendriten: Länge einige $100\mu m$ +- Axon: wenige $\mu m$ bis mehrere Meter. Kann stark verzweigt sein. + +### grundsätzliche Funktionsweise +- Membranruhepotential $~ -70 mV$ +- Synapsen setzen Neurotransmitter frei +- Neurotransmitter durchqueren synaptischen Spalt und erhöhen oder verringern Membranpotential + - $\rightarrow$ Postsynaptische Potentiale mit zeitl./räuml. Ausdehnung + - $\rightarrow$ räuml./zeitliche Integration von Input +- Bei Überschreitung einer Schwelle ($~ -65 mV$) am Axonshügel wird ein Aktionspotential ausgelöst +- AP pflanzt sich mit $0.3-100 m/s$ fort (aktive Übertragung) +- Wenn das AP eine Synapse erreicht, werden Neurotransmitter ausgeschüttet. + +### Membranpotential +- Intrazellulärer Raum: Erhöhte Konzentration von K+ (20...100fach) und organischen Anionen +- Extrazellulärer Raum: Erhöhte Konzentration von Na+ (5...15fach) und Cl-(20...100fach) +- Ionenpumpen: halten Konzentrationsgefälle aufrecht +- Ruhe-Membranpotential -55...-100 mV (je nach Zelltyp) + +### Ionenaustausch +1. Diffusion: Ionen, wie andere Teilchen auch, bewegen sich entlang des Konzentrationsgradienten + - Wenn die Membran für die jeweilige Ionenart durchlässig ist, bewegen sich K+ und A- aus der Zelle, sowie Na+ und Cl- in die Zelle +2. Elektrischer Ionenstrom: Ionen sind geladene Teilchen und bewegen sich entlang des Potentialgradienten + - Wenn die Membran für die jeweilige Ionenart durchlässig ist, bewegen sich K+ und Na+ in die Zelle, sowie Cl- und A- aus der Zelle +3. Aktiver Ionenaustausch: Ionen werden unter Energieverbrauch durch Ionenpumpen durch die Membran transportiert + - z.B. befördert die Natrium-Kalium-Pumpe unter ATP-Verbrauch K+ in die Zelle und Na+ heraus. + +1.+2.: durch Ionenkanäle - spezielle Eiweißmoleküle in der Membran, gesteuert durch elektrische oder metabolische Prozesse + +### Aktionspotential +1. Membranpotential wird angehoben. +2. Bei etwa $-50..-60$ mV öffnen die Natriumkanäle und Na+ strömt in die Zelle +3. Membranpotential steigt plötzlich auf $+20..30$ mV $\rightarrow$ Depolarisation +4. Nach ca. 1 ms schließen Natriumkanäle und Kaliumkanäle öffnen. K+ strömt aus der Zelle +5. Membranpotential fällt, zunächst unter das Ausgangsniveau $\rightarrow$ Re/Hyperpolarisation + +Wird das Membranpotential durch eine äußere Ursache über einen Schwellwert gehoben, regiert die Zelle mit einem kurzen nadelförmigen Impuls. + +- Aktionspotentiale sind (für den gleichen Zelltyp) immer gleich $\rightarrow$ Information ist in Impulsrate kodiert +- Maximale Impulsrate ist etwa 500 pro Sekunde. +- Refraktärzeit: Unerregbarkeit der Zellen nach Auslösung eines AP + - Absolute Refraktärzeit: totale Unerregbarkeit, ca. 2 ms. + - Relative Refraktärzeit: Auslösung verkleinerter APs, mehrere ms. + +## Axonale Erregungsfortleitung +unmyelinisierte Axone +1. Na+-Kanäle noch blockiert $\rightarrow$ kein neues Aktionspotential +2. Schwellwer überschritten $\rightarrow$ Na+ Kanäle öffnen, neues Aktionspotential + +Aktionspotentiale breiten sich entlang von Axonen, in der Regel vom Axonshügel zur Synapse, aus. +- Warum nicht über Soma und Dendriten? Na+ Kanäle gibt es in der Regel nur am Axonshügel und Axon. +- Warum nur in eine Richtung? Na+ haben eine Refraktärzeit, die das Zurücklaufen der Welle verhindert. +- Ausbreitungsgeschwindigkeit hängt quadratisch von der Axonsdicke ab: $\oslash 1 \mu m\rightarrow 1 m/s; \oslash 2 \mu m\rightarrow 4 m/s$ + +saltatorische Erregungsleitung +- Durchmesser des Axons: je größer der Durchmesser, desto schneller die Ausbreitung +- Umhüllung durch Myelinschicht (Markscheiden): Erregung springt von Schnürring zu Schnürring $\rightarrow$ Saltatorische Erregunsleitung +- Myelinscheide: verhindert Ionenaustausch (Schwann-Zelle im PNS, Oligodendrozyt im ZNS) +- ![](Assets/Neurowissenschaften-axon.png) + +## Myelinscheiden +- gebildet von Oligodendrozyten im Gehirn und Rückenmark und von Schwann-Zellen in der Peripherie +- markhaltige (10...120 m/sek) und marklose (0,3...3 m/sek) Fasern + +Klinik -> Multiple Sklerose: +- Abbau der Myelinschicht im ZNS +- Sensibilitätsstörungen, Muskelschwäche, Missempfindungen, Sehstörungen +- Ursachen unbekannt, wahrscheinlich Autoimmunerkrankung, Erbfaktor spielt eine Rolle +- befällt hauptsächlich Erwachsene zwischen 20 und 40 Jahren + +## Chemische Synapsen +![](Assets/Neurowissenschaften-chemische-synapsen.png) + +Erreicht ein AP den Endknopf, +- $Ca^{2+}$-Kanäle öffnen sich, $Ca^{2+}$ strömt in die Zelle +- Vesikel bewegen sich zur Membran und öffnen sich (Exocytose) +- Neurotransmitter werden ausgeschüttet, überqueren den synaptischen Spalt +- Neurotransmitter aktivieren Rezeptoren +- Ionenkanälen werden direkt oder indirekt beeinflusst. +- Beeinflussung des Membranpotentials (Postsynaptische Potentiale). +- Wiederaufnahme oder Abbau der Neurotransmitter + +Gerichteter Informationstransfer von Zelle zu Zelle $\rightarrow$ ,,Diodenfunktion'' + +Informationstransfer ist modifizierbar $\rightarrow$ ,,Transistorfunktion'' + +Verfügbarkeit, Aktivierbarkeit und Wiederaufnahme von Neurotransmittern, Blockierung von Neurorezeptoren, usw. + +präsynaptisch $\rightarrow$ Informationsfluss $\rightarrow$ postsynaptisch + +![](Assets/Neurowissenschaften-chemische-synapsen-verknüpfung.png) +- axo-dentritisch: enden auf dendritischen Dornen (spines);häufig +- axo-somatisch: häufig +- dendro-dentrisch: können Signale in beide Richtungen übertragen +- axo-axonisch: können präsynaptische Inhibition vermitteln + +## Ungerichtete Synapsen +Neurotransmittermoleküle werden diffus aus Erweiterungen entlang des Axons und seiner Verzweigungen freigesetzt. + +## Postsynaptisches Potential +$V(t)=\sum_s w_s*K_s(t) \otimes m_s(t)$ mit +- $V(t)$: Potential Axonshügel +- $w_s$: synaptisches Gewicht +- $K_s$: synaptische Antwort +- $m_s$: Impulsraten Synapsen +- $\sum$: räumliche Integration +- $\otimes$: zeitliche Integration + +Depolarisation +- Reiz senkt Potential ($-70$ auf $-67$) +- Feuerwahrscheinlichkeit $\uparrow$ + +Hyperpolarisation +- Reiz hebt Potential ($-70$ auf $-73$) +- Feuerwahrscheinlichkeit $\downarrow$ + +## Zeitliche und räumliche Integration +- Postsynaptische Potentiale sind abgestufte Antworten + - proportional zur Stärke des auslösenden Signals + - zwei simultane EPSPs addieren sich und rufen ein größeres EPSP hervor +- Postsynaptische Potentiale breiten sich passiv aus + - sehr schnell, werden bei der Ausbreitung abgeschwächt + - Einfluss von Synapsen hängt von Position ab + - zwei EPSPs, die in rascher Folge ausgelöst werden, addieren sich und rufen ein größeres EPSP hervor + +## Elektrische Synapsen +(gap junctions) + +- Direkter Ionenaustausch von Zelle zu Zelle +- Aus sogenannten Connexinen zusammengesetzt +- Porendurchmesser $< 2nm \rightarrow$ kleine Moleküle werden ausgetauscht +- Austausch von Ionen (elektrische Leitung) +- Austausch von ,,second messengers'' (z.B. $Ca^{2+}$ ) + +Räumlicher Aufbau +- Zytosol +- Membran +- Extrazell. Raum +- Membran +- Zytosol + +## Neurotransmitter +Neurotransmitter sind Substanzen, die an (chemischen) Synapsen ausgeschüttet werden und andere Zellen (Neuronen, Muskelzellen, etc.) spezifisch beeinflussen. + +Neurotransmitter ... +- werden in Neuronen synthetisiert +- liegen in der präsynaptischen Endknöpfen vor und werden in genügend großer Menge freigesetzt, um eine spezifische Wirkung hervorzurufen +- ... entfalten dieselbe Wirkung bei exogener Applikation der Substanz +- ... können durch einen spezifischen Mechanismus wieder entfernt werden + +![](Assets/Neurowissenschaften-neurotransmitter.png) + +## Neurorezeptoren +Ionotrope Rezeptoren +- Chemisch gesteuerte Ionenkanäle in der postsynaptischen Membran +- Bei Bindung öffnet oder schließt sich der Ionenkanal und induziert dadurch augenblicklich das postsynaptische Potential + +Metabotrope Rezeptoren +- Häufiger +- Wirkung langsamer und variabler +- Bindung des Neurotransmitter an G-Protein - Untereinheit löst sich im Zellinneren +- Bindet an Ionenkanal und löst AP aus, ... +- ... oder Synthese eines weiteren Botenstoffes (second messenger) + +## Die Catecholamine: Dopamin, Epinephrin, Norepinephrin +- sind Produkte eines gemeinsamen Biosyntheseweges (aus Tyrosin/Phenylanalin über L-Dopa) +- sind chemisch eng miteinander verwandt (gemeinsames Merkmal: Catecholring) +- ![](Assets/Neurowissenschaften-Catechol.png) + +## Das dopaminerge System +Dopamin: erregender oder hemmender Neurotransmitter + +Rezeptoren: D1+D5 erregend, D2-D4 hemmend + +Dopaminbahnen: +1. Nigro-striatales System: Projektionen von Substantia nigra zu Basalganglien (u.a. Nucleus caudatus) + - Bewegungsinitialisierung und -koordinierung (extrapyramidales System) + - Ausfall: Parkinson + - Überfunktion: Hyperkinese/ Hypertonus, z.B. Huntington +2. Mesolimbisches/mesocorticales System: Projektionen von ventralem Tegmentum zu höheren Hirnregionen, Großhirn und limbisches System + - Vermittlung von motivationell-emotionalen Einflüssen, Belohnung, Lernen und Gedächtnisbildung + - Überfunktion: Schizophrenie (?) +3. Tubero-hypophyseales System: Projektionen von Hypothalamus zu Hypophyse + - Hormonausschüttung + +## Das noradrenerge System +Norepinethrin/Noradrenalin: Neurotransmitter im ZNS u. Sympathikus + +Rezeptoren (=Adrenalin): $\alpha_1$ , $\alpha_2$ , $\beta_1$ , $\beta_2$ , $\beta_3$ (komplexe ,,second messenger'' Effekte) + +- noradrenerge Neuronen im Hirnstamm, besonders im Locus Caeruleus +- Projektionen auf sympatische Neurone im Rückenmark, sowie in Hypothalamus, Thalamus, Cerebellum, limbisches System und Cortex +- Aufmerksamkeitssteigerung, führt zu vermehrter Erregung, Angst, Vigilanz; sympathische Aktivität + +## Die Indolamine: Serotonin +- Auch 5-Hydroxytryptamin (5-HT) +- Ausgangssubstanz Tryptophan +- Wird auch über die Nahrung aufgenommen: Walnüssen, Bananen, Tomaten, Kakao etc. +- Chemisches Merkmal: Indol-Doppelring +- ![](Assets/Neurowissenschaften-serotonin.png) + +## Das serotonerge System +Serotonin: Neurotransmitter im gesamten Nervensystem + +Mindestens 14 verschiedene Rezeptoren - vielfältige Wirkungen im gesamten Nervensystem + +- überall im Körper, 95% im Magen-Darm-Trakt +- serotonerge Neuronen im Hirnstamm, in den Raphé-Kernen +- Projektionen ähnlich universell wie beim noradrenergen System +- Funktionen vielfältig, insbesondere allgemeine Stimmung + +## Aminosäuren: Glutamat, Aspartat, Glyzin, GABA +- Im Kontrast zu Acetylcholin und Aminen, die i.d.R. nur in bestimmten Neuronen hergestellt werden können, sind Aminosäuren universelle zelluläre Bestandteile +- gehören zu den wichtigsten und am weitesten verbreiteten Neurotransmittern im ZNS + +Glutamat: +- wichtigster erregender Neurotransmitter im ZNS, auch häufiger Nahrungsbestandteil +- ![](Assets/Neurowissenschaften-glutamat.png) + +Aspartat: +- erregender Neurotransmitter im ZNS, insbes. im Kleinhirn u. Hippocampus. Wirkt ähnlich wie Glutamat. +- ![](Assets/Neurowissenschaften-aspartat.png) + +Glycin: +- hemmender Neurotransmitter in Rückenmark und Hirnstamm +- ![](Assets/Neurowissenschaften-glycin.png) + +Gamma-Amino-Buttersäure (GABA): +- wichtigster hemmender Neurotransmitter im ZNS +- ![](Assets/Neurowissenschaften-gaba.png) + +## Acetylcholin +- Erregender Neurotransmitter im zentralen und peripheren Nervensystem +- Vielfältige Rezeptoren: muscarinische (metabotrop) und nicotinische (ionotrop) +- Signalübertragung zwischen Motorneuronen und Muskelzellen (in motorischen Endplatten) +- Signalübertragung im autonomen Nervensystem + +![](Assets/Neurowissenschaften-acetylocholin.png) + +- Muscarinische Rezeptoren + - metabotrop + - Untertypen: M1, M2, M3, M4, M5 + - weit verbreitet im Gehirn (besonders in verschiedenen Strukturen des Vorderhirns) + - Zielorgane des parasympathischen Systems +- Nicotinische Rezeptoren + - Ionotrop + - Muskelzellen + - sympathisches und parasympathisches Nervensystem + - Gehirn + - Rezeptoren an Muskelzellen und neuronale Rezeptoren sind pharmakologisch unterschiedlich + - Bsp: Rauchen: psychologische Effekte von Nicotin (im Gehirn) jedoch keine Muskelkontraktionen + +## Histamin +- Synthese aus der Aminosäure Histidin +- ![](Assets/Neurowissenschaften-histamin.png) + +## Neuroaktive Peptide +- große Zahl (mehr als 100) +- oft sowohl Hormon als auch Neurotransmitter +- Neuropeptide sind Spaltprodukte von größeren, inaktiven Vorstufen, diese werden im Zellkörper gebildet und anschließend zum Axonterminal transportiert + +## Neurotransmitter - Übersicht +| Neurotransmitter | Postsynaptischer Effekt | Vorläufer | +| ---------------- | ------------------------------- | ----------------- | +| Acetylcholin | Exzitatorisch | Cholin+Azetyl-CoA | +| Glutamat | Exzitatorisch | Glutamin | +| GABA | Inhibitorisch | Glutamat | +| Glyzin | Inhibitorisch | Serin | +| Catecholamine | Exzitatorisch | Tyrosin | +| Serotonin (5-HT) | Exzitatorisch | Tryptophan | +| Histamin | Exzitatorisch | Histidin | +| Neuropeptide | Exzitatorisch und Inhibitorisch | Aminosäuren | + +## Psychopharmaka, Neurotoxine und Drogen +Substanzen beeinflussen synaptische Übertragung + +- Agonisten + - Erleichtern die Aktivierung der Synapsen eines bestimmten Neurotransmitters +- Antagonisten + - Hemmen die Aktivierung der Synapsen eines bestimmten Neurotransmitters + +### Wirkmechanismen Agonisten +1. Neurotransmitter Synthese $\uparrow$ (z.B. durch Erhöhung der Menge von Vorläufersubstanzen) +2. Neurotransmitter Menge $\uparrow$ durch Zerstörung abbauender Enzyme +3. Steigerung der Neurotransmitter-Freisetzung +4. Bindung an, und damit Blockierung von, Autorezeptoren +5. Blockierung von Abbau oder Wiederaufnahme von Neurotransmitter +6. Bindung an und Aktivierung von postsynaptischen Rezeptoren + +### Wirkmechanismen Antagonisten +1. Neurotransmitter Synthese $\downarrow$ (z.B. durch Zerstörung synthetisierender Enzyme) +2. Austreten von Neurotransmitter aus Vesikeln, was zur Zerstörung durch Enzyme führt +3. Blockierung der Neurotransmitter-Freisetzung +4. Aktivierung von Autorezeptoren +5. Bindung an, und Blockierung von, postsynaptischen Rezeptoren + +### Beispiel: Psychopharmaka +Monoaminoxidase (MAO)-Hemmer zur Behandlung affektiver Störungen (Depression) +- Phenelzin, Tranylcypromin, Isocarboxazid +- Wirkprinzip + - MAO zerstört Neurotransmitter außerhalb der Vesikel. + - Durch MAO-Hemmung werden akut die Mengen an Noradrenalin, Dopamin und Serotonin erhöht. +- Erst durch adaptive Veränderungen in der Rezeptordichte und der Second-Messenger-Kette wird der klinische Effekt erreicht. + +### Beispiel: Neurotoxine +Atropin - Muskarinantagonist + +z.B. Atropa belladonna (Tollkirsche) + +- Mittelalter + - beliebtes Gift in der Politik und bei Familienintrigen + - Kosmetik: Erweiterung der Pupillen +- Moderne + - Augenarzt: Erweiterung der Pupillen, um das Innere der Augen besser sehen zu können + - Gegengift für cholinerge Agonisten + - Kreislaufstillstand oder Bradykardie + +- Symptome - Blockierung Parasympathicus + - Herzrasen, Bronchienerweiterung + - Pupillenweitung + - Hemmung Magen/Darmtätigkeit + +blockiert M1-3 Acetylcholin-Rezeptoren + +### Beispiel: Drogen +Cocain - Monoamin-Wiederaufnahmehemmer + +verstärkt Dopamin-, Norepinephrin- und Serotoninaktivität + +Wirkung +- Euphorie, gesteigerte Leistungsfähigkeit +- Unterdrückung Hunger u. Müdigkeit +- in hohen Dosen: Angst, Paranoia +- Lokalanästhetikum + +Gefährlichkeit +- zweitstärkstes Abhängigkeitspotential und physischer Schaden nach Heroin (Nutt et al., The Lancet 2007) +- durch schnelle Abfolge von Euphorie und Depression hohes Potential zu psychischer Abhängigkeit + +Erythroxylum coca +- erstmalig isoliert in der Mitte des 19. Jahrhunderts +- Bis 1906 250mg/l in Coca-Cola (das sind 2-4 Dosen) + + +## Glia-Zellen im Zentralnervensystem +- Vielfältige Funktion: Stützung (,,Bindegewebe''), Ernährung. Homöostase, Myelinbildung, Informationsverarbeitung, etc. +- stellen die Hälfte der Hirnzellen und 80% der Cortexzellen + +Microgliozyten (Hortega-Zellen) +- sehr vielfältige Formen +- Amöboid beweglich +- Abräum- und Abwehrfunktion + +Astrozyten +- kurzstrahlige Astrozyten in grauer Substanz +- Langstrahlige (fasrige) Astrozyten in weißer Substanz +- Gliafüßchen bilden geschlossene Schicht um Kapillaren +- Kontrolle Ionen- und Flüssigkeitsgleichgewicht +- Stütz- und Transportfunktion +- Abgrenzungsfunktion: um Kapillaren: Blut-Hirn-Schranke an Hirnoberfläche, Synapsen u. Ranvierschen Knoten +- Sind teilungsfähig und bilden Glianarben + +Ependymzellen +- Auskleidung Hirnventrikel und Rückenmarkskanal + +Oligodendrogliozyten +- eng an Neuronen angelagert +- Stoffwechelfunktion für Neuronen +- Bilden Markscheide für ZNS-Neuronen + +Schwann-Zelle +- Eng an Neuronen angelagert +- Stoffwechselfunktion für Neuronen +- Bilden Markscheide für PNS Neuron +- Beteiligt an Nervenregeneration + +Periphere Nerven +- ![2004-2005 B. Schwaller, Departementde Médecine, Division d'Histologie de l'Université de Fribourg , Pérolles, CH-1705 Fribourg, Suisse](Assets/Neurowissenschaften-periphere-nerven-2.png) + 1. Nervenfaszikel + 2. Epineurum + 3. Perineurum + 4. Nervenfasern mit Endoneurum +- ![2004-2005 B. Schwaller, Departementde Médecine, Division d'Histologie de l'Université de Fribourg , Pérolles, CH-1705 Fribourg, Suisse](Assets/Neurowissenschaften-periphere-nerven-3.png) + 1. Zellkern der Schwann Zelle + 2. Neurofilamente + 3. Mikrotubuli + 4. Myelinscheide + 5. Axon + 6. Basalmembran + +## Synaptische Verbindung zu Effektoren +Motorische Endplatten: Chemische Synapsen, arbeiten mit Acetylcholin, verbinden Neuronen und Muskelfasern. +- ionotrop: $Ca^{2+}$ , K+, Na+ +- Depolarisation +- $\rightarrow$ Aktionspot. in Muskelzelle +- $\rightarrow$ $Ca^{2+}$ -Einstrom +- $\rightarrow$ Kontraktion + +# Zentralnervensystem - Gehirn +## Orientierung im Nervensystem +![](Assets/Neurowissenschaften-orientierung-1.png) + +![](Assets/Neurowissenschaften-orientierung-2.png) + +## Gliederung des Gehirns +Verbindungen zur Außenwelt +- 12 Hirnnervenpaare +- über Rückenmark zum Rest des Körpers + +## Hirnnerven +- Telencephalon + - (I) N. olfactorius (sensorisch: Riechen) +- Diencephalon + - (II) N. opticus (sensorisch: Sehen) +- Mesencephalon + - (III) N. oculomotorius (motorisch: Augenmuskeln, Augenlid, Linse, Pupille) + - (IV) N. trochlearis (motorisch: Augenmuskeln) +- Metencephalon (Pons) + - (V) N. trigenimus (sensorisch: Gesicht, Nase, Mund, Zunge u.a.; motorisch: Kauen) + - (VI) N. abducens (motorisch: Augenmuskeln) + - (VII) N. facialis (sensorisch: Geschmack; motorisch: Speicheldrüsen, Mimik) +- Myencephalon (Medulla oblongata) + - (VIII) N. vestibulocochlearis (sensorisch: Gleichgewicht, Hören) + - (IX) N. glossopharyngeus (sensorisch: Geschmack, Mittelohr, Rachen (Schluckreflex) u.ä.; motorisch: Speichelfluss) + - (X) N. vagus (motorisch (parasympathisch): Eingeweide; motorisch: Kehlkopf und Rachen; sensorisch: Kehlkopf, Rachen, Eingeweide) + - (XI) N. accessorius(motorisch: Nackenmuskeln) + - (XII) N. hypoglossus (motorisch: Zunge) + +### Medulla oblongata (Myencephalon) +- enthält auf- und absteigende Faserbahnen +- Kerne der Hirnnerven VIII-XII (z.B. VIII- Hörnerv, X - Vagusnerv) +- Atem- und Kreislaufzentrum + - Erhöhung des intrakranialen Drucks (z.B. durch Blutungen oder Tumore) kann die Medulla komprimieren und zu Koma oder Tod führen! + - Menschen können nur mit der Medulla, ohne restliches Gehirn, weiterleben (tiefes Koma, Teilhirntod). +- Zentren für Nies-, Husten-, Schluck-, Saug- und Brechreflexe +- Formatio reticularis + +### Retikuläre Formation (Formatio reticularis) +- Die F. reticularis zieht sich durch Medulla, Pons und Mesencephalon/Diencephalon). +- Netzartige Struktur von Nervenbahnen und Gruppen von diffusen Kernen. +- Lebenswichtige Funktionen, wie Atmung, Kreislauf, Muskeltonus +- Abgrenzbare Kerne: Raphe-Kerne (serotonerges System) und Locus caeruleus (noradrenerges System). +- zeitlichen Koordinierung des gesamten Nervensystems +- Modulation von Schmerzempfinden und Emotionen, Schlaf-Wach-Rhythmus, Aufmerksamkeit + +### Pons (Brücke) - Teil des Metencephalons +- enthält auf- und absteigende Faserbahnen, die End- und Zwischenhirn mit Cerebellum, Medulla und Rückenmark verbinden +- Kerne der Hirnnerven V-VII (z.B. V - Trigenimus) +- bildet zusammen mit Cerebellum das Metencephalon, ist von diesem durch das IV Ventrikel getrennt +- retikuläre Formation + +### Cerebellum (Kleinhirn) - Teil des Metencephalons +- bildet zusammen mit Pons das Metencephalon, ist von diesem durch das IV Ventrikel getrennt +- Funktion: Steuerung der Motorik (Koordination, Feinabstimmung, unbewusste Planung); Erlernen von Bewegungsabläufen; kognitive Funktionen. + +Cerebellarer Cortex +- enthält ca. 50% aller zentralen Neuronen +- fein gefältelt +- ca. 0.5 mm dick, +- Fläche 500 cm² $\approx$ 50 - 75% der Cortexfläche + +Kleinhirnstiele und Marklager +- enthält Nervenfasern +- fein verzweigt +- Im Marklager, auf jeder Seite 4 Kerne (Nuclei) + +Cerebellarer Cortex (Kleinhirnrinde) +- 3 Schichten + - Molekulare Schicht + - Purkinjezellschicht + - Granuläre (Körner-)Schicht + +Zellen und Verschaltung +- Purkinje-Zellen - Zellen mit dem meisten Input (bis 200 000) +- Körner-Zellen: kleinste und häufigste Neurone im Gehirn ($\frac{3}{4}$ aller Neurone) + - Kletterfaser: aus unterer Olive (Medulla) + - Moosfaser: aus Rückenmark und Hirnstamm + +Funktionsprinzipien +- **Feedforward-Verarbeitung:** + - Keine Rückkopplungsschleifen + - Output-Signale werden aus Input-Signalen kombiniert + - Keine intrinsische dynamische Aktivität +- **Divergenz und Konvergenz:** + - Input wird zunächst expandiert (Parallelfasern) und dann konvergiert (Purkinje-Zellen) + - Dadurch ergeben sich sehr viele Freiheitsgrade bei der Rekombination +- **Modularität:** + - Es gibt viele ähnliche Module (,,Rekombinationsmatrizen'') mit unterschiedlichem In- und Output +- **Plastizität:** Synapsen (und damit die ,,Rekombinationsmatrizen'') + - sind adjustierbar, sowohl vorübergehend, z.B. durch dopaminerge, serotonerge oder noradrenerge Beeinflussung, als auch dauerhaft (durch Hebb‘sches Lernen, vielleicht mit Hilfe der Kletterfasern) + +Funktion +- Lernen + - Implizites Lernen / prozedurales Gedächtnis: in der Übertragungsmatrix des Kleinhirns werden die Details automatisierter Bewegungsabläufe gespeichert, die nicht mehr durch die Willkürmotorik (Großhirn) explizit festgelegt werden müssen. + - Assoziatives Lernen: bestimmte sensorische Eindrücke werden mit bestimmtem motorischem Output verbunden (z.B. Lidschlußreflex). +- Kognition + - Genaue Funktion unklar, aber Beteiligung an, zum Beispiel, Sprachverstehen und Sprechen wird vermutet. + +Störungen +- Meist Ataxien, d.h. Störungen in der Bewegungskoordination. +- Nystagmus (Augenzittern), +- Rumpfataxie (Unfähigkeit sich im Stehen oder Sitzen aufrecht zu halten), +- Gangataxie (,,Betrunkenengang''), +- Dysmetrie (Hand erreicht nicht das Ziel beim Greifen etc.), +- Tremor, +- verwaschene oder undeutliche Aussprache, +- Störungen im fließenden Bewegungsablauf. + +### Mesencephalon (Mittelhirn) +- Wichtige Rolle im auditorischen, visuellen sowie extrapyramidalen motorischen System. +- enthält auf- und absteigende Faserbahnen, die End- und Zwischenhirn mit Cerebellum, Medulla und Rückenmark verbinden +- Kerne der Hirnnerven III und IV (Augenbewegungen) +- retikuläre Formation + +Tectum (Mittelhirndach, Vierhügelplatte) + +Colliculi superiores +- Teil der Sehbahn +- steuern optische Reflexe + +Colliculi inferiores +- Teil der Hörbahn + +Tegmentum (Mittelhirnhaube) +- Nucleus ruber (roter Kern) + - Teil des extrapyramidalen motorischen Systems + - steuern Muskeltonus und Körperhaltung +- Kern der Hirnnerven III und IV +- Aquädukt + - Teil des Ventrikelsystems +- Periaquäduktales Grau + - Steuerung von Emotionen +- Substantia nigra + - Teil des extrapyramidalen motorischen Systems + - wichtiger Teil des Dopaminsystems +- retikuläre Formation, diverse auf- und absteigende Fasertrakte + +### Diencephalon (Zwischenhirn) +- Umschließt 3. Ventrikel, im Zentrum des Gehirns +- Sensorisches Zentrum, Ursprung II. Hirnnerv (N. opticus) +- besteht aus: + - Thalamus (größter Teil) + - Epithalamus + - Subthalamus + - Hypothalamus + - Metathalamus + +#### Thalamus +- ,,Eingangskontrolle'' des Großhirns - Umschaltstation sensorischer Information +- Besteht aus spezifischen und unspezifischen Kernen (Unterscheidung nicht immer eindeutig) +- Spezifische Kerne: sind jeweils mit einem abgrenzbaren Bereich der Großhirnrinde verbunden und übertragen sensorische und motorische (aus Basalganglien und Kleinhirn) Information an das Großhirn +- Unspezifische Kerne: modulieren spezifische Thalamuskerne, werden ihrerseits aus den Basalganglien, dem Kleinhirn und der retikulären Formation angesteuert. Wichtigster: N. reticularis +- ca. Form und Größe einer Walnuss + +Funktion +- Durchgangsstation für (fast) alle Information, die die Großhirnrinde erreicht +- Modulation und ,,Gating'' dieser Information in Abhängigkeit von allgemeinen Bedingungen, wie z.B. Aufmerksamkeit +- Modulation und ,,Gating'' kann Information aus der Peripherie (,,first oder relay'') oder aus anderen Großhirnarealen (,,higher order relay'') betreffen. + +#### Hypothalamus +- Lage: unterhalb des Thalamus zwischen den Großhirnhälften + - 2 Hälften, geteilt durch 3. Ventrikel +- sehr sichere Blutversorgung - kaum Schlaganfälle + +Funktionen +- Regelung der Körpertemperatur (Versuchstiere können nach Zerstörung des Hypothalamus die Körpertemperatur nicht mehr halten) +- Regelung des Wasser- und Mineralhaushaltes +- Regelung der Hormonausschüttung der Hypophyse +- Regelung der physiologischen Reaktion auf Erregungszustände (z.B. Erröten, Schweißausbruch, Herzklopfen) +- Appetitregelung (Läsion des Hypothalamus kann sowohl zu Appetitlosigkeit, als auch zu unstillbarem Appetit führen; Appetitszügler wirken hier) +- Steuerung von Schlaf und zirkadianen Rhythmen +- Beeinflussung von Sexualverhalten, Aggression, Flucht usw + +Der Hypothalamus ist das oberste Regulierungszentrum des ANS + +#### Metathalamus +Mediale Kniehöcker +- 4. Neuron der Sehbahn (Input von der Retina) +- $\rightarrow$ Auditorisches System + +Laterale Kniehöcker +- 4. Neuron der Hörbahn (Input vom Colliculus inf.) +- $\rightarrow$ Visuelles System + +### Endhirn (Telencephalon, Großhirn) +- Im Menschen: größter Hirnabschnitt +- Verantwortlich für die komplexesten Funktionen: + - Willkürmotorik + - Sensorik + - Entscheidungsfindung + - Sprache + - Gedächtnis + - Emotionen + - usw. +- Besteht aus: + - Großhirnhälften (stark gefurcht und durch Kommisuren verbunden) + - Basalganglien (Stammganglien) + +#### Großhirnhälften +- Sulci (Furchen) und Gyri (Windungen) +- Große Sulci/Gyri in allen Gehirnen wiedererkennbar, aber variabel +- Kleine Strukturen sehr variabel +- Grobe Einteilungen in 4 Lappen (Lobi) je Hemisphäre +- Beide Großhirnhälften sind durch Querbahnen (Kommissuren) verbunden: + - Corpus Callosum (Balken) + - Commisura anterior + - Commisura fornicis + + +#### Cerebraler Cortex (Großhirnrinde) +- bildet die Oberfläche der Großhirnhälften +- Beim Menschen stark gefaltet (gyrenzephales Gehirn) + - andere gyrenzephale Hirne: die meisten Säuger, z.B. Schwein, Schaf, Pferd, Wal + - nicht gefaltete (lissenzephale) Hirne z.B. bei Nagern und Vögeln +- enthält Zellkörper von Nervenzellen, daneben kurze Axone und Gliazellen +- Oberfläche beim Menschen: ca. $1800 cm^2$ +- Nach histologischem (d.h. zellarchitektonischem) Feinbau Unterscheidung **Allocortex** (3 Schichten) und **Isocortex** (6 Schichten) +- Entwicklungsgeschichtlich einteilbar in **Paläocortex** , **Archicortex** und **Neocortex** + +#### Der Neocortex +- Cortex allgemein kann in Schichten untergliedert werden, die durch Art und Anzahl von Zellkörpern definiert sind. +- Der (phylogenetisch junge) Neocortex ist als Isocortex aufgebaut, d.h. er hat 6 abgrenzbare Schichten. +- Die Ausprägung der Schichten variiert zwischen Hirnarealen ($\rightarrow$ Parzellierung) +- 90 % der Großhirnoberfläche ist Neo- bzw. Isocortex + +#### Archi- und Paläocortex +- ![Helmer & van Hoesen, Neuroscience & Biobehavioural Reviews, 2006](Assets/Neurowissenschaften-archicortex.png) +- Aufgebaut als Allocortex, d.h. 3-schichtig +- Paläocortex (ältester Teil): dunkelgrün +- Archicortex (jüngerer Teil): blau/lila +- Übergangszonen zum Neocortex: hellgrün +- Amygdala: orange + +#### Cortex-Parzellierung +- Die corticale Struktur spiegelt funktionelle Spezialisierung wider +- Struktur ist gekennzeichnet durch Anordnung und Dichte verschiedener Zelltypen (Zytoarchitektur), Verteilung myelinisierter Faserbahnen (Myeloarchitektur), Verbundenheit (Konnektivität) mit entfernten Teilen des Gehirns, Vorkommen und Verteilung von Neurotransmittern, Neurorezeptoren und anderen Stoffen, und vieles andere mehr +- Oftmals lassen sich Gebiete (Areale) auf dem Cortex definieren, die strukturell und funktionell relativ homogen und durch scharfe Grenzen voneinander geschieden sind $\rightarrow$ **Parzellierung** +- Es gibt verschiedene Ebenen der Parzellierung, die zueinander in (evt. hierarchischer) Beziehung stehen. + +### Die Basalganglien (Stammganglien) +- Nucleus caudatus +- Putamen +- Globus pallidus +- Amygdala (Mandelkern) + +Wichtig für das Ausführen von Willkürbewegungen (extra-pyramidales motorisches System) zusammen mit Diencepahlon und Mittelhirn + +### Der Hippocampus +- über Fornix (Faserbündel) mit Corpus mammilare des Hyptothalamus verbunden +- Grenzt rostral an Amygdala und ventral an entorhinalen Cortex +- Verbindung mit Temporallappen, G. parahioopcamalis, cingulärem Cortex, Amygdala, Hypothalamus, Thalamus und Hirnstamm + +### Die Amygdala (Mandelkern) +- Input von Riechhirn, Temporrallappen, cuingulärem Cortex, Hyptothalamus, Thalamus, Hirnstamm +- Output zum Hyptothalamus, Thalamus, Frontallappen, Hirnstamm +- Wichtige Rolle bei Emotionen, insbesondere Angst und Furcht + +### Die weiße Masse (Marklager) +- Enthält Nervenfasern und Glia +- Assoziationsfasern verbinden Areale derselben Hemisphäre: U-Fasern, kurze Assoziationsfasern, lange Assoziationsfasern (zwischen Lappen) +- Projektionsfasern verbinden den Cortex mit anderen Strukturen, wie Hirnstamm, Basalganglien oder Rückenmark. +- Kommissuren verbinden beide Hemisphären (z.B. Corpus callosum) + +## Hirnhäute +- Skalp +- Schädel +- Hirnhaut 1: Dura mater +- Hirnhaut 2: Arachnoidea +- Subarachnoidalraum (mit Cerebrospinalflüssigkeit und Blutgefäßen) +- Hirnhaut 3: Pia mater (überzieht Oberfläche von Hirn und Rückenmark) +- Gehirn Oberfläche (Kortex) + +Hirnhäute: Meningen + +### Hirnhautentzündung (Meningitis) +- meist Entzündung der Arachnoidea und der Pia mater (Leptomeningitis) +- kann durch Bakterien, Viren oder physikalische Einwirkungen (z.B. radioaktive Strahlung) hervorgerufen werden +- Symptome/Diagnose: Fieber, Übelkeit, Verwirrtheit, schmerzreflektorische Nackenmuskelversteifung beim Versuch den Kopf nach vorn zu beugen, daneben natürlich Liquoruntersuchung + +### Blutversorgung des Gehirns +Zufuhr über +- innere Halsschlagader (A. carotis) + - Blutversorgung des Auges + - Versorgung der vorderen und mittleren Hirnarterie (A. cerebri anterior/media) (je 2x) +- Wirbelschlagader (A. vertebralis) (je 2x) + - A. basilaris (nur 1x) + - Blutversorgung von Hirnstamm und Kleinhirn + - Versorgung der hinteren Hirnarterie (A. cerebri posterior) (2x) + +- Versorgungsgebiete der vorderen (blau), mittleren (rot) und hinteren (gelb) Hirnarterien. +- Die 6 Hirnarterien sind an der Hirnbasis durch einen Ring verbunden, dadurch kann ein Verschluss einer der 4 zuführenden Arterien ausgeglichen werden + +Venöse Abfluss +- Venen erreichen Hirnoberfläche und Subarachnoidalraum +- Über Brückenvenen in venöse Sinus (blutgefüllte Räume in der Dura mater) +- Abfluss über Vv. jugulares internae + +## Das Ventrikelsystem +Der Liquor zirkuliert in den 4 Hirnventrikeln und dem Zentralkanal des Rückenmarks sowie im Subarachnoidalraum von Hirn und Rückenmark + +Seitenventrikel +- III. Ventrikel (im Diencephalon) +- Aquädukt (im Mesencephalon) +- IV. Ventrikel (im Hirnstamm) +- Zentralkanal (Rückenmark) + +der Liquor (Nervenwasser) +- Gesamtvolumen: 130-150 ml +- Wird in den Ventrikeln (durch Kapillargeflechte der Pia mater) mit einer Rate von ca. 30 ml/h gebildet. +- Resorption über Arachnoidalzotten im Sinus sagittalis superior ins venöse Blut. + +Hydrozephalus +- bei Kleinkindern: durch angeborene Fehlbildung oder Enzaphalitis kann der Liquor nicht abfließen $\rightarrow$ das Gehirn wird komprimiert und Schädelknochen geweitet +- Therapie: Verbindung zwischen Ventrikel und Subarachnoidalraum durch Katheter +- Diagnosemethode: Lumbalpunktion +- Liquor wird zwischen 3 und 5 Lendenwirkel entnommen (dort ist kein Rückenmark mehr) +- Untersuchung des Nervenwassers auf Leukozyten, Erythozyten oder Bakterien sowie bestimmten Substanzen \ No newline at end of file diff --git a/Grundlagen der Biosignalverarbeitung.md b/Grundlagen der Biosignalverarbeitung.md new file mode 100644 index 0000000..9f03c61 --- /dev/null +++ b/Grundlagen der Biosignalverarbeitung.md @@ -0,0 +1,1197 @@ +Biosignalverarbeitung +- [Sensorik](#sensorik) + - [Klassifikation von Sensoren](#klassifikation-von-sensoren) + - [Druck, Dehnung und Kraft](#druck-dehnung-und-kraft) + - [Durchfluss, Volumen](#durchfluss-volumen) + - [Optische Sensoren](#optische-sensoren) + - [Akustische Sensoren](#akustische-sensoren) + - [Sensoren für elektrische Größen](#sensoren-für-elektrische-größen) + - [Elektrochemische Grundlagen](#elektrochemische-grundlagen) + - [Elektroden der Diagnostik](#elektroden-der-diagnostik) + - [Elektroden der Therapie](#elektroden-der-therapie) + - [Sensoren für magnetische Größen](#sensoren-für-magnetische-größen) + - [Messprinzipien](#messprinzipien) + - [Gradiometer](#gradiometer) + - [SQUID](#squid) +- [Verstärkung und analoge Filterung](#verstärkung-und-analoge-filterung) + - [Eigenschaften von Biosignalen und Störungen](#eigenschaften-von-biosignalen-und-störungen) + - [Entstehung der Biosignale, biologische Signalquellen](#entstehung-der-biosignale-biologische-signalquellen) + - [Biologische und technische Störquellen](#biologische-und-technische-störquellen) + - [Eigenschaften technischer Störungen](#eigenschaften-technischer-störungen) + - [Eigenschaften biologischer Störungen](#eigenschaften-biologischer-störungen) + - [Medizinische Messverstärker](#medizinische-messverstärker) + - [Dynamik, Linearität](#dynamik-linearität) + - [Eigenrauschen](#eigenrauschen) + - [Frequenzgang](#frequenzgang) + - [Differenzverstärker](#differenzverstärker) + - [Funktionsprinzip](#funktionsprinzip) + - [Differenz- und Gleichtaktverhalten](#differenz--und-gleichtaktverhalten) + - [Instrumentationsverstärker](#instrumentationsverstärker) + - [Mehrstufiger Verstärker](#mehrstufiger-verstärker) + - [Hoher Eingangswiderstand](#hoher-eingangswiderstand) + - [Hohe Gleichtaktunterdrückung](#hohe-gleichtaktunterdrückung) + - [Isolationsverstärker](#isolationsverstärker) + - [Funktionsprinzip](#funktionsprinzip-1) + - [Galvanische Trennung und ihre Auswirkung](#galvanische-trennung-und-ihre-auswirkung) + - [Datenübertragung, Modulation und Demodulation](#datenübertragung-modulation-und-demodulation) + - [Guardingtechnik](#guardingtechnik) + - [Funktionsprinzip](#funktionsprinzip-2) + - [Realisierung](#realisierung) + - [Aktive Elektroden](#aktive-elektroden) + - [Funktionsprinzip](#funktionsprinzip-3) + - [Störungsresistenz](#störungsresistenz) + - [Gleichtaktunterdrückung](#gleichtaktunterdrückung) + - [Analoge Filter](#analoge-filter) + - [Passive Filter](#passive-filter) + - [Grundlagen der Filtertheorie](#grundlagen-der-filtertheorie) + - [Filterentwurf](#filterentwurf) + - [Aktive Filter](#aktive-filter) + - [Linearer Phasenfrequenzgang](#linearer-phasenfrequenzgang) +- [Signalkonditionierung, Abtastung und Digitalisierung](#signalkonditionierung-abtastung-und-digitalisierung) + - [Pegelanpassung](#pegelanpassung) + - [Abstastung, Aliasing](#abstastung-aliasing) + - [Digitalisierung](#digitalisierung) + - [Prinzipien der AD Wandlung](#prinzipien-der-ad-wandlung) + - [Breitbandige Wandler](#breitbandige-wandler) + - [Telemetrie](#telemetrie) + - [Analoge Übertragung](#analoge-übertragung) + - [Digitale Übertragung](#digitale-übertragung) +- [Digitale Filterung](#digitale-filterung) + - [IIR-Filter](#iir-filter) + - [FIR-Filter](#fir-filter) + - [Realisierung digitaler Filter - FIR](#realisierung-digitaler-filter---fir) + - [Realisierung digitaler Filter - programm](#realisierung-digitaler-filter---programm) + - [Realisierung digitaler Filter - DSP](#realisierung-digitaler-filter---dsp) + - [CAD digitaler Filter](#cad-digitaler-filter) + - [Adaptive Filter](#adaptive-filter) + +# Sensorik +Im Normalfall werden Sensoren verwendet, die eine physikalische oder chemische Größe in ein elektrisches Signal umwandeln bzw. eine elektrische Größe beeinflussen, die weiter verarbeitet werden können. Eine Umwandlung der Energieform der Biosignale ist notwendig. Selbst bei Sensoren für elektrische Größen ist eine Umwandlung (von Ionenleitung zur Elektronenleitung) nötig. + +Weitere Sensorengruppen, wie Temperatur-und chemische Sensoren werden hier nicht behandelt, da ihre Dynamik aus Sicht der BSA vernachlässigbar gering ist. + +## Klassifikation von Sensoren +Ein Sensor (lateinisch 'sensus': Gefühl) oder Fühler ist ein technisches Bauteil, das die physikalischen oder chemischen Eigenschaften (z.B. Wärmestrahlung, Temperatur, Feuchtigkeit, Druck, Schall, Helligkeit, Magnetismus, Beschleunigung, Kraft, elektrisches Potential) erfassen und in ein elektronisches oder ein anderes geeignetes Signal umwandeln kann. + +Man unterscheidet zwischen aktiven und passiven Sensoren +- Aktiver Sensor: gibt eine Spannung oder einen Strom ab, wobei er für seine Funktion elektrische Energie benötigt oder eine Energieart in die elektrische umwandelt. Er wirkt wie eine elektrische Signalquelle (z.B. Phototransistor) +- Passiver Sensor: ändert elekttrische Größen (z.B. den Widerstand des Dehnmessstreifens in Abhängigkeit von der Dehnung) ohne Energiezufuhr von außen. + +Auflösung von Sensoren: +- temporal: Zeitabstand zwischen Messungen (z.B. Geigerzähler, Aktionspotentiale) +- spektral: Abstand von Spektrallinien (z.B. Wärmebildkamera, Infrarotsensor, Spektralphotometer) +- räumlich: räumlicher Abstand (z.B. EEG, Ultraschall, CT/MRT) +- und alle Kombinationen (z.B. spatialtemporale Auflösung in einem Frequenzband) + +Klassifikation nach Messgröße: +- Physikalisch: Kraft, Druck, Moment, Durchfluss +- Elektrizität: Potential, Strom, Impedanz +- Magnetismus: Fluss, Induktion +- Optik/Licht: spektrale Dämpfung, Extinktion +- Chemisch: Partialdruck von Gasen, Zucker, Hämoglobin +- Akustik: Herzschalltöne, Atmung +- Temperatur: Körpertemperatur + +## Druck, Dehnung und Kraft +Dehnmessstreifen (DMS) +- Messprinzip: Dehnungsabhängiger Widerstand +- Realisierung: Widerstandsdraht oder Halbleiter als Gitter auf Träger +- Messbare Größen: Kraft, Druck, Moment +- Anwendung in der Medizintechnik: Atmungsdiagnostik, Fahrradergometer, Diagnostik des Bewegungsapparates +- Signaleigenschaftem + - passiver Sensor - thermisches und/oder Halbleiter-Rauschen + - empfindlich gegen NF-elektrische/magnetische und HF-elektromagnetische Felder + - temperaturabhängig vor allem Halbleiter + - Übertragungseigenschaften abhängig von der Sensorkopplung + - Signaldynamik abhängig von Masse und Technologie + +Grundlage ist der piezoresestive Widerstandseffekt: Durch Zug/Druck nimmt der elektrische Widerstand zu/ab +- $R=\rho\frac{l}{A}=\rho\frac{4l}{d^2\pi}$, $\rho$ spez. Widerstand, $l$ Drahtlänge, $d$ Drahtdurchmesser +- $R+\delta R=(\rho+\delta\rho)\frac{4(l+\delta l)}{(d-\delta d)^2\pi}$; davon ist $(l+\delta l)$ relevant für die Dehnungsmessung + + +Die Widerstandsänderung ist linear abhängig von der Temperaturabhängigkeit des spez. Widerstandes, jedoch nicht linear abhängig von der mechanisch bedingten Änderung der +Abmessungen. Natürlich hängen die Längenänderung und die des Durchmessers zusammen. Der konkrete Zusammenhang ist jedoch durch die Konstruktion und das Material gegeben und kann nicht verallgemeinert werden. Da für die Messung allein die Längenänderung von Interesse ist, wird im weiteren nur diese betrachtet. + +- $\frac{\delta R}{R}=k\frac{\delta l}{l}=k*\epsilon$, $\epsilon$-relative Dehnung +- $\epsilon=\frac{F}{EA}$, $F=\frac{\delta R}{R}*\frac{EA}{k}$, E-Elastizitätsmodul +- In der Praxis aus Kostengründen und wegen geringer Temperaturabhängigkeit meistens Konstant an (54% Cu, 45% Ni, 1% Mn mit $k=2,05$) verwendet + +Messverfahren: Widerstandsmessung mit Brückenschaltung +- Wheatstone'sche Brücke: $U_A\rightarrow 0|_R \Rightarrow \frac{R_x}{R_V}=\frac{R_2}{R_1}$ +- $R_X=R_V\frac{R_2}{R_1}$ +- ![](./Assets/Biosignalverarbeitung-wheatstone-brücke.png) +- Warum wird Rx mit Wheatstone-Brücke und nicht klassisch über Stromeinspeisung und Spannungsmessung bestimmt? + - Das Messsignal (Ua) ist stärker bzw. die Empfindlichkeit der Messanordnung ist höher als bei einer reinen Strom/Spannungsmessung, außerdem ist Temperaturkompensation möglich. + - Starkes Messsignal ist sinnvoll wegen der immer vorhandenen Störungen vom Netz und Leitungen, die direkt auf die Kabel der Messanordnung wirken. + +Folien-DMS: +- Widerstandsdraht mit ca $20\mu m$ Durchmesser oder Halbleiter +- Träger Acrylharz, Epoxydharz, Polyamid +- ![](Assets/Biosignalverarbeitung-folien-dms.png) + +Dehnungsmessrosette: +- Messung in drei Richtungen +- ![](Assets/Biosignalverarbeitung-Dehnungsmessrosette.png) + +Wie man an diesen Konstruktionsbeispielen gut erkennen kann, bilden die Leitungen ungewollterweise eine Antenne, die alle vorhandenen Störungen aus der Umgebung aufnimmt, vor allem Netzeinstreuung, Mobilfunk und Computernetze. + +Aufbau von Massebezogenen und Massefreien Messungen: +![](Assets/Biosignalverarbeitung-masse-messung.png) + +Messspannung von $U_{R5}$ in der massebezogenen Schaltung +![](Assets/Biosignalverarbeitung-messspannung-massebezogen.png) +Bei massebezogener Messung - auch Single-End genannt, da gegen Masse - werden die Störungen direkt dem Messsignal überlagert, so dass später eine Trennung ohne aufwendige Signalverarbeitung kaum möglich ist. + +Massebezogne eBrückenspannung (rot, blau) und Indikatorspannung $U_d$ (grün) +![](Assets/Biosignalverarbeitung-massebezogen-brückenspannung.png) +Einen großen Teil der Netzstörung bilden die elektrostatischen (kapazitiv eingekoppelten) Felder, die Gleichtaktcharakter haben. Diese lassen sich also durch Differenzbildung -hier mit einer Wheatstonschen Brücke -zum Teil eliminieren. + +## Durchfluss, Volumen +- Massendurchfluss + - $\dot m=\frac{dm}{dt}$ + - $[\dot m]=\frac{kg}{h};\frac{g}{s}$ + - industriell relevante Größe, z.B. Kraftstoffe, Luftverbrauch im Motor +- Volumendurchfluss + - $\dot V=\frac{dV}{dt}$ + - $[\dot V]=\frac{m^3}{h};\frac{l}{min}$ + - wichtige Messgröße in der medizinischen Messtechnik: Blutfluss, Atmung, Gastrointestinalapparat +- Der Durchfluss eines Mediums ist eine der wichtigsten Größen in der technischen und medizinischen Messtechnik. Technisch vor allem der Massendurchfluss, medizinisch der Volumendurchfluss, da medizinisch grundsätzlich die Volumina diagnostisch relevante Größe darstellen. +- Bei bekannter durchflossener Fläche wird der Volumenfluss über die Geschwindigkeitsmessung ermittelt + - $\dot V=\frac{dV}{dt}=\frac{A*dl}{dt}= A*v$ + - Reale Verteilung der Geschwindigkeit ist Parabel mit Maximum in der Mitte $\rightarrow$ Gemessene Geschwindigkeit ist die mittlere Geschwindigkeit +- In der Medizin kann weder eine Geschwindigkeitsverteilung - wie in der Technik - erzwungen werden, noch kann sie vollständig erfasst werden. Daher misst man tatsächlich nur eine ,,mittlere'' Geschwindigkeit, wobei der Begriff ,,mittlere'' hier nicht ganz korrekt ist, da die tatsächliche Verteilung nach wie vor unbekannt ist. +- Messprinzip Druckdifferentmessung nach Gesetz von Hagen-Poiseuille + - $\dot V=\frac{dV}{dt}\frac{\pi d^4}{128\mu}*\frac{\delta p}{l}$ + - $d$ - Durchmesser der Kappilare + - $\delta p=p_A - p_B$ - Druckdifferenz über der Kapillare, abhängigkeit von der Strömungsgeschwindigkeit + - $l$ - Länge der Kapilalre + - $\mu$ - Viskosität des Mediums + - ![](Assets/Biosignalverarbeitung-pneumotachograph.png) + - Bsp: 10% Verengung der Kapillare $\rightarrow$ 34% Reduktion des Durchsatzes, d.h. im Blutkreislauf Anstieg des Blutdrucks um 34% + - Bei externen Sensoren der Durchflussmessung kann man die Messbedingungen relativ klar vorgeben, z.B. im Pneumotachographen. Man erzwingt kapillare Strömung, der Strömungswiderstand und die Fläche sind bekannt, so dass aus der Druckdifferenz direkt auf den Durchfluss geschlossen werden kann. +- Anwendung in der Medizintechnik + - Messung aller vitaler Lungenvolumina + - Messung des Blutflusses +- Nachteile des Messprinzips + - zusätzlicher Strömungswiderstand verfälscht das Ergebnis + - bei Temperaturunterschieden Kappilaren-Medium Tröpfchenbildung + - geringer Dynamikbereich (1:10) + - niedrige Messgenauigkeit wegen Turbulenzen an Kapillarenden + - direkter Kontakt mit Medium +- Ultraschall-Geschwindigkeitsmessung nach dem Laufzeitverfahren + - $v=\frac{T_2-T_1}{T_1 T_2}*\frac{L}{2\ cos\ \alpha}$ + - $v$ - mittlere Strömungsgeschwindigkeit des Mediums + - $T_1$ - Laufzeit des Ultraschalls mit der Strömung + - $T_2$ - Laufzeit des Ultraschalls gegen die Strömung + - $L$ - Länge des Ultraschall-Pfades + - $\alpha$ - Winkel zwischen der Strömung und dem Ultraschall-Pfad + - ![](Assets/Biosignalverarbeitung-ultraschall-geschwindigkeit.png) + - Vorteile + - kein Kontakt mit dem Medium, insbesondere Blutbahnen + - Installation und Messung ohne Unterbrechnung des Flusses + - Nachteile + - invasive Methode, da Blutgefäß freigelegt werden muss + - Ungenauigkeit wegen der Verfomung der Blutgefäße + - Signaleigenschafte + - verrauscht wegen Streuung im Medium, Sensorrauschen + - Echo statisch verteilt wegen Geschwindigkeitsprofil +- Ultraschall-Geschwindigkeitsmessung nach dem Dopplerverfahren + - $f_D=f\frac{c}{c-v} \Rightarrow v=c\frac{f-f_D}{f_D}$ + - $c$ - Ausbreitungsgeschwindigkeit des Ultraschalls im Medium + - $f$ - Originalfrequenz der Signalquelle + - $f_D$ - gemessene Frequenz (Beobachter) + - $v$ - Geschwindigkeit der Signalquelle + - ![](Assets/Biosignalverarbeitung-ultraschall-doppler.png) + - ![](Assets/Biosignalverarbeitung-ultraschall-doppler-2.png) + - Anm: Feste Blutbestandteile (Blutkörperchen) reflektieren die Schallwellen und sind somit für den Ultraschall-Empfänger bewegte Signalquellen +- signalanalytisch relevante Eigenschaften + - Flussgeschwindigkeit ungleichmäßig verteilt + - im technischen Bereich konstruktiv beherrschbar (Messkammer, Durchmesser, Material) + - im medizinischen Bereich kein Einfluss auf die Gefäße, daher relativ ungenaue Messung der mittleren Geschwindgkeit + +## Optische Sensoren +Optische und Strahlungsquellen +- Kaltlichtquelle: in der Endoskopie, bläuliches Tageslicht wegen der Farbtreue +- Diagnostische Laser: in der Ophthalmologie, Urologie, inneren Medizin, Dermatologie +- Leuchtdioden: in der Photoplethysomographie (Pulsoximetrie) +- Röntgen-, Gamma-, UV- und IR-Strahler: in der diagnostischen Bildgebung +- Inspektionslicht: in der HNO (Halogenstrahler) + +Signalanalytisch wichtige Eigenschafte +- Temperaturstrahler: sind träge, daher statisches, konstantes Licht +- Halbleiter (Leuchtdioden), Laser und Leuchtstoffröhren sind gepulste Quellen - mit dem Auge nicht wahrnehmbar, aber analytisch unter Umständen sehr problematisch + +Optische Sensoren +- Phototransistor: in Flachbilddetektoren der Radiologie +- Kamerachips: in den Endoskopen +- Szintillatoren: in Gamma-Kameras +- Photovervielfacher (SEV) in Laser-Fluroszenzsystemen + +Sensoreigenschaften +- starkes Eigenrauschen, typisch für Halbleiter, ,,Dunkelstrom'' +- hohe Temperaturabhängigkeit, ist materialbedingt, variable Parameter +- ungünstige Dynamikeigenschaften, Nachleuchten durch Trägheit, systemanalytisch lange Impulsantwort + +Beispiel Optischer Sensor CMOS Kamera LOGLUX i5 +- wahlfreier Pixelzugriff +- CameraLink oder FireWire Datenschnittstelle +- Auflösung 1280x1024 Pixel, 10 bit Graustufen +- $>100$ dB Kontrast-/Dynamikumfang +- ca 36 fps bei Vollbild; höhere Bildrate bei kleinerem Bildfeld bis ca 1500 fps +- Vorverarbeitung der Bilddaten mittels integrierter LUT (look-up-tables) möglich +- spektraler Arbeitsbereich 400-1000nm + +Optische Messmethoden gewinnen in der Medizin immer mehr an Bedeutung, vor allem, weil sie nichtinvasiv sind und daher patientenfreundlich. Mit der Kombination von Spektralfotometrie und Photoplethysmografie kann die Sauerstoffsättigung bestimmt werden. Dazu ist es notwendig, Gewebe durchzustrahlen, welches mit arteriellem Blut versorgt wird. Sehr verbreiten ist die Transmissionsmessung -d.h., das Gewebe wird durchstrahlt, was den Anforderungen an eine Messanordnung entsprechend der Theorie noch am nächsten kommt. Eine Alternative wurde notwendig, da der Finger u.U. nicht versorgt wird, z.B. beim Schock: Die Reflexionsmessung, bei der das Licht über einem Flächenknochen eingestrahlt und das reflektierte erfasst wird. +- ![](Assets/Biosignalverarbeitung-pulsoxy-1.png) +- ![](Assets/Biosignalverarbeitung-pulsoxy-2.png) +- ![](Assets/Biosignalverarbeitung-pulsoxy-3.png) + +Signal am Photodetektor +- Multiplex bzw. sequentielle Abtastung +- Rauschen (Optoelektronik) +- Umgebungslicht, insbesondere Leuchtstoffröhren +- ![](Assets/Biosignalverarbeitung-pulsoxy-4.png) + +Signal am Demultiplexer +- DC ca 95-98% +- AC nach DC Subtraktion verstärkt +- ![](Assets/Biosignalverarbeitung-pulsoxy-5.png) + +Für die Signalverarbeitung bedeutet die Analyse des empfangenen Signals eine komplexe Herausforderung: Die Störungen, das Rauschen und das Umgebungslicht (vor allem im OP), sind enorm stark, so dass ihre Trennung vom Signal schwierig ist. Hinzu kommt, dass das Nutzsignal im unteren Prozentbereich des gesamten empfangenen Signals liegt, so dass hier das SNR um weitere zwei Dekaden schlechter wird. + +An diesem Beispiel eines realen Pulsoximetriesignals kann man die realen Eigenschaften erkennen: +- ![](Assets/Biosignalverarbeitung-pulsoxy-6.png) + - Der DC-Anteil, der im Grunde durch eine Tiefpassfilterung gewonnen wird, ist real ein stark schwankender gleitender Mittelwert (unterer Verlauf). + - Der AC-Anteil (oberer Verlauf) zeigt ebenfalls starke Schwankungen. Um dem Mediziner einen einigermaßen stabilen Messwert zu bieten, sind mehrere Schritte der SV notwendig +- ![](Assets/Biosignalverarbeitung-pulsoxy-7.png) + - Pulsbreite 1ms, analoger Tiefpass 10kHz, Abtastrate 10 ksps + - Zunächst müssen aus dem Multiplexsignal die aktuellen Signalpegel für das rote und infrarote Licht sowie für das Umgebungslicht gewonnen werden: Durch die 10fache Überabtastung stehen für Rot und Infrarot zunächst elf Messwerte zur Verfügung. Dieser Umfang an Messdaten ist für eine Pegelbestimmung mit dem Mittelwert zu gering, daher wird der Median verwendet. Nach der Medianbildung liegen die Signalpegel für weitere Berechnung vor. +- ![](Assets/Biosignalverarbeitung-pulsoxy-8.png) + - Die gewonnenen Signalpegel werden nun einer Signalanalyse unterzogen. Die Analyse bei einer Wellenlänge ist ausreichend, da die Signalform bei allen qualitativ identisch ist. Für die Bestimmung des AC-Pegels werden die Extrema detektiert. Aus der Physiologie ist bekannt, dass die Anstiegszeit der Pulswelle höchstens 30% der Gesamtzeit beträgt, so dass eine Prüfung im Zeitfenster folgt. Weiterhin ist der Bereich der Periode bekannt, diese Prüfung folgt im nächsten Schritt. Durch Artefakte, vor allem durch Bewegung, entstehen Schwankungen der Basislinie. Nach einem empirische ermittelten Kriterium wird ein Trend von bis zu 30% vor der Berechnung akzeptiert. + +## Akustische Sensoren +Physiologischer Schall (Herztöne, Atmungsapparat) liegt im hörbaren Bereich, so dass hier Methoden eingesetzt werden, die aus der allgemeinen Akustik bekannt sind. +Konventionelle Mikrophontechnik mit spezifischer Signalverarbeitung +- Verstärkung im tieffrequenten Bereich mit linearer Phase +- Richtcharakteristik umschaltbar bzw einstellbar, mechanisch bereits in den ältesten Stetoskopen +- spektrale Filterung für typische Geräusche, wie Herzklappen, Pfeifen in der Lunge, etc +- Merkmalserkennung in computerbasierter Auswertung, Mustererkennung typischer pathologisch bedingter Geräusche + +Beim Ultraschall (CW,PW,Doppler) handelt es sich um mechanische Schwingungen bis in den zweistelligen Megahertzbereich ( ca. 30MHz). Hier müssen aufwendige Methoden der SV angewandt und entwickelt werden, die primär -d.h. bis zum Übergang in den physiologischen Bereich bzw. zur Bildgebung -eher in der Nachrichtentechnik und Stochastik ihren Ursprung haben: Signaldetektion, Korrelationsrechnung, Histogramme, Signalzerlegung. +Signalanalytisch wichtige Eigenschaften: +- bei CW (Continous Wave) keine Tiefeninformation verfügbar, Information über Dopplerfrequenz mit hoher Variationsbreite, stochastischer Charakter mit viel Rauschen +- bei PW (pulsed Wave) Auflösung von der Signalverarbeitung entscheidend abhängig, da physikalische Grenzen lange erreicht +- in der Doppler-Technologie beides (CW und PW) vereint, daher Summe aller Vor- und Nachteile + +## Sensoren für elektrische Größen +### Elektrochemische Grundlagen +- Dieser Sensortyp dient der Erfassung der elektrischen Aktivität des Menschen +- Der Mensch produziert elektrische Signale, daher ist keine Umwandung der Energieform notwendig +- Der Mensch ist elektrisch gesehen ein Volumentleiter der 2. Art - ein Elektrolyt oder ein Ionenleiter +- Das Messsystem ist mit metallischen Leitern aufgebaut - Leiter der 1. Art, Elektronenleiter +- daher ist die Schaffung einer Schnittstelle notwendig - die Elektrode +- ![](Assets/Biosignalverarbeitung-elektrochemische-grundlage.png) + - $mM \Leftrightarrow mM^+ + me^-$ + - $K_k A_a\Leftrightarrow kK^+ + aA^-$ + - $\leftarrow$: Reduktion; $\rightarrow$: Oxidation + - Dynamisches Gleichgewicht an den Phasengrenzen + - An der Phasengrenze der beiden Leitertypen entwickelt sich -ähnlich wie in einem Halbleiter -eine Raumladungszone. Die freien Elektronen im Metall und die Kationen des Elektrolyts ziehen sich an und bilden an der Grenze eine Doppelschicht. Je nach der chemischen Zusammensetzung des Elektrolyts und des Metalls finden unterschiedlich starke chemische Reaktionen statt, die beim dynamischen Gleichgewicht die sog. Elektrodenspannung bilden. Funktionell handelt es sich hierbei also um ein ungewolltes Voltaisches Element. + +### Elektroden der Diagnostik +- aus signalanalytischer Sicht Eingangsdaten +- aus messtechnischer Sicht Systemeingang + +| Ziele | Realisierbarkeit | +| ------------------------------------- | ----------------------------------------------- | +| geringe Elektrodenspannung | durch Materialwahl (AgAgCl) | +| geringer Drift der Elektrodenspannung | physiologisch bedingt, daher kaum beeinflussbar | +| geringes Eigenrauschen | Materialwahl und Technologie | + +Aus signalanalytischer Sicht sind die Ziele ganz klar vorgegeben. In der Praxis muss jedoch immer ein Kompromiss zwischen diesen Zielen und den Anforderungen der Anwendung und Praktikabilität gefunden werden: Wie diese Beispiele zeigen, hängt die Konstruktion der Elektrode von ihrer Bestimmung ab und daraus ergeben sich auch die Signaleigenschaften. So z.B. muss eine subkutane EMG-Elektrode die Form eine Nadel haben und aus einem Edelmetall sein. Dies hat zur Folge, dass die EMG-Elektroden relativ schlechte Signaleigenschaften aufweist: Riesige Elektrodenimpedanz (bis einige MOhm), stark kapazitives Verhalten, sehr hohe Elektrodenspannung (bis in den Voltbereich). Im Vergleich dazu haben die EKG-Elektroden -vor allem auf Grund ihrer großen Fläche und des Materials (AgAgCl, NaCl) -sehr günstige Eigenschaften: Niedrige Elektrodenimpedanz (kOhm-Bereich), sehr tieffrequent (bis DC), niedrige Elektrodenspannung (um 100 mV). + +![](Assets/Biosignalverarbeitung-elektroden.png) + +### Elektroden der Therapie +- aus signalanalytischer Sicht Ausgangsdaten +- aus messtechnischer Sicht Systemausgang + +| Ziele | Realisierbarkeit | +| --------------------------- | ----------------------------------- | +| geringe Impedanz | durch Materialwahl (beschichtet Cu) | +| geringer Drift der Impedanz | physiologisch bedingt | +| Langzeitstabilität | Materialwahl und Technologie | + +Ebensowichtig wie die Eigenschaften der diagnostischen Elektroden, sind es auch die der therapeutischen Elektroden. Dies liegt darin begründet, dass die Therapie von den zuvor analysierten diagnostischen Daten abhängt -natürlich im signalanalytischen Sinne, denn medizinisch ist es immer so. Man muss sich also bei der gewählten Therapie darauf verlassen können, dass das, was man auf die Elektrode schickt, so auch am biologischen Objekt ankommt. Diese Forderung technologisch umzusetzen ist ungleich leichter als bei diagnostischen Elektroden, denn hier können relative große Flächen mit gutem Kontaktmaterial verwendet werden. + +![](Assets/Biosignalverarbeitung-elektrode-therapie.png) + +## Sensoren für magnetische Größen +### Messprinzipien +Um einen Eindruck über die Signalstärke (eher Signalschwäche) der biomagnetischen Signale zu bekommen, wird mit dem natürlichen Erdfeld verglichen, obwohl dieses für den Biomagnetismus eigentlich gar kein Problem darstellt. Störend sind die vom Menschen gemachten magnetischen Felder, vor allem die vom Stromversorgungsnetz, die jedoch weit über dem magnetischen Erdfeld liegen. +1. Das stärkste Biosignal, das MKG, liegt 6 Dekaden unter dem Erdfeld (120dB), und weitere 2...3 Dekaden unter den technischen Feldern. +2. MEG -7 Dekaden, oder 140dB, +3. evozierte Felder -8 Dekaden oder 160dB + +- $10^0T$: MR-Tomographie-Magnete +- $10^{-5}T$: Erdfeld +- $10^{-6}T$: Zivilisationsfelder (Rauschen) +- $10^{-9}T$: magn. Kontamination der Lunge +- $10^{-10}T$: Magnetkardiogramm +- $10^{-12}T$: Magnetoenzephalogramm +- $10^{-13}T$: evozierte kortikale Aktivität +- $10^{-15}T$: SQUID System Rauschen + +Biomagnetische Signale sind sehr schwach (SNR< -120dB). Mehrere Maßnahmen zur SNR-Anhebung notwendig +- Abschirmung des Messkreises gegen Störfelder (dickwandige Kammer aus $\mu$-Metallen) +- Ausnutzung der Feldeigenschaften - Gradiometer +- Spezialtechnologie der Signalverstärker - SQUID + +### Gradiometer +Prinzip: +- Störfelder meist ferne Quellen, Biologische Strukuren nahe Quellen +- ferne Quellen produzieren annährend homogenes Feld +- nahe Quellen Produzieren inhomogenes Feld +- mit Gradiometer wird die erste bzw zweite räumliche Ableitung gebildet, dadurch wird homogenes Störfeld unterdrückt +- ![](Assets/Biosignalverarbeitung-Gradiometer.png) +- ![](Assets/Biosignalverarbeitung-gradiometer-2.png) +- homogenes Fernfeld (Störung, blau): $u=u_2-u_1=0$ +- inhomogenes Nahfeld (Biosignalquelle, rot): $u=u_2-u_1<>0$ + +### SQUID +![](Assets/Biosignalverarbeitung-squid.png) + +Das supraleitende Quanteninterferenzgerät (SQUID) besteht aus zwei Supraleitern, die durch dünne Isolierschichten getrennt sind und zwei parallele Josephson-Kontakte bilden. Das Gerät kann als Magnetometer konfiguriert werden, um unglaublich kleine Magnetfelder zu erkennen - klein genug, um die Magnetfelder in lebenden Organismen zu messen. SQUID wurden zur Messung der Magnetfelder in Mäusehirnen verwendet, um zu testen, ob ihr Magnetismus ausreicht, um ihre Navigationsfähigkeit auf einen inneren Kompass zurückzuführen. [Quelle](http://hyperphysics.phy-astr.gsu.edu/hbase/Solids/Squid.html) + +# Verstärkung und analoge Filterung +## Eigenschaften von Biosignalen und Störungen + +### Entstehung der Biosignale, biologische Signalquellen +- Analysegegenstand: Sensorisches, motorisches und zentrales Nervensystem +- Grundbaustein: Nervenzelle, Neuron. Einzelne Neurone kaum untersuchbar, im Einzelfall mit Mikroelektroden, dennoch für die Gesamtheit wenig Bedeutung. Wichtiger sind Untersuchungen an Neuronenverbänden und -strängen, z.B. motorische Steuerung von Muskeln in den Extremitäten. Hier haben die Nerven überschaubare und anatomisch sowie elektrophysiologisch gut bekannte Struktur. +- am Neuronausgang - Axon: Aktionspotentiale +- am Neuroneingang - Synapsen: EPSP/IPSP (exzitatorische und inhibitorische postsynaptische Potentiale) + +- Sensorisches System ist deutlich komplexer, vor allem das akustische und das visuelle. So hat die Retina allein mehrere Millionen Sensoren (Stäbchen und Zapfen), die mit Ganglienzellen verbunden sind und bereits vor Ort relativ einfache Informationsverarbeitung durchführen. +- Zahlenmäßig und daher in auch in seiner Komplexität ist das größte das zentrale Nervensystem (ZNS), das aus ca. 10 Milliarden Neuronen besteht, die funktionelle und anatomische Zentren bilden aber zeitlich stark variierende Eigenschaften aufweisen. +- Signalanalytisch ist das Grundelement das Aktionspotential (AP), das vom Neuron nach Erreichen der Reizschwelle an seinen Eingängen über das Axon nach außen bzw. an andere Neurone abgegeben wird. Die Synapsen empfangen die Aktionspotentiale von anderen Neuronen und bewerten diese je nach Zustand mit EPSP oder IPSP, die von sich aus starken Veränderungen unterliegen. Im EEG sind die AP deutlich unterrepräsentiert (nur etwa 10% des EEG), wesentlicher Anteil bilden die PSP. Dies ist unter anderem durch den Tiefpasscharakter des Schädels bedingt, das die hochfrequenten AP unterdrückt. + +![](Assets/Biosignalverarbeitung-ekg.png) + +Ein medizinisch und auch signalanalytisch besonders interessantes Signal ist das EKG: Medizinische Indikation ergibt sich allein aus der besonderen Stellung des Herzens in der Physiologie als des Motors des Kreislaufs. Signalanalytisch ist es deswegen interessant, da es unter reproduzierbaren Messbedingungen (Extremitätenableitungen) formkonstanten Signalverlauf zeigt. Das EKG wurde entsprechend seiner elektromedizinischen Bedeutung extensiv untersucht, zahlreiche Erkrankungen und Schäden werden anhand typischer Formveränderungen des EKG diagnostiziert. Die Signalquelle des EKG ist das räumlich zwar recht komplizierte, aber anatomisch qualitativ konstante Reizleitungssystem des Herzens. Zur Ableitung des EKG werden standardmäßig 3-, 6-oder 12-kanalige Extremitäten-und Brustwandsysteme verwendet. + +![](Assets/Biosignalverarbeitung-herz-ekg.png) + +Projektion der Reizausbreitung auf einen längs zur Herzachse liegenden Vektor (vertikal): Zu beachten ist, dass durch die Differenzbildung an zwei Punkten an der Körperoberfläche damit mathematisch die erste räumliche Ableitung (oder auch der erste Gradient) gebildet wird. Das hat zur Folge, dass die Ableitung nicht nur in Phasen der Ruhe (vor der P-Welle), sondern auch bei maximaler Erregung ( PQ-und ST-Strecke) Null ist. Wellen und Zacken im EKG sind Ausdruck der räumlich-zeitlichen Veränderung im Reizleitungssystem. + +![](Assets/Biosignalverarbeitung-gehirn.png) +![](Assets/Biosignalverarbeitung-gehirn-ekg.png) + +Zur Ableitung des EEG werden wie beim EKG standardisierte Elektrodensysteme verwendet. Allerdings ist die anatomische Zuordnung hier ungleich schwieriger, denn die einzigen einigermaßen stabilen anatomischen Bezugspunkte sind das Nasion und das Inion. Es ist jedoch bekannt, dass die Lage des Gehirns in Bezug auf diese Punkte individuell stark unterschiedlich ist und im Zentimeterbereich liegt, so dass eine genaue Zuordnung der Elektroden zu Funktionszentren gar nicht möglich ist. Die Dichte der Elektroden in der Praxis liegt höchstens bei 10% NI, d.h. im Schnit bei etwa 3cm. Eine höhere Dichte bringt keine zusätzliche Information, da der Schädel als räumlicher Tiefpass funktioniert und keine höhere Auflösung erlaubt. + +Aus Sicht der Signalanalyse ist es besonders wichtig zu wissen, unter welchen Messbedingungen das EEG abgeleitet wurde. Im Idealfall wird unipolar gegen verbundene Ohren oder Hals abgeleitet. Aus unipolaren Daten lassen sich die bipolaren Ableitungen einfach berechnen, umgekehrt geht das jedoch nicht. Auf jeden Fall ist zu klären, wie die Verschaltung des EEG-Verstärkers und der Elektroden realisiert wurde. Vermeintlich elegante Tricks, wie hardwaremäßige CAR sind auf jeden Fall zu meiden, ebenso Antialiasingfilter mit nichtlinearer Phase. + +![](Assets/Biosignalverarbeitung-gehirn-eeg.png) + +Das EEG wird in in fünf typische Bereiche unterteilt: delta (0..4Hz), theta (4-7Hz), alpha (8..13Hz), beta (13..30Hz), gamma (>30Hz). Diese Bereiche sind typisch für bestimmte physiologischen (Schlaf, Konzentration, Entspannung) und pathologischen Bilder. Für die Signalanalyse ist wichtig, dass die Bereiche nicht gleichzeitig vorhanden sind, einer ist immer dominant, was die Analyse leicht vereinfacht. + + +### Biologische und technische Störquellen +| periodische | transiente | +| --------------------------------- | ------------------------- | +| öffentliches Stromversorgungsnetz | Spannungsspitzen im Netz | +| Straßenbahn | Bewegungen im Messbereich | +| Monitore | Schaltvorgänge | +| Kommunikationsnetze | Lastschwankungen | +| Rotierende Maschinen | +| Sender inkl. Funktelefon | + +1.Das biomedizinische Messsystem ist von vielen Störquellen umgeben, die meisten sind dem Bereich der Medienversorgung, Industrie, Verkehr und Nachrichtentechnik zuzuschreiben. Für die BSA sind periodische (Versorgungsnetz, Monitore) und quasiperiodische (rotierende Maschinen, Straßenbahn) Störungen noch ein vergleichsweise geringes Problem, denn diese lassen sich gezielt mit spektralen Filtern in der analogen Messkette oder digital nach ADC unterdrücken. +2.Wesentlich schwieriger ist die Situation, wenn transiente Störungen vorliegen, denn diese haben im Allgemeinen einen unbekannten, einmaligen und daher nicht reproduzierbaren Verlauf. Solange die transiente Störung die Signalerfassung nicht beeinträchtigt (durch Übersteuerung des Messverstärkers) und deutlich von der Signalform abweicht (z.B. Ausgleichsvorgang mi EKG), kann sie mit relativ einfachen Mitteln beseitigt werden, dennoch im Allgemeinen ist dies kaum möglich. + +![digitale Bandsperre für die Netzfrequenz](Assets/Biosignalverarbeitung-netzfrequenz-bandsperre.png) +Die häufigste -weil immer vorhanden- ist die Netzstörung. Selbst batteriebetriebene portable Messgeräte sind von dieser Störung betroffen. Da die Frequenz der Störung aber bekannt ist, kann sie -falls keine Übersteuerung vorliegt- mit einer Bandsperre reduziert werden. Allerdings sollte nicht die früher übliche ,,50 Hz -Filter'' Taste verwendet werden, denn diese Filter haben einen nichtlinearen Phasenfrequenzgang und können das Biosignal deutlich verfälschen. Bei der heutigen Technologie werden ausschließlich digitale Filter verwendet. + +![Trendelimination (Hochpassfilterung)](Assets/Biosignalverarbeitung-trendelimination.png) +Eine sehr häufige transiente Störung im medizinischen Bereich ist die Bewegungsartefakte. Jegliche Bewegung im Messbereich erzeugt in der empfindlichen medizinischen Messtechnik Ausgleichsvorgänge. Wenn die Signalform gut bekannt ist, wie z.B. beim EKG, so lässt sich eine langsame Artefakte durch Hochpassfilterung beseitigen. +- Maximal $f_{0,01}=0,5 Hz$ Patienten-Monitor EKG (nicht oberhalb) +- Maximal $f_{0,02}=0,05Hz$ Diagnostischer Monitor bei EKG (nicht oberhalb) + +Ob ein Biosignal gewollt ist oder eine Störung darstellt, ist von der Messaufgabe abhängig: +- soll das EKG gemessen werden, ist das EMG eine Störung +- soll das EEG gemessen werden, ist das EKG eine Störung +- soll das EOG gemessen werden, ist das EEG eine Störung + +Prinzipielles Problem: Biologische Störquellen lassen sich nicht abschalten und kaum unterdrücken + +Aus Sicht der BSA gestaltet sich das Problem der Störungen wesentlich schwieriger als bei technischen Störungen. Erstens, die Biosignalquellen befinden sich innerhalb des Körpers, daher können sie weder abgeschirmt noch abgeschaltet werden. Zweitens, das biologische Signalspektrum ist für alle Biosignale in etwa gleich, streckt sich von 0 bis etwa 1kHz aus und weist ein Maximum bei etwa 100Hz auf. Daher können biologische Störsignale mit spektralen Filtern allein nicht beseitigt werden. + +Ein weiteres -messmethodisches -Problem besteh darin, dass man Biosignale nicht pauschal in Nutz-und Störsignale trennen kann. Es ist vielmehr die Messaufgabe, an Hand der man diese Klassifikation vornehmen muss. + +#### Eigenschaften technischer Störungen +| periodische Störungen | transiente Störungen | +| ------------------------------------------------------------------------------------ | ------------------------------------------------------------------- | +| NF-magnetische Felder nicht eliminierbar durch Schirmung, erzeugen Differenzspannung | kaum eliminierbar, da Signalform unbekannt und nicht reproduzierbar | +| NF-elektrische Felder gut beherrschbar, erzeugen Gleichtaktstörungen | bestenfalls Detektion möglich, Messdaten nicht korrigierbar | +| HF-Felder immer mehr vorhanden (Kommunikationsnetze), Abschirmung unwirtschaftlich | + +1. Naturgemäß erzeugen niederfrequente magnetische Felder am Verstärkereingang Differenzspannungen, die direkt mit dem Biosignal überlagert werden, so dass sie mit der üblichen Verstäkertechnik nicht reduziert werden können. Hinzu kommt, dass auch eine Abschirmung nicht viel bringt, da in diesem Frequenzbereich mehrere 10- Zentimeter dicke Eisenplatten verwendet werden müssten, was in der Praxis nicht realisierbar ist. Da die niederfrequenten elektrischen (kapazitiv eingekoppelten) Störfelder Gleichtaktsignale sind, können sie zum Teil gut durch die Differenzverstärkertechnik reduziert werden. In immer höheren Maße stören hochfrequente Felder, vor allem aus dem Mobilfunk, Datennetzen, WLAN, Bluetooth, etc. Eine Abschirmung ist im normalen Praxisbetrieb unwirtschaftlich, so dass eine Reduktion der Störung allein durch Maßnahmen der EMV zu erreichen ist. +2. Wie schon erwähnt, transiente Störungen sind im Grunde nicht beherrschbar, da sie eigentlich nicht bekannt und nicht vorhersehbar sind. Mit Methoden der BSA ist zum Teil ihre Detektion möglich, wenn z.B. der Messbereich oder das Spektrum des Biosignals nachweislich verlassen wird. Diese Detektion kann allerdings nur dazu genutzt werden, die beeinträchtigten Daten zu verwerfen, eine Korrektur ist nicht möglich. + + +#### Eigenschaften biologischer Störungen +- Spektral alle Biosignale im selben Band (0...100Hz) +- Nichtlineare Verkopplung der Biosignale verhindern Trennung mit herkömmlichen Methoden +- Kein Biosignal deterministisch und reproduzierbar +- Transiente bzw apperiodische und instationäre Biosignale nicht qualifizierbar +- Eine Trennung kaum möglich, bestenfalls eine Reduktion (z.B. Abschwächung des EMG im EKG) + +Das größte Problem bei der Reduktion von biologischen Störsignalen ist ihre funktionelle Verkopplung und physikalische Überlagerung im Volumenleiter Mensch. Die funktionelle Verkopplung (z.B. Einfluss der Atmung auf die Herzrate) ist nicht abschaltbar, ist nichtlinear und qualitativ unbekannt bzw. mit Methoden der BSA nicht beschreibbar. Außerdem sind die Verkopplungen in ihrer Komplexität weitgehend unerforscht und höchstens in Ansätzen dokumentiert. + +Man kann im Einzelfall den Einfluss eines Biosignals auf ein anderes zum Teil reduzieren. So z.B. ist bekannt, dass das EMG ein breitbandiges und vor allem hochfrequentes Signals ist, während das EKG seine Hauptanteile eher im niederfrequenten Bereich besitzt. Daher kann man den Einfluss des EMG mit einem relativ einfachen Tiefpass reduzieren, allerdings auch auf Kosten der Beeinträchtigung des EKG. + + +## Medizinische Messverstärker +### Dynamik, Linearität +Messverstärker Anforderungen: +- Linearität im Arbeitsbereich +- Linearer Phasenfrequenzgang +- Geringes Eigenrauschen +- Hohe Gleichtaktunterdrückung +- Übersteuerungsfestigkeit + +1. Mit Linearität im Arbeitsbereich ist die statische Linearität des Verstärkers gemeint, also die statische Beziehung zwischen der Ausgans-zu der Eingangsspannung $U_a/U_e$. +2. Mit linearem Phasengang ist die dynamische Linearität gemeint, also die Erhaltung der Signalform bei der Verstärkung. Beim nichtlinearen Phasengang wird die Veränderung der Signalform fälschlicherweise auch als ,,lineare Verzerrung'' bezeichnet, wohl in Anlehnung an die nichtlinearen Verzerrungen im Arbeitsbereich. +3. Das Eigenrauschen des Messverstärkers ist ein sehr wichtiger Parameter vor allem in der medizinischen Messtechnik, denn das Rauschen liegt im Bereich der zu messenden Signale im unteren Mikrovoltbereich. Ausgerechnet das 1/f-Halbleiterrauschen liegt dort, wo die Biosignale ihren wesentlichen Spektralanteil aufweisen. +4. Wie schon erwähnt, ein wesentlicher Teil der beherrschbaren technischen Störungen bilden die Gleichtaktsignale. Daher wird von den Messverstärkern eine hohe CMRR gefordert, die nicht unter 100dB liegen sollte. +5. Die Empfindlichkeit eines Verstärkers allein ist noch kein hinreichendes Kriterium. Ein medizinischer Verstärker muss übersteuerungsfest sein, damit er nicht schon beim ersten Defibrilationsimpuls oder bei der ersten OP mit HF-Gerät seine Dienste aufgibt. Und dies zu gewährleisten ist für die Elektroniker eine echte Herausforderung: Es gilt nämlich das Ziel, einen Verstärker aufzubauen, der im Mikrovoltbereich arbeitet, dennoch bei Spannungen von mehreren 100V (Defibrilation) oder HF-Leistungen (um 100W) nicht beschädigt wird und zeitnah seinen Arbeitsbereich wiederfindet. + +![](Assets/Biosignalverarbeitung-Linearität-arbeitsbereich.png) + +Die Pegel der Biosignale sind gut bekannt, so dass den Arbeitsbereich des Verstärkers vorzugeben, kein Problem darstellt. So wird dieser Bereich für das EKG etwa zwischen - 5 und +5 mV liegen. Als Reserve bis zur Begrenzung sollte man mindestens 50% des Arbeitsbereiches vorsehen. + +### Eigenrauschen +![](Assets/Biosignalverarbeitung-eigenrauschen.png) + +Das Halbleiterrauschen (1/f) erreicht bei etwa 10Hz den Pegel des weißen (Widerstands-) Rauschens. Da aber in diesem Bereich die meiste Energie der Biosignale liegt, ist es beim Schaltungsentwurf wichtiger, geeignete Halbleiter auszusuchen als sich auf die Minimierung des Widerstandsrauschens zu beschränken. Da die Auswahl an guten Halbleitern sehr begrenzt ist und dadurch den Entwicklern deutliche technologische Grenzen gesetzt sind, versuchen einige Konstrukteure und Hersteller die Eigenschaften ihrer Technik dadurch zu beschönigen, dass sie das Spektrum nach unten durch einen Hochpass begrenzen und erst dann die Rauschspannung messen und angeben. Daher muss man bei den Vergleichen verschiedener Techniken an dieser Stelle sehr vorsichtig vorgehen. Beispielsweise ist ein Verstärker, der angeblich nur 2uV Rauschspannung erzeugt aber erst bei 1Hz beginnt sicher nicht besser, als einer mit 3uV Rauschspannung dafür aber bereits ab 0.1Hz verstärkt. + +### Frequenzgang +Linearer Phasenfrequenzgang: Keine Formverzerrung +- Gruppenlaufzeit: $d(f)=const.$ +- Phasenfrequenzgang: $\phi(f)=\int d(f)df=\varphi_0*f$ + +Die wichtigste Eigenschaft der Biosignale, die von Medizinern diagnostisch genutzt wird, ist ihre Signalform. Daher lautet eine der grundlegenden Anforderungen an die Messtechnik und die BSA, dass die Signalform nicht verfälscht werden darf. Das bedeutet, dass sowohl im analogen als auch im digitalen Teil des Messsystems die Gruppenlaufzeit konstant sein muss. Daraus lässt sich die Forderung herleiten, dass der Phasengang linear sein muss, zumindest im Übertragungsbereich. + +## Differenzverstärker +### Funktionsprinzip +Vollkommene Symmetrie (DV und Signalanbindung) +- ![](Assets/Biosignalverarbeitung-Differenzverstärker-funktion.png) +- Vg ist Quelle der massebezogenen Störung. Die Störspannung gelangt auf beide Eingänge über Streukapazitäten, deren Impedanzen mit R4 und R5 simuliert werden, in gleicher Phase und im Idealfall auch mit gleichem Pegel. Die Störsignale an den Eingängen U10 und U20 sind also gleich, werden daher als Gleichtaktsignale bezeichnet. +- Vd ist die gewünschte massefreie Spannung (aus Sicht der Signalquelle zählen R4 und R5 nicht als Masseverbindung, die ,,hängt in der Luft'', floating source). Die Signalquelle Vd liegt direkt zwischen den Eingängen an, erzeugt daher eine Differenzspannung (siehe Funktionsprinzip eines Differenzverstärkers: Durch die Verkopplung der beiden Zweige T1 und T2 hat eine Zunahme der Eingangsspannung U10 Abnahme von Ud1 und Zunahme von Ud2, analog gilt das für U20. Daher liegt zwischen Ud1 und Ud2 die verstärkte Differenz von U10 und U20 an). +- Betrachtet man Ud1 und Ud2 massebezogen, so liegen überlagerte Gleichtakt- und Differenzspannungen an (unterer Grafik). Betrachtet man die verstärkte Spannung massefrei (also als Differenz zwischen Ud1 und Ud2), so verschwindet durch die Differenzbildung die Gleichtaktstörung und die gewünschte Differenzspannung bleibt übrig. +- Alle bisherigen Erläuterungen gelten nur im Idealfall: Sowohl der Verstärker ist ideal symmetrisch (identische Transistoren und Widerstände), als auch die Einkopplung der Gleichtaktstörung erfolgt ideal symmetrisch (über R4 und R5). + +Symmetrie im DV, asymmetrische (realistische) Signalanbindung +- ![](Assets/Biosignalverarbeitung-Differenzverstärker-asymmetrisch.png) +- In der Realität lassen sich zwar Verstärker bauen, die an das Ideal gut herankommen. +- Die Einkopplung der Gleichtaktstörung ist jedoch immer unsymmetrisch, es ist unmöglich, im Messkreis Symmetrie herzustellen (R4 und R5 unterschiedlich). Daher wird aus der ihrem Wesen nach Gleichtaktstörung zum Teil eine Differenzstörung. Und die Differenzstörung erscheint in der Ausgangsspannung Ud1-Ud2 zwangsläufig auch. +- Das heißt, in der Realität wird der Gleichtaktanteil der Störung zwar unterdrückt, aber der zur Differenz gewordene Anteil bleibt am Ausgang bestehen. + + +### Differenz- und Gleichtaktverhalten +![](Assets/Biosignalverarbeitung-Diff-und-Gleichtakt.png) +- $SNR_{in} = \frac{U_{d\_in}}{U_{g\_in}}=\frac{1mV}{10V}=10^{-4}\approx -80dB$ +- $V_g$: Gleichtaktstörung (Netz) +- $V_d$: Nutzsignal (EKG) +- Heute werden Differenzverstärker meistens als integrierte analoge Schaltungen mit OPVs eingesetzt. Da der Ausgang massefrei ist, folgt eine zweite Stufe zur Differenzbildung (IC3), die am Ausgang eine -wie üblich -massebezogene Spannung liefert. Diese Anordnung wird als Instrumentationsverstärker bezeichnet (instrumenation amplifier) und ist auch integriert verfügbar. +- Am Eingang liegt eine realistische Situation vor: Das gewünschte Signal hat den Pegel von 1mV (EKG), die Netzstörung erreicht (auch mehr als) 10V. Daher ist der SNR am Eingang sehr niedrig, -80dB. +- ![](Assets/Biosignalverarbeitung-Diff-und-Gleichtakt2.png) +- $CMRR=\frac{U_{d\_out}}{U_{g\_out}}*\frac{U_{g\_in}}{U_{d\_in}}=\frac{200mV}{20mV} *\frac{10V}{1mV}=10^5\approx 100dB$ +- Führt man mit dem Ausgangssignal des Verstärkers Spektralanalyse durch, so stellt man fest, dass die Netzstörung am Ausgang 20mV beträgt, während das gewünschte Signal 200mV erreicht, also der SNR am Ausgang ist 10 bzw. 20dB. Da der SNR am Eingang - 80dB betrug, wurde eine SNR-Verbesserung von 100dB erreicht. Diese Verbesserung ist auf die Gleichtaktunterdrückung selbst bei Asymmetrie am Eingang zurückzuführen, so dass in diesem Fall das CMRR identisch der SNR-Verbesserung ist. (Common-Mode Rejection Ratio, Gleichtaktunterdrückung, muss in der Medizintechnik laut Katalog mindestens 100dB, besser 120dB erreichen). + +## Instrumentationsverstärker +Der Instrumentationsverstärker (IV) ist ein mehrstufiger Verstärker, von dem in der medizinischen Messtechnik ein hoher Eingangswiderstand (besser als 100MOhm) und eine hohe CMRR (besser 100dB) gefordert wird. + +### Mehrstufiger Verstärker +- ![](Assets/Biosignalverarbeitung-mehrstufiger-verstärker.png) +- Die erste Stufe ist der Eingangs-Differenzverstärker mit massefreiem Ausgang; die Ausgangsspannung ergibt sich aus der Differenz der Ausgangsspannungen von IC1 und IC2. Die zweite Stufe verstärkt zusätzlich und bezieht die verstärkte Spannung auf Masse, so dass am Ausgang massebezogene, verstärkte Eingangsdifferenz vorliegt. +- V1: $u_{ad}=A*u_{ed}+B*u_{eg}$, $u_{ag}=C*u_{eg}+D+u_{ed}$, + - $A/B=F$: Diskriminationsfaktor + - $A/C=H$: Rejektionsfaktor +- V2: + - $u_a=V_d u_{ed}+\frac{V_d}{CMR}u_{eg}=V_d(A u_{ed}+\frac{A}{F} u_{eg})+\frac{V_d}{CMR}\frac{A}{H} u_{eg}$ + - $u_a|_{u_{ed}=0} = V_d A(\frac{1}{F}+\frac{1}{CMR*H}) u_{eg}$ + - die gesamt-Gleichtaktunterdrückung eines mehrstufigen Verstärkers ist abhängig im Wesentlichen von der ersten (Eingangs-) Stufe +- Berechnet man die Ausgangsspannung in Abhängigkeit von der Eingangs-Gleichtaktspannung und von den Verstärkerparametern, so zeigt sich, dass für den CMRR die erste Stufe (wie auch bei anderen Parametern, z.B. Eigenrauschen) entscheidend ist, die folgenden Stufen sind unwesentlich beteiligt. Daher wird in der ersten Stufe der höchste Entwicklungsaufwand getrieben. + +### Hoher Eingangswiderstand +- ![](Assets/Biosignalverarbeitung-hoher-eingangswiderstand.png) +- $R^{(1)}_{ed}=2R_D+R_C\approx 2R_D$ +- $R^{(2)}_{ed}=R_1+R_3< Neuentwurf notwendig + - Parameter: Bandstop, Equiripple, FIR; Fs=8000 Hz, Fpass1=30Hz, Fstop1=45Hz, Fstop2=55Hz, Fpass2=70Hz, Apass1=3dB, Astop=40dB, Apass2=3dB + - Filterentwurf: b=Vektor der Länge 3553 + ``` + winfilt = filter(Num, 1, winfufz) + sound(winfilt, Fs) + ``` +- Man kann natürlich eigene diskrete Faltung schreiben und verwenden, mit der Matlab-Funktion filter(b,a,x) geht es viele effektiver. +- Das abgespielte Signal entspricht nicht dem Ziel, undefiniertes Geräusch ist das Ergebnis. +- Das Filter muss überprüft werden. Im Plot des gefilterten Signals wird schnell deutlich, welches Problem aufgetreten ist: Das Signal verläßt den normalen Wertebereich und sogar auch den Zahlenbereich. Fazit ist, das Filter ist instabil. Selbst wenn das fdatool behauptet, das Filter wäre stabil, so stimmt das nur für den Entwurf. Die Stabilität ist auch eine Frage des gefilterten Signals und wird hier eben nicht gewährleistet. Das Problem in diesem konkreten Fall ist, dass die geforderte Bandsperre sehr schmal und bei sehr niedriger Frequenz im Vergleich zur Abtastrate liegt (Breite 10 Hz bei 50Hz Mittenfrequenz und Abtastrate 22050sps), so dass die relative Frequenz gerade nur 0.0023 und die Bandbreite nur 0.00045 betragen. Bei so niedrigen Werten ist ein Filterentwurf sehr problematisch. Der sicherste Ausweg aus diesem Problem ist ein FIR-Filter, das immer stabil ist, denn es hat keine Rückführung. - Die geforderte Bandsperre wird einigermaßen erfüllt, was aber auf Kosten der Filterlänge geht, die hier mit 1776 Koeffizienten schon beachtlich ist. Durch Abspielen kann man sich überzeugen, dass dieses mal das Ziel erreicht wurde. + +![](Assets/Biosignalverarbeitung-netzunterdrückung.png) +Bei der realisierten Filterlänge von 1776 und der Abtastrate von 22050 kommt es zu einer Verzögerung des gefilterten Signals um 38ms, wie man insbesondere im rechten Bild gut erkennen kann. Im Normalfall bzw. bei geringen Ansprüchen wäre diese Verzögerung akzeptabel. Für zeitkritische Methoden der DSV (z.B. Quellenortung bzw. - verfolgung, Beamforming, adaptive Rauschunterdrückung) wäre das jedoch zu viel, wenn man bedenkt, dass der Schall in der Luft in dieser Zeit 12.m Strecke zurücklegt oder es sich um 38 Perioden einer 1kHz-Schwingung handelt. + +## Adaptive Filter +- ![](Assets/Biosignalverarbeitung-adaptiv-fir.png) + - FIR-Filterlänge = $2L+1$ + - Filterausgang: $y(n)=w(-L)x(n-L)+...+ w(L)x(n+L)= \overline{x}^T \overline{w}$ + - Modellfunktion, Sollsignal, desired response: $d(n)$ + - Fehlersignal, error: $e(n)=d(n)-y(n)$ +- Das adaptive Filter ist ein Rückgekoppeltes System mit negativer Rückkopplung, so dass -ähnlich wie bei Regelkreisen -auch Stabilitätsbedingungen eingehalten werden müssen. +- Die einfachste Variante eines adaptiven Filters (AF) ist ein FIR mit der Länge $2L+1$, das man mathematisch mit einem Vektor w beschreiben kann. Grundsätzlich kann der Eingangsvektor x physisch ein Spaltenvektor sein, dann entsprechend die Filterkoeffizienten der Wichtung von Signalen in parallel liegenden Kanälen, üblich in der spatialen Signalverarbeitung, kommt im nächsten Kapitel. Oder x ist ein Zeilenvektor, d.h. er wird als Analysefenster temporal über ein Signal geschoben, ist also ein Filter im üblichen Sinne der temporalen Filterung. Die physikalische Anordnung ist jedoch für die Herleitung an dieser Stelle irrelevant, im weiteren gehen wir wegen der einheitlichen Schreibweise von einem Spaltenvektor aus, wie üblich in der Signalverarbeitung. +- Der Ausgang entspricht der Faltung des Filtervektors mit dem Eingangssignal im Punkt n, jeweils L samples nach links und rechts bzw. nach oben und unten. +- $d(n)$ ist die desired response, regelungstechnisch das Sollsignal oder analytisch das Modell. +- Aus der Differenz von $d(n)$ und $y(n)$ wird das Errorsignal gebildet, das von einem Adaptionsalgorithmus ausgewertet wird und die Filterkoeffizienten dann von dem Algorithmus so verändert, dass der Fehler gegen Null konvergiert. + +- Errorsignal (Zeitindex weggelassen, daher auch spatial gültig): $e=d-y=d-\overline{x}^T \overline{w}$ +- Quadrat des Errorsignals: $e^2=d^2-2d\overline{x}^T\overline{w}+\overline{w}^T\overline{x}\overline{x}^T\overline{w}$ +- Erwartungswert: $F=E\{e^2\}=E\{d^2\}-2E\{d\overline{x}^T\overline{w}\}+E\{\overline{w}^T\overline{x}\overline{x}^T\overline{w}\}$ +- Wiener Filter: $E\{d\overline{x}\}=\overline{w}E\{\overline{x}\overline{x}^T\}$ + - $\overline{w}=R^{-1}*p$, R = Autokovarianzmatrix, p = Kreuzkovarianzvektor + - $W=\frac{p_{xd}}{p_{xx}}$, $p_xd=$ Kreuzleistungsdichte, $p_{xx}=$ Autoleistungsdichte +- Das Errorsignal ist ein Skalar, ergibt sich aus der Differenz der desired response (auf der Position n) und dem Skalarprodukt des Eingangsvektors mit den Filtervektor (Filterkoeffizienten) +- Man geht hier vom stationären Fall der Signalstatistik aus, so dass primär nicht der Momentanwert des Errors Null sein soll, sondern seine Energie bzw. Leistung. Dazu wird der Error zunächst quadriert (zweite Potenz ist Maß für Energie bzw. Leistung). +- Der Erwartungswert des Fehlers F (praktisch der quadratische Mittelwert) soll minimal werden, dann entspricht der Filterausgang der Modellfunktion. +- Man bildet die erste Ableitung des Fehlers F nach den Filterkoeffizienten (w für weights) und setzt diese gleich Null. Die Lösung dieser Gleichung ergibt das Wiener-oder Optimalfilter. +- Das Wienerfilter kann im Originalbereich mit Hilfe von Auto-und Kreuzkovarianzen beschrieben werden, +- oder im Spektralbereich mit Auto-und Kreuzleistungsdichte (siehe Regelungstechnik und Modellbildung) + +- Schätzung des Erwartungswertes des Fehlerquadrats: $E\{e^2\}\approx \frac{1}{M}\sum_{i=1}^M e_i^2$ +- Schätzung des Erwartungswertes der Autokorrelationsmatrix: $R=E\{x*x^T\}\approx\begin{pmatrix} x(0)x(0) &...& x(0)x(M-1)\\ ...\\ x(M-1)x(0)& ...& x(M-1)x(M-1)\end{pmatrix}$ +- Schätzung des Erwartungswertes des Kreuzkorrelationsvektors: $p=E\{dx\}\approx dx$ + +- kontinuierliche Zeit + - Kreuzkorrelationsfunktion: $r_{xd}(\tau)=lim_{T\rightarrow\infty}\frac{1}{2T}\int_{-T}^T x(\tau)d(t+\tau)dt$ + - Autokorrelationsfunktion: $r_{xx}(\tau)=r_{xd}(\tau)|_{d=x}$ + - Kreuzleistungsdichte: $S_{xd}(f)=\int_{-\infty}^{\infty} r_{xd}(\tau)e^{-i2\pi ft}dt$ + - Autoleistungsdichte: $S_{xx}(f)=S_{xd}(f)|_{d=x}$ +- diskrete Zeit + - Kreuzkorrelationsfunktion: $r_{xd}(m)=\frac{1}{N}\sum_{n=1}^N x(n)d(n+m)$ + - Autokorrelationsfunktion: $r_{xx}(m)=r_{xd}(m)|_{d=x}$ + - Kreuzleistungsdichte: $S_{xd}(k)=\frac{1}{M}\sum_{m=0}^{M-1} r_{xd}(m)e^{-i2\pi km}$ + - Autoleistungsdichte: $S_{xx}(k)=S_{xd}(k)|_{d=x}$ + +Proleme bei der Realisierung des optimalen Filters +- Inverse Autokovarianzmatrix - rechentechnisches Problem +- Leistungsspektrum berechenbar, aber nur im stationären Fall +- Warum ein unbekanntes Signal filtern, wenn das gesuchte als Sollsignal bekannt ist + - Wiener Filter existiert nur theoretisch + - Das Wienerfilter zu realisieren ist in der Praxis sehr schwierig. Die Berechnung der inversen Autokovarianzmatrix stößt schon bei niedrigen Rangordnungen (etwa N=10) auf ihre Grenzen. + - Das Leistungsspektrum gilt nur für den stationären Fall, den wir bei Biosignalen auch nicht nur annähernd haben. + - Schließlich stellt sich die pragmatische Frage: Wenn wir genau wissen, wonach wir suchen -den das muss für die Modellfunktion bekannt sein -warum sollten wird danach dann noch suchen? + - Dennoch hat das Wienerfilter für die Filtertheorie grundlegende Bedeutung und kann in modifizierten Varianten auch umgesetzt werden. + +Stochastischer Prozess: Ensemble, Sequenz von Zufallsvariablen +- $X=\{X(n-m),...,X(n),....,X(n+m)\}$ +- ![](Assets/Biosignalverarbeitung-adaptiver-filter-stochastik.png) +- Starke Stationarität: die Verteilungen der Zufallsvariablen sind identisch +- Die Annahme der starken Stationarität ist zwar für viele Methoden der Signalstatistik notwendig (i.i.d. = independent identically distributed). Sie kann aber pratkisch nicht erfüllt bzw. geprüft werden. + +Schwache Stationarität +- $E\{x_t\}=\mu$ +- $var(x_t)<\infty$ +- $cov(x_{t1}, x_{t2})$ +- Da die Annahme der Gleichheit von Verteilungen der Zufallsgrößen real nicht geprüft werden kann, wird sie auch nicht gefordert. Faktisch müssen nur die Momente erster und zweiter Ordnung zeitlich konstant sein. +- Dies wiederum ist für die signalanalytische Praxis oft zu wenig, da Momente dritter und vierter Ordnung nicht gleich sein müssen (Schiefe, Exzess). + +Praktikable Koeffizientenberechnung - LMS +- alternativer Weg zum Fehlerminimum - über den Gradienten: $\Delta_j=\frac{\delta F(\bar{w})}{\delta \bar{w}}|_{w=w_j}$ +- Schätzung des Gradienten über den aktuellen Wert: $\hat{\Delta}_j=\frac{\delta(e_j^2(\bar{w}))}{\delta \bar{w}}|_{w=w_j} =we_j \frac{\delta e_j}{\delta \bar{w}}|_{w=w_j}=-2e_j \bar{x}_j$ +- Rekursionsformel für Filterkoeffizienten $\bar{w}_{j+1}=\bar{w}_j + 2\mu e_j \bar{x}_j$ +- $\mu$: Adoptionskonstante; $\lambda_{max}$: größter Eigenwert der Autokovarianzmatrix; $\frac{1}{\lambda_{max}}>\mu >0$ +- praktisch, Obergrenze gegeben durch Signalenergie: $\frac{1}{\sum_{j=0}^N x^2(j)}>\mu >0$ +- Die Fehlerfunktion $F(w)$ ist eine ($2L+1$ -dimensionale) Parabel, deren Minimum der Optimallösung entspricht. Es gibt mehrere Wege, dieses Minimum zu erreichen. An dieser Stelle leiten wir die Optimallösung mit Hilfe des sehr anschaulichen LMS-Algorithmus her (LMS - Least-Mean-Square, Methode der kleinsten Quadrate). +- Da der Weg zum Optimum über die inverse Autokovarianzmatrix und über die Leistungsdichten verbaut ist, nähern wir uns dem Minimum der Parabel mit Hilfe des Gradienten iterativ. Der Gradient ist mathematisch über die partiellen Ableitungen der Parameter definiert. Das stößt in der Praxis -vor allem bei der Online-Analyse -bald an Grenzen, da der Erwartungswert über längere Zeit ermittelt werden müsste. +- Daher schätzt man den Gradienten aus dem aktuellen Fehler, faktisch lässt man also die Mittelwertbildung weg. Das kann man unter der Annahme der Stationarität machen. Der geschätzte Gradient ergibt sich dann allein aus dem Produkt des Fehlers und des Eingangsvektors. +- Nun kann man den Gradienten dazu nutzen, mit hinreichend kleinen, durch die Adaptionskonstante bestimmten, Schritten auf das Minimum zu konvergieren. +- Die Stabilitätsbedingung ergibt sich aus dem größten Eigenwert der Autokovarianzmatrix. In der Praxis wird die wesentlich einfacher zu berechnende Signalenergie verwendet, die größer ist als der Eigenwert und damit die Stabilität auch hinreichend sicher gewährleistet. + +Reale Aufname: IPG, periodische Störung, Rauschen +- ![](Assets/Biosignalverarbeitung-adaptiver-filter-reale-aufnahme.png) +- Ein reales IPG wurde nachträglich mit additiven simulierten Störungen (50 Hz, 75 Hz, Rauschen) stark gestört (Amplitude der Harmonischen $A=1$, Effektivwert des Rauschens 20). +- Eine Modellfunktion liegt daher vor. +- Das gefilterte Signal erreicht relativ schnell die Qualität des Originals. +- Basiert auf der Übung 5.4 des Buches Biosignalverarbeitung/Elektrische Biosignale in der Medizintechnik + +Adaptiver Muster-Filter +- ![](Assets/Biosignalverarbeitung-adaptiver-filter-aufbau.png) +- $x(n)$: reales Signal +- $e(n)$: Fehler +- $d(n)$: ungestörtes Muster (woher?) +- $y(n)$: Filterausgang +- Funktion: Im Ausgang $y(n)$ erscheinen diejenigen Signalanteile von $x(n)$, die gut mit $d(n)$ korrelieren +- Im stationären Fall und nach erfolgter Konvergenz kann man davon ausgehen, dass der Filterausgang diejenigen Anteile von $x(n)$ enthält, die mit $d(n)$ gut korrelieren. Das funktioniert natürlich nur, wenn man das Mustersignal ganz genau kennt und vorgeben kann. +- Woher aber sollen wir das Mustersignal nehmen, wenn es ja gestört und verrauscht am Filtereingang vorliegt? Fazit ist, ein solches Filter ist nicht realisierbar bzw. macht keinen Sinn, wenn das Muster vorliegt. + +Adaptiver Noise Canceller - ein praktikables adaptives Filter +- ![](Assets/Biosignalverarbeitung-adaptiver-filter-noise-canceller.png) +- $ref$: Rauschreferenz +- $err$: Signal +- $prim$: Signal + Rauschen +- $out$: Rauschen +- In der praktischen Analyse ist es sehr oft so, dass man zwar kein Mustersignal hat, dafür aber eine Rauschreferenz, d.h. genügend Information über das Störsignal ohne Anteile des gewünschten Signals. Die Aufgabe jetzt heißt also, wenn wir schon kein Mustersignal haben, dann können wir versuchen, die Störung zu beseitigen, wenn wir sie kennen. Im Idealfall ist die Störung eliminiert und das gewünschte Signal bleibt übrig. +- Hierzu werden die Filteranschlüsse umfunktioniert: Der Filtereingang wird zur Rauschreferenz, hier wird die vorliegende Störung eingespeist, die allerdings keine Anteile des gewünschten Signals enthalten darf. Dies ist aber bei technischen Störungen bei Biosignalverarbeitung kein wesentliches Problem. +- Der Eingang für Mustersignal wird zum Primäreingang, in den das gestörte aber noch unbekannte Wunschsignal eingespeist wird. +- Entsprechend dem Funktionsprinzip erscheint am Filterausgang der Teil vom Referenzeingang, der gut mit dem Primärsignal korreliert -die Störung, in diesem Beispiel die Netzstörung. Da aber das Primärsignal mit dem Referenzsignal nicht korreliert, muss das gesuchte Signal als Rest -als Errorsignal -übrig bleiben. Demzufolge ist der eigentliche Ausgang eines ANC das ursprüngliche Errorsignal. +- Man kann folgende Überlegung anstellen: Am Filterausgang liegen die Signalanteile vom Filtereingang an, die gut mit dem Primäreingang korrelieren. Das Filter stellt sich relativ langsam auf die Optimallösung ein, denn es geht vom stationären Prozess aus und konvergiert auf das Optimum mit der Adaptionskonstante tau zu. Wenn man nun des gestörte Signal auf den primären Eingang legt und auf den Referenzeingang statt der Rauschreferenz -die nicht immer verfügbar ist -das gleiche, jedoch zeitlich verschobenes Signal, so ändert sich die Lage für die stationäre und gut korrelierende Störung nicht -sie ist in beiden, dem Referenz-und dem Primäreingang enthalten. Demzufolge wird sie auch am Ausgang des Filters -wie mit Rauschreferenz erscheinen. Also wird sich die Störung aus dem Errorsignal wie mit Referenz wegfiltern und übrig bleibt das gewünschte Signal, auch ohne die Notwendigkeit, eine Störungsreferenz bereitstellen zu müssen. Das funktioniert natürlich nur so lange, wie zeitverschobene Anteile des gewünschten Signals miteinander bei der konkreten Zeitverschiebung unkorreliert sind, daher kommt der Wahl des Zeitversatzes entscheidende Bedeutung zu. Allerdings ist es nicht möglich, streng mathematisch oder pauschal eine gute Verschiebung anzugeben. Diese wird -wie auch die Adaptionskonstante -eher nach empirischen Gesichtspunkten (,,nach Gefühl'') eingestellt. + +Adaption des ANC vom IPG +- IPG gestört periodisch und stochastisch (50Hz, 75 Hz, Rauschen) +- Startwert für Gewichte $w(50)$ und $w(52)$ mit $L=101$ bei $(0,0)$ +- Variabilität höher bei größerer Adaptionskonstante +- Variabilität niedriger bei kleinerer Adaptionskonstante +- ![](Assets/Biosignalverarbeitung-adaptiver-filter-adaption-anc.png) +- Verläufe der Gewichte des Signals + - ![](Assets/Biosignalverarbeitung-adaptiver-filter-reale-aufnahme.png) +- Zeitverlauf + - ![](Assets/Biosignalverarbeitung-adaptiver-filter-zeitverlauf-anc.png) + +Beispiel: +- ![](Assets/Biosignalverarbeitung-adaptiver-filter-ekg+netz.png) +- Der ANC enthält nach abgeschlossener Konvergenz die Impulsantwort des optimalen Filters. Im Falle einer Netzstörung ist es also ein sehr schmaler Bandpass bei der Netzfrequenz bzw. die Impulsantwort ist identisch der Harmonischen der Netzfrequenz. + +Beispiel +- ![](Assets/Biosignalverarbeitung-adaptiver-filter-ekg-abdominal.png) +- $\mu=0,02$, $L=101$ +- Der ANC wurde zur Trennung des fötalen EKG (fEKG) vom maternalen mEKG. Zur Gewinnung des fEKG wird das abdominale EKG (aEKG, vom Bauch) benötigt, das mEKG wird konventionell an Extremitäten abgeleitet. Das fEKG (untere Grafik) ist nur schlecht erkennbar und vom mEKG selbst nach zahlreichen empirischen zweidimensionalen Optimierungen der Filterlänge und der Adaptionskonstante noch immer stark gestört. Die Ursache liegt darin, dass beide Signale (Störung und gestörtes Signal) stark instationär sind, die für die Konvergenz zur optimalen Lösung notwendige Bedingung der Stationarität mindestens eines Signalanteils ist hier nicht erfüllt. + +EKG mit Matched Filter +- ![](Assets/Biosignalverarbeitung-adaptive-filter-match-filter.png) +- In bestimmten Messsituationen (Ruhe EKG vor Fahrradergometrie) liegt eine Musterfunktion (Template) vor. +- Für signalanalytische korrekte Detektion/Filterung müssen Signal (EKG) sowie Template (Muster) weißes Spektrum haben +- Zum Prewhitening wird LMS mit binärem Gradienten verwendet. Die selben Filterkoeffizienten filtern auch das Template für das MF +- Lineare Prädikation: $x_p[k]=a_1x[k-1]+a_2x[k-2]+...+a_nx[k-n]$ +- Residualfehler ist weiß: $x_{err}[k]=x[k]-x_p[k]$ +- Robuster LMS mit binärem Gradienten: $w[k+1]=w[k]+\mu*sng(e[k]x[k])$ + +![](Assets/Biosignalverarbeitung-adaptiver-filter-ekg-roh-weiß.png) +- Da Biosignale relativ tieffrequente Signale sind (Energiemaximum zwischen 10 Hz und 100 Hz), führt Prewhitening zur relativen Anhebung der hochfrequenten Anteile (grüne Kurve oben) sowie des breitbandigen Rauschens. +- Wegen der relativen Anhebung hochfrequenten Anteile haben Prewhitener implizit einen Hochpass-Charakter. Dies kann man gut im Vergleich der blauen (Original) und der grünen Kurven erkennen: Die tieffrequenten Anteile (,,langsame Wellen'') sind nach Prewhitening deutlich reduziert. + +Template nach QRS +- ![](Assets/Biosignalverarbeitung-adaptiver-filter-qrs.png) +- QRS Template wird aus den letzten 9 detektierten Komplexen berechnet +- das Template wird mit dem adaptiven Filter gefiltert, mit dem das EKG geweißt wurde +- mit dem geweißten Template wird das geweißte EKG gefiltert +- ![](Assets/Biosignalverarbeitung-adaptiver-filter-ekg-mtchfit.png) +- Durch das Prewhitening und nach dem MF (matched filter) ist die Signalform des Biosignals zum Teil stark verändert. Daher eignet sich das MF nur zur Detektion von Biosignalkomponenten, nicht aber zur diagnostischen Kurvenvermessung. +- Das MF ist der empfindlichste und sicherste Detektor von bekannten Mustern. diff --git a/Kryptographie.md b/Kryptographie.md new file mode 100644 index 0000000..45a4566 --- /dev/null +++ b/Kryptographie.md @@ -0,0 +1,3485 @@ +- [Einführung](#einführung) +- [Symmetrische Verschlüsselung, Sicherheitsmodelle](#symmetrische-verschlüsselung-sicherheitsmodelle) + - [Einmalige symmetrische Verschlüsselung und klassische Verfahren](#einmalige-symmetrische-verschlüsselung-und-klassische-verfahren) + - [Kryptosysteme und possibilistische Sicherheit](#kryptosysteme-und-possibilistische-sicherheit) + - [Wiederholung: Elementare Wahrscheinlichkeitsrechnung](#wiederholung-elementare-wahrscheinlichkeitsrechnung) + - [Informationstheoretische Sicherheit](#informationstheoretische-sicherheit) + - [Fallstudie für Cyphertext-only-Angriffe: Vigenère-Chiffre](#fallstudie-für-cyphertext-only-angriffe-vigenère-chiffre) + - [Die Vigenère-Chiffre und Angriffe bei bekannter Schlüssellänge](#die-vigenère-chiffre-und-angriffe-bei-bekannter-schlüssellänge) + - [Der Kasiski-Test](#der-kasiski-test) + - [Koinzidenzindex und Friedman-Methode](#koinzidenzindex-und-friedman-methode) +- [Frische symmetrische Verschlüsselung und Blockchiffren](#frische-symmetrische-verschlüsselung-und-blockchiffren) + - [Substitutions-Permutations-Kryptosysteme (SPKS)](#substitutions-permutations-kryptosysteme-spks) + - [Einschub: Endliche Körper](#einschub-endliche-körper) + - [AES: Advanced Encryption Standard](#aes-advanced-encryption-standard) + - [AES-Chiffrieralgorithmus](#aes-chiffrieralgorithmus) + - [Die S-Box von AES:](#die-s-box-von-aes) + - [AES-Rundenschlüsselberechnung](#aes-rundenschlüsselberechnung) + - [Bemerkungen zu randomisierten Algorithmen](#bemerkungen-zu-randomisierten-algorithmen) + - [Ressourcenverbrauch](#ressourcenverbrauch) + - [Randomisierung bei Straight-Line-Programmen](#randomisierung-bei-straight-line-programmen) + - [Prozeduren als Parameter](#prozeduren-als-parameter) + - [Sicherheit von Block-Kryptosystemen](#sicherheit-von-block-kryptosystemen) +- [Uneingeschränkte symmetrische Verschlüsselung](#uneingeschränkte-symmetrische-verschlüsselung) + - [Betriebsarten](#betriebsarten) + - [ECB-Betriebsart ( ,,Electronic Code Book mode'' )](#ecb-betriebsart--electronic-code-book-mode-) + - [CBC-Betriebsart( ,,Cipher Block Chaining mode'' )](#cbc-betriebsart-cipher-block-chaining-mode-) + - [R-CBC-Betriebsart( ,,Randomized CBC mode'' )](#r-cbc-betriebsart-randomized-cbc-mode-) + - [OFB-Betriebsart( ,,Output Feed Back mode'' )](#ofb-betriebsart-output-feed-back-mode-) + - [R-CTR-Betriebsart (,,Randomized CounTeR mode'' )](#r-ctr-betriebsart-randomized-counter-mode-) + - [Sicherheit von symmetrischen Kryptoschemen](#sicherheit-von-symmetrischen-kryptoschemen) +- [Zahlentheorie und Algorithmen](#zahlentheorie-und-algorithmen) + - [Fakten aus der Zahlentheorie und grundlegende Algorithmen](#fakten-aus-der-zahlentheorie-und-grundlegende-algorithmen) + - [Modulare Arithmetik](#modulare-arithmetik) + - [Inverse in Restklassenringen](#inverse-in-restklassenringen) + - [Der Chinesische Restsatz](#der-chinesische-restsatz) + - [Primzahlen](#primzahlen) + - [Der Primzahltest von Miller und Rabin](#der-primzahltest-von-miller-und-rabin) + - [Der Fermat-Test](#der-fermat-test) + - [Carmichael-Zahlen](#carmichael-zahlen) + - [Nichttriviale Quadratwurzeln der 1](#nichttriviale-quadratwurzeln-der-1) + - [Der Miller-Rabin-Test](#der-miller-rabin-test) + - [Fehlerschranke für den Miller-Rabin-Test](#fehlerschranke-für-den-miller-rabin-test) + - [Die Erzeugung von (zufälligen) Primzahlen](#die-erzeugung-von-zufälligen-primzahlen) + - [Beweise und Bemerkungen zu Kapitel 4](#beweise-und-bemerkungen-zu-kapitel-4) +- [Asymmetrische Verschlüsselung: RSA & Co.](#asymmetrische-verschlüsselung-rsa--co) + - [Das RSA-Kryptosystem (,,Vorlesungs-Version'')](#das-rsa-kryptosystem-vorlesungs-version) + - [Schlüsselerzeugung](#schlüsselerzeugung) + - [Verschlüsselung](#verschlüsselung) + - [Entschlüsselung](#entschlüsselung) + - [Asymmetrische Kryptoschemen, Sicherheitsbegriff](#asymmetrische-kryptoschemen-sicherheitsbegriff) + - [Asymmetrische Kryptoschemen](#asymmetrische-kryptoschemen) + - [Sicherheit von asymmetrischen Kryptoschemen](#sicherheit-von-asymmetrischen-kryptoschemen) + - [Weitere Bemerkungen zur Sicherheit und effizienten Verwendung von RSA](#weitere-bemerkungen-zur-sicherheit-und-effizienten-verwendung-von-rsa) + - [Äquivalenz ,,d bekannt'' zu ,,N faktorisieren''](#äquivalenz-d-bekannt-zu-n-faktorisieren) + - [Bemerkungen zum Faktorisierungsproblem, allgemein](#bemerkungen-zum-faktorisierungsproblem-allgemein) + - [Zufallskomponente](#zufallskomponente) + - [Effizienzverbesserungen](#effizienzverbesserungen) + - [Das Rabin-Kryptosystem](#das-rabin-kryptosystem) + - [Diskrete Logarithmen und Anwendungen](#diskrete-logarithmen-und-anwendungen) + - [Diskrete Logarithmen](#diskrete-logarithmen) + - [Diffie-Hellman-Schlüsselaustausch](#diffie-hellman-schlüsselaustausch) + - [Das ElGamal-Kryptosystem](#das-elgamal-kryptosystem) + - [Berechnung diskreter Logarithmen](#berechnung-diskreter-logarithmen) + - [Elliptische Kurvenuber endlichen Körpern](#elliptische-kurvenuber-endlichen-körpern) +- [Anhang: Beweis von Satz 3.8](#anhang-beweis-von-satz-38) + - [Beweise und Bemerkungen zu Kapitel 4](#beweise-und-bemerkungen-zu-kapitel-4-1) + +Literaturempfehlung: +- Ralf Küsters und Thomas Wilke: Moderne Kryptographie,Vieweg+ Teubner 2011 +- Jonathan Katz und Yehuda Lindell, Introduction to Modern Cryptography,CRCPress, 2015 +- Ulrike Baumann, Elke Franz, Andreas Pfitzmann,Kryptographische Systeme, SpringerVieweg 2014 +- Albrecht Beutelspacher, Heike B. Neumann,Thomas Schwarzpaul: Kryptographie in Theorie und Praxis,Vieweg, 2005 +- Douglas R. Stinson: Cryptography-Theory and Practice,CRC Press, 1995 +- Dietmar Wätjen: Kryptographie, Spektrum Akademischer Verlag, 2004 +- David Kahn: The Codebreakers, Scribner, 1996 + +# Einführung +_$\kappa\rho\vartheta\pi\tau\delta\zeta$_= kryptos(griech.): verborgen +_$\gamma\rho\alpha\varphi\epsilon\iota\nu$_ = graphein (griech.): schreiben + +Kryptographie im klassischen Wortsinn betrifft also Methoden,Nachrichten so zu schreiben, dass sie ,,verborgen'' bleiben,das heißt von keinem Unberechtigten (mit)gelesen werden können.Das hier angesprochene ,,Sicherheitsziel'' heißt ,,Vertraulichkeit'' oder ,,Geheimhaltung'' oder Konzelation (concelare(lat.):sorgfältig verbergen, davon englisch: conceal). Verfahren, die dieses Ziel erreichen,heißen Konzelationssysteme. + +Simples Schema für dieses Problem (Aktion schreitet von links nach rechts fort, zu Schlüsseln später mehr): +| | | | | +| -------------- | ----------------------------------------- | --------------------------------------------------------------------- | ---------------------------------------------------------------- | ------------------------ | +| Sender | Verschlüsselung | Chiffretext y | Entschlüsselung | Empfänger | +| Alice | (Chiffrierung, authentisieren, signieren) | über | (Dechiffrierung, Absenderdentität prüfen, Unversehrtheit prüfen) | Bob | +| hat Klartext x | | unsicheren Kanal | | rekonstruiert Klartext x | +| | Schlüssel k | | Schlüssel k' | +| | | Gegnerin Eva (enemy, eavesdropper, Kryptoanalytiker/in, Angreifer/in) | | | + +,,Alice'' ist dabei ein eingebürgerter Name für die sendende Instanz, ,,Bob'' der für die empfangende Instanz. Dabei kann es sich um Personen, Organisationen oder auch Computer(systeme) o. ä. handeln. Der Verschlüsselungsbereich von Alice (links von der zweiten senkrechten Linie) ist gegen Zugriffe von Eva geschützt, ebenso der Entschlüsselungsbereich von Bob(rechts von der dritten senkrechten Linie). + +Beispiel 1: +- Alice = Bank (und ihr Computersystem), +- Bob = Online-Bankkunde, +- Nachricht x = Kontoauszug. Übermittlung des Kontoauszugs über das Internet (,,offenerKanal''). +- Sicherheitsziel: Stelle sicher, dass die Angreifer in Eva (der Internetkriminelle) die vertrauliche Information nicht mitlesen kann, obgleich sie die verschlüsselte Version y der Nachricht sehen kann. + +Beispiel 2: +- Alice = Bob = eine Universität. +- Nachricht x = die Liste aller persönlichen Daten aller Studierenden. Diese große Datei soll auf einem Cloudserver (im Ausland) gespeichert werden. Dazu wird sie als y verschlüsselt,um Zugriffe dritter Parteien auf die vertraulichen Daten zu verhindern. + +Im Kontext der modernen elektronischen Kommunikation ergeben sich neben der Konzelation auch weitere, andersartige und unabhängige Aufgaben, die mit kryptographischen Methoden,also von Kryptosystemen ausgeführt werden. Wir führen auf: +- Konzelation: Geheimhaltung/Vertraulichkeit/Zugriffsschutz(kein Unberechtigter kann Nachrichteninhalt mithören oder mitlesen) +- Integrität/Fälschungsschutz (stelle sicher, dass Nachrichten auf dem Übertragungsweg nicht manipuliert worden sind) +- Authentizität/Signaturen: Garantiere Absenderidentität (Bob kann kontrollieren, dass Nachricht vom behaupteten Absender Alice kommt) +- Nichtabstreitbarkeit (Bob kann gegenüber Dritten beweisen,dass die Nachricht in der empfangenen Form vom behaupteten Absender Alice kam) +- ... + +Integrität bzw. Authentisierung: Hier ist die Aufgabenstellung verändert. Eva hat nicht nur die Fähigkeit, Nachrichten passiv mitzulesen, sondern sie kann in den Kommunikationskanal eingreifen. Sie kann Nachrichten abfangen(und sogar die Weiterleitungverhindern) und/oder eine neue bzw. veränderte Nachricht in den Kanal einspeisen. Ihre Absicht ist es,Bob dazu zu bringen, diese Nachricht für die echte von Alice abgeschickte Nachricht zu halten.Diese Art von Angriff soll verhindert werden. Hierfür verwendet man einen Mechanismus,der message authentication code (MAC) heißt. Darunter kann man sich eine Funktion vorstellen, die aus einer Nachricht x einen(nicht allzu langen) Code $mac=MAC(x)$ berechnet. Diese Funktion ist ein Geheimnis von legitimen Sendern von Nachrichten an Bob. Insbesondere kann Eva bei gegebener Nachricht x' (verwandt zu x oder nicht) keinen korrekten MAC für x' berechnen. Bob verfügt über ein Prüfverfahren, das es ihm erlaubt, ein empfangenes Paar $(x,mac)$ darauf zu testen, ob der zweite Teil der zu x gehörende MAC-Wert ist. Wenn Alice die einzige Instanz ist,die die geheime Funktion MAC kennt, dann kann Bob sogar überprüfen, ob Alice tatsächlich die Absenderin ist. + +Beispiel 3: +- Alice = Bankkundin, +- Bob = Bank, +- Nachricht = Überweisungsauftrag +- **Integrität**: Stelle sicher, dass Eva nicht Aufträge von Alice,obgleich über offenen Kanal (Internet) übermittelt, abfangen und durch manipulierten oder ganz neuen Auftrag ersetzen kann(nicht Kontonummern oder Beträge ändern kann). +- **Authentizität**: Eva soll nicht, ohne Aktivität von Alice,der Bank vortäuschen können, dass sie Alice ist, und Aufträge erteilen. +- Die **Nichtabstreitbarkeit** ist eine noch stärkere Anforderung an Geschäftsvorgänge, die über das Internet abgewickelt werden. Bei Streit (vor Gericht) soll die Bank nachweisen können, dass ein Auftrag, den sie ausgeführt hat, tatsächlich von Alice stammt. (Im analogen Leben wird dies durch eine als echt nachgewiesene Unterschrift bewirkt.) Hier übernimmt also sogar Alice, die Kundin,die Rolle der Gegenspielerin. + +Die Kryptographie im engeren und ,,klassischen'' Sinn beschäftigt sich mit Verfahren, um in verschiedenen Kommunikationsszenarien eine gegen Angriffe von Gegnern (Mitlesen, Verändern, Unterschieben, Abstreiten) abgesicherte Kommunikation zu ermöglichen. + +Auf der anderen Seite steht die Kryptoanalyse(englisch cryptanalysis). Ursprünglich und jahrhundertelang entwickelten Kryptoanalytiker Methoden zum ,,Brechen'' von Konzelationssystemen, also zum unberechtigten Mitlesen trotz Verschlüsselung. Heute gehören zur Kryptoanalyse auch Angriffe auf andere kryptographische Methoden, mit dem Ziel, ihre Sicherungsfunktion zu umgehen. Es ist wichtig, im Auge zu behalten, dass die Gleichsetzung von Kryptoanalyse mit der Absicht, unberechtigt in die Kommunikation einzugreifen, nicht unbedingt richtig ist. Um die Sicherheit von kryptographischen Verfahren sicherzustellen, ist es unbedingt nötig, dass mit kryptoanalytischen Methoden versucht wird, Schwachstellen solcher Verfahren offenzulegen.Erst die Kenntnis von Schwachstellen macht es möglich, diese zu beseitigen. + +Eine klassische Einteilung ist also folgende: +- **Kryptologie** = Kryptographie (Entwicklung von kryptographischen Verfahren) + Kryptoanalyse (Versuche, kryptographische Verfahren zu brechen). + +Für sehr lange Zeit war (und ist auch immer noch) die Beziehung zwischen diesen beiden Seiten die eines Katz-und Maus-Spiels. Die Kryptographie war bestrebt, immer cleverere und ,,sicherere'' Verfahren zu entwickeln, die Kryptoanalyse versuchte, Schwächen in diesen Verfahren aufzuspüren, und zwar sowohl, um unberechtigte Zugriffe auszuführen, als auch, um die Schwächen offenzulegen, um ihre Beseitigung zu ermöglichen. (Die Liste der jemals vorgeschlagenen Systeme und Verfahren,die sich früher oder später als ,,schwach'' erwiesen, ist sehr lang.) + +Eine Randbemerkung: Man könnte auf den ersten Blick den Eindruck bekommen, dass das Anliegen, Nachrichten vertraulich und ohne Manipulationen auszutauschen, zunächst einmal legitim ist und dass Angriffe illegitim sind.Dieser Eindruck wird eventuell durch die Verwendung der harmlosen Bezeichnungen ,,Alice'' und ,,Bob'' für die Kommunikationsparteien einerseits und ,,Eva'' (Gegnerin, Angreiferin, usw.) andererseits verstärkt. Sicherlich ist diese Sicht für viele Situationen insbesondere in der Geschäftswelt passend. Es zeigt sich aber nach kurzem Überlegen, dass nicht in allen Fällen der Schutz das legale oder moralisch gute Ziel sein muss, dass kryptographische Verfahren auch für rechtswidrige, unethische, gefährliche, völkerrechtswidrige, terroristische Zwecke eingesetzt werden (können) und die Kryptoanalyse, das Eingreifen in solche Kommunikation,manchmal rechtlich und moralisch geboten ist. Man landet hier schnell bei interessanten und schwierigen ethischen Fragen. Wie sehr viele Technologien, natürlich eigentlich die gesamte IT und die Informatik, ist die Kryptologie eine Wissenschaft, deren verschiedene Ergebnisse und Entwicklungen für erstrebenswerte wie auch für schlimme Ziele benutzt werden können, wir sind hier beim grundlegenden Thema ,,DualUse''. + +Seit den 1980er Jahren wurde eine neue Sicht auf die Kryptologie entwickelt. Dabei schlägt man für verschiedene Kommunikationsszenarien und Sicherheitsziele (Konzelation, Integrität, Authentisierung, Nichtabstreitbarkeit, usw.) ganz präzise mathematische Formulierungen vor, sogenannte Sicherheitskonzepte. Anschließend ist man, wenigstens im Prinzip, in der Lage, Verfahren darauf abzuklopfen, ob sie diese präzise formulierten Sicherheitsanforderungen erfüllen. + +Die ,,moderne'' Kryptologie beschäftigt sich also mit kryptographischen Verfahren, mit kryptoanalytischen Verfahren, mit Sicherheitskonzepten und mit mathematischen Methoden zur Untersuchung dieser Dinge, abstrakt und an konkreten Verfahren. +Achtung: Man findet (heute noch mehr als früher) oft die Bezeichnung ,,Kryptographie'' bzw. ,,cryptography'' für die gesamte Kryptologie. Dies betrifft auch alle Titel von Büchern, die trotz des Namens ,,Kryptographie'' bzw. ,,cryptography'' alle Aspekte behandeln. + +Ein Zitat aus dem Buch von Katz und Lindell: Moderne Kryptographie ist die Wissenschaft von den mathematischen Methoden, die man benutzen kann, um digitale Information, Systeme und verteilte Anwendungen gegen Eingriffe (,,Angriffe'') von unberechtigten Parteien zu schützen. Dabei geht es sowohl um die Konstruktion von kryptographischen Systemen und um die Entwicklung und Untersuchung von Angriffen als auch um Beweise für die Sicherheit von Systemen. + +Leider sind die Sicherheitsbeweise in den allermeisten Fällen relativ zu unbewiesenen (aber wenigstens plausiblen)mathematischen oder komplexitätstheoretischen oder kryptographischen Annahmen. + +In der Vorlesung folgen wir zum Teil den klassischen Ansätzen, ab er stellen auch den modernen Ansatz im Prinzip vor und verstehen ihn an ausgewählten Beispielen. + +Bei der Diskussion im Stil des modernen Ansatzes muss man immer die folgenden Komponenten beschreiben: Was ist die Kommunikationssituation, welches sind die Akteure, was ist das Sicherheitsziel? Bei Konzelationssituationen gibt es Alice und Bob, wobei Alice eine Nachricht oder mehrere Nachrichten an Bob übermitteln möchte. Gegenspielerin Eva kann die gesendeten Nachrichten mitlesen und hat eventuell Zugriff auf einige Klartext-Chiffretest-Paare, ab er sie kann nicht anderweitig eingreifen. Das Sicherheitsziel ist grob gesprochen,dass Eva aus einem Chiffretext y keine ,,nicht trivialen Informationen'' über den Klartext x erlangen kann. (Ein ,,triviale Information'' , die sie immer erhält, ist die Tatsache, dass eine Nachricht geschickt wurde.) Es gibt mehrere Präzisierungen dieser Situation, die von folgenden Faktoren abhängen: +- Art der Kommunikation +- Evas Fähigkeiten und Möglichkeiten (kann sie nur mitlesen oder auch Nachrichten einschleusen?) +- was wir als ,,nichttriviale Information'' bezeichnen + +Wir werden zumindest in einfachen Situationen präzise definieren, was es heißt, ,,das Sicherheitsziel zu erreichen'' und dabei die Komplexität der Anforderungen schrittweise erhöhen. +Exemplarisch wird diskutiert werden, die Verfahren für einfachere Situation zu Verfahren für kompliziertere Verfahren ausgebaut werden können. + +Schließlich muss noch kurz das Konzept ,,Schlüssel'' diskutiert werden. Wir beginnen mit einem Beispiel, nämlich einem jahrtausende alten Konzelationssystem. + +Beispiel: Cäsar-Chiffre. Betrachte das antike lateinische Alphabet mit 21 Buchstaben: + A B C D E F G H I K L M N O P Q R S T V X + 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 + +Cäsar ließ Texte verschlüsseln, indem er folgende Ersetzung Buchstabe für Buchstabe durchführen ließ: + A B C D E F G H I K L M N O P Q R S T V X + D E F G H I K L M N O P Q R S T V X A B C + +(Man nimmt immer den Buchstaben, der im Alphabet drei Positionen ,,weiter rechts'' steht, mit ,,wrap around'' am Ende.) +Beispiel: +- Klartext x= IMPETVS ( ,,Angriff '' ) +- wird y= MPSHABX + +Der Nachteil ist offensichtlich: Wer den Trick kannte, konnte jede Nachricht mitlesen. + +Eine einfache ,,Verbesserung'' dieses sehr primitiven Ansatzes ist Folgendes: Verschiebe zyklisch um eine andere Anzahl von Buchstaben als 3. Für eine Verschiebung um $k=9$ Positionen ergibt sich: + A B C D E F G H I K L M N O P Q R S T V X + K L M N O P Q R S T V X A B C D E F G H Iüm hier die Verschlüsselung und die Entschlüsselung durchzuführen, musste man als ,,Schlüssel'' nur das Bild von A kennen (im Beispiel K), alternativ die Verschiebeweite k +als Zahl. Es gibt dann 21 Schlüssel (wobei zunächst ,,A'' oder Verschiebeweite 0 zunächst ziemlich sinnlos erscheint).Diese Methode heißt Verschiebechiffre. + +Eine ziemlich naheliegende Verallgemeinerung von Verschiebechiffren ist auf den ersten Blick viel mächtiger: Sie sagt, dass das Bild eines Buchstabens ein ganz beliebiger anderer Buchstabe sein soll. Dabei müssen natürlich verschiedene Buchstaben auf verschiedene Buchstaben abgebildet werden. Es er gibt sich eine ,,Substitutionschiffre'' ,die durch eine Tabelle mit ganz beliebiger Buchstabenanordnung gegeben ist. Beispiel: + A B C D E F G H I K L M N O P Q R S T V X + F Q M P K V T A E L H N I G D S B X O R C + +Wenn man hier ver- und entschlüsseln möchte, muss man die gesamte zweite Tabellenzeile kennen. Diese kann hier also als ,,Schlüssel'' dienen. Es gibt $21!\approx 5,11* 10^{19}$ viele verschiedene Schlüssel. + +Viel später (16.Jh.) wurde die ,,Vigenère-Verschlüsselung'' vorgeschlagen: Man benutzt dabei nicht einen Schlüssel,der dann auf jeden Buchstaben des Klartextes angewendet wird,sondern ein Schlüsselwort $a_0,...,a_{s-1}$ größerer Länge $s > 1$. Man könnte (und das wurde auch so getan) s verschiedene Substitutionschiffren benutzen. Zum Ver-und Entschlüsseln +würde man dann eine Liste von s vielen Permutationen der 21 Buchstaben benötigen. Einfacher ist es, s Verschiebe chiffren zu benutzen. Dann ist ein Schlüssel tatsächlich ein Wort über dem Alphabet $\{A,...,X\}$. + +Man geht dann also wie folgt vor: $x=x_0...x_{n-1}$ ist der Klartext, $k=a_0 ...a_{s-1}$ der Schlüssel.Verschlüssle x mit den durch k gegebenen Verschiebungen wie folgt: +$x_0$ mit $A \rightarrow a_0$ ,$x_2$ mit $A \rightarrow a_2,... ,x_{s-1}$ mit $A\rightarrow a_{s-1}$. + +Wenn der Schlüssel k aufgebraucht ist, benutze ihn wieder von vorne: Verschlüssle $x_i,i\geq s$, mit Verschiebung $A \rightarrow a_{i\ mod\ s}$. + +Beispiel: Schlüssel ist $k=ARCVS$ (für arcus, Bogen). Buchstaben an Positionen $0 , 5 , 10 ,...$ bleiben gleich,da A Position 0 hat, Buchstaben an Positionen $1 , 6 , 11 ,...$ werden um 16 Positionen verschoben (da R Position 16 hat),Buchstaben an Positionen $2 , 7 , 12 ,...$ werden um 2 Positionen verschoben (da C Position 2 hat), und so weiter.Es ergibt sich: + +| | | +| ------------------------- | --------------------------- | +| (wiederholter) Schlüssel: | A R C V S A R C V S A R C V | +| Klartext: | S E N A T V S R O M A N V S | +| Chiffretext: | S X P V P V N T M H A G A Q | + +Ab hier betrachten wir meist nur Verfahren, die Schlüssel verwenden. Bei kryptographischen Verfahren mit Schlüsseln betrachten wir zwei grundsätzlich unterschiedliche Ansätze: +- Symmetrische(Private-Key)-Kryptographie: Es gibt einen geheimen Schlüssel $k$, den beide der kommunizierenden Parteien kennen müssen. Bei Konzelationssystemen bedeutet dies etwa, dass das Verschlüsselungsverfahren und das Entschlüsselungsverfahren beide diesen Schlüssel $k=k'$ benutzen. Symmetrische Verfahren sind unser erstes Thema. Ein aktuelles standardisiertes symmetrisches Verfahren ist etwa AES + (AdvancedEncryptionStandard). +- Asymmetrische (Public-Key-) Kryptographie: Nur eine Seite hat einen geheimen Schlüssel $k'$, die andere Seite benutzt einen ,,öffentlichen'' Schlüssel $k\not =k'$. Beispiel: Bei Konzelationssystemen hat der Empfänger (Bob) einen geheimen Schlüssel $k'$, der Sender (Alice) benutzt zur Verschlüsselung einen von Bob ausgegebenen öffentlichen Schlüssel $k\not =k'$. (Bei Authentisierung oder bei digitalen Signaturen ist es umgekehrt.) Asymmetrische Verfahren sind unser zweites Thema. Ein weit verbreitetes asymmetrisches Verfahren ist RSA (nach den Erfindern Rivest, Shamir und Adleman). + +Das Kerckhoffs-Prinzip (1883, Auguste Kerckhoffs von Nieuwenhof(1835, 1903), niederländischer Linguist und Kryptologe) besagt,dass man davon ausgehen muss, dass Eva die Struktur des Verschlüsselungsverfahrens kennt und die Sicherheit nur von der Geheimhaltung des Schlüssels abhängen darf. + +Begründung: +1. Geheimhaltung eines Verfahrens ist schwer sicherzustellen.(Erfahrungstatsache.) +2. Verfahren sind aufwendig zu entwickeln. Ist das geheime Verfahren einmal bekannt, so wäre Verfahren nutzlos. (Mehrfach passiert: Enigma, GSM-Verfahren A5/1 und A5/2 (Mobilfunknetze),Stromchiffre RC4.) +3. Allgemein bekannte Verfahren können von mehr Experten auf ,,Sicherheit'' geprüft werden. Findet niemand einen erfolgreichen Angriff, so kann man eher auf Sicherheit des Verfahrens vertrauen. +4. Nur offen gelegte Verfahren können standardisiert werden und weite Verbreitung finden (DES, AES). + +Bemerkung: In der Realität gibt es auch (viele) geheimgehaltene Systeme. Naturgemäß werden solche nicht in Vorlesungen behandelt. + +# Symmetrische Verschlüsselung, Sicherheitsmodelle +In diesem Teil beschäftigen wir uns ausschließlich mit symmetrischen Konzelationsverfahren, bei denen also Alice und Bob sich auf einen geheimen Schlüssel geeinigt haben. + +Mögliche Kommunikationsszenarien: +- Alice will nur einmal eine Nachricht (mit bekannter maximaler Länge) an Bob schicken. +- Alice will mehrere Nachrichten mit bekannter maximaler Länge schicken. +- Alice will beliebig viele Nachrichten beliebiger Länge schicken. + +Angriffsszenarien/Bedrohungsszenarien: +Das Kerkhoffs-Prinzip impliziert, dass Eva das Ver- und das Entschlüsselungsverfahren kennt (nur den Schlüssel nicht). Folgende Möglichkeiten kann sie weiterhin haben: +1. Nur Mithören: Nur-Chiffretext-Angriff (ciphertext-onlyattack,COA). +2. Mithören + Eva sind einige Paare von Klartext und Chiffretext bekannt: Angriff mit bekannten Klartexten(known-plaintextattack, KPA). + - Beispiele: Einige Klartext-Chiffretext-Paare sind aus Versehen oder absichtlich bekannt geworden, Eva hat einige Chiffretexte mit großem Aufwand entschlüsselt, Eva war früher mit der Verschlüsselung beauftragt (ohne den Schlüssel zu kennen). +3. Mithören + Eva kann einige von ihr gewählte Klartexte verschlüsseln: Angriff mit Klartextwahl (chosen-plaintext attack, CPA). + - Beispiele: Eva war früher mit der Verschlüsselung beauftragt (ohne den Schlüssel zu kennen) + - CPA ist immer möglich bei asymmetrischer Verschlüsselung,die wir aber erst später betrachten. +4. Mithören + Eva kann einige von ihr gewählte Chiffretexte entschlüsseln: Angriff mit Chiffretextwahl (chosen-cyphertext attack, CCA). + - Beispiele: Verschiedene Authentisierungsverfahren verlangen, dass die zu prüfende Partei einen Chiffretext entschlüsselt und den Klartext zurücksendet; Eva war früher mit der Entschlüsselung beauftragt (ohne den Schlüssel zu kennen). +5. Eva hat Möglichkeiten 3. + 4. + +Wesentlich sind auch noch die Fähigkeiten von Eva. Einige Beispiele: +1. Unbegrenzte Rechenkapazitäten. Eva soll keine Information über den Klartext erhalten, egal wieviel sie rechnet (,,informationstheoretische Sicherheit''). +2. Konkrete maximale Anzahl an Rechenoperationen, z.B. $2^{60}$. ,,Konkrete Sicherheit'': Mit diesem Aufwand erfährt Eva ,,(fast) nichts'' über Klartexte. +3. Begrenzter Speicher (z.B. 1000 TB). Analog zu 2. +4. Im Design des Verschlüsselungsverfahrens gibt es einen Stellhebel, einen ,,Sicherheitsparameter''. (Beispiel: Schlüssellänge, Rundenzahl bei DES und AES.) Je nach Leistungsfähigkeit von Eva kann man durch entsprechende Wahl dieses Parameters die Sicherheit des Systems an eine gegebene (geschätzte) Rechenzeitschranke anpassen. +5. Man betrachtet ganze Familien von Verschlüsselungsverfahren, für immer längere Klar-und Chiffretexte Typischerweise werden Verschlüsselung und Entschlüsselung von Polynomialzeitalgorithmen geleistet. Wenn asymptotisch, also für wachsende Textlänge, der Rechenzeitaufwand für Eva zum Brechen des Systems schneller als polynomiell wächst, kann man sagen, dass sie für genügend lange Texte keine Chance mehr hat,das System erfolgreich zu brechen. (,,Asymptotische Sicherheit'') + +Wir untersuchen in diesem ersten Teil drei verschiedene Szenarien, jeweils symmetrische Konzelationssysteme,mit steigender Komplexität. Alice und Bob haben sich auf einen Schlüssel geeinigt. + +1. Einmalige Verschlüsselung: Ein einzelner Klartext $x$ vorher bekannter Länge wird übertragen, Eva hört mit (COA). + - Unvermeidlich: Triviale Information, z.B. der Sachverhalt,dass eine Nachricht übertragenwurde. + - Was vermieden werden soll: Eva erhält nicht-triviale Information, z.B. dass der Klartext $x$ ist oder dass der Klartext aller Wahrscheinlichkeit nach weder $x_1$ noch $x_2$ ist. + - Gegenstand der Steganographie sind Verfahren,Nachrichten so zu übertragen, dass noch nicht einmal die Existenz der Nachricht entdeckt werden kann. +2. Frische Verschlüsselung: Mehrere Klartexte vorher bekannter Länge werden übertragen, Eva hört mit,kann sich einige Klartexte verschlüsseln lassen (CPA). + - Triviale Information: z.B.Anzahl der Nachrichten oder Klartext, falls Eva sich zufälligerweise vorher den ,,richtigen'' Klartext hat verschlüsseln lassen. +3. Uneingeschränkte symmetrische Verschlüsselung: Mehrere Klartexte verschiedener Länge, Eva hört mit, kann sich einige Klartexte verschlüsseln lassen (CPA). + - Triviale Information: Analog zur frischen Verschlüsselung. + +## Einmalige symmetrische Verschlüsselung und klassische Verfahren +Wir diskutieren hier eine einführende, einfache Situation, für symmetrische Konzelationssysteme und Sicherheitsmodelle. In einer Fallstudie betrachten wir Methoden zum ,,Brechen'' eines klassischen Kryptosystems. + +### Kryptosysteme und possibilistische Sicherheit +**Szenarium 1** (Einmalige Verschlüsselung, COA): Alice möchte Bob einen Klartext vorher bekannter Länge schicken, Alice und Bob haben sich auf einen Schlüssel geeinigt, Eva hört den Chiffretext mit. + +,,bekannte Länge'': Klartexte entstammen einer bekannten endlichen Menge $X$, z.B. $X=\{0,1\}^l$. + +Fragen: Wie soll man vorgehen, damit das verwendete Verfahren als ,,sicher'' gelten kann? Was soll ,,sicher'' überhaupt bedeuten? Wie kann man ,,Sicherheit'' beweisen? Was sind die Risiken von Varianten (mehrere Nachrichten,längere Nachrichten usw.)? + +**Definition 1.1** Ein Kryptosystem ist ein Tupel $S=(X,K,Y,e,d)$, wobei +- X und K nicht leere endliche Mengen sind [Klartexte bzw. Schlüssel], +- Y eine Menge ist [Chiffretexte], und +- $e:X\times K\rightarrow Y$ und $d:Y\times K\rightarrow X$ Funktionen sind [Verschlüsselungsfunktion bzw. Entschlüsselungsfunktion], + +so dass Folgendes gilt: +1. $\forall x\in X\forall k\in K:d(e(x,k),k) =x$ (Dechiffrierbedingung) +2. $\forall y\in Y\exists x\in X,k\in K:y=e(x,k)$ (Surjektivität) + +Bemerkung: Surjektivität kann immer hergestellt werden, indem man $Y$ auf das Bild $Bi(e) =e(X\times K)$ einschränkt. Die Forderung ist für unsere Analysen aber bequem. + +Für festes $k\in K$ wird die Funktion $e(.,k):X\rightarrow Y,x \rightarrow e(x,k)$ als Chiffre bezeichnet. + +**Beispiel 1.2** Sei $n>0, X=\{a_i,b_i| 1\leq i\leq n\},K=\{k_0,k_1\},Y=\{A_i,B_i| 1\leq i\leq n\}$. Die Funktionen $e$ und $d$ sind als Tabellen gegeben: + +| e | $a_1$ | $b_1$ | $a_2$ | $b_2$ | ... | $a_n$ | $b_n$ | +| ----- | ----- | ----- | ----- | ----- | --- | ----- | ----- | +| $k_0$ | $A_1$ | $B_1$ | $A_2$ | $B_2$ | ... | $A_n$ | $B_n$ | +| $k_1$ | $B_1$ | $A_1$ | $B_2$ | $A_2$ | ... | $B_n$ | $A_n$ | + +| d | $A_1$ | $B_1$ | $A_2$ | $B_2$ | ... | $A_n$ | $B_n$ | +| ----- | ----- | ----- | ----- | ----- | --- | ----- | ----- | +| $k_0$ | $a_1$ | $b_1$ | $a_2$ | $b_2$ | ... | $a_n$ | $b_n$ | +| $k_1$ | $b_1$ | $a_1$ | $b_2$ | $a_2$ | ... | $b_n$ | $a_n$ | + +Dann gelten Dechiffrierbedingung und Surjektivität, $(X,K,Y,e,d)$ ist also ein Kryptosystem (wenn auch auf den ersten Blick ein nicht sehr intelligentes). + +Man kann Kryptosysteme auch durch eine mathematische Beschreibung angeben. Im Wesentlichen genau dasselbe Kryptosystem wie in Beispiel 1.2 ist das folgende: $X=Y=\{0,1\}^l,n=2^l$. Die Elemente dieser Mengen fassen wir als Binärdarstellungen von Zahlen in $\{0, 1,..., 2^l-1\}$ auf. $A_1,...,A_n$ sind die geraden Zahlen $0,2,...,2^l-2,B_1,...,B_n$ die ungeraden Zahlen $1,3,...,2^l- 1$ in dieser Menge. +Genauso sind $a_1,...,a_n$ und $b_1,...,b_n$ definiert. Die Schlüssel sind $k_0=0$ und $k_1=1$, und $e(x,k_0)=d(x,k_0)=x$ und $e(x,k_1)=d(x,k_1)$ ist das Binärwort, das man erhält, wenn man in $x$ das letzte Bit kippt: $e(x,k) =d(x,k) =x\oplus_l k$. +(Dabei steht $k$ für die Binärdarstellung von $k$ mit l Bits und $\oplus_l$ steht für das bitweise XOR.) + +**Beispiel 1.3** $X=\{a,b\},K=\{k_0,k_1,k_2\},Y=\{A,B,C\}$.Die Funktion $e$ ist gegeben durch die erste, die Funktion $d$ durch die zweite der folgenden Tabellen. Dann ist $(X,K,Y,e,d)$ Kryptosystem, denn die Dechiffrierbedingung und die Surjektivität sind erfüllt. + +| e | a | b | +| ----- | --- | --- | +| $k_0$ | A | B | +| $k_1$ | B | A | +| $k_2$ | A | C | + +| d | A | B | C | +| ----- | --- | --- | --- | +| $k_0$ | a | b | a | +| $k_1$ | b | a | a | +| $k_2$ | a | a | b | + +**Beispiel 1.4** $X=\{a,b\},K=\{k_0,k_1,k_2\},Y=\{A,B,C\}$. Die Funktion $e$ ist durch die folgende Tabelle gegeben: + +| e | a | b | +| ----- | --- | --- | +| $k_0$ | A | B | +| $k_1$ | B | B | +| $k_2$ | A | C | + +Wegen $e(a,k_1)=e(b,k_1)$ existiert keine Funktion $d$, so dass $(X,K,Y,e,d)$ ein Kryptosystem ist, die Dechiffrierbedingung kann also nicht erfüllt werden. + +Merke: Jede Chiffre $e(.,k)$ eines Kryptosystems muss injektiv sein. (Sonst kann es keine Entschlüsselungsfunktion $d$ geben. Anschaulich: Die Einträge in jeder Zeile der Tabelle für $e$ müssen verschieden sein.) + +**Beispiel 1.5** $X=K=Y=\{0\},e(0,0)=d(0,0)=0$ (auch $X=\{x\},K=\{k\},Y=\{y\}$). Dies ist das ,,triviale'' minimale Kryptosystem. Dechiffrierbedingung und Surjektivität gelten offensichtlich. + +**Beispiel 1.6** Sei $\oplus:\{0,1\}\times\{0,1\}\rightarrow\{0,1\}$ die Funktion $(b,c)\rightarrow b+c-2bc$ (=b XOR c). +Für $l>0$ sei $\oplus^l:\{0,1\}^l\times\{0,1\}^l\rightarrow\{0,1\}^l$ die komponentenweise Anwendung von $\oplus=\oplus_l$: + +$(b_1,b_2,...,b_l)\oplus_l(c_1,c_2,...,c_l) = (b_1\oplus c_1,b_2\oplus c_2,...,b_l\oplus c_l)$ + +Sei $l>0$. Das Vernam-Kryptosystem oder one-time pad der Länge $l$ ist das Kryptosystem $(\{0,1\}^l,\{0,1\}^l,\{0,1\}^l,\oplus_l,\oplus_l)$. Benannt nach Gilbert S. Vernam (1890, 1960), der im Jahr 1918 dieses System für fünf Bits in der Sprache einer Relais-Schaltung beschrieben und zum US-Patent angemeldet hat. Siehe [http://www.cryptomuseum.com/crypto/files/us1310719.pdf](http://www.cryptomuseum.com/crypto/files/us1310719.pdf) + +In diesem Fall ist es für nicht ganz kleine l offensichtlich unbequem, wenn nicht ganz unmöglich,die Ver-und Entschlüsselungsfunktion durch Tabellen anzugeben. Man benutzt hier und auch üblicherweise mathematische Beschreibungen. + +Beispiel: $x=1011001,k=1101010$. Dann ist $y=e(x,k)=1011001\oplus_7 1101010 = 0110011$. Zur Kontrolle: $d(y,k) = 0110011\oplus_7 1101010 = 1011001 =x$. + +Wir kontrollieren dass das Vernam-System tatsächlich ein Kryptosystem ist. +1. Für $x\in X$ und $k\in K$ gelten $d(e(x,k),k)=(x\oplus_l k)\oplus_l k=x\oplus_l(k\oplus_l k) =x\oplus_l 0^l=x$, d.h. die Dechiffrierbedingung ist erfüllt. +2. Für $y\in Y$ gilt $e(y,0^l) =y$ und $y\in X,0^l\in K$. Also gilt Surjektivität. + +Wann soll ein Kryptosystemals sicher betrachtet werden? + +Erste Idee: Wenn Eva den Chiffretext $e(x,k)$ abhört und den Schlüssel $k$ nicht kennt, so soll sie nicht in der Lage sein, x zu berechnen. + +**Beispiel 1.2** (Fortsetzung) Wenn Eva den Chiffretext $A_1$ abhört, so weiß sie, dass der Klartext $a_1$ oder $b_1$ ist; sie kann aber nicht sagen, welcher von beiden es ist. Allerdings hat sie (signifikante) nicht triviale Information gewonnen, nämlich dass $a_2,b_2,...,a_n,b_n$ nicht in Frage kommen. + +Die Anforderung, dass $x$ aus $y$ nicht eindeutig bestimmt werden kann, führt also zu keinem befriedigenden Sicherheitsbegriff. + +Zweite Idee: Wenn Eva den Chiffretext $y$ abhört und den Schlüssel $k$ nicht kennt, so kann sie keinen Klartext ausschließen. Dies führt zu der folgenden Definition. + +**Definition 1.7** Ein Kryptosystem $S=(X,K,Y,e,d)$ heißt possibilistisch sicher,wenn $\forall y\in Y\forall x\in X\exists k\in K:e(x,k)=y$. + +Bemerkung +1. Sei $S=(X,K,Y,e,d)$ Kryptosystem. Dann sind äquivalent: + - $S$ ist possibilistisch sicher. + - $\forall x\in X:e(x,K)=\{e(x,k)|k\in K\}=Y$. +2. Für $n\geq 2$ ist das Kryptosystem aus Beispiel 1.2 nicht possibilistisch sicher,denn $A_1$ kann nicht Chiffretext zu $a_2$ sein. +3. Das Kryptosystem aus Beispiel 1.3 ist nicht possibilistisch sicher, denn $C$ kann nicht Chiffretext zu $0$ sein. +4. Das Vernam-Kryptosystem der Länge $l$ ist possibilistisch sicher: Seien $x\in X$ und $y\in Y$. Setze $k=x\oplus_l y$.Dann gilt $e(x,k)=x\oplus_l(x\oplus_l y)=(x\oplus_l x)\oplus_l y= 0^l\oplus_l y=y$. + +In der Einführung wurde die Verschiebechiffre betrachtet, bei der Buchstaben des alten lateinischen Alphabets auf Chiffrebuchstaben abgebildet wurden, indem man das Bild von $A$ angab und jeder andere Buchstabe um dieselbe Distanz verschoben wurde. Auch die allgemeineren Substitutionschiffren wurden erwähnt, bei der man für jeden Buchstaben $x$ einen beliebigen Bildbuchstaben $\pi(x)$ angibt, auf injektive Weise. Beispiel für eine Substitutionschiffre: + +| x | A | B | C | D | E | F | G | H | I | K | L | M | N | O | P | Q | R | S | T | V | X | +| -------- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | +| $\pi(x)$ | F | Q | M | P | K | V | T | A | E | L | H | N | I | G | D | S | B | X | O | R | C | + +Man überlege: Es gibt $21!(= 51090942171709440000)$ viele solche Chiffren. Wir können für ganz beliebige Mengen $X$ die Menge aller Substitutionschiffren auf $X$ betrachten. + +**Definition 1.9** Für eine endliche, nichtleere Menge $X$ sei $K=P_X$ die Menge der Permutationen (Eine Permutation auf $X$ ist eine bijektive Funktion $\pi:X\rightarrow X$) auf $X$.Das Substitutionskryptosystem auf $X$ ist das Tupel $(X,PX,X,e,d)$ +mit $$e(x,\pi)=\pi(x)$ und $d(y,\pi)=\pi^{-1} (y)$$. +Wenn $\pi:X\rightarrow X$ eine Permutation ist, dann ist $\pi^{-1}:X\rightarrow X$ die Permutation mit $\pi^{-1}(\pi(x))=\pi(\pi^{-1}(x)) =x$ für alle $x\in X$. + +Man sieht leicht, dass dies tatsächlich ein Kryptosystem ist (Dechiffrierbedingung und Surjektivität). + +Proposition 1.10 Ist $X$ eine endliche und nichtleere Menge, so ist das Substitutions-kryptosystem auf X possibilistisch sicher. + +Beweis: Seien $y\in Y =X$ und $x\in X$.Definiere $\pi:X\rightarrow X$ wie folgt: + +$$\pi(z) =\begin{cases} y\quad\text{ falls} z=x\\ x\quad\text{ falls} z=y\\ z\quad\text{ falls} z\not\in\{x,y\} \end{cases}$$ + +Dann ist $\pi\in P_X$ mit $e(x,\pi)=\pi(x)=y$. + +Beobachtung: $K$ ist in diesem Fall sehr groß, es gibt $|X|!$ Schlüssel. Im Fall des Vernam-Kryptosystems ist $|X|=|Y|=|K|$. + +Proposition 1.11 Ist $S=(X,K,Y,e,d)$ ein possibilistisch sicheres Kryptosystem, so gilt $|X|\leq|Y|\leq|K|$. + +Beweis: Wähle $k\in K$ beliebig. Da $S$ ein Kryptosystem ist,erfüllt es die Dechiffrierbedingung. Also ist die Chiffre $e(.,k):X\rightarrow Y$ injektiv, d.h. es gilt $|X|\leq |Y|$. + +Sei nun $x\in X$ beliebig. Da $S$ possibilistisch sicher ist, gibt es für jedes $y\in Y$ ein $k\in K$ mit $e(x,k) =y$. Also ist die Abbildung $K\ni k\rightarrow e(x,k)\in Y$ surjektiv, und es folgt $|Y|\leq |K|$. + +Folgerung: Bei possibilistischer Sicherheit und Klartexten und Schlüsseln, die Zeichenreihen über einem Alphabet sind, müssen Schlüssel mindestens so lang sein wieder zu übermittelnde Text. Wenn man etwa den Inhalt einer Festplatte verschlüsseln will, benötigt man eine weitere Festplatte für den Schlüssel. In solchen Fällen extrem langer Klartexte wird possibilistische Sicherheit unrealistisch. Possibilistisch sichere Systeme kommen daher nur als Bausteine in größeren Systemen vor. + +**Beispiel 1.12** Sei $X=\{a,b\},K=\{0,1,2\},Y=\{A,B\}$ und die Verschlüsselungsfunktion sei durch +| e | a | b | +| --- | --- | --- | +| 0 | A | B | +| 1 | A | B | +| 2 | B | A | + +gegeben. Dann ist $S=(X,K,Y,e,d)$ ein possibilistisch sicheres Kryptosystem. Fängt Eva den Chiffretext $e(x,k) =A$ ab, so nimmt sie an, dass $x=a$ ,,wahrscheinlicher'' ist als $x=b$. +Das ist zum Beispiel dann sinnvoll, wenn die Schlüssel $0,1,2$ dieselbe Wahrscheinlichkeit haben. +(Das Kerckhoffs-Prinzip würde sagen, dass Eva auch die verwendete Wahrscheinlichkeitsverteilung auf $K$ kennt.)üm formal auszudrücken, warum dieses Kryptosystem nicht ,,sicher'' ist, wenn Schlüssel $0,1$ und $2$ gleichwahrscheinlich sind, beziehungsweise um einen passenden Sicherheitsbegriff überhaupt zu formulieren, benötigen wir etwas Wahrscheinlichkeitsrechnung. + +## Wiederholung: Elementare Wahrscheinlichkeitsrechnung +Die in dieser Vorlesung benötigten Konzepte aus der Wahrscheinlichkeitsrechnung wurden in den Veranstaltungen ,,Grundlagen und Diskrete Strukturen'' und ,,Stochastik für Informatiker'' im Prinzip behandelt.Wir erinnern hier kurz an die für unsere Zwecke wichtigen Konzepte und legen Notation fest. + +Beispiel: Ein Wahrscheinlichkeitsraum, mit dem man das Zufallsexperiment ,,Einmaliges Werfen eines fairen Würfels'' modellieren kann, ist $\Omega=\{ 1 , 2 , 3 , 4 , 5 , 6\}$ mit der Idee, dass jede ,,Augenzahl'' $a\in\Omega$ Wahrscheinlichkeit $\frac{1}{6}$ hat. Die Wahrscheinlichkeit, $5$ oder $6$ zu würfeln, schreibt man dann als $Pr(\{5,6\})=\frac{1}{3}$, die Wahrscheinlichkeit für eine gerade Augenzahl als $Pr(\{2,4,6\})=\frac{1}{2}$. Allgemein gilt jede Menge $A\subseteq\Omega$ als ,,Ereignis'' mit Wahrscheinlichkeit $Pr(A) =|A|/|\Omega|$. + +Wir fassen unsere Grundbegriffe etwas allgemeiner insofern, als wir auch verschiedene Wahrscheinlichkeiten für Elementarereignisse $a\in\Omega$ zulassen und es erlaubt ist,dass $\Omega$ abzählbar unendlich ist. Wir beschränken uns aber auf den Fall endlicher oder abzählbarer Wahrscheinlichkeitsräume, sogenannter diskreter W-Räume. + +**Definition**: Ein (diskreter) Wahrscheinlichkeitsraum ist ein Paar $(\Omega,Pr)$, wobei +- $\Omega$ eine nichtleere endliche oder abzählbar unendliche Menge und +- $Pr:P(\Omega)\rightarrow[0,1]$ eine Abbildung ($P(\Omega)=\{A|A\subseteq\Omega\}$ ist die Potenzmenge) + +ist, sodass Folgendes gilt: +1. $Pr(\Omega) = 1$ +2. für alle $A\subseteq\Omega$ gilt $Pr(A)=1-Pr(A)$, für $A=\Omega\backslash A$ +3. für alle $A_1,A_2,...\in P(\Omega)$ gilt, falls die Mengen $A_i$ paarweise disjunkt sind: $Pr(\bigcup A_i)=\sum_{i\geq i}^{\infty} Pr(A_i)$ ( ,,$\sigma$-Additivität'' ) + +Man nennt +- die Elemente von $\Omega$ Ergebnisse oder Elementarereignisse, +- die Elemente von $P(\Omega)$ (also die Teilmengen von $\Omega$) Ereignisse und +- $Pr$ die Wahrscheinlichkeitsverteilung + +des Wahrscheinlichkeitsraums $(\Omega,Pr)$. Für $A\in P(\Omega)$ heißt $Pr(A)$ die Wahrscheinlichkeit von $A$. + +Bemerkung 1.13 $Pr(A) =\sum_{a\in A} Pr(\{a\})$ , d.h., die Wahrscheinlichkeitsverteilung $Pr$ ist durch die Wahrscheinlichkeitsfunktion $\Omega\rightarrow[0,1],a \rightarrow p_a= Pr(\{a\})$, eindeutig gegeben. + +Wir schreiben auch für diese Funktion $Pr$ und damit $Pr(a)$ anstelle von $Pr(\{a\})$. Es gilt dann: $Pr(A)=\sum_{a\in A} Pr(a)$, für jedes Ereignis A, und insbesondere $\sum_{a\in\Omega}Pr(a) = 1$. + +Sei nun $\Omega$ sogar endlich. Dann ist die uniforme Verteilung (oder Gleichverteilung) die Wahrscheinlichkeitsverteilung $A\rightarrow\frac{|A|}{|\Omega|}$, für Ereignisse $A\in P(\Omega)$, mit der Wahrscheinlichkeitsfunktion $a\rightarrow \frac{1}{|\Omega|}$, für $a\in\Omega$. + +Lemma 1.14 Sei $(\Omega,Pr)$ ein Wahrscheinlichkeitsraum und seien $A,B\subseteq\Omega$ Ereignisse. Dann gilt $Pr(A\backslash B)\geq Pr(A)-Pr(B)$. + +Beweis: Für Ereignisse $C\subseteq D$ gilt stets $Pr(C)=\sum_{a\in C} Pr(a)\leq \sum_{a\in D} Pr(a) = Pr(D)$. +Daher gilt $Pr(A\backslash B) + Pr(B) = Pr((A\backslash B)\cup B) = Pr(A\cup B)\geq Pr(A)$. + +Sei $(\Omega,Pr)$ Wahrscheinlichkeitsraum, B Ereignis mit $Pr(B)> 0$. Definiere $Pr_B:P(\Omega)\rightarrow[0,1],A \rightarrow\frac{Pr(A\cap B)}{Pr(B)}$. +Dann ist $(\Omega,Pr_B)$ selbst ein Wahrscheinlichkeitsraum, wie man leicht nachrechnet. Intuitiv ist $Pr_B(A)$ die Wahrscheinlichkeit für das Eintreten von $A$, wenn schon bekannt ist, dass $B$ eingetreten ist. Daher nennt man $Pr_B$ die bedingte Wahrscheinlichkeit bzgl. B und schreibt für $Pr_B(A)$ auch $Pr(A|B)$. Aus der Definition folgt die Grundformel $Pr(A\cap B) = Pr(A|B)*Pr(B)$. + +Achtung: die bedingte Wahrscheinlichkeit $Pr(A|B)$ ist nur definiert, wenn $Pr(B)> 0$ gilt. + +Lemma 1.15 Sei $(\Omega,Pr)$ ein Wahrscheinlichkeitsraum. +1. (,,Formel von der totalen Wahrscheinlichkeit'') Seien $B_1,...,B_t$ disjunkte Ereignisse mit $Pr(B_1\cup...\cup B_t)=1$. Dann gilt $Pr(A)=\sum_{1\leq s\leq t} Pr(A|B_s)Pr(B_s)$. +2. Seien $A,B,C$ Ereignisse mit $Pr(B\cap C),Pr(C\backslash B)>0$. Dann gilt $Pr(A|C)=Pr(A\cap B | C) + Pr(A\backslash B|C)= Pr(A|B\cap C)Pr(B|C) + Pr(A|C\backslash B)Pr(\bar{B}|C)$. + +Beispiel: In dem Würfel-Wahrscheinlichkeitsraum mit $\Omega=\{1,...,6\}$ und der uniformen Verteilung betrachten wir die Ereignisse $A=\{3,6\}$ (durch 3 teilbare Augenzahl) und $B=\{2,4,6\}$ (gerade Augenzahl). Wir haben: $Pr(A\cap B) = Pr(\{6\})=\frac{1}{6}=\frac{1}{3}*\frac{1}{2}=Pr(A)*Pr(B)$. + +Damit sind die Ereignisse {Augenzahl ist gerade} und {Augenzahl ist durch 3 teilbar} (stochastisch) unabhängig im folgenden Sinn: + +**Definition 1.16** Sei $(\Omega,Pr)$ ein Wahrscheinlichkeitsraum und seien $A,B$ Ereignisse. Dann heißen A und B unabhängig, wenn $Pr(A\cap B)=Pr(A)*Pr(B)$ gilt. + +Bemerkung: Wenn $Pr(B)> 0$ gilt, dann sind $A$ und $B$ genau dann unabhängig, wenn $Pr(A) = \frac{Pr(A\cap B)}{Pr(B)})= Pr(A|B)$ gilt. Das bedeutet, dass sich durch die Information, dass B eingetreten ist, nichts an der Wahrscheinlichkeit für $A$ ändert. (Im Beispiel: Wenn wir wissen, dass die Augenzahl $b$ eim Würfeln gerade ist, dann ist die Wahrscheinlichkeit für eine Augenzahl, die durch 3 teilbar ist, genau, genau dieselbe wie im gesamten Wahrscheinlichkeitsraum.) + +**Zufallsvariable bzw. Zufallsgrößen** Zufallsvariable ordnen den Ergebnissen eines Experiments (d.h. eines Wahrscheinlichkeitsraums) ,,Werte'' aus einer Menge R zu. (Diese Werte können Zahlen oder andere ,,Eigenschaften'' sein.) + +**Definition 1.17** Sei $(\Omega,Pr)$ ein Wahrscheinlichkeitsraum und R eine endliche oder abzählbare Menge. Eine Zufallsvariable ist eine Abbildung $X:\Omega\rightarrow R$. +Zufallsvariablen mit $R\subseteq R$ heißen reelle Zufallsvariable. + +Beispiel 1.18 Zu $\Omega=\{1,2,...,N\}^q$ (q,$N\geq 1$) betrachten wir den Wahrscheinlichkeitsraum $(\Omega,Pr)$ mit der Gleichverteilung $Pr$. Beispiele für Zufallsvariablen sind: +- $R=\mathbb{N}$ und $X:\Omega\rightarrow R,(a_1,...,a_q)\rightarrow a_5$ (eine Projektion, definiert für $q\geq 5$) +- $R=\{-1,0,1\}$ und $Y_{ij}((a_1,...,a_q))=\begin{cases} -1\quad\text{falls } a_i< a_j\\ 0\quad\text{falls} a_i=a_j, \text{für } 1\leq i < j\leq n \\ 1\quad\text{falls } a_i> a_j\end{cases}$ +- $R=\mathbb{N}$ und $Z:\Omega\rightarrow R,(a_1 ,...,a_q)\rightarrow\sum_{1\leq i\leq q} a_i$ + +Sei $X:\Omega\rightarrow R$ eine Zufallsvariable. Für $S\subseteq R$ setze $Pr^X(S):= Pr(X^{-1}(S))=Pr(\{a\in\Omega|X(a)\in S\})$. Dann ist $(R,Pr^X)$ ein Wahrscheinlichkeitsraum. Dieser heißt der von $X$ auf $R$ induzierte Wahrscheinlichkeitsraum. $Pr^X$ heißt auch die Verteilung von $X$. + +Schreibweisen: Für $S\subseteq R$ ist $X^{-1}(S)=\{a\in\Omega|X(a)\in S\}$ ein Ereignis, für das wir ,,$X\in S$'' oder ,,$\{X\in S\}$'' schreiben. Für $X^{-1}(r)=\{a\in\Omega|X(a) =r\}$ schreiben wir analog ,,$X=r$'' oder ,,$\{X=r\}$''. Insbesondere schreiben wir: $Pr(X=r)=PX(r)=Pr(X^{-1}(r))$ und $Pr(X\in S)=P^X(S)=Pr(X^{-1}(S))$. + +Sind $X_i:\Omega\rightarrow R_i$ Zufallsvariable und $S_i\subseteq R_i$, für $i=1,2$, dann schreiben wir ,,$\{X_1\in S_1,X_2\in S_2\}$'' für das Ereignis $X^{-1}(S_1)\cap X^{-1}(S_2)$. Die beiden Zufallsvariablen $X_1$ und $X_2$ heißen unabhängig, wenn $Pr(X_1\in S_1,X_2\in S_2)=Pr(X_1\in S_1)*Pr(X_2\in S_2)$ gilt, für alle $S_i\subseteq R_i,i=1,2$. Dies ist gleichbedeutend mit der Forderung $Pr(X_1=r_1,X_2=r_2)=Pr(X_1=r_1)*Pr(X_2=r_2)$ für alle $r_i\in\mathbb{R}_i, i=1,2$. + + +## Informationstheoretische Sicherheit +Man erinnere sich an Beispiel 1.12. Eine naheliegende Annahme ist, dass jeder Klartextbuchstabe mit Wahrscheinlichkeit $\frac{1}{2}$ und jeder Schlüssel mit Wahrscheinlichkeit $\frac{1}{3}$ auftritt, und zwar unabhängig voneinander. Dann ist $Pr$(Klartext x ist a $\wedge$ Chiffretext y ist A)$=\frac{1}{3}$, Pr(Chiffretext y ist A)$=\frac{1}{2}$, also Pr(Klartext x ist a | Chiffretext y ist A)$=\frac{2}{3}\not=\frac{1}{2}=$Pr(Klartext x ist a). Wenn Eva also A beobachtet, ändert sich ihre Ansicht über die Verteilung auf den Klartextbuchstaben. + +Für das Konzept der informationstheoretischen Sicherheit nehmen wir an, dass Klartexte mit bestimmten Wahrscheinlichkeiten auftreten. Was diese Wahrscheinlichkeiten sind, kann der Anwender normalerweise nicht kontrollieren. Die konsequente Anwendung des Kerckhoffs-Prinzips besagt aber, dass man annehmen muss, dass Eva die relevante Wahrscheinlichkeitsverteilung auf X kennt. (Zum Beispiel würde sie wissen, dass $Pr^X(x_0)=\frac{1}{2}$ ist, für ein bestimmtes $x_0\in X$.) Nun betrachten wir ein Kryptosystem $S=(X,K,Y,e,d). Wir nehmen an, dass Alice und Bob ihren gemeinsamen Schlüssel k durch ein Zufallsexperiment wählen. Hierzu gehört ein zweiter Wahrscheinlichkeitsraum $(K,Pr_K)$. Es ist sinnvoll anzunehmen, dass $Pr_X$ und $Pr_K$ nichts miteinander zu tun haben. Es wird verschlüsselt und Chiffretext y wird gesendet. Dieser wird von Eva beobachtet. Wenn sich dadurch die Meinung von Eva über die Wahrscheinlichkeiten der verschiedenen Klartexte von der ursprünglichen Verteilung unterscheidet (etwa jetzt: ,,mit 90%iger Wahrscheinlichkeit ist es Klartext $x_0$''), hat Eva aus der Beobachtung von y eine gewisse Information erhalten. + +Wir geben nun ein mathematisches Modell an, innerhalb dessen man über Begriffe wie ,,Eva erhält Information'' sprechen und argumentieren kann. Dazu konstruieren wir einen W-Raum mit $\Omega=X\times K$. In das Modell bauen wir die Vorstellung ein, dass $x\in X$ und $k\in K$ nach den Verteilungen $Pr_X$ und $Pr_K$ zufällig und unabhängig gewählt werden. + +Man beachte, dass die Verteilung $Pr_K$ ,,Teil des Kryptosystems'' ist, also der Kontrolle von Alice und Bob unterliegt, während $Pr_X$ ,,Teil der Anwendung'' oder ,,Teil der Realität'' ist, also von den Teilnehmern normalerweise nicht beeinflusst werden kann. Die Verteilung $Pr_X$ braucht beim Entwurf des Kryptosystems nicht einmal bekannt zu sein. (Alice und Bob sollten ihr Kryptosystem ohne Kenntnis von $Pr_X$ planen können. Die Annahme, dass Eva $Pr_X$ kennt, ist eine worst-case-Annahme, sie muss in der Realität nicht unbedingt erfüllt sein.) + +**Definition 1.19** Ein Kryptosystem mit Schlüsselverteilung (KSV) ist ein 6-Tupel $V=(X,K,Y,e,d,Pr_K)$, wobei +- $S=(X,K,Y,e,d)$ ein Kryptosystem (das zugrundeliegende Kryptosystem) ist und +- $Pr_K:K\rightarrow (0,1]$ eine Wahrscheinlichkeitsfunktion (die Schlüsselverteilung) ist. +- Für $V=(X,K,Y,e,d,Pr_K)$ schreiben wir auch $S[Pr_K]$. +- Achtung: Die Definition verlangt $Pr_K(k)\in (0,1]$, also $Pr_K(k)> 0$ für alle $k\in K$. (Hat man Schlüssel mit Wahrscheinlichkeit 0, kann man sie aus K einfach weg lassen.) + +Sei weiter $Pr_X:X\rightarrow [0,1]$ eine Wahrscheinlichkeitsfunktion auf der Menge der Klartexte. Das heißt: $\sum_{x\in X}Pr_X(x)=1$. Diese Wahrscheinlichkeitsfunktion definiert natürlich eine W-Verteilung auf X, die wir wieder $Pr_X$ nennen. (Achtung: Es kann Klartextexte mit $Pr(x)=0$ geben. Solche Klartexte heißen passiv, die anderen, mit $Pr_X(x)>0$, aktiv.) Wir definieren die gemeinsame Wahrscheinlichkeitsfunktion $Pr:X\times K\rightarrow [0,1]$ durch $Pr((x,k)):=Pr_X(x)*Pr_K(k)$. +Dies definiert einen Wahrscheinlichkeitsraum auf $X\times K$, für den $Pr(X'\times K')=Pr_X(X')*Pr_K(K')$, für alle $X'\subseteq X,K'\subseteq K$ gilt. Durch diese Definition wird die Annahme modelliert, dass der Schlüssel k unabhängig vom Klartext durch ein von $Pr_K$ gesteuertes Zufallsexperiment gewählt wird. + +**Beispiel 1.20** Sei $X=\{a,b,c\},K=\{0,1,2,3\},Y=\{A,B,C\}$ und die Verschlüsselungsfunktion sei durch die folgende Tabelle gegeben: +| e | a(0,4) | b(0) | c(0,6) | +| ----------------- | ------ | ---- | ------ | +| 0 ($\frac{1}{4}$) | A | B | C | +| 1 ($\frac{1}{8}$) | B | C | A | +| 2 ($\frac{1}{2}$) | C | A | B | +| 3 ($\frac{1}{8}$) | C | B | A | + +Die Wahrscheinlichkeiten $Pr_X(x)$ sind beiden Klartexten, die Wahrscheinlichkeiten $Pr_K(k)$ beiden Schlüsseln in Klammern notiert. Klartexte a und c sind aktiv, Klartext b ist passiv. Die Wahrscheinlichkeit für einen Punkt $(x,k)\in X\times K$ erhält man durch Multiplikation: $Pr((c,2)) = 0,6 *\frac{1}{2}=0,3$ und $Pr((b,k))=0*Pr_K(k)=0$ für alle $k\in K$. + +Der Chiffretext y ist dann eine Zufallsvariable auf diesem Wahrscheinlichkeitsraum: $X_3((x,k)):=e(x,k)$. +Auch die beiden Komponenten $x$ und $k$ werden als Zufallsvariable betrachtet (Projektionen): +- $X_1:X\times K\rightarrow X,(x,k) \rightarrow x$ +- $X_2:X\times K\rightarrow K,(x,k) \rightarrow k$ + +Wir beobachten einige einfache Zusammenhänge, für $x_0\in X,k_0\in K,y_0\in Y$: +- $Pr(x_0):=Pr(X_1=x_0)=Pr(\{x_0\}\times K) = Pr_X(x_0)*Pr_K(K) = Pr_X(x_0)$. +- $Pr(k_0):=Pr(X_2=k_0)=Pr(X\times\{k_0\})=Pr_X(X)*Pr_K(k_0)=Pr_K(k_0)$ + +(Man erhält also die ursprünglichen Wahrscheinlichkeiten für Klartexte und Schlüssel zurück. Dies ist eine einfache Grundeigenschaft von Produkträumen.) + +$$Pr(y_0):=Pr(X_3=y_0)=Pr(\{(x,k)|x\in X,k\in K,e(x,k) =y_0\}) =\sum_{x\in X,k\in K,e(x,k)=y_0} Pr((x,k)) =\sum_{x\in X,k\in K,e(x,k)=y_0} Pr_X(x)*Pr_K(k)$$ + +(In Beispiel 1.20 gilt $Pr(A)=\frac{1}{4}*0,4+ \frac{1}{8}*0,6 +\frac{1}{2}*0 +\frac{1}{8}* 0,6=0,25$ und $Pr(B) =\frac{1}{4}*0 +\frac{1}{8}*0,4 +\frac{1}{2}*0,6 +\frac{1}{8}*0 = 0,35$.) + +$$Pr(x_0,y_0):=Pr(X_1=x_0,X_3=y_0)=Pr(\{x_0\}\times\{k\in K|e(x_0,k)=y_0\})= Pr_X(x_0)*\sum_{k\in K:e(x_0,k)=y_0} Pr_K(k)$$ + +(In Beispiel 1.20 gilt $Pr(c,A)=0,6*(\frac{1}{8}+\frac{1}{8})=0,15$ und $Pr(a,C)=0,6*(\frac{1}{2}+\frac{1}{8})= 0,375$.) + +$Pr(x_0|y_0):=Pr(X_1=x_0|X_3=y_0)= \frac{Pr(x_0,y_0)}{Pr(y_0)}= Pr_X(x_0)*\frac{\sum_{k\in K:e(x_0,k)=y_0} Pr_K(k)}{\sum_{x\in X,k\in K:e(x,k)=y_0} Pr_X(x)*Pr_K(k)}$. + +(In Beispiel 1.20 gilt $Pr(c|A)=0,15/0,25=0,6$.) Die letzte Formel ist nur für $y_0$ mit $Pr(y_0)>0$ definiert. + +**Definition 1.21** Sei $V=(X,K,Y,e,d,Pr_K)$ ein Kryptosystem mit Schlüsselverteilung. +1. Sei $Pr_X$ eine Wahrscheinlichkeitsfunktion auf den Klartexten. Dann heißt $V$ informationstheoretisch sicher bezüglich $Pr_X$, wenn für alle $x\in X,y\in Y$ mit $Pr(y)>0$ gilt: $Pr(x) = Pr(x|y)$. +2. Das KSV $V$ heißt informationstheoretisch sicher, wenn es bezüglich jeder beliebigen Klartextverteilung $Pr_X$ informationstheoretisch sicher ist. + +Bemerkungen: Hinter Definition 1. steckt die folgende Vorstellung: Eva kennt (im schlimmsten Fall) die Wahrscheinlichkeitsfunktion $Pr_X$. Das System gilt als sicher, wenn sich durch Abfangen eines Chiffretextes y aus Evas Sicht die Wahrscheinlichkeiten der einzelnen Klartexte x nicht ändern. Die Bedingung $Pr(y)>0$ in 1. ist nötig, damit $Pr(x|y)$ definiert ist. Sie bedeutet aber keine Einschränkung, da Chiffretexte $y$ mit $Pr(y)=0$ nie vorkommen, also auch nicht abgefangen werden können. Das Konzept in 2. ist relevant, weil man beim Entwurf eines Kryptosystems meistens die Klartextverteilung nicht oder nicht genau kennt. + +Man beachte, dass in der Definition der informationstheoretischen Sicherheit die Fähigkeiten von Eva überhaupt nicht eingeschränkt werden. Auf welche Weise sie eventuell ermittelt, dass sich Wahrscheinlichkeiten geändert haben, wird gar nicht diskutiert. (Eva könnte zum Beispiel für jedes $y\in Y$ eine Tabelle haben, in der die Wahrscheinlichkeiten $Pr(x|y)$ für alle $x\in X$ aufgelistet sind. Oder sie fängt beim Vorliegen von $y$ an, eine solche Tabelle zu berechnen. Beides ist natürlich für nicht ganz kleine X und Y völlig unrealistisch.) + +**Beispiel 1.22** +| e | a($\frac{1}{4}$) | b($\frac{3}{4}$) | +| ------------------ | ---------------- | ---------------- | +| $k_0(\frac{1}{3})$ | A | B | +| $k_1(\frac{2}{3})$ | B | A | + +(Notation: In der Tabelle stehen neben den Namen von Klartexten und Schlüsseln in Klammern deren Wahrscheinlichkeiten.) Dieses Kryptosystem ist possibilistisch sicher. Es gilt ab er: +$Pr(a|A)=\frac{Pr(a,A)}{Pr(A)}=\frac{\frac{1}{3}*\frac{1}{4}}{\frac{1}{3}*\frac{1}{4}+\frac{2}{3}*\frac{3}{4}}=\frac{1}{7}$ und $Pr(a)=\frac{1}{4}$. +Nach dem Abhören von A sieht also Eva den Klartext a als weniger wahrscheinlich an als vorher. Also ist dieses Kryptosystem mit Schlüsselverteilung bzgl. $Pr_X$ nicht informationstheoretisch sicher. + +**Beispiel 1.23** +| e | a($\frac{1}{4}$) | b($\frac{3}{4}$) | +| ------------------ | ---------------- | ---------------- | +| $k_0(\frac{1}{2}$) | A | B | +| $k_1(\frac{1}{2}$) | B | A | + +Dieses System ist bezüglich $Pr_X$ informationstheoretisch sicher. Zum Beispiel gilt $Pr(a|A) =\frac{Pr(a,A)}{Pr(A)}=\frac{\frac{1}{4}*\frac{1}{2}}{\frac{1}{4}*\frac{1}{2}+\frac{3}{4}*\frac{1}{2}}=\frac{\frac{1}{8}}{\frac{1}{2}}=\frac{1}{4}$ und $Pr(a)=\frac{1}{4}$. Die anderen drei verlangten Gleichheiten rechnet man analog nach. + +**Satz 1.24** (Informationstheoretische Sicherheit des Vernam-Systems) Sei $l>0$ und $S=(X,K,Y,e,d)$ mit $X=K=Y=\{0,1\}^l$ und $e=d=\oplus_l$ das Vernam-System der Länge $l$. Sei weiter $Pr_K:K\rightarrow [0,1]$ die Gleichverteilung. Dann ist $V=S[Pr_K]$ informationstheoretisch sicher. + +Beweis: Sei $Pr_X:X\rightarrow [0,1]$ eine beliebige Wahrscheinlichkeitsfunktion. Wir müssen zeigen, dass $V$ bezüglich $Pr_X$ informationstheoretisch sicher ist. Wir beginnen mit folgender Beobachtung: Zu $x\in X$ und $y\in Y$ existiert genau ein $k_{x,y}\in K$ mit $e(x,k_{x,y})=y$, nämlich $k_{x,y}=x\oplus_l y$. Damit gilt für jedes $y\in Y$: $Pr(y)=\sum_{x\in X,k\in K,e(x,k)=y} Pr(x)Pr(k) = \sum_{x\in X} Pr(x) Pr(kx,y)= 2^{-l}* \sum_{x\in X} Pr(x)=2^{-l}$. + +(D.h.: Jeder Chiffretext y hat dieselbe Wahrscheinlichkeit $2^{-l}$, ganz gleich was $Pr_X$ ist.) +Sei nun $x\in X$ und $y\in Y$ beliebig gewählt. Dann gilt $Pr(x,y) = Pr(x)*\sum_{k\in K, e(x,k)=y} Pr(k) = Pr(x)*Pr(k_{x,y}) = Pr(x)* 2^{-l}= Pr(x)*Pr(y)$. + +Damit folgt $Pr(x)=\frac{Pr(x,y)}{Pr(y)}= Pr(x|y)$, wie bei der informationstheoretischen Sicherheit verlangt. + +Bemerkung 1.25 +1. Der Beweis und damit das Vernamsystem kommt mit jeder beliebigen Klartextverteilung zurecht. +2. Im KSV V wird die Gleichverteilung $Pr_K$ auf den Schlüsseln benutzt. + +Wir wollen nun überlegen, dass diese beiden Sachverhalte nicht zufällig sind. Es wird sich herausstellen, dass informationstheoretische Sicherheit inbestimmten Fällen (nämlich wenn y und K möglichst ,,sparsam'' gebaut sind) Gleichverteilung auf den Schlüsseln erzwingt, und dass die informationstheoretische Sicherheit eines KSV nichts mit den konkreten Wahrscheinlichkeiten der Klartextverteilung $Pr_X$ zu tun hat, sondern nur die Menge $\{x\in X|Pr_X(x)> 0\}$ der ''aktiven'' Klartexte relevant ist. + +Lemma 1.26 Sei $V=(X,K,Y,e,d,Pr_K)$ ein KSV. Sei $V$ informationstheoretisch sicher bezüglich einer Klartextverteilung $Pr_X$ mit $Pr(x)>0$ für alle $x\in X$. Dann gilt: +1. $Pr(y)>0$ für alle $y\in Y$, und $S=(X,K,Y,e,d)$ ist possibilistisch sicher. +2. Gilt zusätzlich $|X|=|Y|=|K|$, so gilt $Pr_K(k)=\frac{1}{|K|}$ für alle $k\in K$. + +Beweis: +1. Sei $y\in Y$ beliebig. Nach Definition 1.1(2) gibt es $x_0\in X$ und $k_0\in K$ mit $e(x_0,k_0)=y$. Da $Pr_X(x_0)>0$ (nach Vor.) und $Pr_K(k_0)>0$ (nach Def 1.19),erhalten wir $Pr(y)\geq Pr_X(x_0)Pr_K(k_0)>0$. Sei nun zusätzlich auch $x\in X$ beliebig. Dann gilt: $\sum_{k\in K:e(x,k)=y} Pr(x)Pr(k)= Pr(x,y)= Pr(x|y)Pr(y)=^* Pr(x)Pr(y)> 0$. ((*) gilt, da V informationstheoretisch sicher bzgl. $Pr_X$ ist.) Also existiert $k\in K$ mit $e(x,k)=y$. Da $x$ und $y$ beliebig waren, ist S possibilistisch sicher. +2. Nun nehmen wir zusätzlich $|X|=|Y|=|K|$ an. Wir beobachten zuerst zwei Dinge: + 1. Für jedes $x\in X$ ist die Abbildung $K\ni k \rightarrow e(x,k)\in Y$ bijektiv. (Dass diese Abbildung surjektiv ist, ist eine Umformulierung der possibilistischen Sicherheit, die nach 1. gegeben ist. Aus Surjektivität folgt Bijektivität, wegen $|K|=|Y|$.) + 2. Für jedes $k\in K$ ist die Abbildung $X\ni x \rightarrow e(x,k)\in Y$ bijektiv. (Dass die Abbildung injektiv ist, folgt aus der Dechiffrierbedingung. Aus Injektivität folgt Bijektivität, wegen $|X|=|Y|$.) + +Nun seien $k_1,k_2\in K$ beliebig. Unser Ziel ist zu zeigen, dass $Pr(k_1)=Pr(k_2)$ gilt. (Dann ist gezeigt,dass $Pr_K$ die uniforme Verteilung ist.) Wähle $x\in X$ beliebig und setze $y:=e(x,k_1)$. Beachte, dass es wegen 1. keinen Schlüssel $k\not=k_1$ mit $y=e(x,k)$ gibt. Wegen 2. gibt es ein $x'\in X$ mit $e(x',k_2)=y$. Auch hier gibt es kein $k'\not=k_2$ mit $e(x',k')=y$. Es gilt also: $Pr(x)Pr(k_1)=\sum_{k\in K:e(x,k)=y} Pr(x)Pr(k) = Pr(x,y) = Pr(x|y)Pr(y) =^* Pr(x)Pr(y)$, und daher $Pr(k_1)=Pr(y)$, wegen $Pr(x)>0$. (* gilt, weil $V$ informationstheoretisch sicher ist.) Analog gilt $Pr(x')Pr(k_2)=Pr(x')Pr(y)$, und daher $Pr(k_2)=Pr(y)$. Es folgt $Pr(k_1)=Pr(k_2)$, wie gewünscht. +Teil 2. dieses Lemmas hat eine Umkehrung. + +Lemma 1.27 Sei $V=(X,K,Y,e,d,Pr_K)$ KSV mit $|X|=|Y|=|K|$. Wenn $S=(X,K,Y,e,d)$ possibilistisch sicher ist und $Pr_K$ die Gleichverteilung ist, dann ist $V$ informationstheoretisch sicher. + +Beweis: Es sei eine beliebige Klartextverteilung $Pr_X$ gegeben. Da S possibilistisch sicher ist und $|X|=|Y|=|K|$ gilt,existiert für jedes Paar $(x,y)\in X\times Y$ genau ein $k_{x,y}\in K$ mit $e(x,k_{x,y}) =y$ (vgl.Aussage 1. im Beweis des vorherigen Lemmas). +Damit gilt für jedes $y\in Y$:$Pr(y)=\sum_{x\in X,k\in K:e(x,k)=y} Pr(x)Pr(k) =\sum_{x\in X} Pr(x) Pr(k_{x,y})=\frac{1}{|K|}* \sum_{x\in X} Pr(x) = \frac{1}{|K|}$. +Wir haben benutzt, dass $Pr_K$ die uniforme Verteilung ist und dass $\sum_{x\in X} Pr(x) = 1$ gilt. +Seien nun $x\in X$ und $y\in Y$ beliebig. Wenn $Pr(x)=0$ ist, gilt auf jeden Fall $Pr(x|y)=0=Pr(x)$. Wir können also $Pr(x)> 0$ annehmen und rechnen: $Pr(x|y) =\frac{Pr(x,y)}{Pr(y)}=\frac{Pr(y|x)*Pr(x)}{Pr(y)}=\frac{Pr_K(k_{x,y})*Pr(x)}{Pr(y)}=^* \frac{\frac{1}{|K|}*Pr(x)}{\frac{1}{|K|}}=Pr(x)$. +(Für * benutzen wir die Annahme über $Pr_K$ und die Gleichheit $Pr(y)=\frac{1}{|K|}$ von oben.) Das heißt, dass V für $Pr_X$ informationstheoretisch sicher ist. +Aus den beiden Lemmas erhalten wir den folgenden Satz, der die informationstheoretisch sicheren KSVs für den Fall $|X|=|Y|=|K|$ vollständig beschreibt. + +Satz 1.28 Sei $V= (X,K,Y,e,d,Pr_K)$ ein KSV mit $|X|=|Y|=|K|$. Dann sind äquivalent: +1. $V$ ist informationstheoretisch sicher. +2. $(X,K,Y,e,d)$ ist possibilistisch sicher und $Pr_K(k)=\frac{1}{|K|}$ für alle $k\in K$. + +Beweis: ,,$(a)\Rightarrow (b)$'': Wenn V informationstheoretisch sicher ist, dann auch bezüglich einer Klartextverteilung $Pr_X$, in der alle Klartexte aktiv sind. Lemma 1.26 liefert 2. ,,$(b)\Rightarrow (a)$'': Lemma 1.27. + +Der Satz besagt, dass man informationstheoretisch sichere Systeme mit $|X|=|Y|=|K|$ daran erkennt, dass in der Verschlüsselungstabelle (für e) in jeder Spalte alle Chiffretexte vorkommen (possibilistische Sicherheit) und dass die Schlüsselverteilung $Pr_K$ uniform ist. Auch in jeder Zeile kommen natürlich alle Chiffretexte vor: das liegt aber einfach an der Dechiffrierbedingung. +Wir geben ein Beispiel für ein solches informationstheoretisch sicheres Kryptosystem mit $|X|=|Y|=|K|=6$ an. Die Klartextverteilung ist irrelevant. (Die Verschlüsselungsfunktion ist übrigens mit Hilfe der Multiplikationstabelle der multiplikativen Gruppe $\mathbb{Z}^*_7$ des Körpers $\mathbb{Z}_7$ konstruiert worden. Solche Tabellen haben die Eigenschaft, dass jeder mögliche Eintrag in jeder Zeile und in jeder Spalte genau einmal vorkommt.) + +Beispiel 1.29 Wir betrachten $X=\{a,b,c,d,e,f\},K=\{k_0 ,...,k_5\},Y=\{A,...,F\}$. +| e | a | b | c | d | e | f | +| ------------------- | --- | --- | --- | --- | --- | --- | +| $k_0 (\frac{1}{6})$ | A | B | C | D | E | F | +| $k_1 (\frac{1}{6})$ | B | D | F | A | C | E | +| $k_2 (\frac{1}{6})$ | C | F | B | E | A | D | +| $k_3 (\frac{1}{6})$ | D | A | E | B | F | C | +| $k_4 (\frac{1}{6})$ | E | C | A | F | D | B | +| $k_5 (\frac{1}{6})$ | F | E | D | C | B | A | + +Nun betrachten wir allgemeinere Situationen, und fragen auch nach informationstheoretischer Sicherheit für spezifische Klartextverteilungen $Pr_X$ und für Mengen $K$ und $Y$, die größer als $X$ sind. Die Bedingung ,,uniforme Verteilung auf den Schlüsseln'' verschwindet dann komplett! Wir erinnern uns: Klartexte $x$ mit $Pr_X(x)> 0$ heißen aktiv (bzgl. $Pr_X$), die anderen passiv. Es wird sich herausstellen, dass sich informationstheoretische Sicherheit für $Pr_X$ mit dem Verhalten von $e(x,k)$ auf den aktiven Klartexten entscheidet, wobei es auf die tatsächlichen Wahrscheinlichkeiten für die aktiven Klartexte nicht ankommt. + +Technisch hilfreich sind die folgenden Größen, die nur von der Verschlüsselungsfunktion und der Schlüsselverteilung abhängen (nicht von irgendeiner Klartextverteilung): $P^x(y):=\sum_{k\in K, e(x,k)=y} Pr(k)$, für $x\in X,y\in Y$ (1.1). +Man beobachtet sofort die folgenden Gleichungen, die aus der Unabhängigkeit der Verteilungen $Pr_X$ und $Pr_K$ folgen: +- Für alle $x\in X:Pr(x,y) = Pr(x)*P^x(y)$. (1.2) +- Wenn $Pr(x)> 0$:$Pr(y|x) = \frac{Pr(x,y)}{Pr(x)}=P^x(y)$. (1.3) umgekehrt wie bei der Definition der informationstheoretischen Sicherheit stellt man sich hier vor, dass ein Klartext x gegeben ist und man fragt nach der resultierenden Verteilung auf den Chiffretexten. +Das nächste Lemma besagt, dass man die Wahrscheinlichkeiten aktiver Klartexte beliebig ändern kann (auch auf 0, also sie weglassen), ohne dass eine bestehende informationstheoretische Sicherheit zerstört wird. + +Lemma 1.30 Sei $V=(X,K,Y,e,d,Pr_K)$ KSV und seien $Pr_X$ und $Pr'_X$ Klartextverteilungen mit $Pr'_X(x)>0\Rightarrow Pr_X(x)>0$. Dann gilt: Ist $V$ informationstheoretisch sicher bzgl. $Pr_X$, so ist V informationstheoretisch sicher bzgl. $Pr'_X$. + +Beweis: Sei $V$ informationstheoretisch sicher bzgl. $Pr_X$. Wir haben es jetzt mit zwei Wahrscheinlichkeitsräumen zu tun, einem zu $Pr_X$ und $Pr_K$ (bezeichnet mit $(X\times K,Pr)$) und einem zu $Pr'_X$ und $Pr_K$ (bezeichnet mit $(X\times K,Pr')$). +Wir zeigen nacheinander vier Aussagen. +1. $Pr_X(x)> 0 \Rightarrow P^x(y) = Pr(y|x) = Pr(y)$ für alle $y\in Y$. (Die Verteilungen $Pr^X(*)=Pr(*|x)$ auf den Chiffretexten sind für alle (Pr-)aktiven Klartexte x gleich und sind auch gleich der globalen Verteilung auf den Chiffretexten.) Beweis hierzu: Sei $Pr(x)>0$. Dann gilt $P^x(y)=Pr(y|x)$, siehe (1.3). Wenn $Pr(y)=0$ gilt, folgt auch $Pr(y|x)=0$. Sei also $Pr(y)>0$. Dann gilt: $Pr(y|x) =\frac{Pr(x,y)}{Pr(x)}=\frac{Pr(x|y)Pr(y)}{Pr(x)}=^* \frac{Pr(x)Pr(y)}{Pr(x)}= Pr(y)$. (* gilt, weil V informationstheoretisch sicher bzgl. $Pr_X$ ist.) +2. $Pr'_X(x)> 0 \Rightarrow Pr'(y|x) = Pr(y)$ für alle $y\in Y$. Beweis hierzu: Aus $Pr'(x)>0$ folgt $Pr(x)>0$, nach Voraussetzung. Wir wenden (1.3) für $Pr'$ und für $Pr$ an und erhalten für alle $y\in Y$: $Pr'(y|x)=P^x(y)=Pr(y|x)=^a Pr(y)$. +3. $Pr'(y)=Pr(y)$ für alle $y\in Y$. Beweis hierzu: Mit Lemma 1.15(a) (Formel von der totalen Wahrscheinlichkeit): $Pr'(y)=\sum_{x\in X: Pr'(x)> 0} Pr'(y|x)Pr'(x)=^b \sum_{x\in X: Pr'(x)> 0} Pr(y)Pr'(x) = Pr(y)$. +4. $Pr'(x)=Pr'(x|y)$ für alle $x\in X,y\in Y$ mit $Pr'(y)>0$. (D.h.: V ist bzgl. $Pr'_X$ informationstheoretisch sicher.) Beweis hierzu: Wenn $Pr'(x)=0$ gilt, dann folgt $Pr'(x|y)=0=Pr'(x)$. Sei nun $Pr'(x)>0$. Dann: $Pr'(x|y)=\frac{Pr'(x,y)}{Pr'(y)}=\frac{Pr'(y|x)Pr'(x)}{Pr'(y)}=^{b,c} \frac{Pr(y)Pr'(x)}{Pr(y)} = Pr'(x)$. + +Satz 1.31 Sei $V=(X,K,Y,e,d,Pr_K)$ KSV und sei $Pr_X$ eine Klartextverteilung. Dann sind äquivalent: +1. V ist informationstheoretisch sicher für $Pr_X$. +2. Für jedes $x\in X$ und jedes $y\in Y$ gilt: $Pr(x,y)=Pr(x)Pr(y)$ (das Eintreten von x und das Eintreten von y sind unabhängig). +3. Für alle $x\in X$ mit $Pr(x)>0$ und alle $y\in Y$ gilt $Pr(y)=Pr(y|x)$ (andere Formulierung der Unabhängigkeit). +4. Für alle $x,x'\in X$ mit $Pr(x),Pr(x')>0$ und alle $y\in Y$ gilt $P^x(y)=P^{x'}(y)$. + +Bemerkung: Bedingung 1. fragt nach der Situation bei gegebenem Chiffretext y mit $Pr(y)>0$. Bedingung 2. ist die wahrscheinlichkeitstheoretisch klarste Charakterisierung von informationstheoretischer Sicherheit, ohne bedingte Wahrscheinlichkeiten zu verwenden. Bedingungen 3. und 4. machen deutlich, dass es nur auf das Verhalten des Kryptosystems (mit seiner Verteilung $Pr_K$) auf den aktiven Klartexten ankommt, nicht auf die Klartextverteilung. Sie sagen auch, worauf genau es ankommt: Für jeden beliebigen aktiven Buchstaben ist die von $e(x,*)$ und der Schlüsselverteilung erzeugte Verteilung auf den Chiffretexten gleich, und zwar gleich der absoluten Verteilung auf den Chiffretexten. Informationstheoretische Sicherheit von $V$ (also für alle Klartextverteilungen) heißt also, dass alle Funktionen $P^x:Y\rightarrow [0,1]$, für $x\in X$, gleich sind (weil man als $Pr_X$ eine Verteilung wählen kann, bei der alle Klartexte aktiv sind, zum Beispiel die Gleichverteilung). + +Beweis: +- ,,$1.\Rightarrow 2.$'': Wenn $Pr(y)=0$, gilt $Pr(x,y)=0=Pr(x)Pr(y)$. Sei jetzt $Pr(y)>0. Dann gilt $Pr(x,y)=Pr(y)Pr(x|y) = Pr(y)Pr(x)$, nach 1. +- ,,2.\Rightarrow 3.'': Wegen 2. gilt $Pr(y)Pr(x)=Pr(x,y)$. Andererseits ist $Pr(y|x)Pr(x)=Pr(x,y)$, also folgt 3. durch Kürzen mit $Pr(x)>0$. +- ,,3.\Rightarrow 4.'': Verwende (1.3) für $x$ und $x'$ und benutze 3. +- ,,4.\Rightarrow 1.'': (Dies ist natürlich der entscheidende und schwierigste Beweisschritt!) Nach Voraussetzung 4. gibt es für jedes $y\in Y$ ein $p_y$ mit $P^x(y)=p_y$ für alle aktiven $x\in X$. + - Nach Lemma 1.15.1 (Formel von der totalen Wahrscheinlichkeit) gilt dann für jedes y: $Pr(y)=\sum_{x\in X:Pr(x)>0} Pr(y|x)*Pr(x) = \sum_{x\in X: Pr(x)>0} P^x(y)*Pr(x) = \sum_{x\in X:Pr(x)>0} p_y*Pr(x) =p_y$. + - Sei nun $y\in Y$ mit $Pr(y)>0$, und sei $x\in X$. Wenn $Pr(x)=0$ gilt, folgt auch $Pr(x|y)=0$. Wenn $x$ aktiv ist, dann gilt $Pr(x|y)=\frac{Pr(x,y)}{Pr(y)}=\frac{Pr(y|x)Pr(x)}{p_y}=\frac{P^x(y)Pr(x)}{p_y}=Pr(x)$, wie gewünscht. + +Beispiel 1.32 Wir geben noch ein Beispiel für ein informationstheoretisch sicheres Kryptosystem mit $|X|=4,|Y|=6$ und $|K|=8$ an. Die Klartextverteilung ist irrelevant. Sei $X=\{a,b,c,d\},K=\{k_0,...,k_7\},Y=\{A,B,C,D,E,F\}$, und $e$ durch die folgende Tabelle gegeben. (Sie entsteht durch Zusammensetzen zweier informationstheoretisch sicherer Kryptosysteme mit jeweils vier Schlüsseln und vier Chiffretexten.) +| e | a | b | c | d | +| -------------------- | --- | --- | --- | --- | +| $k_0 (\frac{1}{6})$ | A | B | C | D | +| $k_1 (\frac{1}{6})$ | B | C | D | A | +| $k_2 (\frac{1}{6})$ | C | D | A | B | +| $k_3 (\frac{1}{6})$ | D | A | B | C | +| $k_4 (\frac{1}{12})$ | A | B | E | F | +| $k_5 (\frac{1}{12})$ | B | A | F | E | +| $k_6 (\frac{1}{12})$ | E | F | A | B | +| $k_7 (\frac{1}{12})$ | F | E | B | A | + +Offensichtlich ist die Schlüsselverteilung nicht uniform. Jeder Schlüssel $k$ hat eine andere Chiffre $x\rightarrow e(x,k)$. Die (absoluten) Wahrscheinlichkeiten für die Chiffretexte sind ebenfalls nicht uniform ($Pr(A)=Pr(B)=\frac{1}{4}$, $Pr(C)=Pr(D)=\frac{1}{6}$, $Pr(E)=Pr(F)=\frac{1}{12}$). +Die informationstechnische Sicherheit drückt sich dadurch aus, dass diese Chiffretextwahrscheinlichkeiten auch für jeden Klartext (also jede Spalte) separat auftreten. + +## Fallstudie für Cyphertext-only-Angriffe: Vigenère-Chiffre +In der Einleitung wurde schon kurz die sogenannte Vigenère-Chiffre angesprochen. Dies ist ein klassisches Verfahren zur Verschlüsselung natürlich sprachiger Texte. Üblicherweise nimmt man dabei den zu verschlüsselnden Text, lässt alle Satzzeichen und alle Leerzeichen weg und wandelt Groß-in Kleinbuchstaben um. Umlaute und andere Sonderzeichen werden umschrieben. Resultat ist eine Folge $x=(x_0,...,x_{l-1})=x_0 ...x_{l-1}$ von Buchstaben im Klartextalphabet $\{a,...,z\}$ der Größe 26. Wir betrachten hier nur den Fall, wo die Klartextlänge von vornherein beschränkt ist (gemäß Szenario 1), also ist $l\geq L$ für ein festes L. Nun möchte man $x$ verschlüsseln. Ein informationstheoretisch sicheres Verfahren ist, für jede Buchstabenposition $0\geq i < L$ rein zufällig einen Schlüssel $k_i\in\{A,...,Z\}$ zu wählen und an Position $i$ die Verschiebechiffre mit Schlüssel $k_i$ anzuwenden. Der Schlüssel $k_0,...,k_{L-1}$ ist dann aber mindestens so lang wie die Klartextfolge. Allerdings ist das nach unseren bisherigen Ergebnissen auch unvermeidlich: Wenn $V=(X,K,Y,e,d,Pr_K)$ informationstheoretisch sicher ist, ist $(X,K,Y,e,d)$ possibilistisch sicher, also $|X|\geq |K|$. + +Es liegt nahe, zu versuchen, mit nur einem Schlüsselbuchstaben oder mit einem kürzeren Schlüssel auszukommen. Dies führt zur einfachen (wiederholten) Verschiebechiffre und zur Vigenère-Chiffre. Wir zeigen, dass man diese mit einfachen Mitteln ,,brechen'' kann. + +### Die Vigenère-Chiffre und Angriffe bei bekannter Schlüssellänge +Es ist bequem, anstelle von Buchstaben mit Zahlen zu rechnen. Mit $Z_n$ bezeichnen wir den Ring $\mathbb{Z}/n\mathbb{Z}$, also (etwas vereinfachend gesagt) den Ring der Zahlen $\{0,1,...,n-1\}$ mit Addition und Multiplikation modulo n als Operationen. + +Definition: Eine Verschiebechiffre ist ein Kryptosystem $S=(Z_n,Z_n,Z_n,e,d)$ mit $e(x,k)=(x+k) mod\ n$. (Offensichtlich ist dann $d(y,k)=(y-k)mod\ n$.)ünser zentrales Beispiel ist der Fall $n=26$, also $X=Y=K=\{0,1,2,...,25\}$. Wir identifizieren die Elemente dieser Menge mit den Buchstaben $a,...,z$ (bei X) bzw. $A,...,Z$ (bei K und Y). Die Konvention ist nach wie vor, Klartextbuchstaben klein und Schlüsselbuchstaben und Chiffretextbuchstaben groß zu schreiben. + +Die einfachste Methode ist folgende Version der Cäsar-Chiffre: Wähle einen Schlüssel k aus $K=\{0,1,...,25\}=\{A,...,Z\}$ zufällig. Um ,,Texte'' (d.h. Wörterüber $\mathbb{Z}_n$) zu verschlüsseln, wird S buchstabenweise angewandt: Aus $x_0 x_1...x_{l-1}$ wird $e(x_0,k)e(x_1,k)...e(x_{l-1},k)$. + +Diese Methode ist allerdings sehr leicht zu brechen, sogar ,,von Hand'', also ohne massiven Einsatz von Computern. Es gibt mindestens die folgenden naheliegenden Möglichkeiten, einen gegebenen Chiffretext $y_0...y_{l-1}$, der aus einem natürlichsprachigen Text entstanden ist, zu entschlüsseln: +1. probiere die 26 möglichen Schlüssel aus, oder +2. zähle, welche Buchstaben am häufigsten im Chiffretext vorkommen und teste die Hypothese, dass einer von diesen für ,,e'' steht. + +Betrachte beispielsweise den Chiffretext $RYFWAVSVNPLVOULHUZAYLUNBUN$. +- Zählen liefert folgende Häufigkeiten für die häufigsten Buchstaben: $U:4,L:3,N:3,V:3$. +- Vermutung: Einer dieser Buchstaben entspricht dem ,,e''. +- Der Schlüssel $k$ mit $e(e,k)=U$ ist $k=Q$. Entschlüsselung mit $Q$ liefert das Wort $bipgkfcfxzvfyevrejkivexlex$, das nicht sehr sinnvoll erscheint. +- Der Schlüssel $k$ mit $e(e,k)=L$ ist $k=H$. Entschlüsselung mit $H$ liefert kryptologie ohne anstrengung, und wir sind fertig. +- Als Basis für solche Entschlüsselungsansätze benutzt(e) man Häufigkeitstabellen für Buchstaben, wie die folgende (Angaben in Prozent): + | Englisch | Deutsch | Italienisch | + | --------- | --------- | ----------- | + | E,e 12,31 | E,e 18,46 | E,e 11,79 | + | T,t 9,59 | N,n 11,42 | A,a 11,74 | + | A,a 8,05 | I,i 8,02 | I,i 11,28 | + | O,o 7,94 | R,r 7,14 | O,o 9,83 | +- Dass das ,,e'' im Deutschen deutlich häufiger als im Englischen ist, liegt auch daran, dass bei der Umschreibung der Umlaute ä,ö und ü als ae, oe, ue jeweils ein ,,e'' entsteht.) + +Man kann auch die Häufigkeiten von ,,Digrammen'' (zwei Buchstaben, z.B. ng) oder ,,Trigrammen'' (drei Buchstaben, z.B. ung oder eit) heranziehen, auch um unterschiedliche Sprachen zu unterscheiden. + +Eine unangenehme Eigenschaft bei der wiederholten Anwendung von reinen Verschiebechiffren ist, dass identische Buchstaben stets gleich verschlüsselt werden. Zum Beispiel hat unabhängig vom Schlüssel der Klartext otto stets zu einem Chiffretext mit dem Muster abba. + +Die Grundidee der Vigenère-Chiffre ist es nun, verschiedene Verschiebechiffren in festgelegter zyklischer Reihenfolge zu verwenden. + +Schlüssel: $k=k_0 k_1 k_2 ...k_{s-1}\in\mathbb{Z}^s_n,s\in\mathbb{N}$. (Eine Folge von Verschiebewerten.) + +Klartext: $x=x_0 x_1...x_{l-1} \in\mathbb{Z}^l_n,l\in\mathbb{N}$. + +Man verschlüsselt $x_0$ mit $k_0$, $x_1$ mit $k_1$, und so weiter. Wenn irgendwann der Schlüssel ,,aufgebraucht'' ist, weil $s1:AB(4)DE(4)F(14)GH(2)IJ(5)LM(3)O(4)P(5)S(5)T(7)U(7)V(6)X$ + - Mögliches Bild von ,,e'': F. Schlüsselbuchstabe wäre: B +- $y^1 =YWHHCNLXSIHXMZCNCVNAUOOMWMYUCVCYUNHLNALYECUUMYYIUYLBLHAYLCZBYVWBFHLCMNAYNY$. + - Buchstaben in $y^1:A(4)B(3)C(8)EFH(6)I(2)L(7)M(5)N(7)O(2)SU(5)V(3)W(2)X(2)Y(19)Z(2)$ + - Mögliches Bild von ,,e'':Y. Schlüsselbuchstabe wäre: U +- $y^2 =RLSMSEJMTKZMMSREGYEOYIVKLWOIIYQRWXHMEOYLEQXQAHVVWAIVFMIVHIXVVILXEFWRXIEPLR$. + - Buchstaben in $y^2:A(2)E(7)F(2)GH(3)I(8)JK(2)L(5)M(6)O(2)PQ(3)R(5)S(3)TV(7)W(4)X(5)Y(4)Z$ + - Mögliche Bilder von ,,e'':I,V. Schlüsselbuchstaben wären: E,R +- $y^3 =YJIJEELVKZVXVIVRYVVVJSURCVIIZVUGKVWYVVEEKDSVLRXXJREVVTJKVUVVFIEMJVZVVRSFR$. + - Buchstaben in $y^3 :CDE(6)F(2)GI(5)J(6)K(4)L(2)MR(6)S(3)TU(3)V(21)WX(3)Y(3)Z(3)$ + - Mögliches Bild von ,,e'':V. Schlüsselbuchstabe wäre: R +- $y^4 =CHUOGRVYCSBKWAFHSFHWUHSPIZSSVFCOVBIFHWRRSCSBFTSHGSRFWVHKBIBPGOWSGJSUZISSH$. + - Buchstaben in $y^4 :AB(5)C(4)F(6)G(4)H(8)I(4)JK(2)O(3)P(2)R(4)S(13)TU(3)V(4)W(5)YZ(2)$ + - Mögliches Bild von ,,e'':S. Schlüsselbuchstabe wäre: O + +Man versucht Schlüssel BURRO und erhält keinen sinnvollen Text. Mit BUERO ergibt sich: +denho echst enorg anisa tions stand erfuh rdiek rypto logie +inven edigw osiei nform einer staat liche nbuer otaet igkei +tausg euebt wurde esgab schlu essel sekre taere dieih rbuer +oimdo genpa lasth atten undfu erihr etaet igkei trund zehnd +ukate nimmo natbe kamen eswur dedaf uerge sorgt dasss iewae +hrend ihrer arbei tnich tgest oertw urden siedu rften ihreb +ueros abera uchni chtve rlass enbev orsie eineg estel lteau +fgabe geloe sthat ten + +Ohne Gruppierung erhält man: +denhoechstenorganisationsstanderfuhrdiekryptologie +invenedigwosieinformeinerstaatlichenbuerotaetigkei +tausgeuebtwurdeesgabschluesselsekretaeredieihrbuer +oimdogenpalasthattenundfuerihretaetigkeitrundzehnd +ukatenimmonatbekameneswurdedafuergesorgtdasssiewae +hrendihrerarbeitnichtgestoertwurdensiedurftenihreb +uerosaberauchnichtverlassenbevorsieeinegestellteau +fgabegeloesthatten + +Nun muss man nur noch die Wortzwischenräume und Satzzeichen ergänzen, um zu erhalten: +Den höchsten Organisationsstand erfuhr die Kryptologie in Venedig, wo sie in Form einer staatlichen Bürotätigkeit ausgeübt wurde. Es gab Schlüsselsekretäre, die ihr Büro im Dogenpalast hatten und für ihre Tätigkeit rund zehn Dukaten im Monat bekamen. Es wurde dafür gesorgt, dass sie während ihrer Arbeit nicht gestört wurden. Sie durften ihre Büros aber auch nicht verlassen, bevor sie eine gestellte Aufgabe gelöst hatten. + +### Der Kasiski-Test +Das bisher betrachtete Verfahren setzt voraus, dass die Schlüssellänge s bekannt ist. Ist die maximale Schlüssellänge S klein, dann kann man die Schlüssellängen 1 bis S einzeln durchprobieren. Ist S groß, möchte man die Suche nach der richtigen Schlüssellänge abkürzen. (Besonders vor dem Computerzeitalter, wo die Dechiffrierung per Hand durchgeführt werden musste, war eine solche Zeitersparnis wichtig.) Die Schlüssellänge kann oft durch den Kasiski-Test näherungsweise bestimmt werden. (Der Test ist benannt nach Friedrich Wilhelm Kasiski (1805, 1881), einem preußischen Infanteriemajor. Der Test wurde von ihm 1863 veröffentlicht. Er war aber bereits 1854 von Charles Babbage entwickelt, aber nicht veröffentlicht worden.) + +Die zentrale Idee des Tests ist die folgende einfache Beobachtung: Gleiche Klartextfragmente, die eventuell mehrfach vorkommen (z.B. das Wort ,,ein'') werden in gleiche Chiffretexte übersetzt, wenn sie unter dem gleichen Schlüsselfragment liegen. Genauer: Stimmt der Klartext im Abschnitt $i+s*l$ bis $j+s*(l+h)$ mit dem Klartext im Abschnitt von $i+s*l'$ bis $j+s*(l'+h)$ überein, so gilt dies auch für den Chiffretext $(1\geq i,j\geq s,l,l',h\in\mathbb{N})$. +Anders ausgedrückt: Kommt ein Teilwort im Klartext an zwei Positionen i und j und ist j-i ein Vielfaches von s, so werden die beiden Vorkommen des Wortes gleich verschlüsselt. + +Diese Beobachtung wird in die folgende Idee für einen Angriff umgemünzt: Für möglichst viele ,,lange'' Wörter, die im Chiffretext mehrfach auftreten, notiere die Abstände des Auftretens. (,,lang'' sollte wenigstens 3 sein.) Dann suche ein großes s, das viele dieser Abstände teilt (nicht unbedingt alle, denn einige Mehrfach vorkommen im Chiffretext könnten zufällig entstanden sein). + +Beispiel 1.34 Im Chiffretext von Abbildung 1 kommen (mindestens) die folgenden Wörter der Länge 3 mehrfach vor. Wir geben die Positionen und die Abstände an. + +| | #Wörter | +| ----------------------------------------------------------- | ------- | +| AWMCJ IENAW NMOZV EYJOK HPXNK TFKQC JPJSJ NTIVT TCOJA AWKBS | 50 | +| NHKBV UYMJG NNUAH UEKFF DLNSJ SZRZL EUKRW IYLCJ MLZWC ECOBM | 100 | +| NOPSV ECOBX OCSOL IVKFC EYTHF IDYSM EMKFV IPCSK EYZZA CSKBS | 150 | +| LRUFA TSSWK CSKBO ECQNW URKVS BPTIW BPXGL RFQHM RPTRA EPYSJ | 200 | +| LLAPW NOGHW NPLTA ZTKBL ZFUFY AYOGA ECKBM NOGIX ZFLWF DPTIW | 250 | +| BPXVS EFLWY BPTIL ZEKOD GZXWL HXKBM NOAST ECJWW SEGBV ACJHW | 300 | +| CSTWC EYSWL DPTSF MLTOD GZXWL HXOGU HPVFG BWKAW MZJSD LTKFW | 350 | +| NGKFK TPNSF UYJZG EDKBC AYT | + +| Wort | Positionen | Abstände | +| --------- | --------------- | -------- | +| ODGZXWLHX | 269 , 319 | 50 | +| DPT | 246 , 311 | 65 | +| BPT | 176 , 261 | 115 | +| ECOB | 96 , 106 | 10 | +| CSK | 138 , 146 , 161 | 8*, 15 | +| AWM | 1 , 339 | 338* | +| PTIWBPX | 177 , 247 | 70 | +| BMNO | 99 , 234 , 279 | 135 , 45 | + +Wir vermuten: Periode ist 5 (dann wären Wiederholungen von AWM und CSK durch Zufall entstanden) + +Das Ergebnis der Entschlüsselung wie oben beschrieben mit vermuteter Schlüssellänge 5 und versuchten Schlüsseln ALGXS (erfolglos) und ALGOS (erfolgreich) ergibt den folgenden Text. +| | #Wörter | +| ----------------------------------------------------------- | ------- | +| algor ithme nbild endas herzs tueck jeder nicht trivi alena | 50 | +| nwend ungvo ncomp utern daher sollt ejede infor matik erinu | 100 | +| ndjed erinf ormat ikerk enntn isseu eberd iewes entli chena | 150 | +| lgori thmis chenw erkze ugeha benue berst ruktu rendi eeser | 200 | +| laube ndate neffi zient zuorg anisi erenu ndauf zufin denue | 250 | +| berha eufig benut zteal gorit hmenu ndueb erdie stand ardte | 300 | +| chnik enmit denen manal gorit hmisc hepro bleme model liere | 350 | +| nvers tehen undlo esenk ann | + +Mit Wortzwischenräumen und Satzzeichen: +Algorithmen bilden das Herzstück jeder nichttrivialen Anwendung von Computern. Daher sollte jede Informatikerin und jeder Informatiker Kenntnisse über die wesentlichen algorithmischen Werkzeuge haben: über Strukturen, die es erlauben, Daten effizient zu organisieren und aufzufinden, über häufig benutzte Algorithmen und über die Standardtechniken, mit denen man algorithmische Probleme modellieren, verstehen und lösen kann. + +Bemerkungen: +- (i) Der Test funktioniert nur gut, wenn die Schlüssellänge s gering im Verhältnis zur Chiffretextlänge l ist. +- (ii) Um ihn anwenden zu können, muss die Klartextsprache bekannt sein. +- (iii) Der Test kann auch in der viel allgemeineren Situation benutzt werden, in der Schlüssel nicht s Verschiebungen, sondern s beliebige Substitutionschiffren auf $X$ bestimmen (z.B. $X=Y$ und Schlüssel ist Tupel($\pi_0,...,\pi_{s-1}$) von Permutationen von $X$). + +Was passiert im Extremfall $s=l$? +- Grundsätzlich hat man dann ein informationstheoretisch sicheres one-time pad vor sich... +- ... aber nur dann, wenn die Schlüssel gleichverteilt gewählt werden. Wenn der Schlüssel selbst ein deutscher Text ist (z.B. ein Textstück aus einem Buch), so weist der Chiffretext wieder statistische Merkmale auf, die zum Brechen ausgenutzt werden können. (Beispiel: Wenn Schlüssel und Klartext beides deutsche Texte sind, werden ca. $7,6%$ der Buchstaben mit sich selbst verschlüsselt, d.h. Chiffretextbuchstabe$= 2 *$ Klartextbuchstabe modulo 26.) + +Effektive Verfahren der Schlüsselverlängerung (die aber keine informationstheoretische Sicherheit bringen): +- Autokey-Vigenère: Schlüssel k, Klartext m. Dann wird klassische Vigenère-Chiffre mit Schlüssel km auf m angewendet. +- Pseudozufallszahlen: Geheimer Schlüssel ist seed eines (Pseudo-)Zufallszahlengenerators, mit dem eine lange Schlüsselfolge $k_0,...,k_{l-1}$ erzeugt wird. + +### Koinzidenzindex und Friedman-Methode +Wir betrachten noch eine andere interessante Methode zur Abschätzung der Schlüssellänge, die bei der Verwendung einer Vigenère-Chiffre oder anderen Substitutionschiffren mit fester Schlüssellänge s helfen können, diese zu ermitteln. Die Methode beruht darauf, dass die Buchstabenhäufigkeiten (zu einer gegebenen Sprache) fest stehen und sich bei der Verschlüsselung mit einer einfachen Substitutionschiffre nicht ändert. Ebenso ändert sich nicht die Wahrscheinlichkeit, bei der zufälligen Wahl eines Buchstabenpaars zwei identische Buchstaben zu erhalten. Die Methode stammt von William F. Friedman (1891, 1969), einem amerikanischen Kryptographen. + +Sei $x=x_0...x_{l-1}$ ein Klartext, sei $y=y_0...y_{l-1}$ der zugehörige Chiffretext, bei $s=1$ (an jeder Stelle derselbe Schlüssel). Seien $n_0,...,n_{25}$ die Anzahlen der Buchstaben $a,...,z$ in $x,n'_0,...,n'_25$ die in $y$. Wir wählen zufällig ein Paar von zwei Positionen in x (ohne ,,Zurücklegen''). Dafür gibt es $\binom{l}{2}$ Möglichkeiten. Genau $\binom{n_i}{2}$ viele davon führen dazu, dass man zweimal den Buchstaben Nummer i zieht, und $\sum_{0\geq i<26}\binom{n_i}{2}$ viele führen dazu, dass man an den beiden Positionen denselben Buchstaben sieht. Wir setzen $IC(x):=\frac{\sum_{0\geq i<26}\binom{n_i}{2}}{\binom{l}{2}}=\frac{\sum_{0\leq i<26}n_i(n_i-1)}{l(l-1)}$. +Diese Zahl nennt man den Koinzidenzindex von x. Sie ist die Wahrscheinlichkeit dafür, dass an den beiden zufällig gewählten Positionen der selbe Buchstabe steht. Weil die Verschlüsselung auf den Buchstaben eine Bijektion ist, also sich die vorkommenden Häufigkeiten durch die Verschlüsselung nicht ändern, gilt für $IC(y):=\frac{\sum_{0\geq i<26} n'_i(n'_i -1)}{l(l-1)}$ die Gleichung $IC(x)=IC(y)$. +Für lange Texte mit (sprachtypischer) Häufigkeitsverteilung der Buchstaben nähert sich $IC(x)$ einem bestimmten Wert an. Wenn $p_i$ die Häufigkeit von Buchstabe i in der verwendeten Sprache ist, wird für lange Texte x die Näherung $\frac{n_i}{l}\approx\frac{n_i-1}{l-1}\approx p_i$ gelten, also $IC(x)\approx \sum_{0\geq i<26} p^2_i$ sein. Die Summe $\sum_{0\geq i<26} p^2_i$ hat beispielsweise einen Wert von etwa $0,076$ für deutsche und $0,066$ für englische Texte. Wenn (in einer fiktiven Sprache) jeder Buchstabe dieselbe Wahrscheinlichkeit hat, ist $\sum_{0\geq i<26} p^2_i= 26*(\frac{1}{26})^2=\frac{1}{26}\approx 0,0385$; dies ist zugleich der minimal mögliche Wert. + +Für die Ermittlung eines Schätzwertes für die Schlüssellänge s gehen wir wie folgt vor. Wir nehmen an, die zugrunde liegende Sprache ist Deutsch. Wir berechnen zunächst $IC(y)$ für den Chiffretext y. Die unbekannte Schlüssellänge nennen wir s. Dann berechnen wir eine Näherung für $IC(y)$, auf eine zweite Weise. Dies wird uns eine (Näherungs-)Gleichung für s liefern. + +Wir überlegen: Bilde die Teilwörter $y^0,...,y^{s-1}$ wie in Abschnitt 1.4, jedes mit der Länge $\frac{l}{s}$. Innerhalb jedes Teilworts kommen Kollisionen ebenso häufig vor wie in einem gewöhnlichen Text mit nur einem Schlüssel, also erwarten wir zusammen $\binom{l/s}{2} IC(y^0)+...+\binom{l/s}{2} IC(y^{s-1})\approx s\binom{l/s}{2}* 0,076 = \frac{1}{2}l(l/s-1)* 0,076$ viele ,,Kollisionen'' (Paare identischer Chiffretextbuchstaben) aus den einzelnen Teilwörtern. +Zwischen zwei Teilwörtern $y^u$ und $y^v$ erwarten wir $(l/s)^2*261\approx 0,0385(l/s)^2$ Kollisionen, aus allen $\binom{s}{2}$ Paaren von Teilwörtern zusammen also $\binom{s}{2} 0,0385(l/s)^2 =\frac{s(s-1)}{2}* 0,0385(l/s)^2 =\frac{1}{2} *0,0385 l^2 (1-\frac{1}{s})$ viele. Zusammen ist die erwartete Anzahl an Kollisionen in y gleich $\frac{1}{2}l(0,076(l/s-1) + 0,0385 l(1-\frac{1}{s}))$. +Diese Zahl sollte näherungsweise gleich $\frac{1}{2}l(l-1)IC(y)$ sein. Wir können die resultierende Gleichung $(l-1)IC(y) = 0,076(l/s-1) + 0,0385 l(1-\frac{1}{s})$ nach s auflösen und erhalten: $s\approx \frac{(0,076-0,0385)l}{(l-1)IC(y)-0,0385l+0,076}$. (Wenn man anstelle der Konstanten $0,076$ den Wert $0,066$ einsetzt, erhält man die entsprechende Formel für englischsprachige Texte.) +Eine tatsächliche Durchführung des Verfahrens mit Chiffretexten wie im vorigen Kapitel erfordert viel Geduld (oder den Einsatz eines Computers). + +Beim ,,venezianischen'' Chiffretext EYRYC...UYR von oben ergibt sich: +| $a_i$ | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | +| ------ | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | +| $n'_i$ | 8 | 12 | 13 | 2 | 18 | 25 | 7 | 19 | 20 | 14 | 8 | 15 | 16 | 7 | 12 | 8 | 3 | 15 | 25 | 10 | 19 | 41 | 13 | 11 | 19 | 8 | + +Dies liefert $IC(y)\approx 0,048024$ und $l=368$. Damit erhalten wir $s\approx\frac{0,0375*368}{367 *0,048024-0,0385 *368+0,076}\approx 3,9$. +Das ist nicht zu nahe am tatsächlichen Wert 5, aber auch nicht ungeheuer weit weg. (Die Formel reagiert sehr empfindlich auf kleine Änderungen in $IC(y)$. Mit $IC(y)=0,05$ ergibt sich $s\approx 3,24$, mit $IC(y)=0,046$ ergibt sich $s\approx 4,95$.) + +# Frische symmetrische Verschlüsselung und Blockchiffren +Szenarium 2 (frische symmetrische Verschlüsselung): Alice möchte Bob mehrere verschiedene Klartexte vorher bekannter und begrenzter Länge übermitteln. Sie verwendet dafür immer denselben Schlüssel. Eva hört die Chiffretexte mit und kann sich sogar einige Klartexte mit dem verwendeten Schlüssel verschlüsseln lassen (chosen-plaintext attack, CPA). + +Bemerkung: Das informationstheoretisch sichere Vernam-Kryptosystem aus Kapitel 1 ist nutzlos: Aus Kenntnis von $x\in\{0,1\}^l$ und $y=e(x,k)$ für ein einziges Paar $(x,k)\in X\times K$ kann Eva den Schlüssel $k=x\oplus_l y$ berechnen. +Gleiches gilt für das Cäsar-System und das Vigenère-System. + +Mit dem nächsten Begriff erfassen wir folgende Situation: Eva kennt eine ganze Folge von Klartext-Chiffretext-Paaren bezüglich des (ihr unbekannten) Schlüssels k. Dabei kann sie sich die Klartexte sogar selbst herausgesucht haben. Wir wollen ,,possibilistische Sicherheit'' so definieren, dass sie trotzdem bei beliebigem gegebenem weiteren Chiffretext y keinen Klartext ausschließen kann. + +Definition 2.1 Ein Kryptosystem $S=(X,K,Y,e,d)$ ist possibilistisch sicher bzgl. Szenarium 2 ,wenn für jedes $1 \leq r\leq |X|$, jede Folge von paarweise verschiedenen Klartexten $x_1,x_2,...,x_r\in X$, jeden Schlüssel $k\in K$ und jedes $y\in Y\backslash\{e(x_i,k)| 1 \leq i < r\}$ ein Schlüssel $k'\in K$ existiert mit $e(x_i,k)=e(x_i,k')$ für alle $1\leq i< r$ und $e(x_r,k')=y$. + +Wenn man die Definition auf $r=1$ anwendet, ergibt sich, dass S auch possibilistisch sicher im Sinn von Kapitel 1 ist. + +Proposition 2.2 Für jede nichtleere Menge $X$ ist das Substitutionskryptosystem (Def.1.9) auf X possibilistisch sicher. (Erinnerung: $K=P_X=\{\pi|\pi\text{ ist Permutation von }X\}$ und $e(\pi,x)=\pi(x)$.) +Beweis: Seien $x_1,x_2,...,x_r\in X$ paarweise verschieden, $k\in K=P_X$ und $y\in Y\{e(x_i,k)|1\leq iN(log_2 N-log_2 e)> N(log_2 N- 1.45)$) $log(2^{128}!)> 2^{128}*(128- 1.45)> 2^{134}>(10^3 )^{13.4} > 10^{40}$ viele Bits, eine völlig unpraktikable Zahl. +Also können wir in realen Situationen im Szenarium 2 keine possibilistische Sicherheit, geschweige denn informationstheoretische Sicherheit erhalten. + +Wir werden uns in diesem Kapitel also darauf verlassen müssen, dass Eva nur beschränkte Rechenressourcen hat, um einen praktikablen Angriff zu starten. Auf der anderen Seite wollen wir jetzt auch annehmen, dass Alice und Bob mit Computerhilfe verschlüsseln und entschlüsseln wollen, d.h. dass wir effiziente Algorithmen für die Ver- und Entschlüsselung benötigen. Damit wird es sinnvoll anzunehmen, dass Klar- und Geheimtexte und Schlüssel Bitvektoren sind. + +Definition 2.4 Sei $l>0$. Ein l-Block-Kryptosystem ist ein Kryptosystem $S=(\{0,1\}^l,K,\{0,1\}^l,e,d)$ mit $K\subseteq \{0,1\}^s$ für ein $s>0$. + +Beispiele für l-Block-Kryptosysteme sind das Vernam-System der Länge l und Substitutionskryptosystem mit $X=\{0,1\}^l$, falls Permutationen als Bitvektoren kodiert sind. Wir sprechen dann vom Substitutionskryptosystem mit Parameter $l$. +Eine weitere Klasse von Verfahren wird im nächsten Abschnitt vorgestellt. + +## Substitutions-Permutations-Kryptosysteme (SPKS) +Substitutions-Permutations-Kryptosysteme bilden eine große Familie von praktisch relevanten Kryptosystemen, zu denen auch die Verfahren des Data Encryption Standard (DES) und des Advanced Encryption Standard (AES) gehören. + +Grundsätzlich handelt es sich um $mn$-Block-Kryptosysteme. Dabei werden die Klartexte $x=(x_0,...,x_{mn-1})\in\{ 0,1\}^{mn}$ als m-Tupel $(x^{(0)},x^{(1)},...,x^{(m-1)})$ von Bitvektoren der Länge n betrachtet. Dabei gilt $x(i)=(x_{in},x_{in+1},...,x_{(i+1)n-1})$, für $0\leq i10^{38}$ beträgt. Um diesen Trick auszuschließen, werden wir den Ressourcenverbrauch eines Algorithmus als Summe von Laufzeit und Länge des Programmcodes (=Größe der Transitionstabelle der Turingmaschine) messen. Die Programmgröße ist eine untere Schranke für die Zeit, die Eva zur Erstellung ihres Programms benötigt. Unser Ressourcenmaß erfasst also die Zeit für die Erstellung und die Zeit für die Ausführung des Algorithmus.ünsere Algorithmen werden oft mit Kryptosystemen einer festen Blocklänge $l$ und einer fixen Anzahl von Klartext-/Chiffretext-Paaren arbeiten. Damit sind nur endlich viele Eingaben möglich, der Ressourcenverbrauch kann also nicht asymptotisch (,,bei großen Eingaben'') angegeben werden. Daher betrachten wir zunächst Algorithmen mit konstanter Laufzeit. Das führt dazu, dass alle eventuell vorhandenen Schleifen nur konstant oft durchlaufen werden. Damit können wir aber auf Schleifenanweisungen vollständig verzichten. Die resultierenden Programme heißen ,,Straight-Line-Programme''. Man kann sie sich in Pseudocode geschrieben vorstellen (ohne ,,while'' und ,,for'' und ohne Rückwärtssprünge), oder als Turingmaschinenprogramme mit der Eigenschaft, dass nie eine Programmzeile zweimal ausgeführt wird. + +#### Randomisierung bei Straight-Line-Programmen +In unseren Algorithmen wollen wir zusätzlich die Anweisung ,,$y\leftarrow flip(M)$'' erlauben, wobei $M$ eine endliche Menge ist. Die Idee dabei ist, dass der Variable $y$ ein zufälliges Element von $M$ (bzgl. der Gleichverteilung auf $M$) zugewiesen wird. Damit berechnen unsere Algorithmen keine Funktionen, sondern zufällige Werte, die durch eine Wahrscheinlichkeitsverteilung gesteuert werden.üm den Wahrscheinlichkeitsraum definieren zu können, machen wir die folgenden Annahmen (die keine Einschränkung darstellen): +1. Bei nacheinander ausgeführten Kommandos der Form $y\leftarrow flip(M)$, mit identischem oder unterschiedlichem $M$, werden immer neue, unabhängige Zufallsexperimente ausgeführt. +2. Wie eben diskutiert, enthalten unsere Algorithmen keine Schleifen. Wir können daher jedes Ergebnis eines Zufallsexperiments in einer eigenen Variable speichern. Zusätzlich können wir die flip-Kommandos aus dem gesamten Programm, auch den bedingten Anweisungen, herausziehen und sie alle (vorab, auf Vorrat) ausführen. Damit können wir annehmen: Wenn die Anweisung $y\leftarrow flip(M)$ im Programmtext vorkommt, dann wird sie in jedem Durchlauf des Algorithmus (unabhängig von der Eingabe und den Ergebnissen der flip-Anweisungen) genau einmal ausgeführt. + +Abkürzung: $flip(l)$ für $flip(\{0,1\}^l)$ (l-facher Münzwurf) und $flip()$ für $flip(1)$, also $flip(\{0,1\})$ (einfacher Münzwurf). + +Sei nun A ein randomisierter Algorithmus (also ein Straight-Line-Programm), indem die $flip$-Anweisungen $y_i\leftarrow flip(M_i)$ für $1\geq i\geq r$ vorkommen. Dann verwenden wir als zugrundeliegenden Wahrscheinlichkeitsraum die Menge $M=M_1\times M_2\times...\times M_r$ mit der Gleichverteilung. Dies modelliert die Idee, dass die $r$ Zufallsexperimente jeweils mit der uniformen Verteilung und insgesamt unabhängig voneinander ausgeführt werden. + +$I$ sei die Menge der Eingaben, $Z$ sei die Menge der Ausgaben. + +Ist $x\in I$ eine Eingabe, so erhalten wir für jedes $m=(m_1,...,m_r)\in M$ genau eine Ausgabe $A^m(x)\in\mathbb{Z}$, indem wir in $A$ die Anweisung $y_i\leftarrow flip(M_i)$ durch $y_i\leftarrow m_i$ ersetzen. Auf diese Weise erhalten wir +- Für jedes $m\in M$ eine Funktion $A^m:I\rightarrow Z,x \rightarrow A^m(x)$, und +- für jedes $x\in I$ eine Zufallsgröße $A(x):M\rightarrow Z,m\rightarrow A^m(x)$. + +Beispiel 2.8 Betrachte den folgenden Algorithmus: +- $A(x:\{0,1\}^4):\{0,1\}$ // nach dem Doppelpunkt: Typ der Eingabe bzw. Ausgabe + - $b_0 \leftarrow flip()$ + - $b_1 \leftarrow flip()$ + - $b_2 \leftarrow flip()$ + - $b_3 \leftarrow flip()$ + - $if b_0 = 1 \text{ then return } x(0)$ + - $if b_1 = 1 \text{ then return } x(1)$ + - $if b_2 = 1 \text{ then return } x(2)$ + - $if b_3 = 1 \text{ then return } x(3)$ + - return 1 + +Dann ist $M=\{0,1\}^4$, und es gilt: $A^{0110}(1101)=1$ und $A^{0010}(1101)=0$. Kompakt: Wenn $b_0 b_1 b_2 b_3$ mit $i$ Nullen und einer $1$ (an Position $i$) beginnt, dann ist die Ausgabe $x(i)$, für $i=0,1,2,3$. Ist $b_0 b_1 b_2 b_3=0000$, so ist die Ausgabe 1. Also gilt: $Pr(A(1101)=0) = Pr(\{w\in\{0,1\}^4 |w_0=w_1=0, w_2=1\}) =(\frac{1}{2})^3 =\frac{1}{8}$ und $Pr(b_1=1) =Pr(\{w\in\{0,1\}^4 |w(1)=1\})=\frac{1}{2}$ + +Damit erhalten wir auch sinnvolle kombinierte und bedingte Wahrscheinlichkeiten: $Pr(A(1101)=0, b_0=0)= Pr(\{w\in\{0,1\}^4 |w_0=w_1=0, w_2=1\}) =\frac{1}{8}$ und $Pr(A(1101)=0| b_0=0) =\frac{Pr(A(1101)=0, b_0=0)}{Pr(b_0=0)}=\frac{1}{4}$ + +Wir können auch den Algorithmus $A$ so ändern, dass eine Anweisung $y_i\leftarrow flip(M_i)$ durch $y_i\leftarrow m^{(0)}_i$ ersetzt wird. (Diesen Algorithmus bezeichnen wir dann mit $A(y_i=m^{(0)}_i)$.) Es gilt dann für alle Eingaben $x$ und Ausgaben $z$: $Pr(A(x)=z| y_i=m^{(0)}_i) =Pr(A(y_i=m^{(0)}_i)(x) =z)$. Die verallgemeinerte Notation $A(y_1=m^{(0)}_1,...,y_s=m^{(0)}_s)$ erklärt sich von selbst. + +#### Prozeduren als Parameter +Wir werden Algorithmen $A$ betrachten, die als Eingabe eine Prozedur $B$ (z.B. die Verschlüsselungsfunktion einer Blockchiffre mit fest eingesetzem Schlüssel) erhalten. Diese Prozedur darf nur aufgerufen werden, sie wird nicht als Text in den Rumpf von $A$ eingefügt. Sie könnte aber wiederum zufallsgesteuert sein. Um den Wahrscheinlichkeitsraum von $A$ mit einem solchen Funktionsparameter zu bestimmen, müssen folgende Informationen gegeben sein: +- $B$, +- die Anzahl der Aufrufe von $B$ in $A$, +- welche Aufrufe $y\leftarrow flip(M)$ in $B$ vorkommen. + +Wir behandeln dann die Variablen $y$ in verschiedenen Aufrufen von $B$ genau wie die aus einem gewöhnlichen randomisierten Programm (Umbenennen der Variablen, Herausziehen der Zufallsexperimente an den Anfang). In dem resultierenden Wahrscheinlichkeitsraum sind dann die Zufallsexperimente in den verschiedenen Aufrufen von $B$ und die in Teilen von $A$ außerhalb von $B$ unabhängig. + +### Sicherheit von Block-Kryptosystemen +Wir betrachten hier l-Block-Kryptosysteme $B=(X,K,Y,e,d)$ mit $X=Y=\{0,1\}^l$ und $K\subseteq\{0,1\}^s$ für ein $s$. $e$ ist die Verschlüsselungsfunktion und $d$ die Entschlüsselungsfunktion. Wir erinnern uns: +1. Im Szenario 2 (chosen-plaintext attack,CPA) kann die Angreiferin Eva sich eine ,,geringe Zahl'' von Klartexten verschlüsseln lassen, also hat sie eine Liste von Klartext-Chiffretext-Paaren: $(x_1,y_1),...,(x_r,y_r)$. Nun kann jedenfalls nur ein ,,neuer'' Klartext $x$, also ein $x\in X\{x_1,...,x_r\}$, geheim übertragen werden. Die possibilistische Sicherheit verlangt genau, dass dies möglich ist: Wenn $y\in Y\{y_1,...,y_r\}$ ein neuer gegebener Chiffretext ist, dann gibt es für jeden Klartext $x\in X\{x_1,...,x_r\}$ einen Schlüssel $k$, der $x_i$ zu $y_i$ chiffriert, $1 \geq i\geq r$, und $x$ zu $y$ chiffriert. +2. Wenn dabei $r$ beliebig groß sein darf, können nach Prop.2.3 nur Substitutionskryptosysteme in diesem Sinne sicher sein. Da sie $|X|!$ Schlüssel haben müssen und daher immense Schlüssellänge (mindestens $|X|log|X|-O(|X|)$ Bits) erfordern, kommen sie in der Praxis nicht in Frage. + +Idee eines neuen Sicherheitsbegriffs (für Block-Kryptosysteme): Gegeben sei eine Angreiferin Eva mit beschränkten Berechnungsressourcen. Wir fragen, wie sehr aus Evas Sicht das $l$-Block-Kryptosystem $B=(\{0,1\}^l,K,\{0,1\}^l,e,d)$ dem Substitutionskryptosystem $S'=(\{0,1\}^l,P\{0,1\}^l,\{0,1\}^l,e',d')$ (siehe Def.1.9) ähnelt. Ist es ihr mit ,,signifikanter Erfolgswahrscheinlichkeit'' möglich, aufgrund der ihr vorliegenden Information und im Rahmen ihrer Ressourcen, zu unterscheiden, welches der beiden Systeme verwendet wird? Wenn dies nicht der Fall ist, kann das Kryptosystem $B$ als sicher gelten, wie die folgende Überlegung zeigt. +Wenn Eva aufgrund der ihr vorliegenden Information (2.4) nicht mit nennenswerter Erfolgswahrscheinlichkeit unterscheiden kann, ob sie es mit der Chiffre $e(.,k)$ (für ein zufälliges $k\in K$) oder mit $e'(.,\pi)$ (für ein zufälliges $\pi\in P_{\{0,1\}^l}$) zu tun hat, dann hat sie aus der ihr vorliegenden Information keine nennenswerte Information über die konkrete Chiffree $(.,k)$ gelernt. Insbesondere kann sich ihre Information über die Klartextverteilung nicht (wesentlich) ändern, wenn ihr ein neuer Chiffretext $y$ vorgelegt wird, da bei $S'=(\{0,1\}^l,P\{0,1\}^l,\{0,1\}^l,e',d')$ keine solche Änderung eintritt. + +Wir modellieren Verfahren, die eine Chiffre benutzen dürfen und dann ,,raten'' sollen, ob es eine Chiffre zu einem BKS $B$ oder eine Zufallspermutation ist, als randomisierte Algorithmen. + +Definition 2.9 Ein l-Unterscheider ist ein randomisierter Algorithmus $U(F:\{0,1\}^l\rightarrow\{0,1\}^l):\{0,1\}$, dessen Laufzeit bzw. Ressourcenaufwand durch eine Konstante beschränkt ist. + +Das Argument des l-Unterscheiders ist also eine Chiffre $F$. Diese ist als ,,Orakel'' gegeben, das heißt als Prozedur, die nur ausgewertet werden kann, deren Programmtext $U$ aber nicht kennt. Das Programm $U$ kann $F$ endlich oft aufrufen, um sich Paare wie in (2.4) zu besorgen. Danach kann $U$ noch weiter rechnen, um zu einer Entscheidung zu kommen. Das von $U$ gelieferte Ergebnis ist ein Bit. + +Am liebsten hätte man folgendes Verhalten, für ein gegebenes Block-Kryptosystem $B$: Programm $U$ sollte 1 liefern, wenn $F$ eine Chiffre $e(.,k)$ zu $B$ ist, und $0$, wenn $F=\pi$ für eine Permutation $\pi\in P\{0,1\}^l$ ist, die keine $B$-Chiffre ist. Das gewünschte Verhalten wird sich bei $U$ natürlich niemals mit absoluter Sicherheit, sondern nur mit mehr oder weniger großer Wahrscheinlichkeit einstellen, je nach Situation. + +Beispiel 2.10 Als Beispiel betrachten wir das Vernam-Kryptosystem $B=B_{Vernam}$, siehe Beispiel 1.6. Wir definieren einen l-Unterscheider $U=U_{Vernam}$, der als Parameter eine Funktion $F:\{0,1\}^l\rightarrow\{0,1\}^l$ erhält und Folgendes tut: +1. $k\leftarrow F(0^l)$ +2. $y\leftarrow F(1^l)$ +3. falls $1^l\oplus_l k=y$, dann gib $1$ aus, sonst $0$. + +Dieser Unterscheider benutzt keine Zufallsexperimente, obwohl es ihm erlaubt wäre. Man sieht leicht Folgendes: Wenn $F(.) =e(.,k)$ für die Vernam-Chiffre mit beliebigem Schlüssel $k$, liefert $U_{Vernam}$ immer das Ergebnis 1. Wenn hingegen $F$ eine zufällige Permutation $\pi$ von $\{0,1\}^l$ ist, dann ist die Wahrscheinlichkeit, dass $F(1^l)=1^l\oplus_l F(0^l)$ gilt, genau $\frac{1}{2^{l-1}}$, also wird die Ausgabe $1$ nur mit sehr kleiner Wahrscheinlichkeit ausgegeben (wenn $l$ nicht ganz klein ist). + +Wir definieren nun ein Spiel (,,game''), mit dem ein beliebiges Block-Kryptosystem $B$ und ein beliebiger Unterscheider $U$ darauf getestet werden, ob $B$ gegenüber $U$ ,,anfällig'' ist oder nicht. (Das Spiel ist ein Gedankenexperiment, es ist nicht algorithmisch.) Die Idee ist folgende: Man entscheidet mit einem Münzwurf (Zufallsbit b), ob $U$ für seine Untersuchungen als $F(.)$ eine zufällige Chiffre $e(.,k)$ von $B$ (,,Realwelt'') oder eine zufällige Permutation $\pi$ von $\{0,1\}^l$ (,,Idealwelt'') erhalten soll. Dann rechnet $U$ mit $F$ als Orakel und gibt dann seine Meinung ab, ob er sich in der Realwelt oder in der Idealwelt befindet. U ,,gewinnt'', wenn diese Meinung zutrifft. + +Definition 2.11 Sei $B=(\{0,1\}^l,K,\{0,1\}^l,e,d)$ ein l-Block-Kryptosystem, und sei $U$ ein Unterscheider. Das zugehörige Experiment (oder Spiel) ist der folgende Algorithmus: +- $GBU():\{0,1\}$ // kein Argument, Ausgabe ist ein Bit +1. $b\leftarrow flip(\{0,1\})$ + - if $b=1$ (,,Realwelt'') then $k\leftarrow flip(K);F\leftarrow e(.,k)$ // Zufallschiffre von B + - if $b=0$ (,,Idealwelt'') then $F\leftarrow flip(P\{0,1\}^l)$ // Zufallspermutation +2. $b'\leftarrow U(F)$ // Der l-Unterscheider versucht herauszubekommen, ob $b=0$ oder $b=1$ gilt. +3. if $b=b'$ then return 1 else return 0. // 1 heißt, dass $U$ das richtige Ergebnis hat. + +Das verkürzte Experiment/Spiel $S^B_U$ (,,short'') gibt im 3.Schritt einfach $b'$ aus. + +Der Wahrscheinlichkeitsraum für die Analyse des Spiels wird über die Zufallsexperimente zur Wahl von b, von k, der Zufallspermutation $\pi$ aus $P_{\{0,1\}^l}$ und die Zufallsexperimente in $U$ gebildet. Die Wahrscheinlichkeit dafür, dass der Unterscheider richtig liegt, ist $Pr(G^B_U=1)$, gemessen in diesem etwas verschachtelten Wahrscheinlichkeitsraum. + +Wir erläutern intuitiv, wieso diese Definition eine sehr allgemeine Situation erfasst. Angenommen, Angreiferin Eva kann auf irgendeine algorithmische Weise mit einer gewissen positiven Wahrscheinlichkeit eine ,,nicht triviale Information'' über die Klartexte gewinnen, wenn diese mittels einer zufälligen Chiffre des l-Block-Kryptosystems $B$ verschlüsselt worden sind. Damit kann sie einen Unterscheider mit nichttrivialer Erfolgswahrscheinlichkeit bauen! Sie ruft die Verschlüsselungsfunktion $F$ auf, um einige selbstgewählte Klartexte $x_1,...,x_q$ zu $F(x_1)=y_1,...,F(x_q)=y_q$ zu verschlüsseln. Dann berechnet sie aus $y_1,...,y_q$ ihre ,,nichttriviale Information'' $I_1,...,I_q$ zu den entsprechenden Klartexten und prüft, ob $I_r$ auf $x_r$ zutrifft, für $r=1,...,q$. Gibt es eine gute Übereinstimmung, so geht sie davon aus, dass $F$ aus der ,,Realwelt'' stammt, also eine Chiffre von $B$ ist. Ansonsten vermutet sie, dass $F$ aus der ,,Idealwelt'' stammt, also eine zufällige Permutation ist. + +Beispiel 2.12 Für einen l-Bit-String $z$ sei $p(z)=\oplus_{1 \geq i\geq l} z_i$ seine Parität. Nehmen wir an, das Chiffrierverfahren von $N$ ist unvorsichtig geplant und zwar so, dass $p(e(x,k)) =p(x)$ ist für beliebige $x\in X$ und $k\in K$. Bei der Chiffrierung ändert sich also die Parität nicht. (Die Parität ist sicher ,,nichttriviale Information'', auch wenn sie vielleicht nicht unmittelbar nützlich ist.) + +$U_{Parität}(F)$: +1. Wähle Klartexte $x_1,...,x_q$ mit $p(x_1)=...=p(x_q) = 0$. +2. $y_r\leftarrow F(x_r)$, für $r=1,...,q$. +3. falls $p(y_1)=...=p(y_q)=0$, dann gib 1 aus, sonst 0. + +Wenn wir in der ,,Realwelt'' sind $(b=1)$, also $F$ eine Chiffre $e(.,k)$ ist, dann ist die Antwort von $U$ immer ,,1'', also korrekt. Wenn wir in der ,,Idealwelt'' sind $(b=0)$, also $F$ eine zufällige Permutation ist, dann ist die Antwort nur mit Wahrscheinlichkeit $\frac{2^{l-1} (2^{l-1} -1)(2^{l-1}-2)...(2^{l-1} -q+ 1)}{2^l (2^l-1)(2^l-2)...(2^l-q+ 1)} \geq \frac{1}{2^q}$ falsch. (Alle Werte $F(x_1),...,F(x_q)$ müssen zufällig zu Chiffretexten geführt haben, die Parität 0 haben, von denen es $2^{l-1}$ viele gibt.) Es ergibt sich $Pr(G^B_U= 1)\geq\frac{1}{2} (1+1-2^{-q}) =1-2^{-(q+1)}$. Mit der effizienten Berechenbarkeit der ,,nichttrivialen Information'' hat man also einen Unterscheider gefunden, der $Pr(G^B_U=1)$ ,, groß'' macht. + +Beispiel: Der folgende triviale l-Unterscheider $U_{trivial}$ erreicht $Pr(G^B_{U_{trivial}}= 1)=\frac{1}{2}$: $b\leftarrow flip(\{0,1\}); return\ b$. +Daher interessieren wir uns nicht für die Wahrscheinlichkeit $Pr(G^B_U= 1)$ ansich, sondern für den Abstand von $Pr(G^B_U=1)$ zu $Pr(G^B_{U_{trivial}}= 1) =\frac{1}{2}$: + +Definition 2.13 Sei $U$ ein l-Unterscheider und $B$ ein l-Block-KS. Der Vorteil von $U$ bzgl. B ist $adv(U,B):= 2(Pr(G^B_U=1)-\frac{1}{2})$ + +Klar ist: +- Für jeden l-Unterscheider $U$ und jedes l-Block-KS $B$ gilt $-1\geq adv(U,B)\geq 1$. +- Werte $adv(U,B)<0$ sind uninteressant. (Wenn man einen Unterscheider $U$ mit $adv(U,B)<0$ hat, sollte man in $U$ die Ausgaben $0$ und $1$ vertauschen und erhält einen Unterscheider mit positivem Vorteil.) +- Für den trivialen l-Unterscheider $U_{trivial}$ gilt $adv(U,B) = 0$ um den Vorteil eines Unterscheiders auszurechnen, sind seine ,,Erfolgswahrscheinlichkeit'' und seine ,,Misserfolgswahrscheinlichkeit'' hilfreiche Werte: Der Erfolg von U bzgl. B ist (für das verkürzte Spiel $S=S_U^B$) $suc(U,B) := Pr(S〈b= 1〉= 1)$, d.h. die Wahrscheinlichkeit, dass U die Verwendung des l-Block-KS B richtig erkennt. Der Misserfolg ist $fail(U,B) := fail(U) := Pr(S〈b= 0〉= 1)$, d.h. die Wahrscheinlichkeit, dass U die Verwendung des idealen Substitutionskryptosystems nicht erkennt. Man kann in der Notation für ,,fail'' das ,,B'' auch weglassen, da im Fall $b=0$ das Kryptosystem B überhaupt keine Rolle spielt. + +Lemma 2.14 $adv(U,B) = suc(U,B)-fail(U)$. + +Beweis: $Pr(G^B_U= 1) = Pr(S_U^B=b)$ +- $= Pr(S_U^B= 1,b= 1) + Pr(S_U^B= 0,b= 0)$ +- $= Pr(S_U^B= 1|b= 1)* Pr(b= 1) + Pr(S^B_U= 0|b= 0)*Pr(b= 0)$ +- $=\frac{1}{2}( Pr(S_U^B〈b= 1〉= 1) + Pr(S_U^B〈b= 0〉= 0))$ +- $=\frac{1}{2}( Pr(S_U^B〈b= 1〉= 1) + (1-Pr(S_U^B〈b= 0〉= 1)))$ +- $=\frac{1}{2}( (suc(U,B) + (1-fail(U)))$ +- $=\frac{1}{2}(suc(U,B)-fail(U)) + \frac{1}{2}$ + +Durch Umstellen ergibt sich die Behauptung.ünterscheider mit Werten $adv(U,B)$ substanziell über 0 können als interessant (oder möglicherweise gefährlich) für B gelten. Wir müssen noch die beschränkten Ressourcen des Unterscheiders ins Spiel bringen. + +Definition 2.15 Sei $l\in\mathbb{N}$, U ein l-Unterscheider, B ein l-Block-KS. Für $q,t\in\mathbb{N}$ heißt U $(q,t)$-beschränkt, wenn die Laufzeit des Aufrufs von U innerhalb von $G^B_U$ durch t beschränkt ist und dieser Aufruf die Funktion F mit höchstens $q$ verschiedenen Argumenten ausführt. + +Beispiel 2.10 (Fortsetzung) Der l-Unterscheider $U_{Vernam}$ wertet die Funktion $F$ an zwei Stellen $0^l$ und $1^l$ aus. Die Laufzeit des Aufrufs von $U$ ist beschränkt durch $c*l$ für eine Konstante $c\geq 1$. Also ist $U_{Vernam}$ $(2,c*l)$-beschränkt. + +Definition 2.16 Sei $\epsilon>0$. Dann heißt $B(q,t,\epsilon)$-sicher, wenn für jeden $(q,t)$-beschränkten l-Unterscheider $U$ gilt $adv(U,B)< \epsilon$. + +Man kann diese Bedingung auch umgedreht lesen, nämlich so: ,,Um mit Wahrscheinlichkeit größer als $\frac{1}{2}(1 +\epsilon)$ im Experiment $G^B_U$ die richtige Antwort 1 zu erzeugen, braucht ein l-Unterscheider mehr als q Auswertungen oder mehr Laufzeit/Platz als $t$.'' Mit beliebig hohen Rechenzeiten lassen sich praktisch alle Block-Kryptosysteme brechen, selbst mit sehr kleinem $q$. + +Beispiel 2.10 (Fortsetzung) Sei $B$ das Vernam-System der Länge $l$. Um den Vorteil von $U_{Vernam}$ bzgl. $B$ zu bestimmen, berechnen wir Erfolg und Misserfolg von $U$: Es gilt offensichtlich $1=Pr(S^B_U〈b= 1〉= 1) = suc(U,B)$. + +Es gilt $fail(U) = Pr(S^B_U〈b= 0〉= 1) = Pr(S_U^B= 1|b= 0)$. Das verkürzte Experiment $S_U^B$ gibt 1 aus, wenn der Unterscheider $U$ dies tut. Dieser tut es aber genau dann, wenn $1^l\oplus_l F(0^l) =F(1^l)$ gilt, d.h. $fail(U) = Pr(S_U^B〈b= 0〉= 1) = Pr(1^l\oplus_l F(0^l) =F(1^l)) = \frac{1}{2^l- 1}$. + +Damit haben wir aber $adv(U,B) = suc(U,B)-fail(U) = 1-\frac{1}{2^l- 1}=\frac{2^l-2}{2^l-1}\approx 1$. + +Das Vernam-System der Länge $l$ ist also nicht $(2,c*l,\frac{2^l- 2}{2^l- 1})$-sicher. Dafür realistische Werte von $l$ (z.B. 128) der Wert $\frac{2^l-2}{2^l-1}$ praktisch 1 ist, muss das Vernam-System im Szenario 2 als unsicher angesehen werden. + +Natürlich sieht man auch mit bloßem Auge, dass die Vernam-Chiffre bei mehrfacher Verwendung nicht ,,sicher'' ist, da sie leicht entschlüsselt werden kann. Hier geht es aber um die Formulierung eines Sicherheitskonzepts, das allgemein anwendbar ist. Es ist beruhigend, dass im Fall der Vernam-Chiffre herauskommt, dass sie auch im Sinn dieser Definition unsicher ist. + +Am obigen Beispiel eines Block-Kryptosystems, das die Parität von $x$ auf den Chiffretext $e(x,k)$ überträgt, sieht man aber auch, dass das Unterscheiderkonzept sehr empfindlich ist: Obwohl die Information über die Parity klein und harmlos scheint, erklärt es das System für nicht $(q,O(ql), 1-2^{-q})$-sicher, weil die Auswertung der Parität nur Zeit $O(l)$ kostet. + +Beispiel 2.17 Es sei $B$ ein l-Block-Kryptosystem. (Man denke an AES.) Wir nehmen (realistisch) an, dass $t$ (etwa $t=6$) Klartext-Chiffretext-Paare $(x_1,y_1),...,(x_t,y_t)$ in $B$ den Schlüssel $k$ der Länge $s=l$ eindeutig bestimmen, für mindestens die Hälfte der Schlüssel (*). + +Der l-Unterscheider $U_{brute-force}$ wertet die Funktion F an $t+1$ Stellen $x_1,...,x_t,x$ aus, mit Ergebnissen $y_1,...,y_t,y$. Er probiert alle $2^l$ Schlüssel $k$, um einen zu finden, der $e(x_1,k)=y_1 ,...,e(x_t,k) =y_t$ erfüllt. Wenn kein solches $k$ gefunden wird, gibt $U$ den Wert $0$ aus. +Sonst wird getestet, ob $e(x,k)=y$ ist. Falls ja, wird $1$ ausgegeben, sonst $0$. + +Das Verhalten lässt sich so beschreiben: In der ,,Realwelt'', wenn $F=e(.,k)$ ist für einen zufälligen Schlüssel $k$, dann findet $U$ dieses $k$ mit Wahrscheinlichkeit größer als $\frac{1}{2}$ (wegen (*)). Dann ist $e(x,k) =F(x)$ nach Wahl von $F$ und $y=F(x)$, weil $y$ so bestimmt wurde. +Also ist $e(x,k) =y$, also gibt $U$ den Wert 1 aus. In der ,,Idealwelt'' wird entweder kein passendes $k$ gefunden, oder wenn doch, dann ist die Wahrscheinlichkeit, dass $e(x,k) =y$ ist, wo $y$ einzufälliger Wert in $\{0,1\}^l-\{y_1,...,y_t\}$ ist, durch $1/(2^l-t)$ beschränkt. Damit ist $adv(U,B) = suc(U,B)-fail(U)\geq \frac{1}{2}-\frac{1}{2^l-t}\approx\frac{1}{2}$. +Die Laufzeit des Aufrufs von $U$ ist beschränkt durch $O(|K|) =O(2^l)$. + +Daher ist $B$ nicht $(7, O(2^l),\frac{1}{2})$-sicher. Das ist natürlich nicht sehr schlimm, weil die Rechenzeit von $U$ unrealistisch hoch ist. + +Schlussbemerkung: Gesucht wäre nun natürlich ein l-Block-Kryptosystem, das $(q,t,\epsilon)$-sicher ist, wobei $q$ und $t$ einigermaßen groß sind und $\epsilon$ möglichst klein ist. Es gibt unter bestimmten Annahmen (,,Existenz von Einwegfunktionen'') theoretisch konstruierbare Systeme, die für große $l$ einigermaßen effiziente (,,polynomiell in l'') Verschlüsselung und Entschlüsselung erlauben und im definierten Sinn für Angreifer mit (im Bezug zu $l$) nicht zu großen Ressourcen (,,polynomiell in l'') $\epsilon$-sicher sind, für recht kleine $\epsilon$ (der Wert $1/\epsilon$ darf polynomiell groß sein). Diese Systeme sind aber praktisch nicht verwendbar. Von praktisch relevanten Systemen wie AES weiß man nicht, für welche Werte sie sicher sind. + +# Uneingeschränkte symmetrische Verschlüsselung +Szenarium 3: Alice möchte Bob mehrere Klartexte beliebiger Länge schicken. Sie verwendet dafür immer denselben Schlüssel. Eva hört die Chiffretexte mit und kann sich einige wenige Klartexte mit dem verwendeten Schlüssel verschlüsseln lassen. + +Erweiterungen im Vergleich zu vorher: +1. Beliebig lange Texte sind erlaubt. +2. Mehrfaches Senden desselben Textes ist möglich; Eva sollte dies aber nicht erkennen. + +Wir müssen die bisher benutzten Konzepte anpassen, um auch das mehrfache Senden derselben Nachricht zu erfassen. Ein grundlegender Ansatz, um mit identischen Botschaften umzugehen, ist Folgendes: Alices Verschlüsselungsalgorithmus ist randomisiert, liefert also zufallsabhängig unterschiedliche Chiffretexte für ein und denselben Klartext. Allerdings ist normalerweise die Anzahl der Zufallsexperimente fest und nicht von der Klartextlänge abhängig, sodass wir wie vorher davon ausgehen können, dass nur ein Experiment am Anfang ausgeführt wird. Auch der Sicherheitsbegriff und die Rechenzeitbeschränkungen müssen verändert werden. + +Klartexte und Chiffretexte sind nun endliche Folgen von Bitvektoren (,,Blöcken'') der festen Länge $l$. Die Menge aller dieser Folgen bezeichnen wir mit $(\{0,1\}^l)^*$ oder kürzer mit $\{0,1\}^{l*}$. Es gibt also unendlich viele Klartexte und Chiffretexte. Die Menge der Schlüssel heißt $K$. Der Verschlüsselungsalgorithmus $E$ ist randomisiert und transformiert einen Klartext $x$ und einen Schlüssel $k$ in einen Chiffretext. Der Entschlüsselungsalgorithmus $D$ ist deterministisch und transformiert einen Chiffretext $y$ und einen Schlüssel $k$ in einen Klartext. Sicher muss man den Algorithmen eine Rechenzeit zugestehen, die von der Länge der zu verarbeitenden Texte abhängt. Als effizient werden Algorithmen angesehen, die eine polynomielle Rechenzeit haben. Es muss eine verallgemeinerte Dechiffrierbedingung gelten, die die Randomisierung der Verschlüsselung berücksichtigt. + +Definition 3.1 Ein symmetrisches $l$-Kryptoschema ist ein Tupel $S= (K,E,D)$, wobei + - $K\subseteq\{0,1\}^s$ eine endliche Menge ist (für ein $s\in\mathbb{N}$), + - $E(x:\{0,1\}^{l*},k:K) :\{0,1\}^{l*}$ ein randomisierter Algorithmus und + - $D(y:\{0,1\}^{l*},k:K) :\{0,1\}^{l*}$ ein deterministischer Algorithmus +sind, so dass gilt: +- Die Laufzeiten von $E$ und $D$ sind polynomiell beschränkt in der Länge von $x$ bzw. $y$. +- Für jedes $x\in\{0,1\}^{l*},k\in K$ und jedes $m\in M_1\times...\times M_r$ (die Ausgänge der flip-Anweisungen in $E$) gilt: $D(E^m(x,k),k)=x$ (Dechiffrierbedingung). + +Die Elemente von +- $K$ heißen ,,Schlüssel'' +- $\{0,1\}^{l*}$ heißen ,,Klartexte'' bzw. ,,Chiffretexte'', je nachdem, welche Rolle sie gerade spielen. + +$E$ ist der Chiffrieralgorithmus, $D$ der Dechiffrieralgorithmus. + +Bemerkungen: +- Zentral: Die Nachrichtenlänge ist unbestimmt. +- Wir werden immer davon ausgehen, dass der Schlüssel $k$ uniform zufällig aus $K$ gewählt wurde und beiden Parteien bekannt ist. Die Angreiferin Eva kennt $k$ natürlich nicht. +- Etwas allgemeiner ist es, wenn man den Schlüssel nicht uniform zufällig aus einer Menge wählt, sondern von einem randomisierten Schlüsselerzeugungsalgorithmus $G(s:integer):\{0,1\}^*$ generieren lässt. Konzeptuell besteht zwischen den beiden Situationen aber kein großer Unterschied. +- Jeder Klar-und jeder Chiffretext ist ein Bitvektor der Länge $l*h$ für ein $h\in\mathbb{N}$. (Um auf ein Vielfaches der Blocklänge zu kommen, muss man die Texte notfalls mit Nullen auffüllen.) +- Um einen Klartext $x$ zu verschicken, wird der Algorithmus $E$ mit einem neuen, uniform zufällig gewählten Element $m$ abgearbeitet und es wird $E^m(x,k)$ als Chiffretext verschickt. Insbesondere entsteht bei wiederholter Verschlüsselung eines Textes $x$ (mit sehr großer Wahrscheinlichkeit) jedes mal ein anderer Chiffretext. +- In der Literatur finden sich auch Kryptoschemen, bei denen auch die Dechiffrierung randomisiert ist. Wir betrachten dies hier nicht. + +Der Standardansatz zur Konstruktion eines Kryptoschemas besteht darin, von einer Block-chiffre wie in Kapitel 2 auszugehen und sie zu einem Kryptoschema auszubauen. Dies wird im Folgenden beschrieben. + +## Betriebsarten +Symmetrische Kryptoschemen erhält man z.B. aus Blockchiffren. Durch einfache Regeln wird erklärt, wie ein Klartext, der aus einer Folge von Blöcken besteht, zu chiffrieren ist. Für alle folgenden Konstruktionen sei $B=(\{0,1\}^l,K_B,\{0,1\}^l,e_B,d_B)$ ein l-Block- +Kryptosystem für Blöcke einer Länge $l$. (Man darf sich hier zum Beispiel AES mit $l=128$ vorstellen, oder eine Variante von DES.) + +### ECB-Betriebsart ( ,,Electronic Code Book mode'' ) +Dies ist die nächstliegende Methode. Ein Schlüssel ist ein Schlüssel $k$ von $B$. Man verschlüsselt einfach die einzelnen Blöcke von $x$ mit $B$, jedes mal mit demselben Schlüssel $k$. + +Definition: Das zu $B$ gehörende $l$-ECB-Kryptoschema $S=ECB(B)=(KB,E,D)$ ist gegeben durch die folgenden Algorithmen: +- $E(x:\{0,1\}^{l*},k:K_B) :\{0,1\}^{l*}$ + - zerlege $x$ in Blöcke der Länge $l:x=x_0 x_1 ...x_{m-1}$; + - für $0\geq i < m$ setze $y_i\leftarrow e_B(x_i,k)$; + - gib $y=y_0 ...y_{m-1}$ zurück. +- $D(y:\{0,1\}^{l*},k:K_B) :\{0,1\}^{l*}$ + - zerlege $y$ in Blöcke der Länge $l:y=y_0 y_1 ...y_{m-1}$; + - für $0\geq i < m$ setze $x_i\leftarrow d_B(y_i,k)$; + - gib $x=x_0 ...x_{m-1}$ zurück. + +Die Verschlüsselung verzichtet auf die Option, Randomisierung zu verwenden. (Sie hat den großen Vorteil, parallel ausführbar zu sein.) Es ist klar, dass die Dechiffrierbedingung erfüllt ist. Jedoch hat dieses Kryptoschema ein ziemlich offensichtliches Problem, nämlich, +dass ein Block $x\in\{0,1\}^l$ immer gleich verschlüsselt wird, Eva also ganz leicht nicht-triviale Informationen aus dem Chiffretext erhalten kann. Zum Beispiel kann sie sofort sehen, ob der Klartext die Form $x=x_1 x_1$, mit $x_1\in\{0,1\}^l$, hat oder nicht. + +Das Problem wird augenfällig zum Beispiel bei der Verschlüsselung von Bildern. Ein Bild ist dabei einrechteckiges Schema (eine Matrix) von ,,Pixeln'', denen jeweils ein Farbcode (z.B. 1 Byte) zugeordnet ist. Man könnte dabei die Pixel in Gruppen (quadratische Blöcke oder Zeilensegmente) unterteilen. Das Farbmuster jeder solchen Gruppe liefert einen Klartextblock. Wenn viele Bildteile identisch aussehen, etwa gleich konstant gefärbt sind, ergibt sich jeweils derselbe Klartext für den entsprechenden Block, und damit auch derselbe Chiffretext. Wenn man den Chiffretext bildlich darstellt, ergibt sich leicht ein grober Eindruck des Originalbildes. Als Beispiel betrachte diese Bilder aus Wikipedia: [wikipedia](https://de.wikipedia.org/wiki/Electronic_Code_Book_Mode). + +Fazit: Obwohl er so naheliegend ist, sollte der ECB-Modus niemals benutzt werden! + +### CBC-Betriebsart( ,,Cipher Block Chaining mode'' ) +Diese Betriebsart weicht dem zentralen Problem von ECB aus, indem man die Blöcke in Runden $i=0, 1 ,...,m-1$ nacheinander verschlüsselt und das Ergebnis einer Runde zur Modifikation des Klartextblocks der nächsten Runde benutzt. Konkret: Es wird nicht $x_i$ mit $B$ verschlüsselt, sondern $x_i\oplus_l y_{i-1}$ (bitweises XOR). Man benötigt dann einen Anfangsvektor $y_{-1}$ für die erste Runde. Dieser ist Teil des Schlüssels des Kryptoschemas (nicht von B), ein Schlüssel des Schemas ist also ein Paar $(k,v)$ mit $k\in K_B$ und $v\in\{0,1\}^l$. + +Definition: Das zu $B$ gehörende $l$-CBC-Kryptoschema $S=CBC(B)=(KB\times\{0,1\}^l,E,D)$ ist durch die folgenden Algorithmen gegeben: +- $E(x:\{0,1\}^{l*},(k,v) :KB\times\{0,1\}^l) :\{0,1\}^{l*}$ + - zerlege $x$ in Blöcke der Länge $l:x=x_0 x_1 ...x_{m-1}$; + - $y_{-1} \leftarrow v$; + - für $i= 0,...,m-1$ nacheinander: $y_i\leftarrow e_B(x_i\oplus_l y_{i-1},k)$; + - gib $y=y_0 ...y_{m-1}$ zurück. +- $E(x:\{0,1\}^{l*},(k,v) :K_B\times\{0,1\}^l) :\{0,1\}^{l*}$ + - zerlege $y$ in Blöcke der Länge $l:y=y_0 y_1 ...y_{m-1}$ + - $y_{-1} \leftarrow v$; + - für $i=0,...,m-1$ nacheinander: $x_i\leftarrow d_B(y_i,k)\oplus_l y_{i-1}$; + - gib $x=x_0 ...x_{m-1}$ zurück. + +Der Vektor $v$ wird Initialisierungsvektor genannt. Man versteht recht gut, was beim Chiffrieren passiert, wenn man sich das Bild auf Seite 104 im Buch von Küsters/Wilke ansieht. Beim Dechiffrieren geht man den umgekehrten Weg: Entschlüssele einen Block $y_i$ mittels B, dann addiere $y_{i-1}$, um den Klartextblock $x_i$ zu erhalten. Es ist klar, dass die Dechiffrierbedingung erfüllt ist. + +Interessant ist die folgende Eigenschaft der Entschlüsselung im CBC-Modus: Wenn bei der Übertragung des Chiffretextes ein einzelner Block $y_i$ durch einen Fehler zu $y_i'$ verfälscht wird, dann ist die Entschlüsselung ab Block $y_{i+2}$ trotzdem wieder korrekt. + +In diesem Kryptoschema ist der zentrale Nachteil der ECB-Betriebsart verschwunden: Identische Klartextblöcke führen nun praktisch immer zu verschiedenen Chiffretextblöcken. Die Verschlüsselung von $x=x_1 x_1$ mit $x_1\in\{0,1\}^l$ liefert i.a. keinen Chiffretext der Form $y=y_1 y_1$. Die oben erwähnte Wikipedia-Seite zeigt auch, dass bei der Verschlüsselung des Bildes mit CBC keine offensichtlichen Probleme mehr auftauchen. + +Ein Problem bleibt aber bestehen: Wird zweimal der Klartext $x$ verschlüsselt, so geschieht dies immer durch denselben Chiffretext $y=E(x,(k,v))$. Dies ist eine Folge der Eigenschaft von CBC, deterministisch zu sein. Auch CBC wird man in der Praxis daher nicht benutzen. + +### R-CBC-Betriebsart( ,,Randomized CBC mode'' ) +Um das Problem der identischen Verschlüsselung identischer Klartexte zu beseitigen, muss in die Verschlüsselung eine Zufalls komponente eingebaut werden. Beispielsweise kann man dazu CBC leicht modifizieren. Der Initialisierungsvektor $y_{-1}=v\in\{0,1\}^l$ ist nicht mehr Teil des Schlüssels, sondern wird vom Verschlüsselungsalgorithmus einfach zufällig gewählt, und zwar für jeden Klartext immer aufs Neue. Damit der Empfänger entschlüsseln kann, benötigt er $v$. Daher wird $y_{-1}$ als Zusatzkomponente dem Chiffretext vorangestellt. Damit ist der Chiffretext um einen Block länger als der Klartext, und Eva kennt auch $v=y_{-1}$. + +Definition: Das zu $B$ gehörende l-R-CBC-Kryptoschema $S=R-CBC(B) = (K_B,E,D)$ ist gegeben durch die folgenden Algorithmen: +- $E(x:\{0,1\}^{l*},k:K_B) :\{0,1\}^{l*}$; + - zerlege $x$ in $m$ Blöcke der Länge $l:x=x_0 x_1 ...x_{m-1}$ + - setze $y_{-1}= flip(\{0,1\}^l)$; + - für $i=0,...,m-1$ nacheinander: $y_i\leftarrow e_B(x_i\oplus_l y_{i-1} ,k)$; + - gib $y=y_{-1} y_0 ...y_{m-1}$ zurück. //Länge: $m+1$ Blöcke +- $D(y:\{0,1\}^{l*},k:K_B) :\{0,1\}^{l*}$; + - zerlege $y$ in $m+1$ Blöcke der Länge $l:y=y_{-1} y_0 y_1 ...y_{m-1}$ + - für $i=0,...,m-1$ nacheinander: $x_i\leftarrow d_B(y_i,k)\oplus_l y_{i-1}$; + - gib $x=x_0 ...x_{m-1}$ zurück. //Länge: m Blöcke + +Es gibt zwei Unterschiede zu CBC: +1. Für jede Verschlüsselung eines Klartextes wird ein neuer zufälliger Initialisierungsvektor verwendet. Dadurch wird ein Klartext $x$ bei mehrfachem Auftreten mit hoher Wahrscheinlichkeit immer verschieden verschlüsselt. +2. Der Initialisierungsvektor ist nicht Teil des geheimen Schlüssels, sondern ist dem Angreifer bekannt, da er Teil des Chiffretextes ist. (Intuitiv würde man vielleicht sagen, dass dies ,,die Sicherheit verringert'' .) + +Tatsächlich und etwas unerwartet kann man nach einer sorgfältigen Formulierung eines Sicherheitsbegriffs für Kryptoschemen beweisen, dass die Betriebsart R-CBC zu ,,sicheren'' Verfahren führt, wenn die zugrundeliegende Blockchiffre ,,sicher'' ist. (Der Beweis ist +aufwendig.) + +Warnung, als Beispiel für harmlos erscheinende Modifikationen, die Kryptoschemen unsicher machen: +1. Man könnte meinen, dass es genügt, bei jeder Verschlüsselung einen neuen Initialisierungsvektor zu benutzen, also zum Beispiel nacheinander $v,v+1,v+2,...$. Dies führt jedoch zu einem unsicheren Kryptoschema. +2. Um Kommunikation zu sparen, könnte man auf die Idee kommen, dass Alice und Bob sich von einer Kommunikationsrunde zur nächsten den letzten Chiffretextblock merken und ihn bei der nächsten Runde als Initialisierungsvektor benutzen. Dieses Verfahren heißt ,,chained CBC'' und wurde in SSL3.0 und TLS1.0 verwendet. Es stellte sich heraus, dass dieses Verfahren mit einem Angriff mit gewähltem Klartext erfolgreich attackiert werden kann! + +### OFB-Betriebsart( ,,Output Feed Back mode'' ) +Wir kommen nun zu zwei Betriebsarten, die einen ganz anderen Ansatz für die Verschlüsselung der einzelnen Blöcke von $x$ verfolgen. Es wird dazu nämlich nicht $B$ mit Schlüssel $k$ benutzt, sondern der Mechanismus des Vernam-Systems (One-Time-Pads, siehe Beispiel 1.6) :$y_i=x_i\oplus_l k_i$, wobei $k_i\in\{0,1\}^l$ ein ,,Rundenschlüssel'' für Block $x_i$ ist. Das Kryptosystem $B$ wird nur dafür benutzt, diese Rundenschlüssel herzustellen, die bei Verschlüsselung und bei Entschlüsselung identisch sind. Die Dechiffrierbedingung folgt dann daraus, dass das Vernam-System korrekt dechiffriert. Der Ansatz führt dazu, dass die Entschlüsselungsfunktiond $B$ des Block-Kryptosystems gar nicht benötigt wird. + +Zuerst betrachten wir die Betriebsart ,,Output Feedback''. Dabei wird ein zufälliger Startvektor $v$ aus $\{0,1\}^l$ gewählt. Man setzt $k_{-1}=v$, und konstruiert die Rundenschlüssel $k_0,...,k_{m-1}$ dadurch, dass man iteriert den letzten Rundenschlüssel durch die Verschlüsselungsfunktion von $B$ schickt: $k_i=e_B(k_{i-1}, k)$, für $i=0,1,...,m-1$. (Der Name ''Output Feedback''rührt daher, dass das Ergebnis einer Verschlüsselung durch $e_B$ wieder als Input des nächsten Aufrufs von $e_B$ benutzt wird.) Der Empfänger benötigt $v$, um seinerseits die Rundenschlüssel zu berechnen; daher wird $v$ als $y_{-1}$ dem Chiffretext vorangestellt, wie beim R-CBC-Modus. + +Definition: Das zu $B$ gehörende l-OFB-Kryptoschema $S=(K_B,E,D) =OFB(B) =(K_B,E,D)$ ist gegeben durch die folgenden Algorithmen: +- $E(x:\{0,1\}^{l*},k:K_B) :\{0,1\}^{l*}$; + - zerlege $x$ in $m$ Blöcke der Länge $l:x=x_0 x_1 ...x_{m-1}$; + - $k_{-1} \leftarrow y_{-1} \leftarrow flip(\{0,1\}^l)$; + - für $i=0,...,m-1$ nacheinander: $k_i\leftarrow e_B(k_{i-1},k)$ und $y_i\leftarrow x_i\oplus_l k_i$; + - gib $y=y_{-1} y_0 ...y_{m-1}$ zurück. +- $D(y:\{0,1\}^{l*},k:K_B) :\{0,1\}^{l*}$; + - zerlege $y$ in $m+1$ Blöcke der Länge $l:y=y_{-1} y_0 y_1 ...y_{m-1}$; + - $k_{-1} \leftarrow y_{-1}$; + - für $i=0,...,m-1$ nacheinander: $k_i\leftarrow e_B(k_{i-1} ,k)$ und $x_i\leftarrow y_i\oplus k_i$; + - gib $x=x_0 ...x_{m-1}$ zurück. + +Dieses Verfahren hat einen interessanten Vorteil. Oft werden die Blöcke des Chiffretextes beim Empfänger nacheinander eintreffen. Die Hauptarbeit, nämlich die iterierte Verschlüsselung mit $e_B$ zur Ermittlung der Rundenschlüssel $k_i$, kann unabhängig von der Verfügbarkeit der Klartextblöcke erfolgen, sobald $y_{-1}$ eingetroffen ist. + +Man kann beweisen, dass die Betriebsarten R-CBC und OFB ,,sicher'' sind, wenn die zugrundeliegende Blockchiffre ,,sicher'' ist. Dazu weiter unten mehr. + +### R-CTR-Betriebsart (,,Randomized CounTeR mode'' ) +Dies ist die zweite Betriebsart, bei der das Kryptosystem $B$ nur zur Herstellung von m ,,Rundenschlüsseln'' benutzt wird, mit denen dann die Blöcke per $\oplus_l$ verschlüsselt werden. Anstatt iteriert zu verschlüsseln, was bei OFB eine sequentielle Verarbeitung erzwingt, werden hier die mit $B$ zu verschlüsselnden Strings anders bestimmt. Man fasst $\{0,1\}^l$ als äquivalent zur Zahlenmenge $\{0,1,...,2^{l-1}\}$ auf, interpretiert einen $l$-Bit-String also als Block oder als Zahl, wie es passt. In dieser Menge wählt man eine Zufallszahl $r$. Man ,,zählt'' von $r$ ausgehend nach oben und berechnet die Rundenschlüssel $k_0,...,k_{m-1}$ durch Verschlüsseln von $r,r+1,...,r+m-1$ (modulo $2^l$ gerechnet) mittelse $B(.,k)$. Rundenschlüssel $k_i$ ist also $e_B((r+i) mod\ 2^l,k)$, und Chiffretextblock $y_i$ ist $k_i\oplus_l x_i$. Interessant ist, dass hier die Berechnung der Rundenschlüssel und die Ver- bzw. Entschlüsselung der Blöcke parallel erfolgen kann, also sehr schnell, falls mehrere Prozessoren zur Verfügung stehen. + +Definition: Das zu $B$ gehörende l-R-CTR-Kryptoschema $S=R-CTR(B) = (K_B,E,D)$ ist gegeben durch die folgenden Algorithmen: +- $E(x:\{0,1\}^{l*},k:K_B) :\{0,1\}^{l*}$; + - zerlege $x$ in $m$ Blöcke der Länge $l:x=x_0 x_1 ...x_{m-1}$; + - $r\leftarrow flip(\{0,..., 2^l-1\})$; + - für $0\geq i < m:y_i\leftarrow e_B((r+i) mod\ 2^l,k)\oplus_l x_i$; + - gib $y=r y_0 ...y_{m-1}$ zurück. +- $D(y: (\{0,1\}^l)+,k:K_B) :\{0,1\}^{l*}$; + - zerlege $y$ in $m+1$ Blöcke der Länge $l:y=y_{-1} y_0 y_1 ...y_{m-1}$; + - $r\leftarrow y_{-1}$; + - für $0\geq i < m:x_i\leftarrow e_B((r+i) mod\ 2^l,k)\oplus_l y_i$; + - gib $x=x_0 ...x_{m-1}$ zurück. + +Es ist offensichtlich, dass die Dechiffrierbedingung erfüllt ist. + +Bemerkungen: +- Wie bei R-CBC und OFB wird hier ein zufälliger Initialisierungswert $r$ verwendet, der als Teil des Chiffretextes dem Angreifer bekannt ist. +- Wie bei OFB wird die Entschlüsselungsfunktion $d_B$ gar nicht verwendet, man kann also anstelle der Verschlüsselungsfunktion $e_B$ eine beliebige Funktion $e_B:\{0,1\}^l\times\{0,1\}^l\rightarrow\{0,1\}^l$ benutzen, bei der die ,,Chiffren'' $e_B(.,k)$ nicht einmal injektiv sein müssen. +- Man kann dieses Kryptoschema auch wie folgt verstehen: Zu einem gegebenen Klartext $x\in\{0,1\}^{lm}$ wird aus einem zufälligen Initialwert $r$ ein langer Bitstring $k'=E_B(r,k) E_B((r+1) mod\ 2^l,k)... E_B((r+m-1) mod\ 2^l,k)$ berechnet und der Klartext $x$ dann mittels Vernamsystem und diesem Schlüssel verschlüsselt. Der Empfänger erhält $r$ und den Chiffretext, kann also ebenfalls $k'$ b erechnen und damit entschlüsseln. Ist $B$ ein sicheres Block-Kryptosystem, so kann ein Angreifer aus $r$ den Vernam-Schlüssel $k'$ nicht so einfach berechnen, da er $k$ nicht kennt. Die R-CTR-Betriebsart liefert also intuitiv einen hohen Grad an Sicherheit. + +## Sicherheit von symmetrischen Kryptoschemen +Wir werden hier ein Sicherheitsmodell definieren, das es gestattet, Aussagen wie die folgende zu formulieren (und zu beweisen): Wenn B ein ,,sicheres'' l-Block-Kryptosystem ist (bzgl. einer Reihe von Parametern), und das Kryptoschema $S$ wird aus $B$ konstruiert, indem man einen geeigneten Betriebsmodus verwendet, dann ist $S$ ebenfalls ,,sicher'' (bzgl. einer variierten Reihe von Parametern). Ziel ist dabei, Betriebsmodi zu identifizieren, die keine unnötigen neuen Unsicherheitskomponenten ins Spiel bringen, die nicht im Block-KS +$B$ schon vorhanden waren. + +Wir beschränken uns hier auf den Fall, wo Eva begrenzte Ressourcen (Zeit, Orakelaufrufe) hat. Damit müssen wir uns bei Überlegungen zu Kryptoschemen auf das Verhalten auf Klartexten begrenzter Länge und auf feste Rechenzeiten beschränken. Nach dem Kerckhoffs-Prinzip nehmen wir an, dass Eva das Kryptoschema kennt, also zum Beispiel das verwendete Block-Kryptosystem und den Betriebsmodus. Sie kann sich einige Klartexte verschlüsseln lassen (,,known-plaintext attack'') und sieht einen Chiffretext $y$. Ihr Ziel ist, aus $y$ Information über den zugrundeliegenden Klartext $x$ zu gewinnen. Wir können nicht verhindern, dass Eva aus der Länge des Chiffretextes $y$ auf die Länge von $x$ schließt. (Bei allen Betriebsmodi, die wir gesehen haben, ergibt sich die Länge von $x$ direkt aus der Länge von $y$). Abgesehen hiervon soll sie mit hoher Wahrscheinlichkeit ,,keine signifikante Information'' über den Klartext erhalten können. + +Wir skizzieren zunächst eine Idee für ein Sicherheitsmodell, das die Fähigkeit, in so einer Situation ,,Information zu ermitteln'', formalisiert. Eva behauptet, sie könne ,,aus $y$ Information über $x$ ermitteln, die über die Länge von $x$ hinausgeht''. Um das zu überprüfen, stellt ihr ein ,,Herausforderer'' Charlie folgende Aufgabe: Eva darf sich zunächst eine Reihe von Klartexten ihrer Wahl verschlüsseln lassen. Dann wählt sie selbst zwei verschiedene, gleichlange Klartexte $z_0$ und $z_1$. Charlie verschlüsselt einen von diesen; der Chiffretext ist $y$. Eva bekommt $y$. Sie soll herausfinden, ob $y$ von $z_0$ oder von $z_1$ kommt. Für diese Entscheidung darf sie sich weitere Klartexte verschlüsseln lassen und weiter rechnen. Wir betrachten ein Kryptoschema als unsicher, wenn Eva eine signifikant von ,,purem Raten'' abweichende Erfolgswahrscheinlichkeit hat, sie also mit guten Chancen unterscheiden kann, ob $z_0$ oder $z_1$ zu $y$ verschlüsselt wurde. + +Wie in Abschnitt 2.4 formulieren wir den Vorgang wieder als Spiel. Gegeben ist also $S=(K,E,D)$. Akteure sind Eva, hier ,,Angreifer'' (engl.: adversary) genannt, und Charlie (,,Herausforderer'' ,engl.: challenger). Die Parameter, mit denen wir die Erfolgschancen von Eva unter Ressourcenbeschränkungen messen, sind der ,,Vorteil'' in Analogie zu Definition 2.13, die Rechenzeit (inklusive Speicherplatz, wie vorher), Anzahl der Orakelaufrufe und Anzahl der bei der Verschlüsselung bearbeiteten Blöcke. +- Charlie wählt zufällig einen Schlüssel $k$ aus $K$ und legt damit die Chiffre $H=E(.,k)$ fest, die Klartexte aus $\{0,1\}^{l*}$ in Chiffretexte aus $\{0,1\}^{l*}$ transformiert. +- Eva wählt einige Klartexte und lässt sie sich von Charlie mit $H$ verschlüsseln. +- Eva wählt zwei Klartexte $z_0$ und $z_1$ gleicher Länge und gibt sie an Charlie. +- Verdeckt vor Eva: Charlie wirft eine Münze, um zufällig einen der beiden Klartexte zu wählen. Er verschlüsselt ihn mit $H$, das Ergebnis ist $y$. Charlie gibt $y$ an Eva. +- Eva kann sich weitere Klartexte verschlüsseln lassen und (mit beschränkten Ressourcen) rechnen und muss schließlich sagen (raten?), ob Charlie $z_0$ oder $z_1$ zu $y$ verschlüsselt hat. + +Wenn die Wahrscheinlichkeit, dass Eva richtig antwortet, weit von zufälligem Raten abweicht, wollen wir das Kryptoschema als unsicher ansehen. + +Man beachte: Unter den vorher oder nachher verschlüsselten Klartexten können auch $z_0$ und $z_1$ sein. Ein deterministisches Kryptoschema, also eines, das zu gegebenem Schlüssel $k$ einen Klartext stets gleich verschlüsselt, ist damit sofort disqualifiziert. Wenn aber bei der Verschlüsselung Randomisierung im Spiel ist, liefern wiederholte Verschlüsselungsanforderungen mit Klartexten $z_0$ und $z_1$ (wahrscheinlich) lauter unterschiedliche Antworten, so dass dieser direkte Weg zur Ermittlung des verschlüsselten Klartextes nicht funktioniert. + +Wir beschreiben den Part von Eva in diesem Spiel als Algorithmenpaar. Der erste Algorithmus $AF$ (der ,,Finder'', ,,find'' ) ist für das Erzeugen von $z_0$ und $z_1$ zuständig. Als Argument erhält dieser Teil eine Chiffre $H$, die er im Sinne eines Orakels benutzen kann. Außerdem werden Aufzeichnungen über die angeforderten Verschlüsselungen und ihre Ergebnisse gemacht. Diese Aufzeichnungen sind als Element $v$ einer endlichen Menge $V$ kodiert. Der zweite Algorithmus $AG$ (der ,,Rater'' , ,,guess'' ) ist dafür zuständig, herauszufinden, ob $z_0$ oder $z_1$ verschlüsselt wurde. Dieser Algorithmus bekommt $H$ als Orakel, die Aufzeichnungen $v$ von $AF$ und den Chiffretext $y$ als Input. + +Definition 3.2 Ein l-Angreifer $A$ ist ein Paar von randomisierten Algorithmen +- $AF(H(\{0,1\}^{l*}) :\{0,1\}^{l*}) : (\{0,1\}^l\times\{0,1\}^l)^+\times V$ +- $AG(v:V,H(\{0,1\}^{l*}) :\{0,1\}^{l*},y:\{0,1\}^{l*}) :\{0,1\}$ + +Hierbei ist $H$ ein randomisierter Algorithmus (und nicht als Funktion zu verstehen). + +Der ,,Finder'' AF bekommt also eine Chiffre $H=E(.,k)$ für einen zufälligen Schlüssel $k$ gegeben. (Er darf diese Chiffre nur zum Verschlüsseln benutzen; $k$ kennt er nicht.) Daraus berechnet er zwei verschiedene Klartexte $(z_0,z_1)$ gleicher Länge und ,,Notizen'' $v\in V$. Das Ausgabeformat $(\{0,1\}^l\times\{0,1\}^l)^+$ sagt, dass eine Folge $((z_0^{(0)},z^{(0)}_1),(z_0^{(1)},z_1^{(1)}),...,(z_0^{(m-1)},z_1^{(m-1)}))$ von Blockpaaren ausgegeben werden soll, die wir dann als Paar $(z_0 ,z_1) = ((z^{(0)}_0 ,z_0^{(1)},...,z_0^{(m-1)}),(z_1^{(0)},z^{(1)}_1 ,...,z_1^{(m-1)}))$ von zwei Folgen gleicher Länge lesen. Danach wird zufällig $z_0$ oder $z_1$ zu $y$ verschlüsselt. +Im zweiten Schritt verwendet der ,,Rater'' $AG$ die Notizen $v$, die Chiffre $H=E(.,k)$ und die ,,Probe'' $y$, um zu bestimmen, ob $z_0$ oder $z_1$ verschlüsselt wurde. + +Definition 3.3 Sei $S=(K,E,D)$ ein symmetrisches Kryptoschema, und sei $A=(AF,AG)$ ein l-Angreifer. Das zugehörige Experiment (oder Spiel) ist der folgende Algorithmus $G^S_A:\{0,1\}:$ +1. $k\leftarrow flip(K)$, $H\leftarrow E(.,k)$ (In diesem Schritt wählt Charlie zufällig eine Chiffre des Kryptoschemas $S$.) +2. $(z_0, z_1 ,v)\leftarrow AF(H)$ (In dieser Phase berechnet der Finder ein Paar von Klartexten gleicher Länge, von denen er annimmt,ihre Chiffretexte unterscheiden zu können.) +3. $b\leftarrow flip(\{0,1\})$ und $y\leftarrow E(z_b,k)$ (In dieser Phase wählt Charlie zufällig einen der beiden Klartexte und verschlüsselt ihn zu $y$.) +4. $b'\leftarrow AG(v,H,y)$ (In dieser Phase versucht der Rater herauszubekommen, ob $z_0$ oder $z_1$ verschlüsselt wurde.) +5. falls $b=b'$, so gib $1$ zurück, sonst $0$. (Charlies Auswertung: Hat $AG$ recht oder nicht?) + +Das verkürzte Experiment oder Spiel $S^S_A$ gibt im 5.Schritt einfach $b'$ aus. + +Dann ist $Pr(G^S_A = 1)$ die Wahrscheinlichkeit dafür, dass der Angreifer $A$ sich für den korrekten Klartext entscheidet. Der Wahrscheinlichkeitsraum entsteht durch die expliziten Zufallsexperimente in Schritt 1. und 3. in Kombination mit den Zufallsexperimenten, die bei der Verwendung von $H$ ausgeführt werden. Man kann jetzt wie in Abschnitt 2.4 (Sicherheit von l-Block-Kryptosystemen) den Vorteil $adv(A,S) = 2(Pr(G^S_A= 1)-\frac{1}{2})$ und die Größen $suc(A,S) = Pr(S^S_A〈b= 1〉= 1)$ (,,Erfolg'') und $fail(A,S) = Pr(S_A^S〈b= 0〉= 1)$ ( ,,Misserfolg'' ) definieren. Allerdings haben die beiden letzten Werte eine etwas andere Semantik. Der Wert $suc(A,S)$ ist die bedingte Wahrscheinlichkeit, dass richtig erkannt wird, dass $z_1$ verschlüsselt wurde, $fail(A,S)$ ist die bedingte Wahrscheinlichkeit, dass nicht erkannt wird, dass $z_0$ verschlüsselt wurde. Lemma 2.14 gilt wörtlich. Das heißt: $$adv(A,S) = suc(A,S)-fail(A,S)$$. + +Wenn ein Angreifer $A$ mit ,,nicht zu großem Rechenaufwand'' einen Vorteil erzielen kann, der deutlich über $0$ liegt, wird man das Kryptoschema als unsicher einstufen. + +Beispiel 3.4 Ziel ist es, die ECB-Betriebsart anzugreifen, d.h. sei $S=ECB(B)$ für ein l-Block-Kryptosystem $B$. Wir wollen zeigen, dass es einen l-Angreifer $A$ mit $Pr(G^S_A= 1) = 1$, also $adv(A,S) = 1$, gibt. Dieser ist wie folgt aufgebaut. +- l-Angreifer $A$ mit $V=\{1\}$ ($V=\{1\}$ bedeutet, dass stets $v=1$ gilt, dass die Aufzeichnung $v$ also keinerlei Information übermittelt.) +- $AF(H)$ arbeitet wie folgt: $z_0\leftarrow 0^{2l}; z_1\leftarrow 0^l 1^l;$ Ausgabe: $(z_0,z_1 ,1)$ +- $AG(v,H,y)$ tut Folgendes: falls $y=y_1y_1$ für ein $y_1\in\{0,1\}^l$, gib $0$ aus, sonst $1$. + +Im Ablauf des Spiels $G^S_A$ wird der Rater $AG$ mit $y=E(0^{2l},k)=e_B(0^l,k)e_B(0^l,k)$ oder mit $y=E(0^l 1^l,k)=e_B(0^l,k)e_B(1^l,k)$ gestartet. Im ersten Fall ist $y=y_1y_1$ für ein $y_1\in\{0,1\}^l$, im zweiten Fall ist dies nicht so, wegen der Dechiffrierbedingung. Daher gilt $Pr(G^S_A= 1) = 1$, d.h. $adv(A,S) = 1$. + +Die Ressourcen, die $A$ benötigt, sind sehr klein: Zwei Aufrufe des Verschlüsselungsverfahrens $e_B$ des Block-Kryptosystems. Wir können schließen, dass es einen effizienten Angreifer $A$ gibt, dem das Sicherheitsmodell Vorteil 1 gibt. Damit gilt das Kryptoschema $ECB(B)$ als komplett unsicher (ganz egal was $$ ist). + +Beispiel 3.5 Ziel ist es, die CBC-Betriebsart anzugreifen, d.h. es sei $S=CBC(B)$ für ein Block-Kryptosystem $B$. Das Problem mit dieser Betriebsart ist, dass ein Klartext bei Wiederholung identisch verschlüsselt wird. Um dies auszunutzen, verwenden wir den folgenden l-Angreifer $A$ mit $V=\{0,1\}^l$, der zwei verschiedene Klartexte benutzt, die nur einen Block enthalten: +- $AF(H)$ arbeitet wie folgt: $z_0\leftarrow 0^l;v\leftarrow H(z_0);z_1\leftarrow 1^l;$ Ausgabe: $(z_0,z_1,v)$ +- ($A$ merkt sich den Chiffretext zu $x=0^l$.) +- $AG(v,H,y)$ tut Folgendes: falls $v=y$, so gib $0$ aus, sonst $1$. + +Im Ablauf des Spiels $G^S_A$ wird der Rater $AG$ mit $E(0^l,k)$ oder mit $E(1^l,k)$ gestartet. Wegen $e_B(0^l,k)\not=e_B(1^l,k)$ (wegen der Dechiffrierbedingung) gilt also $Pr(G^S_A=1)=1$, d.h. $adv(A,S)=1$. + +Dieses Beispiel lässt sich verallgemeinern: + +Lemma 3.6 Es gibt einen l-Angreifer $A$, so dass für jedes l-Kryptoschema $S$ mit deterministischer Verschlüsselungsfunktion gilt: $adv(A,S) = 1$. + +Wir benutzen einfach den in Beispiel 3.5 beschriebenen Angreifer. Damit zeigt sich, dass das beschriebene Spiel in der Lage ist, alle deterministischen Kryptoschemen als unsicher einzustufen (und damit die intuitive Einschätzung zu bestätigen). + +Nun bringen wir die Ressourcen ins Spiel, die der Angreifer benutzen darf. Komponenten dabei sind die Laufzeit des gesamten Experiments, die Anzahl der durchgeführten H-Verschlüsselungen von Chiffretexten und die Anzahl der dabei bearbeiteten Blöcke. ($S$ kann eine beliebige Struktur haben, muss also nicht notwendigerweise auf einem l-Block-Kryptosystem beruhen. Dennoch sind die Klartexte in Blöcke eingeteilt, und die Gesamtlänge aller betrachteten Blöcke ist eine sinnvolle Maßzahl.) + +Definition 3.7 Sei $n,q,t,l\in\mathbb{N}$, $A$ ein l-Angreifer, $S$ ein symmetrisches l-Kryptoschema. Dann heißt $A(n,q,t)$-beschränkt, wenn die Laufzeit des Experiments $G^S_A$ durch $t$ beschränkt ist, der Algorithmus $H$ (als Orakel) höchstens $q$ mal aufgerufen wird und bei diesen Aufrufen höchstens $n$ Blöcke verwendet werden. + +Sei $\epsilon> 0$. Dann heißt $S(n,q,t,\epsilon)$-sicher, wenn für jeden $(n,q,t)$-beschränkten l-Angreifer $A$ gilt $adv(A,S)\geq\epsilon$. + +Nach obigem Lemma gibt es (kleine) Konstanten $c_1,c_2$ und $c_3$, so dass kein deterministisches l-Kryptoschema $(c_1,c_2,c_3,1-\delta)$-sicher ist, für jedes noch so kleine $\delta > 0$. + +Wir stellen nun fest, dass man aus sicheren Block-Kryptosystemen mit der R-CTR-Betriebsart sichere Kryptoschemen erhält, wenn man die Parameter richtig wählt, das heißt im Wesentlichen, wenn die Blocklänge genügend groß ist. + +Diese ,,relative Sicherheit'' kann man folgendermaßen ,,rückwärts'' ausdrücken: Wenn das Kryptoschema $S=R-CTR(B)$ unsicher ist, es also einen Angreifer mit großem Vorteil $adv(A,S)$ gibt, bei beschränkten Ressourcen, dann ist schon $B$ unsicher, das heißt, es gibt einen Unterscheider $U$ für $B$ mit großem Vorteil $adv(U,B)$, bei beschränkten Ressourcen. Technisch wird dies folgendermaßen formuliert, unter Einbeziehung gewisser Fehlerterme und genauer Benennung der Ressourcenschranken. + +Satz 3.8 Es gibt eine kleine Konstante $c$, so dass für alle $t,n,q,l > 0$, alle l-Block-Kryptosysteme $B$ und alle $(n,q,t)$-beschränkten l-Angreifer $A$ ein $(n,t+c(q\ log(q) +n)*l)$-beschränkter l-Unterscheider $U$ existiert, so dass $adv(A,S)\geq 2 *adv(U,B) + \frac{2 qn+n^2}{2^l}$, wobei $S$ das symmetrische l-Kryptoschema ist, das $B$ in der R-CTR-Betriebsart verwendet. + +Den Fehlerterm $(2qn+n^2)/2^l$ kann man vernachlässigen, wenn $l$ genügend groß gewählt wird. Die Zahlen $q$ und $n$ entsprechen der Verarbeitung von Blöcken, Werte für $q$ und $n$ von mehr als $1012$ sind also eher unrealistisch. Mit $l=128$ ist $2^l> 3 * 10^{38}$. Damit kann man ohne Weiteres $\frac{2qn+n^2}{2^l} <10^{-14}$ annehmen. Im Wesentlichen besagt der Satz also, dass aus der Existenz eines effizienten l-Angreifers mit einem gewissen Vorteil $a>0$ gegen R-CTR($B$) folgt, dass es einen effizienten l-Unterscheider $U$ mit Vorteil $a/2$ gegen $B$ gibt. Wenn also R-CTR($B$) unsicher ist (nicht $\epsilon$-sicher für relativ großes $\epsilon$), dann muss schon $B$ unsicher gewesen sein (nicht $\epsilon/2$-sicher). Oder noch kürzer: Wenn $B$ ,,sicher'' ist, dann auch R-CTR($B$). Durch die R-CTR-Betriebsart wird keine neue Unsicherheitskomponente ins Spiel gebracht. +Mit den folgenden Definitionen lässt sich diese Aussage vielleicht noch griffiger formulieren. + +Definition 3.9 Die Unsicherheit eines Block-Kryptosystems $B=(X,K,Y,e,d)$ zu Parametern $q,t$ ist $insec(q,t,B) := max\{adv(U,B)|\text{ U ist } (q,t) \text{-beschränkter Unterscheider}\}$. +Man beachte: Weil mit $t$ auch die Programmtextlänge beschränkt ist, gibt es nur endlich viele solche Unterscheider. Damit ist das Maximum wohl definiert. Offensichtlich gilt, nach den Definitionen aus Abschnitt 2.4: $B$ ist $(q,t,\epsilon)$-sicher 4\Leftrightarrow insec(q,t,B)\geq\epsilon$. + +Analog definiert man: + +Definition 3.10 Die Unsicherheit eines Kryptoschemas $S=(K,E,D)$ zu Parametern $n,q,t$ ist $insec(n,q,t,S):=max\{adv(A,S)|A \text{ ist }(n,q,t)\text{-beschränkter Angreifer}\}$. + +Satz 3.8 liest sich dann wie folgt: Wenn $S$ das symmetrische l-Kryptoschema ist, das $B$ in der R-CTR-Betriebsart verwendet, dann gilt für beliebige $n,t,q$: $insec(n,q,t,S)\geq 2 * insec(n,t+c(q\ log(q) +n)*l,B) +\frac{2qn+n^2}{2^l}$. + +$S$ ,,erbt'' also die obere Schranke für die Unsicherheit von $B$, bezüglich $n$ Orakelanfragen und einer vergrößerten Rechenzeit von $t+c(q\ log(q) +n)*l$, verschlechtert nur um einen Faktor $2$ und einen additiven Term $\frac{2qn+n^2}{2^l}$. Die Unsicherheit kommt also nicht durch die Verwendung der Betriebsart R-CTR ins Spiel, sondern steckt gegebenenfalls schon in $B$. + +Bemerkung: Für die Betriebsarten R-CBC und OFB gelten Aussagen, die zu Satz 3.8 analog sind. Die Beweise sind allerdings noch aufwendiger. Einen vollständigen Beweis von Satz 3.8 findet man in ,,Küsters und Wilke, Moderne Kryptographie'' (S.114, 121), und im Anhang. + +Im Buch werden auch die folgenden konkreten Parameter diskutiert: $l=128$. Nehmen wir an, die zugelassene Laufzeit $t$ für den Angreifer ist $2^{60} > 10^{18}$ Rechenschritte (das ist so groß, dass es nicht wirklich realisierbar ist), und wir gestatten $q=2^{30} \approx 10^{9}$ Orakelanfragen, wobei die gesamte betroffene Textlänge $n=2^{36}\approx 64*10^9$ Blöcke ist (etwa $2^{40}$ Byte,also ein Terabyte). Wenn die Konstante aus dem Satz etwa $c=10$ ist, erhalten wir: $$insec(2^{36}, 2^{30}, 2^{60},S)\geq 2*insec(2^{36}, 2^{60}+ 10(30*2^{30}+ 2^{36})* 128 ,B) +\frac{2^{66} + 2^{72}}{2^{128}}$. +Man sieht, dass der additive Term $\frac{2^{66} +2^{72}}{2^{128}}$ kleiner als $2^{-55}$ ist, und die für den Unterscheider zugelassene Zeitschranke mit $2^{60} + 10(30* 2^{30}+2^{36})*128 < 2^{61}$ kaum größer ist als die für den Angreifer. Wenn man für $insec(2^{36}, 2^{61} ,B)$ eine Schranke $\geq 2^{-55}$ hätte, wäre $insec(2^{36}, 2^{30}, 2^{60},S)$ auch kleiner als $2^{-54}$. (Solche konkreten Schranken sind allerdings für kein konkretes Block-Kryptosystem bewiesen.) + +# Zahlentheorie und Algorithmen +Zu Aussagen, die mit (*) markiert sind, gibt es Beweise oder Anmerkungen im Anhang A. Beweise von rein zahlentheoretischen Aussagen sind nicht prufungsrelevant. Beweise für Wahrscheinlichkeitsaussagen und Begründungen für Rechenzeiten von Algorithmen dagegen sind prüfungsrelevant. + +## Fakten aus der Zahlentheorie und grundlegende Algorithmen +Unsere Zahlenbereiche: +- $\mathbb{N}=\{ 0 , 1 , 2 , 3 ,...\}$, +- $\mathbb{Z}=\{...,- 2 ,- 1 , 0 , 1 , 2 , 3 ,...\}$ + +Wir stellen uns die Zahlen immer als zu einer passenden Basis $b$ dargestellt vor: Binärdarstellung, (Oktaldarstellung,) Dezimaldarstellung, Hexadezimaldarstellung, Darstellung zur Basis 256 (eine Ziffer ist ein Byte) oder $2^{32}$ oder $2^{64}$ (eine Ziffer ist ein 32- bzw. 64-Bit-Wort, passend für die Darstellung in einem Rechner). + +Die Anzahl der Ziffern in der Darstellung von $a\in\mathbb{N}$ zur Basis $b$ ist $\lceil log_b(a+1)\rceil$. Das ist etwa $\frac{ln\ a}{ln\ b}=\frac{log\ a}{log\ b}$. + +Verwendete Operationen: Addition, Subtraktion, Multiplikation, Division mit Rest. + +Wir nehmen an, dass zwei einziffrige Zahlen in Zeit $O(1)$ addiert und subtrahiert werden können (,,von der Hardware''). Addition zweier n-ziffriger Zahlen kostet dann Zeit $O(n)$, Multiplikation einer n-ziffrigen und einer l-ziffrigen Zahl mit der Schulmethode kostet Zeit $O(nl)$. Es gibt schnellere Verfahren: Karatsuba mit $O(n^{1,59})$ für zwei n-ziffrige Zahlen, Schönhage-Strassen (1977) sogar mit $O(n\ log\ n\ log\ log\ n)$. Nach längerer Pause erschienen 2007 und 2008 Verbesserungen. Im März 2019 erschien eine Arbeit, die zeigt, wie man zwei n-Bit-Zahlen in Zeit $O(n\ log\ n)$ multiplizieren kann. Man vermutet, dass das optimal ist. (Nach aktuellem Stand ergeben sich Vorteile gegenüber Karatsuba aber erst für unrealistisch lange Zahlen.) + +Fakt 4.1 Division mit Rest: Zu $x\in\mathbb{Z}$ und $m\geq 1$ gibt es ein $r$ mit $0\leq r < m$ und ein $q$ mit $x=qm+r$. Die Zahlen $q$ und $r$ sind eindeutig bestimmt. + +Die Zahl $r$ (,,Rest'') bezeichnen wir mit $x\ mod\ m$. Sie hat die Darstellung $x-qm$, unterscheidet sich also von $x$ um ein Vielfaches von $m$. Der Quotient $q$ wird mit $x\ div\ m$ bezeichnet. +Beispiel: $30 = 3*9 + 3, 30\ mod\ 9 = 3, -30 = (-4) *9 + 6, (-30)\ mod\ 9 = 6$. + +Aufwand für Division mit Rest: Die Division einer n-ziffrigen Zahl durch eine l-ziffrige Zahl mit der Schulmethode kostet Zeit $O(nl)$. + +Wir sagen, dass eine ganze Zahl $y$ die ganze Zahl $x$ teilt (oder dass $y$ ein Teiler von $x$ ist), wenn $x=qy$ für eine ganze Zahl $q$ gilt. Oft schreibt man dafür kurz $y|x$. Wenn $y$ kein Teiler von $x$ ist, schreiben wir $y\not|x$. + +Beispiel: $3|12,-3|12,-3|-12,-3|12,3|0,0|0$. + +Beobachtungen: Die Teilbarkeitsrelation $|$ ist reflexiv und transitiv. Es handelt sich damit um eine ,,Präordnung'' (oft auch ,,Quasiordnung'' genannt). Zahlen $x$ und $-x$ können von ihr nicht unterschieden werden: Es gilt $x|y\Leftrightarrow -x|y$ und $y|x\Leftrightarrow y|-x$, und weiter $x|-x$ und $-x|x$. Die Präordnung ist also nicht antisymmetrisch. Sie ist auch nicht total, weil manche Elemente nicht verglichen werden können: $4\not|9$ und $9\not|4$. Aus $0|x$ folgt $x=0$; für jede ganze Zahl $y$ gilt $y|0$; also ist in dieser Präordnung $0$ das eindeutig bestimmte größte Element. Für jede ganze Zahl $x$ gilt: $1|x$ und $-1|x$, also sind $1$ und $-1$ kleinste Elemente. Wenn $m\geq 1$ ist, ist $m|x$ gleichbedeutend mit $x\ mod\ m= 0$. + +Fakt 4.2 Teilbarkeit: Für beliebige $x,y,z\in\mathbb{Z}$ gilt: +1. Aus $x|y$ und $x|z$ folgt $x|uy+vz$ für alle $u,v\in\mathbb{Z}$. +2. Aus $x|y$ folgt $ux|uy$ für alle $u\in\mathbb{Z}$. +3. Aus $x|y$ und $y|z$ folgt $x|z$ (Transitivität). +4. Aus $x|y$ und $y\not= 0$ folgt $0<|x|\leq |y|$. +5. Aus $x|y$ und $y|x$ folgt $|x|=|y|$. Wenn zudem $x,y\geq 0$ gilt, folgt $x=y$. + +![Abbildung 1](Assets/Kryptographie-teilbarkeitsbeziehung.png) +Einige Zahlen und ihre Teilbarkeitsbeziehungen. Beziehungen, die aus der Transitivität folgen, sind nicht eingetragen. Man erkennt $1$ und $-1$ als kleinste Elemente und $0$ als größtes Element der Teilbarkeitsbeziehung als Präordnung. Die Elemente in der Ebene unmittelbar über $\{1,-1\}$ sind die Primzahlen, positiv und negativ, also Zahlen $x\not=\pm 1$, die durch keine Zahl außer $\pm x$ und $\pm 1$ teilbar sind. +Der Beweis ist eine einfache Übung. + +Definition 4.3 Größter gemeinsamer Teiler: +1. Für $x,y\in\mathbb{Z}$ heißt $t\in\mathbb{Z}$ ein gemeinsamer Teiler von $x$ und $y$, wenn $t|x$ und $t|y$ gilt. (Bemerkung: 1 ist stets gemeinsamer Teiler von $x$ und $y$.) +2. Für $x,y\in\mathbb{Z}$ sei $ggT(x, y)$, der größte gemeinsame Teiler von $x$ und $y$, die (eindeutig bestimmte) nichtnegative Zahl $d$ mit: + - $d$ ist gemeinsamer Teiler von $x$ und $y$; + - jeder gemeinsame Teiler von $x$ und $y$ ist Teiler von $d$. +3. $x,y\in\mathbb{Z}$ heißen teilerfremd, wenn $ggT(x,y)=1$ gilt, d.h. wenn sie nicht beide $0$ sind und keine Zahl $>1$ beide teilt. + +Bei Definition 4.3.2 stellt sich die Frage nach Existenz und Eindeutigkeit von $ggT(x,y)$. Wir beweisen diese Eigenschaften im Anhang. + +Wir bemerken, dass $ggT(0,0) = 0$ gilt. (Sei $d = ggT(0,0)$. Weil $0|0$, folgt mit Def. 4.3.2 $0|d$ und damit $d=0$.) Wenn $x\not= 0$ oder $y\not= 0$ gilt, kann es keinen gemeinsamen Teiler geben, der größer als $max\{|x|,|y|\}$ ist, und der größte gemeinsame Teiler ist auch größtmöglich im Sinn der gewöhnlichen Ordnung auf $\mathbb{Z}$. Weil das Vorzeichen für die Teilbarkeit irrelevant ist, gilt stets $ggT(x,y) = ggT(|x|,|y|)$, und man kann sich immer auf den Fall nichtnegativer Argumente beschränken. Weiter gilt $$ggT(x,y) = ggT(x+uy,y) \quad\quad(4.1)$$, für beliebige $x,y,u\in\mathbb{Z}$. (Wenn $d$ gemeinsamer Teiler von $x$ und $y$ ist, dann teilt $d$ auch $x+uy$. Wenn $d$ gemeinsamer Teiler von $z=x+uy$ und $y$ ist, dann teilt $d$ auch $z-uy =x$. Also haben die Paare $(x,y)$ und $(x+uy,y)$ dieselbe Menge gemeinsamer Teiler, und es folgt $ggT(x,y) = ggT(x+uy,y)$.) + +Es gibt einen effizienten Algorithmus zur Ermittlung des größten gemeinsamen Teilers. Er beruht auf den Gleichungen +1. $ggT(x,y) = ggT(|x|,|y|)$ für alle $x,y\in\mathbb{Z}$, +2. $ggT(x,y) = ggT(y,x)$ für alle $x,y\in\mathbb{Z}$, +3. $ggT(a,0) =a$ für $a\geq 0$, +4. $ggT(a,b) = ggT(b,a\ mod\ b)$ für $a\geq b >0$. + +(1. gilt, weil Teilbarkeit das Vorzeichen ignoriert. 2. ist trivial. 3. folgt daraus, dass jede Zahl Teiler von $0$ ist. 4. folgt aus 4.1 und 2., weil $a\ mod\ b=a-qb$ mit $q=ba/bc$ gilt.) + +Wir setzen die Beobachtung in ein iteratives Verfahren um. + +Algorithmus 4.1 Euklidischer Algorithmus: +- Input: Zwei ganze Zahlen $x$ und $y$. +- Methode: + 1. $a,b:integer;a\leftarrow |x|;b\leftarrow |y|;$ + 2. $while\ b> 0\ repeat$ + 3. $(a,b)\leftarrow (b,a\ mod\ b);$ // simultane Zuweisung + 4. return $a$. + +Die eigentliche Rechnung findet in der while-Schleife statt. In dieser Schleife wird immer ein Zahlenpaar durch ein anderes ersetzt, das dieselben gemeinsamen Teiler hat wie $x$ und $y$. Wenn der Algorithmus terminiert, weil der Inhalt $b$ von $b$ Null geworden ist, kann man den Inhalt von $a$ ausgeben. + +Beispiel: Auf Eingabe $x=10534, y=12742$ ergibt sich der nachstehenden Tabelle angegebene Ablauf. Die Zahlen $a_i$ und $b_i$ bezeichnen den Inhalt der Variablen $a$ und $b$, nachdem die Schleife in Zeilen $2-3$ i-mal ausgeführt worden ist. Die Ausgabe ist $46 = ggT(10534,12742)$. +| i | $a_i$ | $b_i$ | +| --- | ----- | ----- | +| 0 | 10534 | 12742 | +| 1 | 12742 | 10534 | +| 2 | 10534 | 2208 | +| 3 | 2208 | 1702 | +| 4 | 1702 | 506 | +| 5 | 506 | 184 | +| 6 | 184 | 138 | +| 7 | 138 | 46 | +| 8 | 46 | 0 | + + +Fakt 4.4 Algorithmus 4.1 gibt $ggT(x,y)$ aus. + +Wenn $|x|<|y|$, hat der erste Schleifendurchlauf nur den Effekt, die beiden Zahlen zu vertauschen. Wir ignorieren diesen trivialen Schleifendurchlauf. Wir betrachten die Zahlen $a$ in $a$ und $b$ in $b$. Es gilt stets $a>b$, und $b$ nimmt in jeder Runde strikt ab, also terminiert der Algorithmus. Um einzusehen, dass er sogar sehr schnell terminiert, bemerken wir Folgendes. Betrachte den Beginn eines Schleifendurchlaufs. Der Inhalt von $a$ sei $a$, der Inhalt von $b$ sei $b$, mit $a\geq b >0$. Nach einem Schleifendurchlauf enthält $a$ den Wert $a'=b$ und $b$ den Wert $b'=a\ mod\ b$. Falls $b'=0$, endet der Algorithmus. Sonst wird noch ein Durchlauf ausgeführt, an dessen Ende $a$ den Wert $b'=a\ mod\ b$ enthält. Wir behaupten: $b'<\frac{1}{2} a$. Um dies zu beweisen, betrachten wir zwei Fälle: Wenn $b>\frac{1}{2} a$ ist, gilt $b'=a\ mod\ b=a-b<\frac{1}{2} a$. Wenn $b\leq\frac{1}{2} a$ ist, gilt $b'=a\ mod\ b < b\leq\frac{1}{2} a$. - Also wird der Wert in $a$ in jeweils zwei Durchläufen mindestens halbiert. Nach dem ersten Schleifendurchlauf enthält $a$ den Wert $min\{x,y\}$. Daraus ergibt sich Teil 1. der folgenden Aussage. + +Fakt 4.5 +1. Die Schleife in Zeilen $2-3$ wird höchstens $O(log(min\{x,y\}))$-mal ausgeführt. +2. Die gesamte Anzahl von Ziffernoperationen für den Euklidischen Algorithmus ist $O((log\ x)(log\ y))$. + +Man beachte, dass $\lceil log(x+1)\rceil\approx log\ x$ die Anzahl der Bits in der Binärdarstellung von $x$ ist. Damit hat der Euklidische Algorithmus bis auf einen konstanten Faktor denselben Aufwand wie die Multiplikation von $x$ und $y$, wenn man die Schulmethode benutzt. (Der Beweis der Schranke in 2. benötigt eine Rechnung, die die Längen der beteiligten Zahlen genauer verfolgt.) + +Beispiel: +1. $21$ und $25$ sind teilerfremd. Es gilt $31*21 + (-26)*25 = 651-650 = 1$. +2. Auch $-21$ und $25$ sind teilerfremd. Aus 1. folgt sofort $(-31)*(-21) + (-26)*25 =651 -650 = 1$. +3. Es gilt $ggT(21,35) = 7$, und $2* 35 - 3 *21 = 7$. + +Die folgende sehr nützliche Aussage verallgemeinert diese Beobachtung: + +Lemma 4.6... von Bezout +1. Wenn $x,y\in\mathbb{Z}$ teilerfremd sind, gibt es $s,t\in\mathbb{Z}$ mit $sx+ty= 1$. +2. Für $x,y\in\mathbb{Z}$ gibt es $s,t\in\mathbb{Z}$ mit $sx+ty= ggT(x,y)$. + +Wir geben einen Algorithmus an, der zu $x$ und $y$ die Werte $s$ und $t$ (sehr effizient) berechnet. Damit ist die Frage der Existenz natürlich gleich mit erledigt. Vorab bemerken wir noch, dass es eine Art Umkehrung von 1. gibt: Wenn $sx+ty= 1$ für ganze Zahlen $s$ und $t$ gilt, dann sind $x$ und $y$ teilerfremd. (Beweis: Alle gemeinsamen Teiler von $x$ und $y$ teilen auch $1$, sind also $1$ oder $-1$. Daraus folgt $ggT(x,y) = 1$.) + +Für den Algorithmus können wir o.B.d.A. annehmen, dass $x,y\geq 0$ gilt. Die Umrechnung für negative Inputs ist offensichtlich. + +Algorithmus 4.2 Erweiterter Euklidischer Algorithmus: +- Eingabe: Natürliche Zahlen $x$ und $y$. +- Methode: + 1. $a,b,sa,ta,sb,tb,q:integer;$ + 2. $a\leftarrow x; b\leftarrow y;$ + 3. $sa\leftarrow 1; ta\leftarrow 0; sb\leftarrow 0; tb\leftarrow 1;$ + 4. while $b> 0$ repeat + 1. $q\leftarrow a\ div\ b$; + 2. $(a,b)\leftarrow (b,a-q*b)$; + 3. $(sa,ta,sb,tb)\leftarrow (sb,tb,sa-q*sb,ta-q*tb)$; + 5. return$(a,sa,ta)$; + +Genau wie im ursprünglichen Euklidischen Algorithmus findet die eigentliche Arbeit in der while-Schleife (Zeilen 4 - 7 ) statt. + +Die Idee hinter dem Algorithmus ist folgende. Wie im (einfachen) Euklidischen Algorithmus werden in den Variablen $a$ und $b$ Zahlen $a$ und $b$ mit geführt, die stets $ggT(a,b) =d= ggT(x,y)$ erfüllen. Nach dem ersten Durchlauf gilt $b\leq a$. Die Variablen $sa,ta,sb$ und $t_b$ enthalten immer Zahlenpaare $(s_a,t_a)$ und $(s_b,t_b)$, die folgende Gleichungen erfüllen: +$$a=s_a*x+t_a*y$$ +$$b=s_b*x+t_b*y \quad\quad(4.2)$$ + +Diese Gleichung wird durch die Initialisierung hergestellt. In einem Schleifendurchlauf wird $a$ durch $b$ ersetzt und $(s_a,t_a)$ durch $(s_b,t_b)$, und es wird $b$ durch $a-q*b$ ersetzt sowie $(s_b,t_b)$ durch $(s_a-q*s_b, t_a-q*t_b)$. Dadurch bleiben die Gleichungen (4.2) gültig. Wenn schließlich $b=0$ geworden ist, gilt $d=ggT(x,y) =a=s_a*x+t_a*y$. Das bedeutet, dass die Ausgabe das gewünschte Ergebnis darstellt. + +Als Beispiel betrachten wir den Ablauf des Algorithmus auf der Eingabe $(x,y) =(10534,12742)$. Die Zahlen $a_i,b_i,s_{a,i},t_{a,i},s_{b,i},t_{b,i}$ bezeichnen den Inhalt von $a,b,sa,ta,sb,tb$ nach dem i-ten Schleifendurchlauf. +| $i$ | $a_i$ | $b_i$ | $s_{a,i}$ | $t_{a,i}$ | $s_{b,i}$ | $t_{b,i}$ | $q_i$ | +| --- | ----- | ----- | --------- | --------- | --------- | --------- | ----- | +| 0 | 10534 | 12742 | | 1 | 0 | 0 | 1 | - | +| 1 | 12742 | 10534 | | 0 | 1 | 1 | 0 | - | +| 2 | 10534 | 2208 | 1 | 0 | - | 1 | 1 | 1 | +| 3 | 2208 | 1702 | - | 1 | 1 | 5 - | 4 | 4 | +| 4 | 1702 | 506 | 5 | - | 4 | - 6 | 5 | 1 | +| 5 | 506 | 184 | - | 6 | 5 | 23 | - | 19 | 3 | +| 6 | 184 | 138 | 23 | - | 19 | - | 52 | 43 | 2 | +| 7 | 138 | 46 | - | 52 | 43 | 75 | - | 62 | 1 | +| 8 | 46 | 0 75 | - | 62 | - | 277 | 229 | 3 | + +Die Ausgabe ist $(46, 75 ,-62)$. Man überprüft leicht, dass +$$46 = ggT(10534,12742) = 75* 10534 - 62 * 12742$$ +gilt. - Allgemein gilt: + +Fakt 4.7: Wenn Algorithmus 4.2 auf Eingabe $(x,y)$ mit $x,y\geq 0$ gestartet wird, dann gilt: +1. Für die Ausgabe $(d,s,t)$ gilt $d= ggT(x,y) =sx+ty$. +2. Die Anzahl der Schleifendurchläufe ist dieselbe wie beim gewöhnlichen Euklidischen Algorithmus. +3. Die Anzahl von Ziffernoperationen für Algorithmus 4.2 ist $O((log\ x)(log\ y))$. + +Wir notieren noch eine wichtige Folgerung aus dem Lemma von Bezout. Die Aussage ist aus der Schule bekannt: Wenn eine Zahl z.B. durch $3$ und durch $5$ teilbar ist, dann ist sie auch durch 15 teilbar. Dort benutzt man die Primzahlzerlegung zur Begründung. Diese ist aber gar nicht nötig. + +Fakt 4.8: Wenn $x$ und $y$ teilerfremd sind und $a$ sowohl durch $x$ als auch durch $y$ teilbar ist, dann ist $a$ auch durch $xy$ teilbar. + +Beweis: Weil $x$ und $y$ Teiler von $a$ sind, kann man $a=ux$ und $a=vy$ schreiben, für ganze Zahlen $u,v$. Weil $x$ und $y$ teilerfremd sind, liefert Lemma 4.6.1 zwei ganze Zahlen $s$ und $t$ mit $1=sx+ty$. Dann ist $a=asx+aty=vysx+uxty= (vs+ut)xy$, also ist $xy$ Teiler von $a$. + +## Modulare Arithmetik +Definition 4.9: Für $m\geq 2$ definieren wir eine zweistellige Relation auf $\mathbb{Z}$: $x\equiv y (mod\ m)$ heißt $m|(x-y)$. + +Man sagt: ,,$x$ ist kongruent zu $y$ modulo $m$.'' In der Mathematik sieht man auch oft die kompaktere Notation $x\equiv y(m)$ oder $x\equiv_m y$. Es besteht eine enge Beziehung zwischen dieser Relation und der Division mit Rest. + +Fakt 4.10: +1. $x\equiv y(mod\ m)$ gilt genau dann wenn $x\ mod\ m=y\ mod\ m$ gilt. +2. Die zweistellige Relation $*\equiv *(mod\ m)$ ist eine Äquivalenzrelation, sie ist also reflexiv, transitiv und symmetrisch. + +Beispiel für 1.: $29\ mod\ 12 = 53\ mod\ 12 = 5$ und $53-29 = 24$ ist durch $12$ teilbar. + +Der Beweis von 1. ist eine leichte Übung; 2. folgt sofort aus 1. + +Die Kongruenzrelation $* \equiv *(mod\ m)$ führt (wie jede Äquivalenzrelation) zu einer Zerlegung der Grundmenge $\mathbb{Z}$ in Äquivalenzklassen (die hier ,,Restklassen'' heißen): $[x]_m= [x] =\{y\in\mathbb{Z}|x\equiv y(mod\ m)\}=\{y\in\mathbb{Z}|x\ mod\ m=y\ mod\ m\}$. Wir definieren: $m\mathbb{Z}:=\{...,-3m,-2m,-m,0,m,2m,3m,...\}$ und $x+A:=\{x+y|y\in A\}$, für $A\supseteq Z$. + +Beispiel: Für $m=3$ gibt es die drei Restklassen +- $[0] = [0]_3 =\{...,-6,-3,0,3,6,...\}= 0 + 3\mathbb{Z}$, +- $[1] = [1]_3 =\{...,-5,-2,1,4,7,...\}= 1 + 3\mathbb{Z}$, +- $[2] = [2]_3 =\{...,-4,-1,2,5,8,...\}= 2 + 3\mathbb{Z}$. + +Mit den Restklassen kann man dann wieder rechnen: Addition und Multiplikation lassen sich wie folgt definieren. +- $[x]_m+ [y]_m := [x+y]_m$, +- $[x]_m*[y]_m := [x*y]_m$ + +Beispielsweise gelten für $m=3$ die Gleichheiten $[4] + [5] = [9] = [0]$ und $[4]*[5] =[20] = [2]$. + +Fakt 4.11: Diese Operationen sind wohldefiniert, d.h., aus $x\equiv x'(mod\ m)$ und $y\equiv y'(mod\ m)$ folgt $[x+y]_m= [x'+y']_m$ und $[x*y]_m= [x'*y']_m$. + +Der Beweis ist einfach. Weil $x\equiv x' (mod\ m)$ und $y\equiv y' (mod\ m)$ gilt, sind $x-x'$ und $y-y'$ durch $m$ teilbar. Also ist auch $xy-x'y'=x(y-y') + (x-x')y'$ durch $m$ teilbar, und es gilt $x*y\equiv x'*y' (mod\ m)$. Der Fall der Addition ist noch einfacher. + +Aus der Definition und der Wohldefiniertheit ergibt sich, dass man anstatt mit Restklassen auch mit Repräsentanten rechnen kann. Statt $([5]_3 *[5]_3)*[2]_3 = [25]_3 *[2]_3 = [1]_3 *[2]_3 = [2]_3$ schreibt man dann einfach $(5*5)* 2 \equiv 25 * 2 \equiv 1 * 2 \equiv 2 (mod\ 3)$. + +Fakt 4.11 besagt auch, dass an jeder Stelle einer solchen Rechnung jede Zahl durch eine dazu kongruente Zahl ersetzt werden darf, je nachdem, wie es bequem ist. Beispiel: $(5*5)* 2 \equiv((-1)*(-1))*(-1) = (-1)^3 =- 1 \equiv 2 (mod\ 3)$. Da $(x\ mod\ m)\equiv x(mod\m)$ für alle $x$ und $m\geq 1$ gilt, kann man in ,,modulo-m-Rechnungen'' eine Zahl $x$ insbesondere immer durch ihren Rest modulo m ersetzen. + +Beispiel: Um $13^7\ mod\ 11$ zu berechnen, rechnet man $13^7\equiv 27\equiv 2^5*4 =32* 4\equiv (-1)*4 = -4\equiv 7(mod\ 11)$. Um $3^{1006}\ mod\ 7$ zu berechnen, bemerkt man, dass $3^2\ mod\ 7=2$ ist, also $3^{1006}\equiv 2^{503}(mod\ 7)$. Weil nun $2^3\ mod\ 7=1$ gilt, folgt $2^{503}=(2^3)^{167} * 2^2 \equiv 1^{167}*4=4(mod\ 7)$. + +Zu $m\geq 1$ betrachtet die Menge aller Restklassen: $\mathbb{Z}_m:=\mathbb{Z}/m\mathbb{Z}:=\{[x]_m|x\in\mathbb{Z}\}=\{[x]| 0 \leq x1$ ist, gibt es kein Inverses zu $x$ in $\mathbb{Z}_m$. Wenn $d=1$ ist, folgt $sx\ mod\ m=1$, also ist $s\ mod\ m$ das gewünschte inverse Element. Die Rechenzeit für das Berechnen des ,,modularen Inversen'' beträgt also $O((log\ x)(log\ m))$. + +Die Menge der invertierbaren Elemente von $\mathbb{Z}_m$ erhält eine eigene Bezeichnung. + +Definition 4.17: Für $m\geq 2$ sei $\mathbb{Z}^*_m:=\{x\in\mathbb{Z}_m| ggT(x,m)=1\}$. + +(Wieder sind eigentlich die Restklassen $[x]_m, 0\leq x < m, ggT(x,m) = 1$, gemeint.) + +Fakt 4.18: Für jedes $m\geq 2$ gilt: $\mathbb{Z}^*_m$ mit der Multiplikation modulo m als Operation ist eine (kommutative) Gruppe. + +Beispiel: $\mathbb{Z}^*_{21}=\{1,2,4,5,8,10,11,13,16,17,19,20\}$ und $\mathbb{Z}^*_7=\{1,2,3,4,5,6\}$. + +Wir haben $8*16 \equiv 128 \equiv 2 (mod\ 21)$, mit $2\in\mathbb{Z}^*_{21}$. Für $17\in\mathbb{Z}^_{21}$ gibt es das Inverse $5$, denn $17*5 = 85\equiv 1 (mod\ 21)$. + +Aus den Gruppeneigenschaften weiß man, dass Inverse eindeutig bestimmt sind. Für das Inverse von $x$ (wenn es existiert) schreiben wir $x^{-1} mod\ m$ (gemeint ist die Restklasse oder der eindeutig bestimmte Repräsentant in $\{0,1 ,...,m-1\}$). + +Am schönsten ist die Situation, wenn alle Zahlen $1,...,m-1$ in $\mathbb{Z}^*_m$ liegen. Das heißt insbesondere, dass keine der Zahlen $2, 3 ,...,m-1$ die Zahl $m$ teilt. Um diese Situation zu beschreiben, definieren wir vorläufig den Begriff der Primzahl. Man erinnere sich, dass jede ganze Zahl $x$ durch $x$ und $-x$ sowie durch $1$ und $-1$ teilbar ist. + +Eine ganze Zahl $p\geq 1$ heißt Primzahl, wenn $p$ genau zwei positive Teiler hat, nämlich $1$ und $p$. Die Folge der Primzahlen beginnt mit $2, 3 , 5 , 7 , 11 , 13 , 17 , 19 , 23 ,....$ + +Fakt 4.19 (*): Für jedes $m\geq 2$ sind folgende Aussagen äquivalent: +1. $m$ ist eine Primzahl. +2. $\mathbb{Z}^*_m=\{ 1 ,...,m-1\}$. +3. $\mathbb{Z}_m$ ist ein Körper. + +Der Beweis erfolgt durch einen Ringschluss. +- ,,1. $\Rightarrow$ 2.'': Sei $m$ Primzahl. Dann kann für kein Element $x\in\{1 ,...,m-1\}$ die Beziehung $ggT(x,m)>1$ gelten, weil sonst die Zahl $ggT(x,m)$ ein Teiler von $m$ strikt zwischen $1$ und $m$ wäre. +- ,,2. $\Rightarrow$ 3.'': Wenn $\mathbb{Z}^*_m=\{1 ,...,m-1\}$ gilt, hat nach Fakt 4.16 jedes Element von $\mathbb{Z}_m -\{0\}$ ein multiplikatives Inverses. Das ist genau die Eigenschaft, die dem Ring $\mathbb{Z}_m$ zum Körper fehlt. +- ,,3. $\Rightarrow$ 1.'': Das beweisen wir durch Kontraposition. Sei also 1. falsch, d.h. sei $m$ keine Primzahl. Dann gibt es ein $x\in\{2,...,m-1\}$, das Teiler von $m$ ist. Insbesondere ist $ggT(x,m) =x >1$. +- Mit Fakt 4.16 folgt, dass $x$ kein multiplikatives Inverses modulo $m$ hat, also ist $\mathbb{Z}_m$ kein Körper, d.h. 3. ist falsch. + +Beispiel: $m=13$. Wir geben für jedes $x\in\mathbb{Z}^*_{13}$ das Inverse $y$ sowie das Produkt $x*y$ an (das natürlich bei der Division durch $13$ Rest $1$ lassen muss). +| x | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | +| ----- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | +| y | 1 | 7 | 9 | 10 | 8 | 11 | 2 | 5 | 3 | 4 | 6 | 12 | +| $x*y$ | 1 | 14 | 27 | 40 | 40 | 66 | 14 | 40 | 27 | 40 | 66 | 144 | + +$14$ ist keine Primzahl, und es gibt keine Zahl $y$ mit $2*y\ mod\ 14 = 1$; das heißt, dass $2\not\in\mathbb{Z}^*_{14}$ und daher, dass $\athbb{Z}_{14}$ kein Körper ist. +Wir notieren noch einen altehrwürdigen Satz aus der Zahlentheorie. Der Satz wurde von Pierre de Fermat, 1607-1665, einem französischen Mathematiker und Juristen, gefunden. + +Fakt 4.20 (Kleiner Satz von Fermat): Wenn $p$ eine Primzahl ist, dann gilt: $a^{p-1}\ mod\ p= 1$, für jedes $a\in\mathbb{Z}^*_p$. + +Beweis: Sei $a\in\mathbb{Z}^*_p$ gegeben. Betrachte die Abbildung $g_a: \mathbb{Z}^*_p \owns s\rightarrow as\ mod\ p\in\mathbb{Z}^*_p$. Diese Abbildung ist injektiv, da für das zu $a$ inverse Element $b=a^{-1}\ mod\ p$ gilt: $b*g_a(s)\ mod\ p=b(as)\ mod\ p=((ba)\ mod\ p)s\ mod\ p=s$. Also gilt: $\{1,...,p-1\}=\{g_a(1),...,g_a(p-1)\}$. +Wir multiplizieren die Zahlen $1,...,p-1$ in zwei Anordnungen: $1*...*(p-1)\ mod\ p =g_a(1) *...*g_a(p-1)\ mod\ p=a^{p-1} *(1*...*(p-1)\ mod\ p)$. +Wenn wir beide Seiten mit dem multiplikativen Inversen von $X:= 1*...*(p-1)\ mod\ p$ multiplizieren, erhalten wir $1=a^{p-1}\ mod\ p$. +Wir bemerken, dass auch eine gewisse Umkehrung gilt, sogar für beliebige $m$: Wenn $a^{m-1}\ mod\ m=1$ ist, d.h. $a^{m-1}-qm=1$ für ein $q$, dann folgt $ggT(a,m)=1$. Wenn also $a\in\mathbb{Z}_m -\mathbb{Z}^*_m$, dann gilt auf jeden Fall $a^{m-1}\ mod\ m\not= 1$. + +## Der Chinesische Restsatz +Der ,,Chinesische Restsatz'' besagt im Wesentlichen, dass für teilerfremde Zahlen $m$ und $n$ die Strukturen $\mathbb{Z}_m \times\mathbb{Z}_n$ (mit komponentenweisen Operationen) und $\mathbb{Z}_{mn}$ isomorph sind. + +Wir beginnen mit einem Beispiel, nämlich $m=3,n=8$, also $mn=24$. Die folgende Tabelle gibt die Reste der Zahlen $x\in\{0,1,...,23\}\ modulo\ 3$ und $modulo\ 8$ an. Die Restepaare wiederholen sich zyklisch für andere $x\in\mathbb{Z}$. + +| x | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | +| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- ||| | | +| x mod 3 | 0 | 1 | 2 | 0 | 1 | 2 | 0 | 1 | 2 | 0 | 1 | 2 | 3 | 0 | 1 | 2 | 0 | 1 | 2 | 0 | 1 | 2 | 0 | 1 | 2 | +| x mod 8 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 0 | 1 | 2 | 3 | 8 | 4 | 5 | 6 | 7 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | + +Wenn wir die Einträge in Zeilen 2 und 3 als 24 Paare in $\mathbb{Z}_3 \times\mathbb{Z}_8$ ansehen, erkennen wir, dass sie alle verschieden sind, also auch alle Möglichkeiten in $\{0,1,2\}\times\{0,1,...,7\}$ abdecken. D.h.: Die Abbildung $x\rightarrow (x\ mod\ 3,x\ mod\ 8)$ ist eine Bijektion zwischen $\mathbb{Z}_{24}$ und $\mathbb{Z}_3\times\mathbb{Z}_8$. Zudem spiegeln sich arithmetische Operationen auf den Elementen von $\mathbb{Z}_{24}$ in den Resten modulo $3$ und $8$ wider. Beispielsweise liefert die Addition von $(2,7)$ und $(2,1)$ das Resultat $(1,0)$, das der Addition von $23$ und $17$ mit dem Resultat $40\ mod\ 24 = 16$ entspricht. Genauso ist $(2^5\ mod\ 3, 3^5\ mod\ 8)=(2,3)$, was der Beobachtung $11^5\ mod\ 24 = 11$ entspricht. +Der Chinesische Restsatz sagt im wesentlichen, dass eine solche strukturelle Entsprechung zwischen den Resten modulo $mn$ und Paaren von Resten modulo $m$ bzw. $n$ immer gilt, wenn $m$ und $n$ teilerfremd sind. + +Fakt 4.21 Chinesischer Restsatz (*): $m$ und $n$ seien teilerfremd. Dann ist die Abbildung $\Phi:\mathbb{Z}_{mn} \owns x \rightarrow (x\ mod\ m, x\ mod\ n)\in\mathbb{Z}_m\times\mathbb{Z}_n$ bijektiv. Weiterhin: Wenn $\Phi(x)=(x_1,x_2)$ und $\Phi(y)=(y_1,y_2)$, dann gilt: +1. $\Phi(x+_{mn} y) = (x_1 +_m y_1 , x_2 +_n y_2)$ +2. $\Phi(x*_{mn} y) = (x_1 *_m y_1 , x_2 *_n y_2)$ +3. $\Phi(1) = (1,1)$ + +(Dabei bezeichnen $+_j$ und $*_j$ die Addition und die Multiplikation modulo $j$.) + +Für mathematisch-strukturell orientierte Leser/innen: Die Gleichungen 1. bis 3. kann man etwas abstrakter auch so fassen, dass die Abbildung $\Phi$ ein Ring-mit-1-Isomorphismus zwischen $\mathbb{Z}_{mn}$ und $\mathbb{Z}_m \times\mathbb{Z}_n$ ist. + +Man kann sich noch fragen, wie man nötigenfalls zu gegebenen Zahlen $s\in\mathbb{Z}_m$ und $t\in\mathbb{Z}_n$ die Zahl $x\in\mathbb{Z}_{mn}$ berechnen kann, die $\Phi(x)=(s,t)$ erfullt. Dazu betrachtet man zunächst den Fall $s=1$ und $t=0$. Weil $m$ und $n$ teilerfremd sind, kann man mit dem erweiterten Euklidischen Algorithmus ein $u\in\mathbb{Z}_{m}$ mit $un\ mod\ m=1$ +finden. Wir setzen $y=un\in\mathbb{Z}_{mn}$. Dann gilt $y\ mod\ m=1$ und $y\ mod\ n=0$. Analog findet man ein $z\in\mathbb{Z}_{mn}$ mit $z\ mod\ m=0$ und $z\ mod\ n=1$. Nun setzen wir $x:=(sy+tz)\ mod\ mn\in\mathbb{Z}_{mn}$. Wir haben, modulo $m$ gerechnet: $x\equiv sy+tz\equiv s*1+t* 0 \equiv s\ (mod\ m)$. Analog ergibt sich $x\equiv sy+tz\equiv s*0+t*1 \equiv t(mod\ n)$, wie gewünscht. Der Berechnungsaufwand für das Finden von $x$ ist $O((log\ m)(log\ n))$ Ziffernoperationen, das geht also sehr schnell. + +Beispiel: $m=5,n=8,s=3,t=7$. Wir finden $u=2$ mit $u*8\ mod\ 5 = 1$ und $y= 2*8=16$ sowie $v=5$ mit $v*5\ mod\ 8=1$ und $z=5*5=25$. Nun setzen wir $x=(3*16+7*25) \ mod\ 40=(48+175)\ mod\ 40 = (8 + 15)\ mod\ 40 = 23$. Und tatsächlich: $23\ mod\ 5 = 3$ und $23\ mod\ 8 = 7$. + +Wir wollen noch untersuchen, wie sich Zahlen, die zu $m$ und $n$ teilerfremd sind, in der Sichtweise des Chinesischen Restsatzes verhalten. + +Proposition 4.22 (*): Wenn man die Abbildung $\Phi$ aus dem Chinesischen Restsatz auf $\mathbb{Z}^*_{mn}$ einschränkt, ergibt sich eine Bijektion zwischen $\mathbb{Z}^*_{mn}$ und $\mathbb{Z}^*_m\times\mathbb{Z}^*_n$. + +Bemerkung: Der Chinesische Restsatz und die nachfolgenden Bemerkungen und Behauptungen lassen sich leicht auf $r>2$ paarweise teilerfremde Faktoren $n_1,...,n_r$ +verallgemeinern. Die Aussagen lassen sich durch vollständige Induktion über $r$ beweisen. Mit Prop. 4.22 können wir eine übersichtliche Formel für die Kardinalitäten der Mengen $\mathbb{Z}^*_m, m\geq 2$, entwickeln. + +Definition 4.23 (Eulersche $\varphi$-Funktion): für $m\geq 2$ sei $\varphi(m):=|\mathbb{Z}^*_m| =|\{x| 01$ hätten, dann wäre $p_1$ Teiler von $p^{t_2}_2...p^{t_s}_s$, was sofort einen Widerspruch zur Eindeutigkeit der Primfaktorzerlegung ergibt. Mit Lemma 4.24, $(s-1)$-mal angewendet, erhalten wir $\varphi(m) =\prod^s_{i=1} \varphi(p^{t_i}_i) = \prod^s_{i=1} (p^{t_i}_i (1-1/p_i)) =m* \prod^s_{i=1} (1-\frac{1}{p_i})$. +Mit dieser Formel lassen sich die Werte in Tabelle 2 schnell verifizieren. (Beispiel: $\varphi(12) = 12(1-1/2)(1-1/3) = 12*(1/2)*(2/3) = 4$) Man beachte als Spezialfall: Wenn $m=pq$ für verschiedene Primzahlen $p$ und $q$, dann ist $\varphi(m)=pq(1-1/p)(1-1/q) =(p-1)(q-1)$. (Beispiel: $\varphi(15) =2*4=8$) + +Bemerkung: Die einfache Formel in Lemma 4.29 könnte zu dem Schluss verleiten, dass sich $\varphi(m)$ zu gegebenem $m$ immer leicht berechnen lässt. Aber Achtung: Man muss dazu die Menge der Primfaktoren von $m$ kennen. Dies läuft darauf hinaus, dass Faktorisierungsproblem für $m$ zu lösen, also einen beliebigen Primfaktor für $m$ zu finden, und hierfür kennt man keine effizienten Algorithmen. Tatsächlich ist auch +kein effizienter Algorithmus bekannt, der es erlaubt, $\varphi(m)$ aus $m$ zu berechnen. + +Fakt 4.30: Jede zusammengesetzte Zahl $x$ besitzt einen Primfaktor $p$ mit $p\leq\sqrt{x}$. + +Beweis: Man schreibt $x=yz$ für Zahlen $y$ und $z$, die weder 1 noch $x$ sind. Es ist nicht möglich, dass beide größer als $\sqrt{x}$ sind. Der kleinere Faktor enthält also einen Primfaktor, der nicht größer als $\sqrt{x}$ ist. +Bemerkung: Wir betrachten das resultierende naive Faktorisierungsverfahren: Teste die Zahlen in $\{2,...,\lfloor\sqrt{x}\rfloor\}$ nacheinander darauf, ob sie $x$ teilen; wenn ein Faktor $p$ gefunden wurde, wende dasselbe Verfahren auf $x'=x/p$ an. Dieses Verfahren hat im schlechtesten Fall Rechenzeit mindestens $Θ(\sqrt{x}) = Θ(2^{(log\ x)/ 2})$, also exponentiell in der Bitlänge von $x$. Wie wir später genauer diskutieren werden, sind für das Auffinden der Primzahlzerlegung einer gegebenen Zahl $x$ überhaupt keine effizienten Algorithmen bekannt (also Algorithmen mit Laufzeiten $O((log\ x)^c)$ für konstantes $c$). Aber es gibt effiziente Algorithmen, mit denen man feststellen kann, ob eine Zahl $x$ eine Primzahl ist oder nicht. Dieser Unterschied in der Schwierigkeit des Faktorisierungsproblems und des Primzahlproblems liegt einer ganzen Reihe von kryptographischen Verfahren zugrunde. + +Satz 4.31 (Euklid): Es gibt unendlich viele Primzahlen. + +Beweis: Wenn $\{p_1,...,p_k\}$, für $k\geq 1$, eine endliche Menge von (verschiedenen) Primzahlen ist, betrachten wir die Zahl $x=1+p_1...p_k$. Die Zahl $x$ kann durch keine der Zahlen $p_1,...,p_k$ teilbar sein, sonst wäre $1$ durch diese Primzahl teilbar, was nicht möglich ist. Also sind alle Primfaktoren in der Primzahlzerlegung von $x$ von $p_1,...,p_k$ verschieden, es muss also außer $p_1,...,p_k$ noch weitere Primzahlen geben. + +Über die Verteilung der Primzahlen (ihre ,,Dichte'') in $N$ gibt der berühmte Primzahlsatz Auskunft. Mit $\pi(x)$ bezeichnen wir die Anzahl der Primzahlen, die nicht größer als $x$ sind. + +Satz 4.32 Primzahlsatz: $lim_{x\rightarrow \infty} \frac{\pi(x)}{x\backslash ln\ x}= 1$ + +Das heißt, dass für große $x$ in $(x,2x]$ etwa $\frac{2x}{ln(2x)}-\frac{x}{ln\ x}\approx \frac{x}{ln\ x}$ Primzahlen zu erwarten sind. Die $n$-Bit-Zahlen bilden das Intervall $[2^{n-1} , 2n)$. Der Anteil der Primzahlen in diesem Intervall ist näherungsweise $\frac{2^{n-1} /ln(2^{n-1})}{2^{n-1}}\approx \frac{1}{(ln\ 2)(n-1)}\approx 1,44/n$. +Für $n\approx 2000$ ist der relative Anteil von Primzahlen im interessanten Zahlenbereich also $\approx 1,44/2000\approx 1/1400$. Er sinkt umgekehrt proportional zur Ziffernzahl. +Eine schärfere Form des Primzahlsatzes ist folgende Aussage (wobei der Beweis Nichtspezialisten nicht zugänglich ist): $\frac{x}{ln\ x}(1+\frac{1}{ln\ x})\leq \pi(x)\leq \frac{x}{ln\ x}(1+\frac{1,2762}{ln\ x})$. + +Für $x\geq 500 000$ folgt daraus: $\frac{x}{ln\ x}< \pi(x)< 1, frac{x}{ln\ x}$. +Daraus folgt, dass für $n\geq 20$ der Anteil der Primzahlen unter den n-Bit-Zahlen folgende Ungleichung erfüllt: $\frac{|\{p\in [2^{n-1}, 2^n)| \text{p is prime}\}|}{2^{n-1} = \frac{\pi(2^n)-\pi(2^{n-1})}{2^{n-1}} \geq \frac{2^n\backslash (n\ ln\ 2)- 1,1*2^{n-1}\backslash ((n-1)ln\ 2)}{2^{n-1}}\geq \frac{2}{n\ ln\ 2}-\frac{1,1}{n\ ln\ 2}*\frac{n}{n-1}\geq \frac{6}{5n}$. + +Mit Hilfe eines Computeralgebraprogramms findet man heraus, dass die Ungleichung $|\{p\in [2^{n-1}, 2^n)|\text{ p is prime}\}|/2^{n-1} \geq 6 /(5n)$ auch für $9\leq n\leq 20$ gilt. (Für $n=8$ ist sie falsch.) Man kann sich also merken: für $n\geq 9$ ist der Anteil der Primzahlen an den n-Bit-Zahlen mindestens $\frac{6}{5n}$. + +| Ziffernzahl $n$ | Dusart-Schranke $(\pi(2^n)-\pi(2^{n-1}))\backslash 2^{n-1}$ | für numerische untere Schranke | +| --------------- | ----------------------------------------------------------- | ------------------------------ | +| $256$ | $\frac{6}{5*256}$ | $\geq \frac{1}{214}$ | +| $512$ | $\frac{6}{5*512}$ | $\geq \frac{1}{427}$ | +| $1024$ | $\frac{6}{5*1024}$ | $\geq\frac{1}{854}$ | +| $2048$ | $\frac{6}{5*2048}$ | $\geq\frac{1}{1707}$ | + +Eine leichter zu beweisende Aussage der Art $\pi(2m)-\pi(m) = O(m/log\ m)$ ist die folgende: + +Satz 4.33 Ungleichung von Finsler: Für jede ganze Zahl $m\geq 2$ liegen im Intervall $(m, 2m]$ mindestens $m/(3\ ln(2m))$ Primzahlen: $\pi (2m)-\pi(m)\geq \frac{m}{3\ ln(2m)}$. + +Ein vollständiger, vergleichsweise einfacher Beweis für Satz 4.33 findet sich zum Beispiel in dem Lehrbuch ,,Elemente der Diskreten Mathematik: Zahlen und Zählen, Graphen und Verbände'' von Diekert, Kufleitner, Rosenberger (De Gruyter 2013). + +## Der Primzahltest von Miller und Rabin +In diesem Abschnitt lernen wir einen randomisierten Algorithmus kennen, der es erlaubt, zu einer gegebenen Zahl $N$ zu entscheiden, ob $N$ eine Primzahl ist oder nicht. + +Ein idealer Primzahltest sieht so aus: +- Eingabe: Eine natürliche Zahl $N\geq 3$. +- Ausgabe: $0$, falls $N$ eine Primzahl ist; $1$, falls $N$ zusammengesetzt ist. + +Wozu braucht man Primzahltests? Zunächst ist die Frage ,,Ist $N$ eine Primzahl?'' eine grundlegende mathematisch interessante Fragestellung. Spätestens mit dem Siegeszug des RSA-Kryptosystems hat sich die Situation jedoch dahin entwickelt, dass man Algorithmen benötigt, die immer wieder neue vielziffrige Primzahlen (etwa mit 1000 oder 1500 Bits bzw. 301 oder 452 Dezimalziffern) bereitstellen können. Den Kern dieser Primzahlerzeugungs-Verfahren bildet ein Verfahren, das eine gegebene Zahl $N$ darauf testet, ob sie prim ist. Ein naiver Primzahltest (,,versuchsweise Division''), der dem brute-force-Paradigma folgt, findet durch direkte Division der Zahl $N$ durch $2,3,4,...,\lfloor\sqrt{N}\rfloor$ heraus, ob $N$ einen nichttrivialen Teiler hat. Man kann dieses Verfahren durch einige Tricks beschleunigen, aber die Rechenzeit wächst dennoch mit $O(\sqrt{N})$. Dies macht es für Zahlen mit mehr als $40$ Dezimalstellen praktisch undurchführbar, von Zahlen mit mehr als $100$ Dezimalstellen ganz zu schweigen. (Achtung: Damit wird nichts über den Zeitaufwand bei anderen Faktorisierungsalgorithmen gesagt. Es gibt andere, sehr fortgeschrittene Faktorisierungsalgorithmen, die bei entsprechendem Zeitaufwand und mit sehr leistungsstarken Rechnern auch noch mit $200$-stelligen Zahlen zurechtkommen. Für Information zu früheren und aktuelleren Faktorisierungserfolgen siehe z.B. [http://en.wikipedia.org/wiki/RSA_numbers](http://en.wikipedia.org/wiki/RSA_numbers.)) + +In diesem Abschnitt beschreiben wir den randomisierten Primzahltest von Miller-Rabin. Dabei handelt es sich um einen ,,Monte-Carlo-Algorithmus mit einseitigem Fehler''. Das heißt: Auf Eingaben $N$, die Primzahlen sind, wird immer $0$ ausgegeben; auf Eingaben $N$, die zusammengesetzt sind, gibt es eine gewisse (von $N$ abhängige) Wahrscheinlichkeit, dass die Ausgabe $0$, also falsch ist. Für kein zusammengesetztes $N$ ist diese Wahrscheinlichkeit größer als die ,,Fehlerschranke'' $\frac{1}{4}$. Wir beweisen nur die Fehlerschranke $\frac{1}{2}$. Im Beweis benutzen wir einfache zahlentheoretische Überlegungen. Eine herausragende Eigenschaft des Miller-Rabin-Tests ist seine Effizienz. Wir werden sehen, dass selbst bei Verwendung der Schulmethoden für Multiplikation und Division die Anzahl der Ziffernoperationen des Primzahltests nur $O((log\ N)^3)$ ist. + +Bemerkung: Der Miller-Rabin-Algorithmus stammt aus dem Jahr 1977; er folgte einem kurz vorher vorgestellten anderen randomisierten Primzahltest (Solovay-Strassen-Test). Für diesen und andere randomisierte Primzahltests (z.B. der ,,Strong Lucas Probable Prime Test'' oder der ,,Quadratic Frobenius Test'' von Grantham) sei auf die Literatur verwiesen. Im Jahr 2002 stellten Agarwal, Kayal und Saxena einen deterministischen Primzahltest mit polynomieller Rechenzeit vor. (Die Rechenzeit ist z.B. durch $O((log\ N)^{7,5})$ beschränkt.) Dieser Algorithmus stellte insofern einen gewaltigen Durchbruch dar, als er ein Jahrhunderte altes offenes Problem löste, nämlich die Frage nach einem effizienten deterministischen Verfahren für das Entscheidungsproblem ,,ist $N$ Primzahl oder zusammengesetzt''? Andererseits ist seine Laufzeit im Vergleich etwa zu dem hier diskutierten randomisierten Verfahren so hoch, dass nach wie vor die randomisierten Algorithmen benutzt werden, um für kryptographische Anwendungen Primzahlen zu erzeugen. +Da gerade Zahlen leicht zu erkennen sind, beschränken wir im Folgenden unsere Überlegungen auf ungerade Zahlen $N\geq 3$. + +### Der Fermat-Test +Wir erinnern uns an Fakt 4.20, den Kleinen Satz von Fermat: Wenn $p$ eine Primzahl ist und $1\leq a < p$, dann gilt $a^{p-1} mod\ p=1$. +Wir können diese Aussage dazu benutzen, um ,,Belege'' oder ,,Zertifikate'' oder ,,Zeugen'' dafür anzugeben, dass eine Zahl $N$ zusammengesetzt ist: Wenn wir eine Zahl $a$ mit $1\leq a < N$ finden, für die $a^{N-1} mod\ N\not=1$ gilt, dann ist $N$ definitiv keine +Primzahl. + +Beispiel: Mit $N=15$ und $a=2$ rechnen wir: $2^{14}\equiv (2^4)^3 * 2^2 \equiv 16^3*4 \equiv 1*4\equiv 4 (mod\ 15)$. Also ist $2^{14} mod\ 15 = 4\not= 1$, also ist $15$ definitiv keine Primzahl. (Man beachte, dass wir keinen Faktor angeben müssen, um zu diesem Schluss zu kommen.) + +Definition 4.34: Sei $N\geq 3$ ungerade und zusammengesetzt. Eine Zahl $a\in\{1,...,N-1\}$ heißt F-Zeuge für $N$, wenn $a^{N-1} mod\ N\not= 1$ gilt. Eine Zahl $a\in\{1,...,N-1\}$ heißt F-Lügner für $N$, wenn $a^{N-1} mod\ N=1$ gilt. Die Menge der F-Lügner nennen wir $L^F_N$. + +Wir bemerken, dass ein F-Zeuge belegt, dass es Faktoren $k,l >1$ mit $N=k*l$ gibt, dass aber ein F-Zeuge nicht auf solche Faktoren hinweist oder sie beinhaltet. Das Finden von Faktoren wird von Primzahltests auch nicht verlangt und normalerweise auch nicht geleistet. +Man sieht sofort, dass $1$ und $N-1$ immer F-Lügner sind: Es gilt $1^{N-1} mod\ N=1$ und $(N-1)^{N-1} \equiv (-1)^{N-1}=1 (mod\ N)$, weil $N-1$ gerade ist. +Für jede zusammengesetzte Zahl $N$ gibt es mindestens einen F-Zeugen. Nach Fakt 4.19 gilt \{1,...,N-1\}-\mathbb{Z}^*_N\not=\varnothing$, wenn $N$ zusammengesetzt ist. + +Lemma 4.35: Wenn $N$ zusammengesetzt ist, ist jedes $a\in\{1,...,N-1}-\mathbb{Z}^*_N$ ein F-Zeuge. + +Beweis: Sei $d=ggT(a,N)>1$. Dann ist auch $a^{N-1}$ durch $d$ teilbar, also auch $a^{N-1}\ mod\ N=a^{N-1}- \lfloor a^{N-1}\backslash N\rfloor *N$. Daher ist $a^{N-1} mod\ N\not= 1$. + +Beispiel: Für $N=15$ und $a=6$ gilt $6^{14}\equiv 36^7\equiv 6^7 \equiv 36^3 * 6 \equiv 6^4 \equiv 6^2 \equiv 6\ (mod\ 15)$. Der Rest $6$ ist durch $ggT(6,15) = 3$ teilbar. + +Leider ist für manche zusammengesetzten Zahlen $N$ die Menge $\{1 ,...,N-1\}-\mathbb{Z}^*_N$ äußerst dünn. Wenn zum Beispiel $N=pq$ für zwei Primzahlen $p$ und $q$ ist, dann gilt $ggT(a,N)> 1$ genau dann wenn $p$ oder $q$ ein Teiler von $a$ ist. Es gibt genau $p+q-2$ solche Zahlen $a$ in $\{ 1 ,...,N-1\}$, was gegenüber $N$ sehr klein ist, wenn $p$ und $q$ annähernd gleich groß sind. Um eine gute Chance zu haben, F-Zeugen zu finden, sollte es also mehr als nur die in $\{1 ,...,N-1\}-\mathbb{Z}^*_N$ geben. + +Beispiel: $N=91 = 7*13$. Es gibt 18 Vielfache von 7 und 13 (für größere $p$ und $q$ wird der Anteil dieser offensichtlichen F-Zeugen noch kleiner sein), und daneben weitere $36$ F-Zeugen und $36$ F-Lügner in $\{1 , 2 ,..., 90\}$. + +In diesem Beispiel gibt es um einiges mehr F-Zeugen als F-Lügner. Wenn dies für alle zusammengesetzten Zahlen $N$ der Fall wäre, wäre es eine elegante randomisierte Strategie, einfach zufällig nach F-Zeugen zu suchen. Dies führt zu unserem ersten Versuch für einen randomisierten Primzahltest. + +Tabelle 3: F-Zeugen und F-Lügner für $N=91= 7*13$. Es gibt $36$ F-Lügner und $36$ F-Zeugen in $\mathbb{Z}^*_{91}$. Wir wissen nach Lemma 4.35, dass alle 18 Vielfachen von $7$ und $13$ F-Zeugen sind. +| | | +| ------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------ | +| F-Zeugen in $\{ 1 ,..., 90\}-\mathbb{Z}^*_{91}$: | 7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84; 13, 26, 39, 52, 65, 78 | +| F-Lügner: | 1, 3, 4, 9, 10, 12, 16, 17, 22, 23, 25, 27, 29, 30, 36, 38, 40, 43, 48, 51, 53, 55, 61, 62, 64, 66, 68, 69, 74, 75, 79, 81, 82, 87, 88, 90 | +| F-Zeugen in $\mathbb{Z}^*_{91}$ : | 2, 5, 6, 8, 11, 15, 18, 19, 20, 24, 31, 32, 33, 34, 37, 41, 44, 45, 46, 47, 50, 54, 57, 58, 59, 60, 67, 71, 72, 73, 76, 80, 83, 85, 86, 89 | + +Algorithmus 4.4: Fermat-Test +- Eingabe: Ungerade Zahl $N\geq 3$ +- Methode: + 1. Wähle $a$ zufällig aus $\{1,...,N-1\}$ + 2. if $a^{N-1}\ mod\ N\not= 1$ then return $1$ else return $0$ + +Die Laufzeitanalyse liegt auf der Hand: Der teuerste Teil ist die Berechnung der Potenz $a^{N-1}\ mod\ N$ durch schnelle Exponentiation, die nach den Ergebnissen von Lemma 4.14 $O(log\ N)$ arithmetische Operationen und $O((log\ N)^3)$ Ziffernoperationen benötigt. Weiter ist es klar, dass der Algorithmus einen F-Zeugen gefunden hat, wenn er ,,1'' ausgibt, dass in diesem Fall also $N$ zusammengesetzt sein muss. Umgekehrt ausgedrückt: Wenn $N$ eine Primzahl ist, gibt der Fermat-Test garantiert ,,0'' aus. Für $N=91$ wird das falsche Ergebnis $0$ ausgegeben, wenn als $a$ einer der 36 F-Lügner gewählt wird. Die Wahrscheinlichkeit hierfür ist $\frac{36}{90} =\frac{2}{5} = 0,4$. + +Für viele zusammengesetzte Zahlen $N$ gibt es reichlich F-Zeugen, so dass der Fermat-Test für diese $N$ mit konstanter Wahrscheinlichkeit das korrekte Ergebnis liefert. Wir analysieren das Verhalten des Fermat-Tests für solche ,,gutmütigen'' Eingabezahlen $N$ (für die $N=91$ ein typisches Beispiel ist). + +Satz 4.36: Sei $N\geq 9$ eine ungerade zusammengesetzte Zahl. Wenn es mindestens einen F-Zeugen $b\in\mathbb{Z}^*_N$ gibt, dann liefert der Fermat-Test auf Eingabe $N$ mit Wahrscheinlichkeit größer als $\frac{1}{2}$ die korrekte Antwort ,,1''. + +Beweis: Sei $b\in\mathbb{Z}^*_N$ ein F-Zeuge. Betrachte die Funktiong $b:L^F_N\rightarrow\mathbb{Z}^*_N$, die den F-Lügner $a$ auf $g_b(a) =ba\ mod\ N$ abbildet. Wie im Beweis von Fakt 4.20 sieht man, dass $g_b$ injektiv ist. Weiter ist $g_b(a)$ für jedes $a\in L^F_N$ ein F-Zeuge: $(ba\ mod\ N)^{N-1}\ mod\ N= (b^{N-1}\ mod\ N)(a^{N-1}\ mod\ N) =b^{N-1}\ mod\ N\not= 1$. +Wir können also jedem F-Lügner $a$ einen eigenen F-Zeugen $g_b(a)$ in $\mathbb{Z}^*_N$ zuordnen. Daraus folgt, dass es in $\mathbb{Z}^*_N$ mindestens so viele F-Zeugen wie F-Lügner gibt. Mit Lemma 4.35 ergibt sich, dass $\{1,...,N-1\}$ mehr F-Zeugen als F-Lügner enthält. Daher ist die Wahrscheinlichkeit, dass die im Fermat-Test zufällig gewählte Zahl $a$ ein F-Lügner ist, kleiner als $\frac{1}{2}$. +Eine Fehlerwahrscheinlichkeit in der Nähe von $\frac{1}{2}$ ist natürlich viel zu groß. Wir verringern die Fehlerschranke durch wiederholte Ausführung des Fermat-Tests. + +Algorithmus 4.5: Iterierter Fermat-Test +- Eingabe: Ungerade Zahl $N\geq 3$, eine Zahl $l\geq 1$ +- Methode: + 1. repeat $l$ times + 1. $a\leftarrow$ ein zufälliges Element von $\{1 ,...,N-1\}$ + 2. if $a^{N-1}\ mod\ N\not= 1$ then return $1$ + 2. return 0 + +Wenn die Ausgabe $1$ ist, hat der Algorithmus einen F-Zeugen für $N$ gefunden, also ist $N$ zusammengesetzt. D.h.: Wenn $N$ eine Primzahl ist, ist die Ausgabe $0$. Andererseits: Wenn $N$ zusammengesetzt ist, und es mindestens einen F-Zeugen $b\in\mathbb{Z}^*_N$ gibt, dann ist nach Satz 4.36 die Wahrscheinlichkeit für die falsche Ausgabe ,,0'' höchstens $(\frac{1}{2})^l= 2^{-l}$. Indem wir $l$ genügend groß wählen, können wir die Fehlerwahrscheinlichkeit so klein wie gewünscht einstellen. + +Wenn es darum geht, aus einem genügend großen Bereich zufällig gewählte Zahlen darauf zu testen, ob es sich um eine Primzahl handelt, dann ist der Fermat-Test (in Kombination mit dem Testen auf kleine Teiler, etwa alle Primzahlen unter 1000) allem Anschein nach eine sehr effiziente und zuverlässige Methode. Dies wird durch empirische Resultate nahegelegt. Wenn man allerdingsüber die Herkunft der zu testenden Zahl $N$ keine Information hat und eventuell damit rechnen muss, dass jemand (ein ,,Gegenspieler'') absichtlich eine besonders schwierige Eingabe vorlegt, dann stößt der Fermat-Test an eine Grenze. Es gibt nämlich ,,widerspenstige'' zusammengesetzte Zahlen, denen man mit diesem Test nicht beikommen kann, weil alle Elemente von $\mathbb{Z}^*_N$ F-Lügner sind. Mit diesen befasst sich der folgende Abschnitt. + +### Carmichael-Zahlen +Definition 4.37: Eine ungerade zusammengesetzte Zahl $N$ heißt eine Carmichael-Zahl, wenn für alle $a\in\mathbb{Z}$^*_N$ die Gleichung $a^{N-1}\ mod\ N= 1$ gilt. + +Die kleinste Carmichael-Zahl ist $561 = 3* 11 *17$. Weitere kleine Carmichael-Zahlen sind $1105 = 5* 13 *17$ und $1729 = 7* 13 *19$. Erst im Jahr 1994 wurde bewiesen, dass es unendlich viele Carmichael-Zahlen gibt, genauer: Wenn $x$ genügend groß ist, dann gibt es in $\{N\in\mathbb{N}| N\leq x\}$ mehr als $x^{2/7}$ Carmichael-Zahlen. Die aktuell beste bekannte untere Schranke ist $x^{1/3}$. Von Erdös (1956) stammt die obere Schranke $x*exp(\frac{-c\ ln\ x\ ln\ ln\ ln\ x}{ln\ ln\ x})$, für eine Konstante $c>0$, die zeigt, dass Carmichael-Zahlen viel seltener als Primzahlen sind. + +Wenn wir dem Fermat-Test eine Carmichael-Zahl $N$ als Eingabe geben, ist die Wahrscheinlichkeit für die falsche Antwort $0$ nach Lemma 4.29 genau $\frac{\varphi(N)}{N-1} > \frac{\varphi(N)}{N} = \prod_{p\ prim, p\ teilt\ N} (1 -\frac{1}{p})> 1 -\sum_{p\ prim, p\ teilt\ N} \frac{1}{p}$. +Diese Wahrscheinlichkeit liegt nahe an $1$, wenn $N$ nur wenige und relativ große Primfaktoren hat. An solchen Carmichael-Zahlen besteht etwa im Bereich der Zahlen im Bereich $[10^{17} , 10^{18} ]$ kein Mangel, wie ein Blick in entsprechende Tabellen zeigt. Zum Beispiel ist $N=925619721362375041 = 425681* 1277041 *1702721$ eine 18-ziffrige Carmichael-Zahl mit $\varphi(N)/N > 0.999996$. +Der Wiederholungstrick zur Wahrscheinlichkeitsverbesserung hilft hier leider auch nicht, denn wenn etwa $p_0$ der kleinste Primfaktor von $N$ ist, und $N$ nur $3$ oder $4$ Faktoren hat, dann sind $\Omega(p_0)$ Wiederholungen nötig, um die Fehlerwahrscheinlichkeit auf $\frac{1}{2}$ zu drücken. Sobald $p_0$ mehr als 30 Dezimalstellen hat, ist dies undurchführbar. + +Für einen zuverlässigen, effizienten Primzahltest, der für alle Eingabezahlen funktioniert, müssen wir über den Fermat-Test hinausgehen. Interessanterweise ist dies praktisch ohne Effizienzverlust möglich. Für spätere Benutzung stellen wir noch eine Hilfsaussage über Carmichael-Zahlen bereit. + +Lemma 4.38: Wenn $N$ eine Carmichael-Zahl ist, dann ist $N$ keine Primzahlpotenz. + +Beweis: Wir beweisen die Kontraposition: Wenn $N=p^l$ für eine ungerade Primzahl $p$ und einen Exponenten $l\geq 2$ ist, dann ist $N$ keine Carmichael-Zahl. Dazu genügt es, eine Zahl $a\in\mathbb{Z}^*_N$ anzugeben, so dass $a^{N-1}\ mod\ N\not= 1$ ist. Wir definieren: $a:=p^{l-1} + 1$. (Wenn z.B. $p=7$ und $l=3$ ist, ist $N=343$ und $a=49+1=50$.) Man sieht sofort, dass $a0$. Wir wählen $d=a$. Dann gilt (i), weil $a$ Teiler von $a$ und von 0 ist, und es gilt (ii), weil jeder gemeinsame Teiler von $a$ und 0 auf jeden Fall Teiler von $a$ ist. +- *Induktionsschritt*: $b>0$. Setze $q:=a\ div\ b$ und $r:=a-qb=a\ mod\ b$ und $(a',b'):=(b,r)$. Dann ist $b'=r < b=a'$. Nun haben $a$ und $b$ genau dieselben gemeinsamen Teiler wie $a'$ und $b'$. (Aus $t|a$ und $t|b$ folgt $t|(a-qb)$, also $t|a'$, und aus $t|a'$ und $t|b'$ folgt $t|r+qb$, also $t|a$.) Nach I.V. existiert $d= ggT(a',b')$, und dieses $d$ ist dann auch größter gemeinsamer Teiler von $a$ und $b$. + + +# Asymmetrische Verschlüsselung: RSA & Co. +## Das RSA-Kryptosystem (,,Vorlesungs-Version'') +RSA: Erfunden von Ronald L. Rivest, Adi Shamir und Leonard Adleman, 1977. Ein ähnliches Verfahren wurde (von J. H. Ellis, C. C. Cocks und M. J. Williamson) bereits Anfang der 1970er Jahre in den Government Communications Headquarters, der Kryptologie-Abteilung des britischen Geheimdienstes, entwickelt, aber nicht veröffentlicht. + +Vorsicht: In der hier zunächst vorgestellten einfachen/naiven Version ist RSA unsicher. Es müssen Modifikationen und Einschränkungen vorgenommen werden, um ein +sicheres Verfahren zu erhalten. Gute Referenz hierfür: Baumann, Franz, Pfitzmann, Kryptographische Systeme, Springer Vieweg 2014, S. 231ff. + +Wir betrachten ein einfaches Kommunikationsszenario. Die Teilnehmer sind Alice und Bob. Alice möchte an Bob eine Nachricht schicken. Dies soll über einen offen zugänglichen Kanal (E-Mail, ein Webportal) geschehen. Dieser Kanal wird von Eva mitgelesen. Alice und Bob wollen vermeiden, dass Eva den Inhalt der Nachricht erfährt. Wenn auch Bob an Alice Nachrichten schicken möchte, müssen die Aktionen auch mit vertauschten Rollen ausgeführt werden. +Die Menge $X$ der möglichen Nachrichten kann als Teilmenge von $\{0,1\}^*$ aufgefasst werden. Wir möchten vermeiden, dass sich Alice und Bob vor der Kommunikation auf einen gemeinsamen Schlüssel einigen müssen. Stattdessen wird ein Schlüsselpaar $(k,\hat{k})$ verwendet. Die erste Komponente $k$ heißt der öffentliche Schlüssel von Bob und wird von Bob allen zugänglich gemacht, etwa über seine Webseite oder als Anhang von E-Mails. Die zweite Komponente $\hat{k}$ heißt der private Schlüssel von Bob und ist nur ihm bekannt. Die Menge der Schlüsselpaare $(k,\hat{k})$, die zusammengehören, nennen wir die Schlüsselmenge $K$. + +Definition 5.1: Ein Public-Key-Kryptosystem $(X,Y,K,E,D)$ hat 5 Komponenten: +- Klartextmenge $X$ (endlich), +- Chiffretextmenge $Y$ (endlich), +- Schlüsselmenge $K$, wobei $K\supseteq K_{pub} \times K_{priv} für Mengen $K_{pub}$ und $K_{priv}$, +- Verschlüsselungsfunktion $E:X\times K_{pub} \rightarrow Y$, +- Entschlüsselungsfunktion $D:Y\times K_{priv} \rightarrow X$, +- wobei die folgende Dechiffrierbedingung gilt: $D(E(x,k), \hat{k}) =x$, für alle $x\in X,(k,\hat{k})\in K$. + +Um ein solches System benutzen zu können, benötigt man noch ein Verfahren, um Schlüsselpaare $(k,\hat{k})$ zu erzeugen. Dieses Verfahren heißt $G$, ist randomisiert und wird von Bob angestoßen, dem auch das Ergebnis mitgeteilt wird. Dies ist notwendig, da die Ausgabe von $G$ den geheimen Schlüsselteil $\hat{k}$ enthält. Nach Erzeugung des Paars $(k,\hat{k})$ gibt Bob $k$ bekannt und speichert $\hat{k}$ geheim ab. Wenn Alice Bob eine Nachricht $x\in X$ schicken will, berechnet sie $y=E(x,k)$ und schickt $y$. Wenn Bob einen Chiffretext $y$ empfängt, berechnet er $z=D(y,\hat{k})$. Nach der Dechiffrierbedingung ist dies wieder $x$. + +Das RSA-System in seiner puren Form benutzt Klartext- und Chiffretextmenge $X=Y=[N]$, für eine feste Zahl $N$. Ab hier nehmen wir stets an, dass der Klartext $x$ selbst eine Zahl in $X = X_N= [N]$ ist. Dann ist $Y = Y_N= [N]$ die Menge der möglichen Chiffretexte. + +Das (randomisierte) Verfahren $G$ zur Erzeugung von Schlüsselpaaren $(k,\hat{k})$ aus $K_{pub} \times K_{priv}$ hat üblicherweise einen Parameter $l$, die Schlüssellänge. Den Wertebereich von $G$, also die Menge aller möglichen Schlüsselpaare $(k,\hat{k})$, wollen wir $K$ nennen. Dabei ist $k$ Bobs ,,öffentlicher Schlüssel'', der öffentlich zugänglich ist (zum Beispiel in einem allgemein zugänglichen ,,Schlüsselbuch'' oder auf Bobs Webseite) und $\hat{k}$ ist sein ,,privater Schlüssel'', den nur er kennt. Alice (und andere Teilnehmer, die Bob eine Nachricht schicken wollen) verwendet $k$ zur Verschlüsselung, Bob verwendet $\hat{k}$ zur Entschlüsselung. + +Es gibt einen (eventuell randomisierten) Verschlüsselungsalgorithmus $E$, der aus $x\in X$ und dem öffentlichen Schlüssel $k$ den Chiffretext $y\in Y$ berechnet, sowie einen (deterministischen) Entschlüsselungsalgorithmus $D$, der aus $y\in Y$ und dem privaten Schlüssel $\hat{k}$ den entschlüsselten Text $z\in X$ berechnet. Abstrakt haben wir zwei Funktionen $E: (x,k)\rightarrow y\in Y$, wobei $x\in X$ und $k$ erste Komponente eines Schlüsselpaars $(k,\hat{k})\in K$ mit zugeordneter Zahl $N$ ist, und $D:(y,\hat{k})\rightarrow z\in X$, wobei $y\in Y$ und $\hat{k}$ zweite Komponente eines Schlüsselpaars $(k,\hat{k})\in K$ mit zugeordneter Zahl $N$ ist. + +Typischerweise sind die Funktionen $E$ und $D$ allgemein bekannt; das einzige Geheimnis im Verfahren steckt im privaten Schlüssel $\hat{k}$. + +Korrektheit/Dechiffrierbedingung: Es gilt: $D(E(x,k), \hat{k}) =x$, für $x\in X$ und $(k,\hat{k})\in K$. + +Sicherheit: Es soll verhindert werden, dass Eva aus dem Chiffretext $y$ und dem öffentlichen Schlüssel $k$ ,,relevante Informationen''über den Klartext $x$ gewinnen kann. Hierbei wird üblicherweise angenommen, dass sie nur ,,begrenzten Rechenaufwand'' betreiben kann. + +### Schlüsselerzeugung +Wir beschreiben den Erzeugungsprozess $G$. Dieser Vorgang wird von Bob selbst oder einer Sicherheitsagentur (,,trust center'') durchgefuhrt. Die Schlüssellänge ist festzulegen (etwa $l= 1024, 2048$ oder $4096$ Bits). Danach werden zwei (zufällige, verschiedene) Primzahlen $p$ und $q$ bestimmt, deren Bitlänge die Hälfte der Schlüssellänge ist. +Hierzu kann man im Prinzip wie in Abschnitt 4.7 beschrieben vorgehen. Nun wird das Produkt $N=pq$ berechnet. Die Zahl $N$ hat $l$ oder $l-1$ Bits. Weiter wird $\varphi(N) = (p-1)(q-1)$ berechnet. Es wird eine Zahl $e\in\{3,...,\varphi(N)-1\}$ mit $ggT(e,\varphi(N)) = 1$ gewählt. (Überprüfung mittels des erweiterten Euklidischen Algorithmus (Algorithmus 4.2), Rechenzeit $O(l^3)$.) Dann wird das multiplikative Inverse $d<\varphi(N) modulo\ \varphi(N)$ von $e$ bestimmt, so dass also $ed\ mod\ \varphi(N) = 1$ gilt. (Man beachte, dass nur ungerade $e$ in Frage kommen, weil $\varphi(N)$ gerade ist. Man weiß, dass die Anzahl der geeigneten Werte $e$ mindestens $\frac{\varphi(N)}{log(\varphi(N))}$ ist, so dass die erwartete Anzahl von Versuchen $O(log(\varphi(N)))=O(logN)$ ist.) + +Bob erhält aus seiner Rechnung $N$, $e$ und $d$. Aus diesen wird das Schlüsselpaar $(k,\hat{k})$ gebildet: +- Der öffentliche Schlüssel $k$ ist das Paar $(N,e)$. Dieser wird bekanntgegeben. +- Der geheime Schlüssel $\hat{k}$ ist $(N,d)$. (Natürlich ist nur der Teil $d$ wirklich geheim.) + +Der erwartete Berechnungsaufwand für die Schlüsselerzeugung ist $O((log\ N)^4) =O(l^4)$, weil dies die Kosten der Primzahlerzeugung sind (siehe Abschnitt 4.7); die Kosten für das Finden von $e$ sind geringer. + +### Verschlüsselung +- Gegeben: Klartext $x$. +- Benötigt: Öffentlicher Schlüssel $k= (N,e)$. + +Verschlüsselung von $x\in X= [N]: y=E(x,(N,e)) :=x^e\ mod\ N$. (Zu berechnen mit schneller Exponentiation, Rechenzeit $O((log\ N)^3) =O(l^3)$.) + +### Entschlüsselung +- Gegeben: Chiffretext $y$. +- Benötigt: Privater Schlüssel $\hat{k}= (N,d)$. + +$z=D(y,(N,d)) :=y^d\ mod\ N$. (Zu berechnen mit schneller Exponentiation, Rechenzeit $O((log\ N)^3) =O(l^3)$.) + +Nach den Potenzrechenregeln, die auch für die modulare Arithmetik gelten, ist $z=(x^e\ mod\ N)^d\ mod\ N=x^{ed}\ mod\ N$. Die Korrektheit der Entschlüsselung beruht auf folgendem Satz. + +Satz 5.2: Korrektheit/Dechiffrierbedingung von RSA: Wenn $ed\ mod\ \varphi(N) = 1$ gilt, dann haben wir $x^{ed}\ mod\ N=x$, für alle $x\in [N]$. + +Beweis: Weil $x$ und $x^{ed}\ mod\ N$ beide in $[N]$ liegen, also der Betrag ihrer Differenz kleiner als $N$ ist, genügt es zu zeigen, dass $x^{ed} \equiv x(mod\ N)$ gilt, d.h. dass $N$ Teiler von $x^{ed}-x$ ist. +Dies weisen wir im Folgenden nach. Betrachte die Primfaktoren $p$ und $q$ von $N$. Da $ed\equiv 1 (mod\ \varphi(N))$ und $\varphi(N) = (p-1)(q-1)$ gilt, haben wir $ed=k(p-1)(q-1) + 1$ für eine Zahl $k\in\mathbb{N}$, also $x^{ed}-x= (x^{k(p-1)(q-1)} -1)*x$. +Behauptung: $p$ teilt $x^{ed}-x$. - Wenn $x$ durch $p$ teilbar ist, ist dies klar. Wir können also annehmen, dass $p$ kein Teiler von $x$ ist, dass also $x$ und $p$ teilerfremd sind. Nach dem kleinen Satz von Fermat (Fakt 4.27) gilt $x^{p-1}\ mod\ p= 1$, also auch $x^{k(p-1)(q-1)}\ mod\ p= (x^{(p-1)})^{k(q-1)}\ mod\ p= 1$. +Dies bedeutet, dass $p$ ein Teiler von $x^{k(p-1)(q-1)}-1$ ist, also auch ein Teiler von $x^{ed}-x$. +Die Behauptung gilt naturlich genauso für $q$: Auch $q$ ist ein Teiler von $x^{ed}-x$. Da $p$ und $q$ teilerfremd sind, folgt aus Fakt 4.8, dass $N=pq$ Teiler von $x^{ed}-x$ ist, wie gewünscht. + +Beispiel: +- Schlüsselerzeugung: $N= 55 = 5*11$. +- $\varphi(N) = 4*10 = 40$. +- $e= 3, ggT(3,40) = 1, d=e^{-1}\ mod\ 40 = 27$, weil $3*27 = 81\equiv 1 (mod\ 40)$ gilt. +- Also: $k= (55,3)$, $\hat{k}= (55,27)$. +- Sei der Klartext $x=9$ gegeben. +- Verschlüsselung: $y= 9^3\ mod\ 55 = 729\ mod\ 55 = 14$. +- Entschlüsselung: Wir rechnen modulo 55: $y^{27}\equiv (14^2 * 14)^9 \equiv (31*14)^9 \equiv 434^9 \equiv ((-6)^3)^3 \equiv 4^3 \equiv 64 \equiv 9\ (mod\ 55)$. + +RSA, unsichere Version, insgesamt +- Bob erzeugt einen Schlüsselsatz $(k, \hat{k}) = ((N,e),(N,d))$. +- Er veröffentlicht $(N,e)$ und hält $d$ geheim. +- Wenn Alice $(x_1,...,x_r)\in [N]^r$ an Bob schicken will, verschlüsselt sie $y_i:=x^e_i\ mod\ N, für $i=1,...,r$, und sendet $(y_1,...,y_r)$ an Bob. +- Dieser entschlüsselt $z_i:=y^d_i\ mod\ N$, für $i=1,...,r$, und erhält $(z_1,...,z_r) = (x_1,...,x_r)$. + +## Asymmetrische Kryptoschemen, Sicherheitsbegriff +Wir betrachten die Situation asymmetrisch verschlüsselter Kommunikation allgemein, also für beliebig lange Klartexte, und formulieren ein Sicherheitskonzept. Der Einfachheit halber nehmen wir als Menge $Y$ der Chiffretexte die Menge aller Binärstrings an. + +Szenarium 4: Alice möchte Bob vertrauliche Nachrichten beliebiger Länge über einen abhörbaren Übertragungsweg zukommen lassen. Alice und Bob besitzen keinen gemeinsamen Schlüssel. + +### Asymmetrische Kryptoschemen +Definition 5.3: Ein asymmetrisches Kryptoschema ist ein Tupel $S= (X,K,G,E,D)$, wobei +- $X,K\supseteq K_{pub} \times K_{priv}$ Mengen, +- $G():K_{pub} \times K_{priv}$ ein randomisierter Algorithmus, +- $E(x:X,k:K_{pub}):\{0,1\}^*$ ein randomisierter Algorithmus und +- $D(y:\{0,1\}^*,k:K_{priv}):\{0,1\}^*$ ein deterministischer Algorithmus sind, +- so dass gelten + - die (erwartete) Laufzeit von $$ ist beschränkt durch eine Konstante, + - die Laufzeiten von $$ und $D$ sind polynomiell beschränkt in der Länge von $x$ bzw. $y$, + - für jedes $x\in X,k\in K_{pub}$, jede Ausgabe $(k,\hat{k})$ von $$ und jedes $m\in\{0,1\}^{p(|x|)} (die Ausgänge der flip-Anweisungen in $E$, für ein Polynom $p(n)$) gilt: $D(E^m (x,k), \hat{k}) =x$. + +Begriffe +- Die Elemente von X heißen ,,Klartexte'', die Menge der ,,Chiffretexte'' ist $\{0,1\}^*$. +- Die Elemente von $K_{pub}$ heißen ,,Öffentliche Schlüssel'', die von $K_{priv}$ ,,private Schlüssel'', mit $K\supseteq K_{pub} \times K_{priv}$ bezeichnen wir die Menge der Schlüsselpaare, die $G$ möglicherweise ausgibt. +- $G$ ist der ,,Schlüsselgenerierungsalgorithmus''. Er hat im Prinzip kein Argument, eventuell gibt es verschiedene Varianten, die von einem ,,Sicherheitsparameter'' $l$ abhängen. +- $E$ ist der ,,Verschlüsselungs-'' und $D$ der ,,Entschlüsselungsalgorithmus''. + +Beispiel: Die Erweiterung des RSA-Schemas auf Strings beliebiger Länge durch Anwendung auf Blöcke der Länge $w\leq log\ N$, wie oben beschrieben, liefert ein Kryptoschema. Die Frage ist, wie gut dieses Kryptoschema ist. + +### Sicherheit von asymmetrischen Kryptoschemen +Definition 5.4: Ein Angreifer $A$ auf ein asymmetrisches Kryptoschema $S= (X,K,G,E,D)$ ist ein Paar zufallsgesteuerter Algorithmen $AF(k:K_{pub}):(\{0,1\}\times\{0,1\})+\times V$, $AG(v:V,k:K_{pub}, y:\{0,1\}^*) :\{0,1\}$ + +Die Idee ist wie folgt: Der Finder $AF$ bekommt einen öffentlichen Schlüssel $k$. Daraus berechnet er zwei verschiedene Klartexte $(z_0,z_1)$ gleicher Länge und ,,Notizen'' $v\in V$. Danach wird zufällig $z_0$ oder $z_1$ zu $y$ verschlüsselt. Im zweiten Schritt verwendet der Rater $AG$ die Zwischeninformation $v$, den öffentlichen Schlüssel $k$ und die ,,Probe'' $y$, um zu bestimmen, ob $z_0$ oder $z_1$ verschlüsselt wurde. + +Definition 5.5: Sei $S=(X,K,G,E,D)$ ein asymmetrisches Kryptoschema und $A=(AF,AG)$ ein Angreifer. Das zugehörige Experiment oder Spiel ist der folgende Algorithmus $G^S_A:\{0,1\}$: +1. $(k,\hat{k})\leftarrow G()$ (ein Schlüsselpaar des Kryptoschemas $S$ wird gewählt) +2. $(z_0,z_1,v)\leftarrow AF(k)$ (der Finder berechnet ein Paar von Klartexten gleicher Länge, von denen er annimmt, ihre Chiffretexte unterscheiden zu können) +3. $b\leftarrow flip()$ und $y\leftarrow E(z_b,k)$ (einer der Klartexte wird zuyverschlüsselt) +4. $b'\leftarrow AG(v,k,y)$ (der Rater versucht herauszubekommen, ob $z_0$ oder $z_1$ verschlüsselt wurde) +5. falls $b=b'$, so gib $1$ zurück, sonst $0$. +- Das verkürzte Experiment oder Spiel $S^S_A$ gibt im 5. Schritt einfach $b'$ aus. + +Dann ist $Pr(G^S_A= 1)$ die Wahrscheinlichkeit dafür, dass der Angreifer $A$ den korrekten Klartext erkennt. Man kann jetzt wie in Abschnitt 2.4 (Sicherheit von $l$-Blockkryptosystemen) den Vorteil $adv(A,S) = 2 Pr(G^S_A = 1)- 1$, den ,,Erfolg'' $suc(A,S) = Pr(G^S_A〈b = 1〉 = 1)$ und den ,,Misserfolg'' $fail(A,S) =Pr(G^S_A〈b= 0〉= 1)$ definieren. Lemma 2.16 gilt dann wörtlich. + +Beispiel 5.6: Sei $S=(X,K,G,E,D)$ ein asymmetrisches Kryptoschema, in dem der Verschlüsselungsalgorithmus $E$ deterministisch ist. Wir betrachten den folgenden Angreifer $A$ mit $V=\{0,1\}^*$. Seien $z_0$ und $z_1$ verschiedene Elemente von $X$: +- $AF(k:K_{pub}) : (\{0,1\}\times\{0,1\})^+\times V$ + - $v\leftarrow E(z_0,k);return(z_0,z_1,v)$ +- $AG(v:V,k:K_{pub},y:\{0,1\}^*):\{0,1\}$ + - if $v=y$ then return 0 else return 1. +- Im Ablauf des Spiels $G^S_A$ wird der Rater $AG$ also mit $E(z_0,k)$ oder mit $E(z_1,k)$ gestartet. Wegen $E(z_0,k)\not=E(z_1,k)$ gilt $Pr(G^S_A=1)=1$, d.h. $adv(A,S)=1$. + +Dieses Beispiel lässt sich verallgemeinern: + +Lemma 5.7: Für jedes deterministische asymmetrische Kryptoschema $S$ gibt es einen Angreifer $A$ mit $adv(A,S) = 1$. + +Definition 5.8: Sei $t\in\mathbb{N}$, $A$ ein Angreifer auf ein asymmetrisches Kryptoschema $S$. Dann heißt $A$ $t$-beschränkt, wenn die Laufzeit des Experiments $G^S_A$ durch $t$ beschränkt ist. +Sei $\epsilon >0$. Dann heißt $S(t,\epsilon)$-sicher, wenn für jeden $t$-beschränkten Angreifer $A$ gilt $adv(A,S)\leq \epsilon$. + +Nach obigem Lemma gibt es für jedes deterministische asymmetrische Kryptoschema $S$ eine kleine Konstante $t$, so dass $S$ für kein $\epsilon >0 (t,\epsilon)$-sicher ist. Da die Verschlüsselung von RSA deterministisch ist, ist dieses Verfahren nach Lemma 5.7 nicht sicher. + +Zur Übung entwerfe man einen Angreifer $A$ gegen das RSA-System für die Situation, wo die Klartexte $(x_1,x_2)$ nur aus zwei Blöcken in $[N]$ bestehen. Dabei soll $A$ das Spiel mit Wahrscheinlichkeit $1$ gewinnen und die Notizenmenge $V$ soll trivial sein, also $V=\{0\}$, so dass $A$ sich gar keine Notizen machen kann. + +Betrachten wir nun konkret das RSA-System mit nur einem Block, also $X=[N]$. Kann Eva aus Kenntnis von $y=x^e\ mod\ N$, $e$ und $N$ irgendeine konkrete Information über $x$ ermitteln? + +Definition 5.9: +1. Das ,,Legendre-Symbol'' gibt an, ob $a\in\mathbb{Z}$ modulo einer Primzahl $p$ ein Quadrat ist. Für $p>2$ prim und $a\in\mathbb{Z}$ setze $L_p(a) =\begin{cases} 0 \quad\text{ falls } p|a \\ 1 \quad\text{ falls } p\not|a, \exists b:b^2 \equiv a (mod\ p) \\ -1 \quad\text{ falls } p\not|a, \lnot\exists b:b^2 \equiv a (mod\ p)\end{cases}$. +2. Das ,,Jacobi-Symbol'' verallgemeinert dies auf Moduli $N$, die nicht notwendig Primzahlen sind. Für $N>2$ ungerade mit Primzahlzerlegung $N=\prod_{1\leq i\leq r} p^{alpha_i}_i$ und $a\in\mathbb{Z}$ setze $J_N(a) =\prod_{1 \leq i\leq r} L_{p_i}(a)^{\alpha_i}$ + +Beobachtungen und Beispiele: +- Weil $4^2\ mod\ 7 = 2$, gilt $L_7(2) = 1$. Weiter gilt $L_7(21) = 0$ und $L_7(5) =-1$, weil $1,2,4$ die einzigen Quadrate modulo $7$ sind. +- $J_N(a) = 0$ genau dann, wenn $ggT(a,N)>1$. +- Wenn $p\not|a$ und $p$ ist ein Primfaktor, der in $N$ mit geradem Exponenten vorkommt, dann ist der Beitrag von $p$ zu $J_N(a)$ der Faktor 1, spielt also keine Rolle. +- Wenn $ggT(a,N) = 1$, dann ist $J_N(a) = (-1)^{#{i\leq r|\text{a ist Nichtquadrat modulo } p_i}$. + +Das Legendre-Symbol ist leicht mit schneller modularer Exponentiation zu berechnen. + +Fakt 5.10 Euler-Kriterium: $L_p(a) =a^{(p-1)/ 2}mod\ p$ für alle $a\in\mathbb{Z}$ und Primzahlen $p>2$. + +Überraschenderweise lässt sich auch das Jacobi-Symbol $J_N(a)$ effizient berechnen, selbst wenn man die Primzahlzerlegung von $N$ nicht kennt. + +Fakt 5.11: Für $a\geq 1$ und ungerade $N\geq 3$ lässt sich $J_N(a)$ in Zeit $O((log\ N+log\ a)^3)$ berechnen (ohne $N$ zu faktorisieren!). + +(Man benutzt einen klassischen Satz aus der Zahlentheorie, nämlich das quadratische Reziprozitätsgesetz, das auf Gauß zurückgeht. Damit erhält man eine Berechnung, deren Rekursionsschema dem des Euklidischen Algorithmus ähnelt. Details: Buch von Küsters/Wilke.) + +Lemma 5.12: Seien $p,q >2 prim,N=pq,e\in\mathbb{Z}^*_{\varphi(N)}$. Dann gilt $J_N(x^e\ mod\ N) =J_N(x)$ für alle $x\in\mathbb{Z}$. + +Beweis: $L_p(x^e\ mod\ N)\equiv_p (x^e\ mod\ N)^{\frac{p-1}{2}} \equiv_p x^{e\frac{p-1}{2}} \equiv_p (x^{\frac{p-1}{2}}\ mod\ p)^e \equiv_p (L_p(x)^e =L_p(x)$ +denn $e$ ist ungerade und damit $L_p(x^e\ mod\ N) =L_p(x)$. Analog gilt $L_q(x^e\ mod\ N) =L_q(x)$. +Also: $J_N(x^e\ mod\ N) =L_p(x^e\ mod\ N)*L_q(x^e\ mod\ N) =L_p(x)*L_q(x) =J_N(x)$. + +Das heißt: $J_N(E(x,(N,e))) =J_N(x)$. Der Chiffretext zu $x$ erbt eine nichttriviale Eigenschaft von $x$, nämlich den Wert des Jacobi-Symbols. Da sich das Jacobi-Symbol effizient berechnen lässt, erhält man sofort einen effizienten Angreifer. Wie? Der Finder berechnet zwei Klartexte $z_0$ und $z_1$ mit $J_N(z_0) = 1$ und $J_N(z_1) = -1$. Aus dem Jacobisymbol $J_N(y)$ der Probe kann er schließen, welcher der beiden Klartexte verschlüsselt wurde. Es folgt erneut: RSA ist nicht sicher im Sinn des Tests in Abschnitt 5.2.2. +Man könnte versuchen, diesem ,,kleinen'' Problem zu entkommen, indem man nur Klartexte $x\in [N]$ mit $J_N(x) = 1$ zulässt. Allerdings wird dadurch die Menge der Bitstrings, die Klartexte sein dürfen, auf etwas unübersichtliche Weise eingeschränkt. + + +## Weitere Bemerkungen zur Sicherheit und effizienten Verwendung von RSA +Der Einwand, dass man das Jacobisymbol des Klartextes ermitteln kann, ist vielleicht eine Schwäche von RSA, die man als praktisch geringfügig einschätzen kann. Viel schlimmer ist es, wenn man aus $y$ und $(e,N)$ den kompletten Klartext $x$ ermitteln kann. Es ist kein Verfahren bekannt, das dies in der allgemeinen Situation effizient bewerkstelligt. Wir beschreiben hier (informal) Begründungen dafür, dass die naheliegendsten Angriffe vermutlich nicht effizient durchführbar sind, und Maßnahmen, die RSA zu einem (praktisch, vermutet) sicheren System machen. + +### Äquivalenz ,,d bekannt'' zu ,,N faktorisieren'' +Wenn Eva die Zahl $N$ effizient in ihre Faktoren $p$ und $q$ zerlegen kann, kann sie natürlich sofort $\varphi(N)$ und $d$ berechnen und damit sämtliche mit $k=(e,N)$ verschlüsselten Nachrichten lesen. Nach aktuellem Stand sind Faktorisierungsverfahren nicht effizient genug, um Zahlen mit einigen hundert Dezimalstellen zuverlässig effizient zu faktorisieren. +Eine scheinbar schwächere Anforderung ist, dass Eva den Wert $\varphi(N)$ berechnen kann, denn dann kann sie auch $d$ berechnen (mit dem erweiterten Euklidischen Algorithmus) und direkt entschlüsseln. +Ganz allgemein ist der RSA-Schlüssel $(k,\hat{k}) = ((e,N),(d,N))$ vollständig gebrochen, wenn Eva $d$ ermitteln kann, nur aus der Kenntnis von $(e,N)$. Ist dies vielleicht ,,leichter'' als die Faktorisierung von $N$? Man kann Folgendes zeigen: Aus $N$, $e$ und $d$ lassen sich mit einem randomisierten Verfahren effizient die Faktoren $p$ und $q$ berechnen. +Das heißt: Das vollständige Brechen eines RSA-Schlüssels durch Ermittlung von $d$ ist in etwa genauso schwierig wie die Faktorisierung von $N$. + +Wir skizzieren die entsprechenden überlegungen. + +Satz: Es gibt einen randomisierten Polynomialzeitalgorithmus, der aus $e$, $d$ und $N$ die Primfaktoren $p$ und $q$ von $N$ berechnet. + +Skizze des Vorgehens in diesem Algorithmus: Wir schreiben $ed-1 = 2^k u$ für eine ungerade Zahl $u$ und $k\geq 1$. (Beachte, dass $e$ und $d$ ungerade sein müssen, weil sie teilerfremd zu $\varphi(N) = (p-1)(q-1)$ sind, einer geraden Zahl.) Definiere: $ord_p(b) = min\{w|b^w\ mod\ p= 1\}$, für $b\ mod\ p\not= 0$, analog $ord_q(b)$, für $b\ mod\ q\not= 0$. Dies ist die ,,Ordnung'' von $b\ mod\ p$ in der multiplikativen Gruppe $\mathbb{Z}^*_p$ bzw. $b\ mod\ q$ in $\mathbb{Z}^*_q$. + +Lemma 1: $p\not| a\Rightarrow ord_p(a^u)\in\{2^0, 2^1,...,2^k\}$. +Beweis des Lemmas: Wenn $p|a$, ist nichts zu zeigen. Sonst benutze, dass es ein $s$ mit s\varphi(N) =ed-1$ gibt. Dann gilt $(a^u)^{2^k}\equiv a^{s(p-1)(q-1)}\equiv (a^{p-1})^{s(q-1)}\equiv 1 (mod\ p)$ nach dem kleinen Satz von Fermat. Also ist (das gilt immer in Gruppen) die Ordnung von $a^u$ ein Teiler von $2^k$. Dies beweist das Lemma. + +Lemma 2: Wenn $p\not| a$ und $q\not| a$ und $ord_p(a^u)\not= ord_q(a^u)$, dann gibt es ein $i\leq k$ mit $ggT(N,(a^{u2^i}-1) mod\ N)\in\{p,q\}$. +Beweis des Lemmas: O.B.d.A.: $ord_p(a^u)>ord_q(a^u) = 2^i$, mit $i1$. Falls ja, ist $ggT(a, N)$ ein Primfaktor von $N$. Sonst berechne $ggT(N, a^{u 2^i}-1\ mod\ N)$, für $i=0,1,... , k$. Falls einer dieser Werte $>1$ ist, ist er ein Primfaktor von $N$. Was noch fehlt: Satz $|\{a\in\{1,...,N-1\}|ord_p(a^u)\not= ord_q(a^u)\}|\geq\frac{1}{2}\varphi(N)$. Der Satz, für dessen Beweis wir auf das Buch von Baumann, Franz, Pfitzmann verweisen, besagt, dass der Algorithmus mit Wahrscheinlichkeit mindestens $\frac{1}{2}$ erfolgreich einen Primfaktor von $N$ findet. +Konsequenz aus diesen Überlegungen: Wenn $d$ bekannt wird, darf man den Modulus $N$ keinesfalls weiter verwenden. +Im Wesentlichen ist also das vollständige Brechen des Systemsäquivalent dazu, $N$ in seine Faktoren zu zerlegen. Das Faktorisierungsproblem gilt bislang als im Allgemeinen schwierig und für das Produkt $N$ von zwei zufälligen Primzahlen mit 512 Bits (oder 1024 Bits) als praktisch nicht lösbar. +Man beachte aber: Den geheimen Schlüssel $d$ zu finden muss nicht die einzige Möglichkeit sein, aus $N,e$ und $y$ partielle Information über $x$ zu gewinnen, wie man am Jacobi-Symbol sieht. + +### Bemerkungen zum Faktorisierungsproblem, allgemein +Nach wie vor gibt es keinen Polynomialzeitalgorithmus, der beliebige zusammengesetzte Zahlen $N$ in ihre Primfaktoren zerlegen kann (äquivalent: in polynomieller +Zeit einen nichttrivialen Faktor von $N$ bestimmen kann). Allerdings gab es in den letzten Jahrzehnten auch gewaltige Fortschritte bei der Entwicklung immer besserer Verfahren. +- Pollards $(p-1)$-Methode (klassisch): Führt zu schneller Ermittlung eines Faktors von $N$, wenn für einen Primfaktor $p$ von $N$ gilt, dass $p-1$ nur kleine Primfaktoren hat. +- Pollards $ρ$-Methode (klassisch): Führt zur Ermittlung eines Faktors von $N$ in Zeit $O(\sqrt{p})$, wo $p$ ein Primfaktor von $N$ ist. Da $N$ immer einen Primfaktor in $O(\sqrt{n})$ hat, ist die Rechenzeit im schlechtesten Fall in $O(\sqrt[4]{n}) =O(2^{(log\ N)/ 4)})$. Schnell zum Ziel kommt man also, wenn $N$ einen kleinen Primfaktor $p$ hat. (Die oben angegebenen Vorschriften zur Wahl von $p$ und $q$ vermeiden diese Situation.) +- Quadratisches Sieb (Pomerance, 1981): Rechenzeit $O(e^{sqrt{(ln\ N)(ln\ ln\ N)}})$. +- Faktorisierung mit Elliptischen Kurven (Hendrik W. Lenstra, 1987): Rechenzeit $O(e^{(1+o(1)) \sqrt{(ln\ p)(ln\ ln\ p)}})$, wo $p$ der kleinste Primteiler von $N$ ist. +- Zahlkörpersieb (um 1990, zwei Varianten): Die schnellsten heute bekannten Faktorisierungsverfahren. Die anfallenden Rechnungen können auf vielen Rechnern parallel durchgeführt werden. Die Gesamtrechenzeit ist beschränkt durch $O(e^{C(ln\ N)^{\frac{1}{3}} (ln\ ln\ N)^{\frac{2}{3}}})$, für eine Konstante $C$. An der Verbesserung der Verfahren wird laufend gearbeitet. + +Der Rechenaufwand für die Faktorisierung auch nur 260-stelliger Zahlen in Dezimaldarstellung ist heute noch so immens, dass diese Art von Angriff auf das RSA-System noch nicht als ernsthafte Bedrohung angesehen wird. Das BSI (Bundesamt für Sicherheit in der Informationstechnik) empfiehlt für RSA-Anwendungen Schlüssellängen von 2000 Bits oder etwa 600 Dezimalziffern (bzw. 3000 Bits oder 900 Dezimalziffern, wenn auch Entwicklungen der nächsten Jahre mit einkalkuliert werden sollen.) +Wenn sich $p$ und $q$ nur geringfügig unterscheiden, lässt sich $N$ effizient faktorisieren. Man sollte also darauf achten, dass $p$ und $q$ in nicht mehr als etwa den ersten 20 Binärstellen übereinstimmen. Bei zufälliger Wahl wird dies mit sehr hoher Wahrscheinlichkeit eintreten. + +Es gibt ein RSA-spezifisches Angriffsverfahren (,,Iteration''), das effizient funktioniert, wenn $p-1$ und $q-1$ kleine Primfaktoren haben. Bei der Wahl von $p$ und $q$ ist also auch darauf zu achten, dass dies nicht der Fall ist (s. Buch von Buchmann). + +### Zufallskomponente +In der Praxis wird der Klartext $x\in\{0,1\}^w$ mit $w<\lfloor log\ N\rfloor$ durch Anhängen eines zufälligen Bitstrings $r$ auf Länge $\lfloor log\ N\rfloor$ gebracht und das Wort $x\circ r$ (Konkatenation von $x$ und $r$) wie beschrieben verschlüsselt. Die Zufallskomponentermacht den Verschlüsselungsalgorithmus $E$ zu einem randomisierten Verfahren. Der Empfänger muss natürlich ebenfalls die Länge $w$ kennen, um nach der Entschlüsselung aus $x\circ r$ die eigentliche Botschaft $x$ zu ermitteln. Dieses Vorgehen hat auch den Vorteil, dass selbst bei mehrmaligem Versenden derselben Botschaft (oder Wiederholung von Blöcken) unterschiedliche Chiffretexte entstehen und zum Beispiel die Parität der Anzahl der 1-Bits in $x\circ r$ sowie das letzte Bit von $x\circ r$ rein zufällig sind und keine Information über $x$ liefern. Auch das Problem mit dem Jacobisymbol wird damit entschärft, da $J_N(x\circ r)$ vermutlich einigermaßen zufällig sein wird. Zudem wird in realen Anwendungen noch eine ,,kryptographische Hashfunktion'' $h$ auf $x\circ r$ angewendet und der neue Klartext $x'=x\circ r\circ h(x\circ r)$ mit dem RSA-System verschlüsselt. Bob entschlüsselt zu $z\circ t\circ w$ und akzeptiert die Nachricht $z$ nur, wenn $h(z\circ t)=w$ ist. Vorteil hiervon: Manipulationen an der Nachricht werden erkannt, die Nachrichten-Integrität +ist gesichert. (Es bleibt das Problem sicherzustellen, dass die Nachricht tatsächlich von Alice gesendet worden ist.) + +### Effizienzverbesserungen +1. Wahl des Verschlüsselungsschlüssels $e$: +Mitunter wird vorgeschlagen, $e=3$ zu wählen, weil dann die Verschlüsselung besonders effizient vor sich geht. (Man benötigt nur zwei Multiplikationen modulo N.) Es gibt aber einen Angriff, der den Klartextxeffizient ermitteln kann, wenn drei Chiffretexte für $x$ mit verschiedenenöffentlichen Schlüsseln $(N_1,3),(N_2,3),(N_3,3)$ vorliegen. (Dies kann passieren, wenn Alice dieselbe Nachricht ohne Zufallskomponente an drei verschiedene Empfänger mit verschiedenen RSA-Schlüsseln schickt.) +Diesem Problem entgeht man, indem man etwa $e=2^{16}+1$ wählt. Auch in diesem Fall ist die Verschlüsselung billiger als im allgemeinen Fall, da man mit 17 Multiplikationen modulo N auskommt. + +2. Empfänger rechnet modulo $p$ und $q$, um Rechenzeit zu sparen: Da Bob $d$ kennt, können wir auch annehmen, dass er sogar die Faktoren $p$ und $q$ kennt. Dies kann zu einer Beschleunigung der Berechnung von $z=y^d\ mod\ N$ benutzt werden, wie folgt: Bob berechnet $z_p=y^d\ mod\ p$ und $z_q=y^d\ mod\ q$. Aus diesen beiden Zahlen bestimmt er mit dem Chinesischen Restsatz $z\in [N]$ mit $z\equiv z_p (mod\ p)$ und $z\equiv z_q(mod\ q)$. Dieses Vorgehen spart Rechenaufwand, da die Exponentiationen nur mit Zahlen der halben Länge durchgeführt werden müssen und die Anwendung des Chinesischen Restsatzes auf den erweiterten Euklidischen Algorithmus hinauslaufen, der eine deutlich kleinere Rechenzeit als eine Exponentiation hat. +Eine Überschlagsrechnung ergibt, dass sich durch dieses Vorgehen der Rechenaufwand für die Entschlüsselung etwa um den Faktor 4 verringert. (Man beachte, dass dies die im vorherigen Abschnitt diskutierte Erweiterung des Klartextes um einen Zufallsstring und einen Hashwert kompensiert.) + +### Das Rabin-Kryptosystem +Es ist nicht bekannt, ob das Problem, RSA-verSchlüsselte Botschaften unberechtigterweise zu entschlüsseln, äquivalent zum Faktorisierungsproblem ist. Wir betrachten hier noch das Rabin-Verschlüsselungsverfahren, bei dem dies der Fall ist. Auch beim Rabin-Verfahren handelt es sich um ein Public-Key-Kryptosystem. + +*Schlüsselerzeugung* (Bob oder Trust Center): Wähle zwei verschiedene zufällige große Primzahlen $p$ und $q$ mit $p\equiv q\equiv 3 (mod\ 4)$, also Primzahlen, die um 1 kleiner als ein Vielfaches von 4 sind. Berechne $N=pq$. Der öffentliche Schlüssel ist $k=N$; der geheime Schlüssel ist $\hat{k}= (p,q)$. + +*Verschlüsselung* eines Blocks, der eine Zahl $x1$, ist sie fertig, denn dieser größte gemeinsame Teiler ist entweder $p$ oder $q$. Andernfalls berechnet sie $y=x^2\ mod\ N$. Dann wendet sie ihr Entschlüsselungsverfahren an und berechnet ein $z=B(y)$ mit $z^2 \equiv y\ mod\ N$. Dieses $z$ hängt wohlgemerkt nicht von $x$, sondern nur von $y$ ab. Es gilt $x^2\equiv z^2 +(mod\ N)$. Wie oben gesehen gibt es vier Möglichkeiten: +1. $x\equiv z (mod\ p)$ und $x\equiv z (mod\ q)$ +2. $x\equiv z (mod\ p)$ und $x\equiv -z (mod\ q)$ +3. $x\equiv -z (mod\ p)$ und $x\equiv z (mod\ q)$ +4. $x\equiv -z (mod\ p)$ und $x\equiv -z (mod\ q)$ + +Welche dieser Möglichkeiten die richtige ist, hängt vom Zufall ab, der die Auswahl von $x$ steuert. Jede der 4 Quadratwurzeln von $y$ hat dieselbe Wahrscheinlichkeit $1/4$, als $x$ gewählt worden zu sein. + +1. Fall: $x=z$, Misserfolg. +2. Fall: $0<|x-z|< N$ und $x-z$ durch $p$ teilbar, woraus $ggT(x-z,N) =p$ folgt: Erfolg! +3. Fall: $0<|x-z|< N$ und durch $q$ teilbar, woraus $ggT(x-z,N) =q$ folgt: Erfolg! +4. Fall: $x+z=N$, also $x-z\equiv 2x(mod\ N)$. Weil $2x$ teilerfremd zu $N$ ist, ergibt sich $ggT(x-z,N)=1$, Misserfolg. + +Eva muss also nur $ggT(x-z,N)$ berechnen! Damit gelingt es ihr mit Wahrscheinlichkeit $1/2$, die Faktoren von $N$ zu ermitteln. Durch l-fache Wiederholung desselben Experiments lässt sich die Erfolgswahrscheinlichkeit auf $1-\frac{1}{2^l}$ erhöhen. + +## Diskrete Logarithmen und Anwendungen +### Diskrete Logarithmen +Wir betrachten eine endliche zyklische Gruppe $(G,\circ,e)$ (multiplikativ geschrieben) mit einem erzeugenden Element $g$. Das bedeutet : $G=\{g^0=e,g^1=g,g^2,...,g^{|G|- 1}\}$. Sei $N=|G|$ die Größe (,,Ordnung'') dieser Gruppe. Dann haben wir: +- Die Exponentiationsabbildung $exp_g:\{0,1,...,N-1\}\rightarrow G, a\rightarrow g^a$, ist eine Bijektion (sogar ein Gruppenisomorphismus zwischen $(\mathbb{Z}_N,+,0)$ und $(G,\circ,e)$). +- Die Umkehrfunktion $log_g:G\rightarrow\{0,1,...,N-1\},g^a\rightarrow a$, heißt der diskrete Logarithmus zur Basis $g$. +- Das DL-Problem für $G$ und $g$ bezeichnet die Aufgabe, zu gegebenem $h\in G$ den Exponenten $a=log_g (h) \in\{0,1,...,N-1\}$ zu berechnen, also den Exponenten $a$ mit $g^a=h$. + +Für alle kryptographischen Verfahren, die mit zyklischen Gruppen arbeiten, müssen die Gruppenelemente eine explizite Darstellung haben, auf denen die Gruppenoperationen $\circ$ und $^{-1}$ effizient ausführbar sind. +Dann ist auch die Exponentiation $a\rightarrow h^a$ effizient ausführbar (mit $\leq 2 log\ a$ Gruppenoperationen), mittels einer Variante der schnellen modularen Exponentiation. Das DL-Problem darf jedoch keinen (bekannten) effizienten Algorithmus haben. +Als Gruppen $G$ kommen u.a. in Frage: +- Für Primzahlen $p$: Die multiplikative Gruppe $\mathbb{Z}^*_p$ mit Grundmenge $\{1,...,p-1\}$ und Multiplikation modulo $p$ als Operation. Die Ordnung (d.h. die Größe) dieser Gruppe ist bekanntermaßen $N=p-1$. Siehe die folgende Tabelle. Es ist ein recht einfacher Fakt aus der Zahlentheorie, dass diese Gruppe für jede Primzahlpzyklisch ist, also ein erzeugendes Element $g$ hat. Die Gruppenoperationen sind effizient ausführbar: Die Gruppenoperation $\circ$ ist die Multiplikation modulo $p$; das neutrale Element ist die 1; zu gegebenem $h\in G$ kann man $h^{-1}$ mit dem erweiterten Euklidischen Algorithmus berechnen. Für $p$ mit 2048 Bits oder mehr, wobei $p-1$ einen ,,großen'' Primteiler enthält, gilt das DL-Problem als praktisch nicht lösbar (für ,,allgemeine'' $a$). +- Die multiplikative Gruppe eines beliebigen endlichen Körpers, z. B. $GF(2^k)$. Es muss nur sichergestellt sein, dass die Multiplikation im Körper effizient ausführbar ist. Hierfür benötigt man ein irreduzibles Polynom von Grad $k$ und man muss Implementierungen von Polynommultiplikation und -Division haben. Für das Bilden von Inversen kann man den Potenzierungstrick benutzen oder den erweiterten Euklidischen Algorithmus für Polynome. Schließlich muss ein erzeugendes Element der multiplikativen Gruppe $GF(2^k)^*$ bekannt sein. (Die Kardinalität der Gruppe sollte mindestens $2^{2000}$ sein.) +- Zyklische Untergruppen von ,,elliptischen Kurven'' über endlichen Körpern. (Hier genügen Körperelemente mit einer Bitlänge von 256 Bits.) + +Tabelle: Die multiplikative Gruppe $\mathbb{Z}^*_{11}$ für $p=11$ mit erzeugendem Element $g=2$. Die erzeugenden Elemente sind mit $*$ markiert. Sie entsprechen den Potenzen $g^a$ mit $ggT(a,10) = 1$. + +| a | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | +| ----- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | +| $2^a$ | 1 | 2 | 4 | 8 | 5 | 10 | 9 | 7 | 3 | 6 | +| | | * | | * | | | | * | | * | + +Für kryptographische Anwendungen ungeeignetist dagegen die bekannteste zyklische Gruppe $(\mathbb{Z}_N,+,0)$. Hier ist die Gruppenoperation die Addition modulo $N$; die Potenz $g^a$ für $a\in\mathbb{Z}$ entspricht dem Element $a*g\ mod\ N$. Die erzeugenden Elemente sind gerade die Elemente von $\mathbb{Z}^*_N$. Wenn $g\in\mathbb{Z}^*_N$ ist, dann besteht das DL-Problem für $g$ in folgendem: Gegeben $h=g^a$ (in der Gruppe gerechnet, das ist also $h=a*g\ mod\ N)$, finde $a$. Dies ist mit dem erweiterten Euklidischen Algorithmus leicht möglich: finde $g-1\ mod\ N$, berechne $h*g^{-1}\ mod\ N$. Das DL-Problem in dieser Gruppe ist also effizient lösbar. +Wenn eine zyklische Gruppe $G$ mit effizienten Operationen gefunden worden ist, muss man immer noch ein erzeugendes Element finden. Das ist unter Umständen nicht ganz einfach. Wir wissen: +- Eine zyklische Gruppe $G=〈g〉$ mit $|G|=N$ hat genau $\varphi(N) = |\mathbb{Z}^*_N|$ viele erzeugende Elemente, nämlich die Elemente $g^a$ mit $a\in\mathbb{Z}^*_N$. + +Das bedeutet, dass ein Anteil von $\varphi(N)/N$ der Elemente von $G$ erzeugende Elemente sind. Aus Kapitel 4 wissen wir, dass $\varphi(N)/N=\prod_{p\ ist\ prim, p|N}(1-\frac{1}{p})$ gilt. Man kann zeigen, dass dies $\Omega(1/log\ log\ N)$ ist. Wir können also analog zum Vorgehen bei der Primzahlerzeugung ein erzeugendes Element finden, wenn wir folgende Operationen zur Verfügung haben: +1. zufälliges Wählen eines Elements von $G$ +2. Test, ob $h\in G$ ein erzeugendes Element ist oder nicht + +Jedoch setzen alle bekannten effizienten Verfahren für den Test ,,Ist $h$ erzeugendes Element?'' voraus, dass man die Primfaktoren von $N=|G|$ kennt. +Für den Fall $G=\mathbb{Z}^*_p$ ist die Situation so: Für große zufällige Primzahlen $p$ (512, 1024 oder 2048 Bits) ist die Primfaktorzerlegung von $N=p-1$ normalerweise nicht leicht zu ermitteln. Ein Ausweg ist, gezielt nach Primzahlen $p$ zu suchen, für die $p-1$ eine übersichtliche Primfaktorzerlegung hat. Besonders angenehm ist die Situation, wenn $p=2q+1$ für eine Primzahl $q$ ist. +In dieser Situation gibt es genau $q-1=(p-3)/2$ erzeugende Elemente und man kann ein $x\in G$ durch schnelle Exponentiation darauf testen, ob es ein erzeugendes Element ist. Man erhält direkt ein randomisiertes Verfahren, das nach durchschnittlich zwei Tests ein erzeugendes Element gefunden hat. +Alle im Folgenden beschriebenen kryptographischen Verfahren werden unsicher, wenn man in der verwendeten Gruppe das DL-Problem effizient lösen kann. Bei der Verwendung solcher Verfahren muss man also unbedingt darauf achten, keine Gruppen zu benutzen, bei denen praktikable Verfahren für das DL-Problem bekannt sind. +Für das Folgende nehmen wir an, dass die verwendete Gruppe diesen Mindestanforderungen genügt. + +### Diffie-Hellman-Schlüsselaustausch +Sei $G$ eine zyklische Gruppe mit Erzeuger $g$ und sei $(X,G,Y,e,d)$ ein symmetrisches Kryptosystem wie in Kapiteln 1 und 2 oder $(G,E,D)$ ein symmetrisches Kryptoschema wie in Kapitel 3. (Das heißt, dass die Elemente von $G$ die Schlüssel sind.) Nehmen wir an, Alice und Bob möchten per Kommunikationüber einen öffentlich (insbesondere von Eva) einsehbaren Kanal einen gemeinsamen, geheimen, zufälligen Schlüssel $k\in G$ festlegen. Das Diffie-Hellman-Schlüsselaustausch-Protokoll macht dies möglich! +Die Idee dabei ist, dass $k=g^{ab}$ ist, wo nur Alice $a$ kennt und nur Bob $b$. Über den öffentlichen Kanal laufen die Gruppenelemente $g^a$ und $g^b$. Eva hat also das Problem, aus $g^a$ und $g^b$ den Wert $g^{ab}$ zu berechnen. (Das ist das sogenannte DH-Problem, +benannt nach W. Diffie und M. E. Hellman, die das Schlüsselaustauschverfahren 1976 vorgeschlagen haben.) Wenn Eva das DL-Problem lösen könnte, wäre dies leicht. Andere Möglichkeiten, das DH-Problem effizient zu lösen, ohne einen effizienten Algorithmus für das DL-Problem, sind prinzipiell denkbar, aber nicht bekannt. + +*Protokoll ,,Diffie-Hellman-Schlüsselaustausch''* +- Voraussetzung: Alice and Bob kennen $G,|G|$ und $g$. +1. Alice wählt $a\in\{2 ,...,|G|- 2\}$ zufällig, und sendet $A=g^a$ an Bob. +2. Bob wählt $b\in\{2 ,...,|G|-2\}$ zufällig, und sendet $B=g^b$ an Alice. +3. Alice berechnet $B^a= (g^b)^a=g^{ab}=k$. +4. Bob berechnet $A^b= (g^a)^b=g^{ab}=k$. + +Dabei wird benutzt, dass die Multiplikation der Exponenten $a$ und $b$ kommutativ ist. Alice und Bob kennen nun $k$; Eva kennt nur $A$ und $B$, sowie (nach dem Kerckhoffs-Prinzip) $G$ und $|G|$. + +Achtung! Das DH-Protokoll in der hier vorgestellten Form wird völlig unsicher, wenn Eva den Kommunikationskanal nicht nur abhört, sondern aktiv eingreifen kann. + +,,Man-in-the-middle-attack'': Eva fängt alle Nachrichten von Alice an Bob und umgekehrt ab und modifiziert sie. + +Schlüsselvereinbarung: Alice sendet $A=g^a$. Eva fängt $A$ ab, wählt selbst eine Zufallszahl $a'$ und schickt $A'=g^{a'}$ an Bob. Dieser nimmt an, $A'$ käme von Alice. Sein $B=g^b$ wird ebenfalls von Eva abgefangen und durch $B'=g^{b'}$ ersetzt, für ein von Eva gewähltes $b'$. Alice nimmt an, $B'$ käme von Bob. + +Senden eines Chiffretextes: Wenn Alice Nachricht $x$ an Bob schicken möchte, verwendet sie Schlüssel $k'= (B')^a=g^{ab'}$ und sendet $y'=E(x,k')$. Eva fängt dies ab und entschlüsselt mittels $k'=A^{b'}$. Sie kennt nun $x$, berechnet $k''=B^{a'}$ und schickt $E(x,k'')$ an Bob. Dieser entschlüsselt mittels $k''= (A')^b$, und erhält wieder $x$. + +Um das DH-Protokoll gegen solche Angriffe abzusichern, muss man andere Protokolle (sog. Authentifizierungsprotokolle) benutzen, die es ermöglichen herauszufinden, ob der Absender einer Nachricht tatsächlich der gewünschte Partner (Alice bzw. Bob) ist. + +### Das ElGamal-Kryptosystem +Das ElGamal-Kryptosystem steht in engem Zusammenhang mit dem DH-Schlüsselaustausch. Wie RSA ist auch dieses System ein Public-Key-Kryptosystem. Seine Sicherheit beruht nicht auf der (vermuteten) Schwierigkeit des Faktorisierungsproblems wie RSA, sondern auf der (vermuteten) Schwierigkeit des DL-Problems bzw. des DH-Problems. + +*Erzeugung* des Schlüssels (Bob oder Trust-Center im Auftrag von Bob): Es wird eine zyklische Gruppe $(G,\circ,e)$ mit einem erzeugenden Element $g$ benötigt, sowie $N=|G|$, so dass das zugehörige DH-Problem schwer zu lösen ist. Ein Element $b$ wird zufällig aus $\{2 ,...,|G|-2\}$ gewählt, und es wird mittels schneller Exponentiation $B=g^b$ berechnet. Der öffentliche Schlüssel ist $k_{pub}= (G,g,B)$, der geheime Schlüssel ist $b$ bzw. $k_{priv}=(G,g,b)$. + +*Verschlüsselung*: Wir nehmen an, dass die Menge der möglichen Botschaften (Binärstrings) eine Teilmenge von $G$ ist. Um eine Botschaft $x\in G$ zu verschlüsseln, wählt Alice eine Zufallszahl $a$ aus $\{2,...,|G|-2\}$ und berechnet $A=g^a$. Weiter berechnet sie $y:=B^a \circ x$. Der Chiffretext ist $(A,y)$. + +Kommentar: Der Rechenaufwand liegt im Wesentlichen in den zwei schnellen Exponentiationen. RSA benötigt eine schnelle Exponentiation. Man erkennt die Komponenten $A$ und $B$ aus dem Diffie-Hellman-Schlüsselaustausch wieder. Der Wert $B^a$ ist $k=g^{ab}$, der Wert $y$ ist $k\circ x$. + +*Entschlüsselung*: Bob kennt die Gruppe $G$ und $g$, sowie $A$ und $y$ (von Alice) sowie seinen geheimen Schlüssel $b$. Er berechnet $A^b= (g^a)^b=k$. Dann berechnet er das Gruppenelement $z=k^{-1}\circ y$, mit Hilfe der effizienten Invertierung und Gruppenoperation in $G$. + +*Beobachtung*: $z=x$. (Das ist klar: $z=k^{-1}\circ y=k^{-1}\circ(k\circ x) =x$) + +Kommentar: Der Rechenaufwand der Entschlüsselung liegt im Wesentlichen in der schnellen Exponentiation und der Invertierung von $k$. + +*Sicherheit*: Man kann sichuberlegen, dass für eine Angreiferin Eva und eine Gruppe G mit erzeugendem Element $g$ folgende Situationen äquivalent sind: +1. Eva kann alle mit dem ElGamal-Verfahren bzgl. $G$ und $g$ verschlüsselten Nachrichten effizient entschlüsseln, also aus $B$, $A$ und $y$ die Nachricht $x$ berechnen, die zum Chiffretext $(A,y)$ geführt hat. +2. Eva kann das DH-Problem für $G$ lösen. + +Wenn Eva diskrete Logarithmen bezüglich $G$ und $g$ berechnen kann, gelten natürlich 1. und 2. Wir beweisen die Äquivalenz. + +- ,,1.$\Rightarrow$2.'': Eva hat $B=g^b$ und $A=g^a$ vorliegen und möchte $k=g^{ab}$ bestimmen. Sie wendet ihr Entschlüsselungsverfahren auf $B$, $A$ und $y=1$ an. Es ergibt sich ein Wert $x$ mit $g^{ab}\circ x=k\circ x=y=1$. Es gilt also $x=k^{-1}$, und Eva kann $k$ durch Invertierung von $x$ in $G$ berechnen. +- ,,2.\Rightarrow$1.'': Eva hat $B=g^b$,$A=g^a$,$y=g^{ab}\circ x$ vorliegen. Weil sie das DH-Problem lösen kann, kann sie $k=g^{ab}$ berechnen und damit natürlich $x=k^{-1}\circ y$ bestimmen. + +Unterschiede zwischen RSA und ElGamal: +- RSA in der puren Form benötigt einen Chiffretext $y=x^e\ mod\ N$, der die gleiche Bitlänge hat wie der Klartext $x$. ElGamal hat einen doppelt so langen Chiffretext $(B,y)$. +- ElGamal ist erzwungenermaßen randomisiert. Daher führt die wiederholte Verschlüsselung desselben Klartextes $x$ stets zu unterschiedlichen Chiffretexten, weil der Schlüssel $k$ zufällig ist. + +Allerdings gibt es die Empfehlung, beim Arbeiten mit RSA den Klartext $x$ durch das Anhängen eines nicht ganz kurzen Zufallsstrings zu +randomisieren. Wenn dieser angehängte Zufallsstring die gleiche Länge wie $x$ hat, ist der Chiffretext genauso lang wie bei ElGamal. + +### Berechnung diskreter Logarithmen +Wie schwierig ist das ,,DL-Problem''? + +Geg.: Zyklische Gruppe $(G,\circ,e),|G|=N,$ mit erzeugendem Element $g$. + +Input: $h\in G$ + +Gesucht: $a$ mit $0\leq a 10^{36}$, und an eine Ausführung von ,,Enumeration'' ist nicht zu denken. + +Babystep-Giantstep-Algorithmus von Shanks: +Wähle $m=\lceil \sqrt{N}\rceil$. Der gesuchte Exponent $a$ hat eine Zerlegung $a=bm+c$, für $0\leq c < m$ und passendes $b\leq a/m < N/m\leq \sqrt{N}$. +- Es gilt: $h=g^a=g^{bm+c}=g^{bm} \circ g^c$, also $g^{-c}=h^{-1}\circ g^{bm}$. +- Gesucht: $b$ und $c$. +- Algorithmus: Berechne alle Potenzen $g^{bm}$, $0\leq b < N/m$, und speichere $h^{-1}\circ g^{bm}$ (als Schlüssel) mit Wert $b$ in einer Hashtabelle $T$, Umfang $2N/m\leq 2\sqrt{N}$. Berechne $g^{-c}$, für $c=0,1,...,m-1$ und suche $g^{-c}$ in $T$. Wenn gefunden, gilt $h^{-1} \circ g^{bm}=g^{-c}$, also $h=g^{bm+c}$. +- Rechenzeit: $O(\sqrt{N})$ (erwartet) für Tabellenaufbau und $O(\sqrt{N})$ (erwartet) für die Suche, zusammen $O(\sqrt{N})$. +- Platzbedarf: $O(\sqrt{N})$ +- Wenn $N=2^{200}$, ist $\sqrt{N}= 2^{100}> 10^{30}$. Selbst wenn man nur in dem unwahrscheinlichen Fall $a\leq 2^{160}$ erfolgreich sein möchte, muss man Tabellengröße $2^{80}> 10^{24}$ veranschlagen. Auch dies ist nicht durchführbar. + +Pollards $ρ$-Algorithmus für DL +Idee: Definiere eine Folge $(x_i,a_i,b_i),i= 0,1,2,...,$ in $G\times\mathbb{Z}_N\times\mathbb{Z}_N$, so dass $x_i=F(x_{i-1})$ gilt, für eine als zufällig geltende Funktion $F:G\rightarrow G$. Dann verhalten sich die ersten Komponenten $x_i$ wie zufällige Elemente in $G$, solange noch keine Wiederholung in der Folge $(Z_i)_{i=0, 1 , 2 ,...}$ aufgetreten ist. Nach dem Geburtstagsparadoxon weiß man, dass für eine genügend große Konstante $K$ die Wahrscheinlichkeit, dass $K\sqrt{N}$ zufällig gewählte Elemente von $G$ alle verschieden sind, sehr klein ist. Wir erwarten also nach $O(\sqrt{N})$ Schritten die Wiederholung eines Elements, also $i_0< j_0=O(\sqrt{N})$ mit $x_{i_0}= x_{j_0}$. Danach wiederholt sich die Folge: $x_{i_0 +1}= F(x_{i_0}) =F(x_{j_0}) = x_{j_0 +1}$, usw., also gilt $x_i=x_{i+kl}$ für alle $i\geq i_0$ und alle $k\geq 1$, wenn man $l=j_0 -i_0$ definiert. Man kann das Verhalten der Folge wie folgt zeichnen: $x_0,...,x_{i0}$ als gerade Linie ohne Wiederholung, daran angehängt $x_{i0},...,x_{j0}=x_{i0}$ als Kreis. Dies gibt die Form ,,$ρ$'', wie beim griechischen Buchstaben ,,rho''. Wenn man es nun noch schafft, aus zwei Indizes $i < j$ mit $x_i=x_j$ den gesuchten Exponenten $a$ mit $h=g^a$ auszurechnen, ist man fertig. +Um den Algorithmus auszuführen, muss man scheinbar $x_0,x_1,...,x_{j0-1}$ speichern, was wieder zu Speicherplatzbedarf $Θ(\sqrt{N})$ führen würde. Es gibt nun einen Trick, mit dessen Hilfe man nur Platz $O(1)$ benötigt. Man beobachtet die Doppelfolge $((x_i,x_{2i}))_{i=0, 1 , 2 ,...}$ und wartet, bis $x_i= x_{2i}$ gilt. Gibt es solche $i$? Ja, denn für jedes $i\geq i_0$, für das $2i-i=i$ durch $l=j_0-i_0$ teilbar ist, ist $x_{2i}=x_{i+kl}$ für ein $k>0$, also $x_{2i}=x_i$. Zwischen $i_0$ und $j_0$ liegt auf jeden Fall ein solches $i$. Nun müssen wir noch $F$ definieren. Dazu betrachten wir erweiterte Elemente $(x,b,c)\in G\times\mathbb{Z}_N \times\mathbb{Z}_N$, die die Gleichung $x=g^b \circ h^c$ erfüllen. Das Starttripel ist $(g^{b0},b_0,0)$ für ein zufällig gewähltes $b_0$. Die Gruppe $G$ muss in etwa drei gleich große disjunkte Teilmengen $S_1,S_2,S_3$ aufgeteilt sein, etwa über die letzten 10 Bits der Darstellung der Elemente. Dann definieren wir die Schrittfunktion wie folgt: +$$f(x,b,c) =\begin{cases} (h\circ x,b,c+1)\,\quad\text{ falls }x\in S_1\\ (x^2, 2b, 2c),\quad\text{ falls }x\in S_2\\ (g\circ x,b+1,c),\quad\text{ falls } x\in S_3 \end{cases}$$ +Beachte, dass mit $(x,b,c)$ auch $f(x,b,c)$ die geforderte Gleichung erfüllt. Die Funktion $F$ ist einfach die Einschränkung von $f$ auf die erste Komponente. +Nun berechnen wir in Runden $Y_i= (x_i,b_i,c_i)$ und $Z_i= (x_{2i},b_{2i},c_{2i})$, für $i=0,1,2,....$ (Es ist $Y_0=Z_0=(g^{b0},b_0,0)$ für $b_0$ zufällig und $Y_i=f(Y_{i-1})$ und $Z_{2i}=f(f(Z_{i-1}))$.) + +Dies wird so lange durchgeführt, bis zum ersten Mal $x_i=x_{2i}$ gilt. Dann haben wir: $g^{b_{2i}} h^{c_{2i}}=g^{b_i} h^{c_i}$, also $g^{b_{2i}+ac_{2i}}=g^{b_i+ac_i}$. Weil $g$ Ordnung $N$ hat, folgt $b_{2i} +ac_{2i}\equiv b_i+ac_i (mod\ N)$, das heißt $a(c_{2i}-c_i)\equiv b_i-b_{2i} (mod\ N)$. +Falls nun $ggT(c_{2i}-c_i,N) = 1$ ist, können wir mit $a= (b_i-b_{2i})(c_{2i}-c_i)^{-1}\ mod\ N$ den gesuchten Exponenten berechnen. +Die Rechenzeit ist $O(\sqrt{N})$, wenn man unterstellt, dass die Abbildung $F:x_{i-1}\rightarrow x_i$ rein zufällig ist. (In der Praxis bestätigt sich diese Vorstellung.) +Weitere Algorithmen für das DL-Problem: +- Pohlig-Hellman-Algorithmus. Dieser Algorithmus benötigt die Primfaktorzerlegung von $N=|G|$. Seine Rechenzeit ist $O(\sum_{1 \leq i\leq k} e_i(log|G|+\sqrt{p_i}) + (log\ |G|)^2)$, wenn $|G|$ die Primfaktorzerlegung $p^{e_1}_1... p^{e_k}_k$ hat. Dieser Algorithmus ist also effizient, wenn $|G|$ nur eher kleine Primfaktoren hat. Wenn man also mit $G$ arbeiten will, muss $N=|G|$ mindestens einen ,,großen'' Primfaktor enthalten, damit nicht der Pohlig-Hellman-Algorithmus das DL-Problem effizient löst. +- Indexkalkül. Dieser Algorithmus ist nur für die multiplikative Gruppe $GF(q)^*$ in endlichem Körper $GF(q)$ anwendbar. +- Zahlkörpersieb. Ebenso nur für $GF(q)^*$ (mit ähnlichen subexponentiellen Rechenzeiten wie bei dem gleichnamigen Algorithmus bei der Faktorisierung). + +Letzteres ist eine allgemeine Beobachtung: DL in $GF(q)^*$ scheint nicht viel schwieriger zu sein als das Faktorisierungsproblem für Zahlen in der Größenordnung von $q$. + +### Elliptische Kurvenuber endlichen Körpern +Elliptische Kurven (,,elliptic curves'', ,,EC'') sind mathematische Strukturen, die eine moderne, attraktive Methode zur Erzeugung endlicher zyklischer Gruppen zur Verwendung in der Kryptographie liefern. Der Ansatz wurde 1985 unabhängig von den amerikanischen Mathematikern Neal Koblitz (\*1948) und Victor S. Miller (\*1947) vorgeschlagen. Der große Vorteil des Verfahrens ist, dass die unter gewissen Umständen schnellen DL-Verfahren für $GF(q)^*$, nämlich Indexkalkül und Zahlkörpersieb, nicht anwendbar sind. Die benötigte Gruppengröße, um ,,Sicherheit'' im praktischen Sinn zu garantieren, ist deutlich kleiner als die bei der zyklischen Gruppe $GF(q)^*$. Dies führt zu Gruppenelementen mit kleinerer Darstellungsgröße und daher effizienterer Verfahren für Verschlüsselung und Entschlüsselung. +(Übliche Längen im Jahr 2016: Bestehende Verfahren benutzen 160 Bits, Planung bis 2030: 224 oder 256 Bits. Ein System, das $\mathbb{Z}^*_p$ für eine 256-Bit-Primzahl $p$ benutzt, gilt als äußerst sicher. Andere endliche Körper kommen ebenfalls in Frage. Vorsicht bei $GF(2^k)^*$! Man benötigt andere Formeln als die unten diskutierten!) + +Wir geben nur eine Beschreibung der Verfahren. Für mathematischen Hintergrund sei auf die Literatur verwiesen, z.B. A. Werner, Elliptische Kurven in der Kryptographie, Springer 2002, oder Diekert, Kufleitner, Rosenberger, Diskrete algebraische Methoden, de Gruyter 2013. + +Als anschaulichen Hintergrund, nicht zur Anwendung in der Kryptographie, betrachten wir zunächst Elliptische Kurven in $\mathbb{R}^2$. Gegeben seien Koeffizienten $A, B$ in $\mathbb{R}$, die die Ungleichung $4A^3+ 27B^3 \not= 0$ erfüllen. (Diese Bedingung hat zur Folge, dass die Funktion $x\rightarrow x^3+Ax+B$ keine Mehrfachnullstellen hat, weder im Reellen noch im Komplexen. Dabei heißt $a\in C$ eine Mehrfachnullstelle, wenn man $x^3+Ax+B= (x-b)(x-a)^2$ schreiben kann, für ein $b\in C$.) Betrachte die Menge $\{(x,y)\in\mathbb{R}^2| y^2=x^3+Ax+B\}$. +Diese bildet eine ,,Kurve'' in $\mathbb{R}^2$. Verschiedene Formen sind möglich. Die ,,Kurve'' kann auch mehrere Komponenten haben. Man beobachtet allgemein: Die Punktmenge ist symmetrisch bezüglich der x-Achse; die ,,Gestalt'' hängt von der Lage der Nullstellen von $x\rightarrow x^3+Ax+B$ ab. Veranschaulichung für $(A,B)\in\{(- 1 ,-1),(- 1 ,0),(- 1 ,1)\}$ später. Da Doppelnullstellen ausgeschlossen sind, gibt es eine oder drei Nullstellen. +Solche Kurven, eventuell ergänzt um einen Punkt $O$, nennt man Elliptische Kurven in $\mathbb{R}^2$. + +Unsere eigentliche Konstruktion benutzt nicht $\mathbb{R}$, sondern endliche Körper $\mathbb{Z}_p$ für eine Primzahl $p>3$. Wir rechnen ab hier in einem solchen Körper, für festes $p$; die Operationen $+$ und $*$ sind immer als Addition und Multiplikation modulo $p$ zu interpretieren. + +Definition 5.13: Sei $p >3$ eine Primzahl, seien $A,B\in\mathbb{Z}_p$ mit $4A^3+ 27B^3 \not= 0$. Die elliptische Kurve $E_{A,B}$ besteht aus der Menge aller Lösungen $(x,y)\in\mathbb{Z}^2_p$ der Gleichung $y^2=x^3+Ax+B$ sowie einem zusätzlichen Punkt $O$ (genannt ,,der unendliche Punkt''). +Wenn man für $\mathbb{Z}_p$ die Repräsentanten $-\frac{p-1}{2},..., 0 , ...,\frac{p-1}{2}$ benutzt, beobachtet man wiederum die Symmetrie entlang der x-Achse, sonst gibt es kein erkennbares Muster. + +Beispiel: $\mathbb{Z}_7$. Setze $f(x)=x^3+ 3x+ 3$ (in $\mathbb{Z}_7$) und betrachte $E_{3,3}=\{(x,y)\in\mathbb{Z}^2_7 | f(x)=y^2\}\cup \{O\}$. Damit $(x,y)$ zu $E_{3,3}$ gehört, muss $f(x)$ ein Quadrat sein. Allgemein weiß man, dass es in $\mathbb{Z}_p$ genau $\frac{p-1}{2}$ Quadrate gibt. Jedes $f(x)$, das von $0$ verschieden und ein Quadrat ist, führt zu zwei Punkten auf der elliptischen Kurve. Weiter gibt es für jedes $x$ mit $f(x) = 0$ einen Punkt auf der Kurve. Man rechnet aus: + +| x | 0 | 1 | 2 | 3 | 4 | 5 | 6 | +| -------- | --- | ----- | --- | ----- | ----- | --- | --- | +| f(x) | 3 | 0 | 3 | 4 | 2 | 3 | 6 | +| Quadrat? | - | X | - | X | X | - | - | +| Wurzeln | | 0 | | 2, 5 | 3, 4 | | +| Punkte | | (1,0) | | (3,2) | (4,3) | +| | | | | (3,5) | (4,4) | | + +Um auf dieser Menge eine Gruppenstruktur festzulegen, benötigen wir ,,Geraden'' in $\mathbb{Z}^2_p$. Dies sind Punktmengen $\{(x,y)|y=ax+b\}$ für $a,b\in\mathbb{Z}_p$ oder $\{(x,y)|x=b\}\cup\{O\}$ (,,senkrechte Geraden''). Man stellt nun (durch Unterscheiden verschiedener Fälle) Folgendes fest: Wenn eine Gerade eine elliptische Kurve $E=E_{A,B}$ in mindestens einem Punkt schneidet, dann sogar in drei Punkten, die aber nicht notwendigerweise verschieden sein müssen. (Das liegt an der Anzahl der Nullstellen von $x^3+Ax+B$. Veranschaulichung im Reellen!) +Wenn zwei der betrachteten Schnittpunkte zusammenfallen, ist die Gerade eine Tangente in diesem Punkt; bei senkrechten Geraden gilt der unendliche Punkt als einer der Schnittpunkte oder gar als drei zusammenfallende Schnittpunkte. +Die Operation $\circ$ kann dann anschaulich wie folgt beschrieben werden (man verwendet wieder für einen Moment die Bilder im $\mathbb{R}^2$): Gegeben seien Punkte $P$ und $Q$ auf der elliptischen Kurve, beide von $O$ verschieden. Man legt eine Gerade durch $P$ und $Q$ (wenn sie identisch sind, eine Parallele zur Kurve in $P$) und bestimmt den dritten Punkt $R$ im Schnitt von Kurve und Gerade. Wenn $R=O$ ist, ist $P\circ Q=O$, wenn $R= (x,y)\not=O$, dann ist $P\circ Q=\overline{R}= (x,-y)$ (Spiegelung an der x-Achse). +Weiter definiert man: $P\circ O=O\circ P=P$ für alle Punkte $P$. + +Es ergeben sich (mit einigem Rechnen) die folgenden Formeln. Diese werden dann wörtlich auch als Definition für eine Operation $\circ$ in einer elliptischen Kurve über $\mathbb{Z}_p$ benutzt. +- $O+O=O,$ +- $O+ (x,y) = (x,y) +O$ für alle $(x,y)\in\mathbb{Z}^2_p$, +- $(x_1,y_1) + (x_2,y_2) =\begin{cases} O,\quad\text{ falls } x_1=x_2 \text{ und } y_1=-y_2 \\ (x_3,y_3),\quad\text{ sonst,}\end{cases}$ + +wobei $(x_3,y_3)$ folgendermaßen berechnet wird: $x_3=\lambda^2-x_1-x_2$, $y_3=\lambda(x_1-x_3)-y_1$ mit $\lambda=\begin{cases} (y_2-y_1)/(x_2-x_1),\quad\text{ falls } (x_1,y_1)\not= (x_2,y_2)\\ (3x^2_1+A)/(2y_1),\quad\text{ falls } (x_1,y_1) = (x_2,y_2)\end{cases}$. +Der erste Fall bezieht sich auf den dritten Schnittpunkt einer Geraden durch zwei Punkte; der zweite auf den Tangentenfall. + +Satz 5.14: Mit dieser Operation $\circ$ bildet $E_{A,B}$ eine kommutative Gruppe. + +Man beweist dies durch Nachrechnen. Der Nachweis der Assoziativität ist etwas mühselig. Das zu $(x,y)$ inverse Element ist $(x,-y)$, das zu $O$ inverse Element ist $O$. + +Notation: Die Gruppenoperation in Gruppen zu elliptischen Kurven wird additiv geschrieben, also mit $+$ bezeichnet. Das Inverse von $P$ heißt $-P$. Die wiederholte Verknüpfung eines Elementes mit sich selbst ist dann eine Multiplikation mit $a\in\mathbb{Z}$, etwa $2P, 3P,...$. +Beispiel: Wenn $P=(x,0)$, dann gilt $P=-P$ und $2P=O$. + +Wir benötigen zyklische Untergruppen von $E_{A,B}$. Damit eine solche Gruppe ein schwieriges DL-Problem hat, muss sie natürlich groß sein, also muss auch $E_{A,B}$ groß sein. Wenn die Funktion $f(x) =x^3+Ax+B$ wie eine zufällige Funktion wirkt, wird sie für etwa die Hälfte der $x$ einen Wert haben, der ein Quadrat ist, und alle diese Werte (außer der $0$) führen zu zwei Punkten auf der Kurve. Nullstellen ergeben einen Punkt. Wir erwarten daher, dass $E_{A,B}$ etwa $p$ Elemente hat, und Folgendes sollte nicht zu sehr überraschen. + +Fakt 5.15 Hasse-Schranke: Sei $E$ elliptische Kurve über $\mathbb{Z}_p$. Dann gilt $p+ 1- 2\sqrt{p}\leq |E|\leq p+1 + 2\sqrt{p}$. + +Es gibt einen ,,effizienten'' Algorithmen zur Ermittlung der Gruppenordnung $N=|E|$ der höchstens $O((log\ p)^6)$ Gruppenoperationen benötigt. Wenn wir Glück haben, ist $N$ eine Primzahl; dann ist jedes Element von $E-\{O\}$ ein erzeugendes Element. Ein Standardverfahren ist, die Wahl von $A$ und $B$ so lange wiederholen, bis $N=|E_{A,B}|$ eine Primzahl $q$ ist. Dann wird ein Element $P$ aus $E-\{O\}$ zufällig gewählt und $(p,A,B,N,P)$ an den Kunden abgeliefert. Mit $p$ und $A$ kann man die Gruppenoperationen implementieren, mit $P$ und $N$ zusätzlich kann man den Diffie-Hellman-Schlüsselaustausch und das ElGamal-Kryptoschema umsetzen. +Standardverfahren für das DL-Problem (Pollards $ρ$-Algorithmus, Pohlig-Hellman) funktionieren auch für Gruppen, die zu elliptischen Kurven gehören, nicht aber die viel schnelleren Verfahren wie Indexkalkül oder Zahlkörpersieb. Dies führt dazu, dass man annimmt, dass in EC-basierten Gruppen das DL-Problem (noch) schwieriger zu lösen ist als in $\mathbb{Z}^*_p$, so dass man mit kleineren Zahlbereichen arbeiten kann, was Verschlüsselung und Entschlüsselung wieder effizienter macht. + +*Effizienter Einsatz*: Wenn man versucht, das ElGamal-Kryptosystem auf der Basis einer elliptischen KurveEumzusetzen, gibt es das Problem, dass die Elemente von $E$ in $\mathbb{Z}^2_p$ eher dünn sind, so dass die Menge $E$ oder auch die Menge der x- +Koordinaten von Punkten in $E$ als Klartextmenge schlecht geeignet ist. Wie soll man also gewöhnliche Nachrichten auf Punkte auf der Kurve abbilden? Es gibt ein reales kryptographisches Verfahren, das zeigt, wie man diese Schwierigkeit umgeht: ,,Elliptic Curve Integrated Encryption Scheme (ECIES)''. Es beruht darauf, nur für die Manipulationen auf der Schlüsselseite die Gruppe $E$ zu benutzen, und die eigentliche Verschlüsselung in $\mathbb{Z}^*_p$ auszuführen. Das reale ECIES-Verfahren integriert noch ein symmetrisches Verschlüsselungsverfahren und ,,message authentication'' (ein ganz anderes kryptographisches Elementarwerkzeug). Wir geben hier nur den Kern an, der ein asymmetrisches Kryptosystem darstellt. Es gibt Anklänge an das ElGamal-Kryptosystem, aber Unterschiede im Detail. +Mit eingebaut ist ein Verfahren, das Elemente von $E-\{O\}$ kompakt darstellt: Anstelle von $(x,y)\in\mathbb{Z}^2_p$ speichern wir $x$ und ein Bit $b$. Im Allgemeinen gibt es keinen oder zwei Punkte auf $E_{A,B}$ mit erster Koordinate $x$ (außer bei den Nullstellen von $f$). Wenn $f(x)=x^3+Ax+B\not= 0$ ein Quadrat in $\mathbb{Z}_p$ ist, gibt es zwei passende Werte $y_1$ und $y_2$ mit $y_1+y_2=p$, von denen einer gerade und einer ungerade ist. Diese beiden Situationen werden durch $b$ unterschieden. + +$$Point-Compress: E-\{O\}\rightarrow\mathbb{Z}_p \times\{0,1\},(x,y)\rightarrow (x,y\ mod\ 2)$$ + +Dies ist eine injektive Funktion. Die Umkehrfunktion Point-Decompress benötigt die Funktion ,,Quadratwurzel modulo $p$'', die effizient berechnet werden kann, wenn $p+1$ durch $4$ teilbar ist, siehe ,,Entschlüsselung beim Rabin-Kryptosystem''. Daher verwendet man in der EC-Kryptographie vorzugsweise solche Primzahlen. Wenn man eine (und damit beide) Quadratwurzeln von $f(x)$ berechnet hat, wählt man als $y$ die gerade/ungerade davon, je nachdem ob $b=0$ oder $b=1$ ist, und gibt $(x,y)$ aus. + +*Simplified ECIES* +Gegeben (und allen Beteiligten bekannt): Elliptische Kurve $E=E_{A,B}$ über $\mathbb{Z}_p$ (also $p,A,B$), zyklische Untergruppe $G=〈P〉$ mit erzeugendem Element $P$, Kardinalität $N=|G|$, wobei $N$ eine Primzahl ist. Wir unterdrücken diese Angaben im Folgenden. +(Sie sind aber Teil des öffentlichen Schlüssels und natürlich auch dem Empfänger Bob bekannt.) + +*Klartextmenge*: $X=\mathbb{Z}^*_p$. + +*Chiffretextmenge*: $Y=(\mathbb{Z}_p \times\{0,1\})\times\mathbb{Z}^*_p$. +- (Paare aus: (komprimiertes) Element von $G$ und Element von $\mathbb{Z}^*_p$). +- Öffentliche Schlüssel: $K_{pub}=G$. Private Schlüssel: $K_{priv}=\mathbb{Z}_N$. +- Schlüsselmenge: $K=\{(Q,b)|Q\in K_{pub} = G,b\in K_{priv} =\mathbb{Z}_N,Q=bP\}$. + +*Schlüsselerzeugung*: (Gegeben sind $E$ [also $p,A,B$], $P$, $N$.) +- Wähle $b\in\mathbb{Z}_N$ zufällig und berechne $Q=bP$ (schnelle Exponentiation). +- Schlüssel:$(Q,b)$. +- Der öffentliche Schlüssel ist $k_{pub}=Q$. +- Der private Schlüssel ist $k_{priv}=b$. + +*Verschlüsselungsfunktion* $E:X\times G\rightarrow Y$, als randomisierter Algorithmus. +- Gegeben: Klartext $x\in\mathbb{Z}^*_p$. +- Öffentlicher Schlüssel $Q\in G$. +- Wähle zufällig $a\in\mathbb{Z}_N$ und berechne $(k,y) =aQ$ mit $k\in\mathbb{Z}^*_p$. //(Falls $k=0$, wähle neues $a$.) +- Berechne $E^a (x,Q)\leftarrow (Point-Compress(aP),x*k\ mod\ p) =: (y',y'');$ das Paar $(y',y'')\in(\mathbb{Z}_p\times\{0,1\})\times\mathbb{Z}^*_p$ ist der Chiffretext. + +Bemerkung: $k\in\mathbb{Z}^*_p$, die erste Komponente eines Punktes in $G$, wird durch eine Operation in $G$ erstellt, und dann wie beim One-Time-Pad (oder beim Vernam-System) benutzt, wobei diese Verschlüsselung durch Multiplikation in $\mathbb{Z}^*_p$ ausgeführt wird. + +*Entschlüsselungsfunktion* $D:Y\times\mathbb{Z}_N \rightarrow X$, als (deterministischer) Algorithmus. +- Gegeben: Chiffretext $y=(y',y'')$ mit $y'\in\mathbb{Z}_p\times\{0,1\}$ und $y''\in\mathbb{Z}^*_p$. Privater Schlüssel $b$. +- Berechne $(x_1,y_1)\leftarrow Point-Decompress (y')$ //nun gilt $(x_1,y_1) =aP$ +- $(x_0,y_0)\leftarrow b(x_1,y_1)$ (in $G$, nun gilt $(x_0,y_0) = (ba)P=a(bP) =aQ= (k,y))$, und schließlich in $\mathbb{Z}^*_p$ +- $D((y',y''),b)\leftarrow y''*(x_0)^{-1}\ mod\ p$. + +Behauptung: Wenn $Q=bP$, dann gilt $D(E^a (x,Q),b) =x$, für jedes $x\in X$ und jedes $a$, für das $(k,y) =aQ\in\mathbb{Z}^*_p \times\mathbb{Z}_N$. (Dies gilt nach den Anmerkungen in der Beschreibung von $E$ und $D$.) + + + + +# Anhang: Beweis von Satz 3.8 +Wir b eweisen Satz 3.8. Gegeb enist alsoein l-Blo ck-KS B, aus dem wir mitdem R- +CTR-Betriebsmo duseinKryptoschemaS=R-CTR(B)gewinnen.Gegeb enistweiterein +(n,q,t)-b eschränkterl-AngreiferA= (AF,AG).Wirwollenzeigen,dassmanausAeinen +UnterscheiderfürBgewinnen kann,derimWesentlichen dieHälftedes VorteilsvonA +gegenS=R-CTR(B)hat. + +Manerinnere sichan Definition2.11. DasSpiel(Exp eriment) GBU wählt inFormeines +Zufallsbitsbdie ,,Welt'' ,indergespieltwird,undstelltdemUnterscheiderUeineentspre- +chendeBlo ckchiffreFzurVerfügung. + +- Wennb= 1,istF eineChiffree(.,k)zuB( ,,Realwelt'' ),mitzufälligemSchlüsselk. +- Wennb= 0,istF einezufälligePermutationvon{ 0 , 1 }l( ,,Idealwelt'' ).üsolleineVermutungabgeb en,welcherderb eidenFällezutrifft.DieIdeedernunfolgenden +Konstruktionist,dassU imWesentlichen das SpielGSA fürA ausführtunddab eiden +VerschlüsselungsalgorithmusHF b enutzt,dersichausderChiffreF mitderBetriebsart +R-CTR ergibt. Dazu startet U den Findungsteil AF von A, der ein Paar(z 0 ,z 1 ) von +Klartextenerzeugt.DannwähltU zufällig(miteinemZufallsbitcaus{ 0 , 1 })einender +b eidenaus:zc.DerChiffretexty=HF(zc)wirdAGvorgelegt,dereinAntwortbitc'liefert. +(DiesesBitsollte,wennderAngreifergutistundF vonBherstammt,ehergleichc'als +verschiedenvon c' sein.)Wenn c= c', vermutetU ,,Realwelt'' ,gibt alsob' = 1 zurück, +sonstvermutetU ,,Idealwelt'' undantwortetmitb' = 0.U gewinntdasSpiel,wenndas +Ausgab ebitb'mitbüb ereinstimmt. + +ImFall b = 0liegen dieErfolgschancen fürU sehrnahe an\frac{1}{2} , wiewir sehen werden, +daHF sichselbstunterBerücksichtigungderInformationen,dieAF undAG sammeln, +fastwieeineVernam-Chiffreverhält,unddaherderChiffretextzuz 0 eb ensowiederzu +z 1 einfachwieeinZufallsstringaussieht,sodassU keineMöglichkeithat,dieb eidenzu +unterscheiden.ImFallb = 1hingegenist derAblauf vonGBU genauderdesSpiels GSA +vonAmitS=R-CTR(B),unddieErfolgswahrscheinlichkeitvonUentsprichtdemdieses +Spiels.Kombinationderb eiden Fälleergibt,dassderVorteilvonU bisaufFehlerterme +dieHälftedesVorteilsvonAist.Detailsfolgen. + +Wirb eschreib enzunächstdieArb eitsweisevonUimDetail.Ub ekommteineBlo ckchiffre +F:{ 0 , 1 }l\rightarrow { 0 , 1 }lalsVerschlüsselungsorakelzurVerfügunggestellt.ü b enutztden AngreiferA = (AF,AG)als Unterprogramm.Von denProgrammteilen +AF undAG vonAwerdenOrakelanfragengestellt,diefordern,dassTextex\in { 0 , 1 }l** +verschlüsseltwerden.DieseAnfragenb eantwortetU,indemesdieChiffreF inR-CTR- + + +Betriebsart,alsodenVerschlüsselungsalgorithmusHF einsetzt.DasentsprechendeUnter- +programmvonUheißtSim: + +Sim(x:{ 0 , 1 }l**,F:{ 0 , 1 }l\rightarrow { 0 , 1 }l) :{ 0 , 1 }l** + +//Inputx:Klartext,F:Blo ckchiffre(alsOrakel);Outputy:Chiffretext. + +1.r\leftarrow flip(l) //Zufallszahlin[2l] ={ 0 , 1 }l + +2.t\leftarrow |x|/l; //AnzahlderBlö ckeinx,alsox= (x_0 ,...,xt- 1 ) + +3.y\leftarrow (r,F(r)\oplus_l x_0 ,F((r+ 1) mod 2l)\oplus_l x 1 ,...,F((r+t-1) mod 2l)\oplus_l xt- 1 ) + +4.returny + +WennwirimFolgendenAF(Sim(.,F))schreib en,meinenwir,dassderFindungsteilvon +Aaufgerufenwird,wob eiOrakelanfragenvonAFfürxmitSim(x,F)b eantwortetwerden. +AnalogistAG(Sim(.,F))zuinterpretieren.üarb eitetmitgegeb enemVerschlüsselungsorakelF:{ 0 , 1 }l\rightarrow { 0 , 1 }lwiefolgt.DieIdee +ist,dassUdasSpielGA...durchführt,wob eialsVerschlüsselungsverfahrenfürdasKrypto- +schemadieR-CTR-BetriebsartvonF b enutztwird.JenachdemobAdab eidasrichtige +o derdasfalscheErgebniserhält,tipptUauf ,,Realwelt'' bzw. ,,Idealwelt'' . + +1. Findungsphase + (z 0 ,z 1 ,v)\leftarrow AF(Sim(.,F)). + //FindungsteilvonA;OrakelanfragenwerdenmitSim(.,F)b eantwortet. + //vsinddieNotizenvonA. +2. Auswahl //Wählezufälligz 0 o derz 1 ,verschlüssle,Ergebnisisty + c\leftarrow flip(),y\leftarrow Sim(zc,F). +3. Ratephase + c'\leftarrow AG(v,Sim(.,F),y). + //RateteilvonA;OrakelanfragenwerdenmitSim(.,F)b eantwortet. +4. Auswertung + return[c=c'] + +NachdenRegelnfürSzenario 2 darfdieBlo ckverschlüsselungF nichtmehrfachfürden- +selb enBlo ckaufgerufenwerden.Beidemangegeb enenVerfahrenkanndiesab er(aufgrund + + +der zufälligenWahldes Startwertsr b eiden Aufrufenvon Sim)durchaus vorkommen. +WirzähleneinesolcheAbfragenichtalsneuenAufruf.OhnedassdiesimProgrammtext +ausgeführtist,solltemansichvorstellen,dassUbzw.dasSpielGBUeineDatenstrukturfür +allebisherb enanntenBlö ckesunddieschonabgefragtenWerteF(s)mitführtundb eider +AusführungvonSimimmernachsieht,obF(s)füreinenBlo cksschonb ekanntist.Der +AufwandhierfürwirdinderRechenzeitvonUb erücksichtigt.Wirdiskutierendiesganz +amEndedesBeweises. + +WirerinnernunsandieDefinitionvonsuc(U,B)(WahrscheinlichkeitfürAntwort 1 inder +Realwelt)undfail(U)(WahrscheinlichkeitfürAntwort 1 inderIdealwelt)undLemma2.14 +mitderFormel +adv(U,B) = suc(U,B)-fail(U). (1.5) + +Zielist,eineuntereSchrankefüradv(U,B)zub eweisen.Wiranalysierendieb eidenTerme +separat.Dazugeb enwirsuc(U,B)anundb eweisenundeineob ereSchrankefürfail(U). +Dasersteisteinfach,daszweitetechnischetwasaufwendiger. + + ,,Realwelt'' :Hieristb= 1undF:{ 0 , 1 }l \rightarrow { 0 , 1 }l einedurchdenzufälliggewählten +Schlüsselkb estimmteChiffree(.,k)vonB.Wiranalysierensuc(U,B) = Pr(SUB〈b= 1〉= +1).Mansiehtsofort,dassU genaudasinDefinition3.3b eschrieb eneSpielfürAundS +ausführt,unddassdaherdieWahrscheinlichkeitfürdasErgebnis ,,1'' genauPr(GSA= 1) +ist.Wegenadv(A,S) = 2Pr(GSA= 1)- 1 gilt + + +suc(U,B) = Pr(GSA= 1) = + + +1 + adv(A,S) +2 + +. (1.6) + + ,,Idealwelt'' :NunwendenwirunsderAnalysevonfail(U) = Pr(SUB〈b= 0〉= 1)zu.Diesist +dieWahrscheinlichkeit,dassUinderSituation ,,Idealwelt'' ,inderFeineZufallsp ermutation +ist,dasrichtigeBitc'=causgibt.Wirwerdensehen,dassdieseWahrscheinlichkeitnur +unwesentlichvon\frac{1}{2} abweichenkann,wennlgenügendgroßist.(Dannergibtsichmit(1.6), +dassadv(U,B)\approx \frac{1}{2} adv(A,S)gilt.)Wirmüsseneineob ereSchrankefürfail(U)angeb en. +Wirb emerkenzunächst,dassdasSup erskriptBinSUB〈b= 0〉redundantist,dasichdieser +AlgorithmusaufdieIdealweltb ezieht,inderBkeineRollespielt.Wirschreib endaherim +FolgendendafürSU〈b= 0〉. + +Wirwissen,dassderAngreiferAinsgesamtnicht mehralsqOrakelanfragenstelltund +dassdab eidieAnzahlderb etroffenenl-Bit-Blö ckenichtgrößeralsnist.Wirkönnensogar +o. B. d. A. annehmen,dassdie Anzahlder verschiedenenb eim Ablauf vonU insgesamt +verschlüsseltenBlö ckeexaktnist, fallsnicht,lassenwirUeinfach,außerhalbvonSim, +dieVerschlüsselung derfehlenden Anzahl von neuenBlö cken anfordern,ohne dassdas +ErgebniseineAuswirkungaufdieAusgab evonUhat. + + +Ersetzung von Zufallsp ermutationen durch Zufallsfunktionen Umdie weitere +Arb eitzuvereinfachen,b etrachtenwireinenleichtverändertenWahrscheinlichkeitsraum +fürF.Wirnehmennämlichan,dassalsOrakelfürdieBlo ckchiffrenichteineZufallsp er- +mutationF,sonderneinereinzufälligeFunktionF' von{ 0 , 1 }l nach{ 0 , 1 }l,verwendet +wird.^33 Hierist esalsoerlaubt,dassF'(s 1 ) = F'(s 2 )fürBlö ckes 1\not= s 2 ist.Derneue +Wahrscheinlichkeitsraumheißt$\Omega$',dieWahrscheinlichkeitsfunktiondarinPr'.Esstelltsich +heraus,dasseskeinengroßenUnterschiedmacht,welchenderb eidenRäumemanb enutzt, +solangennichtzugroßunddieBlo cklängelnichtzukleinist. + +Behauptung1: |Pr(SU〈b= 0〉= 1)-Pr'(SU〈b= 0〉= 1)|\geq + + +n^2 +2 l+1 + +. + +Bemerkung:DieseBehauptungliefertoffenbareinenTeildesFehlertermsinSatz3.8. + +Beweis vonBehauptung 1:Definiere Ereignisse (fürb eide Wahrscheinlichkeitsräumein +gleicherWeise),unterBezugnahmeaufdenAblaufdesSpielsfürUmitb= 0.Indiesem +AblaufgibtesgenaunAnfragenzuverschiedenenBlö ckenandasOrakelF.(DerAblauf +selb er,undumwelcheBlö ckeessichhandelt,hängtauchvomZufallab.)Betrachtedie +folgendenEreignisse: + + +Di:={diei-teAnfrageanFlieferteinResultatin{ 0 , 1 }l,dasvorherschonvorkam}, + +füri= 1,...,n,undD:= + +⋃ + +1 \geq i\geq nDi. Dann ist DdiedisjunkteVereinigungderEreignisse +Di\cap D 1 \cap D 2 \cap ***\cap Di- 1 .Wirhab en + + +Pr'(Di\cap D 1 \cap D 2 \cap ***\cap Di- 1 )\geq Pr'(Di|D 1 \cap D 2 \cap ***\cap Di- 1 ) = + + +i- 1 +2 l + +, (1.7) + +(diei-teAnfragelieferteinenderi- 1 vorherausgegeb enenWerte),also + + +Pr'(D)\geq + +\sum + + +1 \geq i\geq n + + +i- 1 +2 l + += + + +n(n-1) +2 * 2 l + +< + + +n^2 +2 l+1 + +. (1.8) + +BedingtaufdenTeilwahrscheinlichkeitsraumD= $\Omega$'-DistdieFolgedernverwendeten +F'-WerteeinereinzufälligeFolgein{ 0 , 1 }lmitderZusatzeigenschaft,dassdieWertealle +verschiedensind.Diesistab ergenaudieselb eSituation,diewirerhaltenwürden,wennwir +imOriginalwahrscheinlichkeitsraummiteinerZufallsp ermutationFarb eitenwürden.Das +heißt: +Pr(SU〈b= 0〉= 1) = Pr'(SU〈b= 0〉= 1|D). + +Wegen(1.7) genügtes fürden BeweisderBehauptung,mitder AbkürzungC fürdas +Ereignis{SU〈b= 0〉= 1}Folgendeszuzeigen: + + +|Pr'(C|D)-Pr'(C)|\geq Pr'(D). (1.9) + +(^33) DiesistkeinewirklicheVerschlüsselungsfunktion,sondernnureinmathematischesKonstrukt. + + +(Diesgiltimmer,völliggleichgültigwasCist.)Nunist + +Pr'(C)\geq Pr'(C\cap D) = Pr'(C|D)Pr'(D) = Pr'(C|D)(1-Pr'(D))\geq Pr'(C|D)-Pr'(D). + +Andererseitsist + + +Pr'(C) = Pr'(C|D)Pr'(D) + Pr'(C|D)Pr'(D)\geq Pr'(C|D) + Pr'(D). + +Damitist (1.9)unddamitdieBehauptunggezeigt.Ab hierarb eitenwiralsoin$\Omega$'mit +einerZufallsfunktionF'. + +Wirüb erlegennun,wiedieArgumenteb estimmtwerden,fürdiedieZufallsfunktionF' +aufgerufenwird.VonAF,b eiderVerschlüsselungvonzcundvonAG werdendemUnter- +programmSim(.,F')(biszu)qKlartextex(1),...,x(q)mitt 1 ,...,tqBlö ckenzurVerschlüs- +selungvorgelegt,indieserReihenfolge,mitt 1 +***+tq\geq n.Dab eiwerdeninSim(x(i),F') +dietiArgumenter(i),...,(r(i)+ti-1) mod 2lfürF'b enutzt,füreinereinzufälligeZahl +r(i)\in [2l].Wirb etrachtendasEreignis + + +W:={unterdenalsArgumentfürF'b enutztenBlö ckengibtesWiederholungen},ündschätzenPr'(W)ab.DazudefinierenwirIntervalle + + +Ii:={r(i),...,(r(i)+ti-1) mod 2l} + +(gegeb enenfallsmitWraparound,wennr(i)+ti> 2 l),für 1 \geq i\geq q.Für beliebig eWerte +i < i'b etrachtenwirdasEreignis + + +Wi,i':={Ii\cap Ii'\not=\varnothing}. + + Dann ist Pr'(Wi,i')\geq (ti+ti')/ 2 l.(Umdieszusehen,darfmansichIiundti' alsdurch +denAblauf bisvorder Wahlvon r(i +') +schonfestgelegtvorstellen.Nurr(i +') +wirdzufällig +gewählt.)Mit + + +W\subseteq + +⋃ + + +2 \geq i'\geq t + +⋃ + + +1 \geq i1 sucht man einen echten Faktorx 1 vonx(d. h. +1 < x 1 < xundx 1 y 1 =xfür einy 1 ), dann einen echten Faktorx 2 vonx 1 usw., bis +man einen echten Faktorxkvonxerhält, der selber keinen echten Faktor hat. Dieses +xkist ein Primfaktor vonx, man kann alsox=x'*xkschreiben. Aufx'wendet man +die Induktionsvoraussetzung an. + +Die Eindeutigkeit sieht man wie folgt mit einem indirekten Beweis: Annahme: Es +gibt einxmit unterschiedlichen Primfaktorzerlegungen. Wähle das kleinste solche +xund unterschiedliche Primfaktorzerlegungenp 1 ***pk undq 1 ***ql vonx. Aus der +Minimalität vonxfolgt, dass in der Listep 1 ,...,pk keine der Primzahlenq 1 ,...,ql +vorkommt. Nun teiltq 1 die Zahlx=p 1 ***pk. Nach Fakt 4.27, wiederholt angewendet, +teiltq 1 einen der Faktorenp 1 ,...,pk, etwapi. Weilq 1 undpiPrimzahlen sind, muss +q 1 =pigelten, ein Widerspruch. + +Beweisvon Fakt 4.16: + +,, +\Rightarrow '': Es seiabmodm= 1. Das heißt: Es gibt einq\in\mathbb{Z}mitab-qm= 1. Wenn nun +eine Zahld >0 sowohlaals auchmteilt, dann teiltdauchab-qm= 1, also ist +d= 1. Also sindaundmteilerfremd. + + +,, + +\Leftarrow '':aundmseien teilerfremd. Nach Lemma 4.6(a) gibt esx,y\in\mathbb{Z}mitxa+ym= 1. +Setzeb:=xmodm. Dann gilt: + +(a*b) modm= (a*(xmodm)) modm=axmodm= 1, +d. h.bist ein multiplikatives Inverses vona. + +Beweis von Fakt 4.18: Natürlich ist die 1 das neutrale Element der Multiplikation +in\mathbb{Z}_m und in $\mathbb{Z}^*$ m. Wir bemerken zuerst, dass $\mathbb{Z}^*$ m unter Multiplikation modulo m +abgeschlossen ist: Seienxund yzumteilerfremd. Nach Lemma 4.6(a) kann man +1 =sx+tm=uy+vmschreiben, und erhält daraus + +1 = (sx+tm)(uy+vm) = (su)(xy) + (sxv+tuy+tvm)m. +Daraus folgt, dass jeder gemeinsame Teiler vonxyundmauch 1 teilen muss, also ist +ggT(xy,m) = 1. + +Nach Fakt 4.16 hat jedes Elementxvon $\mathbb{Z}^*$ mein multiplikatives Inversesy\in\mathbb{Z}m. Weil +natürlichxauch das Inverse vonyist, folgt nach Fakt 4.16 auch, dassy\in\mathbb{Z}*mist. + +Kommutativität ist klar. + +Beweisvon Fakt 4.19: Die zweiteAquivalenz ist klar: Der Ring \mathbb{Z}_m ist nach Definition +ein Körper genau dann wenn jedes Element von\mathbb{Z}_m -{ 0 }ein multiplikatives Inverses +besitzt. + +ErsteAquivalenz: + +,, + +\Rightarrow '': Sei meine Primzahl. Dann ist jedesa \in { 1 ,...,m- 1 }= \mathbb{Z}_m -{ 0 } zum +teilerfremd; nach der Definition folgt $\mathbb{Z}^*$ m=\mathbb{Z}_m -{ 0 }. + +,, +\Leftarrow '': Seimeine zusammengesetzte Zahl, etwa durchkmit 2\leq k < mteilbar. Dann +ist k = ggT(k,m) > 1, also kannk nach Fakt 4.16 kein multiplikatives Inverses +modulomhaben. (Man sieht auch direkt, dasskbmodm=kb-qmdurchkteilbar +ist, also für kein bgleich 1 sein kann.) + +Beweisvon Fakt 4.21: Wir beschränken uns darauf, die Bijektivität zu beweisen. Als +erstes bemerkt man, dass\mathbb{Z}_m nund\mathbb{Z}_m \timesZnbeide genaum*nElemente haben. Daher +reicht es zu zeigen, dass die Abbildung \Phi injektiv ist. Seien dazu 0\leq x\leq y < mn +beliebig mit \Phi (x) = \Phi (y). Das heißt:xmodm=ymodmundxmodN=ymodN. +Das wiederum heißt, dassm|(y-x) undn|(y-x) gilt. Nach Fakt 4.8 folgt, dass + + +mnTeiler vony-xist. Nun ist 0\leq y-x < mn, worausy-x= 0, alsox=y, folgt. +Damit ist die Injektivität von \Phi bewiesen. + +Beweisvon Prop. 4.22: Seix\in\mathbb{Z}*mn. Dann gibt es in $\mathbb{Z}^*$ mnein Inversesymitxymod +mn= 1. Daraus folgtxymodm= 1, also istx modm\in\mathbb{Z}*m. Die entsprechende +Aussage für nergibt sich analog. - Umgekehrt müssen wir zeigen, dass für u\in\mathbb{Z}*mund +v\in\mathbb{Z}*ndie eindeutig bestimmte Zahlx\in\mathbb{Z}mmit \Phi (x) = (xmodm,xmodn) = (u,v) +teilerfremd zumnist. Wähle Inversesvonuin $\mathbb{Z}^*$ mundtvonvin $\mathbb{Z}^*$ nund wähle nach +dem Chinesischen Restsatzymit \Phi (y) = (s,t). Dann giltxymodm=usmodm= 1 +undxymodn=vtmodn= 1, also nach der Eindeutigkeitsaussage im Chinesischen +Restsatzxymodmn= 1, alsox\in\mathbb{Z}*mn. + +Beweisvon Satz 4.25: +Man geht genauso vor wie im Beweis des kleinen Satzes von Fermat. Sei xmit +ggT(m,x) = 1 gegeben. Da wir modulomrechnen, können wirxdurchxmodm +ersetzen, d. h., wir können annehmen, dass 1\leq x < mgilt. Betrachte die Abbildung +gx: $\mathbb{Z}^*$ m 3 s7\rightarrow xsmodm\in\mathbb{Z}*m. (Um zu sehen, dass diese Abbildung wohldefiniert +ist, erinnere man sich, dass mitxund sauchxsteilerfremd zumist.) Diese Ab- +bildung ist injektiv, weil für das multiplikative Inverse yvonxin $\mathbb{Z}^*$ mdie Gleichung +y*gx(s) modm=yxsmodm=sgilt. Weil $\mathbb{Z}^*$ mendlich ist, muss die Abbildunggx +sogar bijektiv sein. Das heißt:{gx(s)|s\in\mathbb{Z}*m}= $\mathbb{Z}^*$ m. Daher: + +\prod +s\in\mathbb{Z}*m +s\equiv +\prod + +s\in\mathbb{Z}*m +gx(s)\equiv +\prod + +s\in\mathbb{Z}*m +xs\equiv x\varphi(m)* +\prod + +s\in\mathbb{Z}*m +s (modm). +Die Zahl ( + +\prod + +s\in\mathbb{Z}*ms) modmist teilerfremd zum, hat also ein multiplikatives Inverses +z in $\mathbb{Z}^*$ m. Wenn wir beide Seiten der Gleichung mit z multiplizieren, erhalten wir +1 \equiv x\varphi(m) (modm). diff --git a/Logik und Logikprogrammierung.md b/Logik und Logikprogrammierung.md new file mode 100644 index 0000000..29564f6 --- /dev/null +++ b/Logik und Logikprogrammierung.md @@ -0,0 +1,3524 @@ +# Logik +Die Logik +- versucht, gültige Argumentationen von ungültigen zu unterscheiden, +- hat Anwendungen in der Informatik, +- formalisiert die zu untersuchenden Aussagen und +- beschränkt sich auf einen wohldefinierten Teil der möglichen Aussagen => es gibt verschiedene "Logiken", z.B. "Aussagen-" und "Prädikatenlogik" + - daneben: + - temporale Logiken (Mastervorlesung "Verifikation") + - modale Logiken + - epistemische Logiken + - ... + + +## Syllogismen +Aristoteles (384-322 v.Chr.) untersuchte das Wesen der Argumentation und des logischen Schließens mit dem Ziel, korrekte von inkorrekten Argumenten zu unterscheiden. +Verschiedene Werke, u.a. Analytica priora, Analytica posteriora. + +Aristoteles nennt die logischen Schlußfolgerungen Syllogismen (griechisch: "Zusammenrechnung"). + +Ein Syllogismus ist eine Aussage, in der bestimmte Dinge [die Prämissen] behauptet werden und in der etwas anderes [die Konsequenz], unumgänglich aus dem Behaupteten folgt. Mit dem letzten Satz meine ich, dass die Prämissen die Konsequenz zum Resultat haben, und damit meine ich, dass keine weitere Prämisse erforderlich ist, um die Konsequenz unumgänglich zu machen. + +#### Beispiele +``` +Wenn alle Menschen sterblich sind und +Sokrates ein Mensch ist, +dann ist Sokrates sterblich. +``` +``` +Wenn eine Zahl gerade und größer als zwei ist, +dann ist sie keine Primzahl. +``` +``` +Wenn die Leitzinsen hoch sind, +dann sind die Börsianer unzufrieden. +``` + +Aristoteles identifizierte einige zulässige Syllogismen, die Scholastiker fügten weitere hinzu: + +(Barbara) +``` +Alle Dackel sind Hunde Alle P sind M +Alle Hunde sind Tiere Alle M sind S +Dann sind alle Dackel Tiere Alle P sind S +``` + +(Cesare) +``` +Keine Blume ist ein Tier Kein P ist M +Alle Hunde sind Tiere Alle S sind M +Dann ist keine Blume ein Hund Kein P ist S +``` + +(Darapti) +``` +Alle Delfine leben im Meer Alle M sind P +Alle Delfine sind Säugetiere Alle M sind S +Dann leben einige Säugetiere im Meer Einige S sind P +``` + +### Kalküle +Gottfried Wilhelm Leibniz (1646-1716) wollte korrekte von inkorrekten Argumentationsketten unterscheiden. Hierzu sollte ein Kalkül entwickelt werden, in dem alle korrekten Argumentationsketten ermöglicht sind (und keine inkorrekten). + +David Hilbert (1862-1943) entwickelte solche Kalküle. +Diese "Hilbertkalküle" sind sehr verschieden von üblichen Argumentationsmustern. + +Gerhard Gentzen (1909-1945) entwickelte Kalküle des "natürlichen Schließens", die übliche Argumentationsmuster formalisieren. + +### Die Aussagenlogik +George Boole (1815 - 1864) entwickelte einen Kalkül zum Rechnen mit atomare Aussagen, die entweder wahr oder falsch sein können. + +Verknüpfung durch Operatoren(und, oder, nicht, wenn-dann... ). + +### Die Prädikatenlogik (Ende des 19. Jahrhunderts) +Gottlob Frege (1848-1925), Giuseppe Peano (1858-1932) und Bertrand Russell (1872-1970)entwickelten die Logik zur Grundlage der Mathematik, als formale Basis für die Vermeidung von Widersprüchen. +Entwicklung der Prädikatenlogik, die erlaubt: +- Beziehungen zwischen "Objekten" zu beschreiben +- existentielle Aussagen zu treffen: "es gibt ein x, so dass... " +- universelle Aussage zu treffen: "für jedes x gilt, dass... " + + +## Logik in der Informatik +Claude Shannon (1916 - 2001) benutzt die Aussagenlogik 1937, um elektromechanische Schaltkreise zu beschreiben und zu optimieren. + +Allen Newell (1927-1992), Herbert Simon (1916-2001) und Alan Robinson (1930-2016) entwickelten 1950-1960 die ersten Systeme für die Automatisierung des logischen Schließens als Werkzeug der Künstlichen Intelligenz. + +- Schaltkreisentwurf: Schaltkreise lassen sich durch logische Formeln darstellen -> Entwurf und Optimierung von Schaltungen +- Modellierung und Spezifikation: Eindeutige Beschreibung von komplexen Systemen +- Verifikation: Beweisen, dass ein Programm das gewünschte Verhalten zeigt +- Datenbanken: Formulierung von Anfragen an Datenbanken -> Abfragesprache SQL (Structured Query Language) +- (klassische) Künstliche Intelligenz: + - Planung + - Mensch-Maschine Kommunikation + - Theorembeweiser: Der Computer beweist mathematische Sätze -> automatischer Beweis von wichtigen Sätzen im Bereich der Booleschen Algebren +- Logische Programmiersprachen + + +Außerdem: Logik ist ein Paradebeispiel für Syntax und formale Semantik + +Edsger W. Dijkstra (1920-2002): Informatik = VLSAL (Very large scale application of logics) + +Die Logik +- versucht, gültige Argumentationen von ungültigen zu unterscheiden, +- hat Anwendungen in der Informatik, +- formalisiert die zu untersuchenden Aussagen + +### Probleme mit natürlicher Sprache +1. Problem: Zuordnung von Wahrheitswerten zu natürlichsprachigen Aussagen ist problematisch. + - Beispiele: + - Ich habe nur ein bißchen getrunken. + - Sie hat sich in Rauch aufgelöst. + - Das gibt es doch nicht! + - Rache ist süß. +2. Problem: Natürliche Sprache ist oft schwer verständlich. + - Beispiel: Auszug aus der "Analytica Priora" von Aristoteles + - Die Aussage: Wenn der Mittelbegriff sich universell auf Ober- oder Untersatz bezieht, muss ein bestimmter negativer Syllogismus resultieren, immer wenn der Mittelbegriff sich universell auf den Obersatz bezieht, sei es positiv oder negativ, und besonders wenn er sich auf den Untersatz bezieht und umgekehrt zur universellen Aussage. + - Der Beweis: Denn wenn M zu keinem N gehört, aber zu einem O, ist es notwendig, dass N zu einem O nicht gehört. Denn da die negative Aussage umsetzbar ist, wird N zu keinem M gehören: Aber es war erlaubt, dass M zu einem O gehört: Deshalb wird N zu einem O nicht gehören: Denn das Ergebnis wird durch die erste Figur erreicht. Noch einmal: Wenn M zu allen N gehört, aber nicht zu einem O, ist es notwendig, dass N nichtzu einem O gehört: Denn wenn N zu allen O gehört und M auch alle N-Eigenschaften zugeschrieben werden, muss M zu allen O gehören: Aber wir haben angenommen, dass M zu einem O nicht gehört. Und wenn M zu allen N gehört, aber nicht zu allen O, können wir folgern, dass N nicht zu allen O gehört: Der Beweis ist der gleiche wie der obige. Aber wenn M alle O-Eigenschaften zugeschrieben werden, aber nicht alle N-Eigenschaften, wird es keinen Syllogismus geben. +3. Problem:Natürliche Sprache ist mehrdeutig. + - Beispiel: "Ich sah den Mann auf dem Berg mit dem Fernrohr." + - (((Ich sah den Mann) auf dem Berg) mit dem Fernrohr) + - ((Ich sah (den Mann auf dem Berg)) mit dem Fernrohr) + - ((Ich sah den Mann) (auf dem Berg mit dem Fernrohr)) + - (Ich sah ((den Mann auf dem Berg) mit dem Fernrohr)) + - (Ich sah (den Mann (auf dem Berg mit dem Fernrohr))) +4. Problem:Natürliche Sprache hängt von Kontext ab. +``` +Die Beatles sind Musiker +Paul McCartney ist ein Beatle +Paul McCartney ist ein Musiker +``` +``` +Die Beatles sind vier +Paul McCartney ist ein Beatle +Paul McCartney ist vier +``` + +# Kapitel 1: Aussagenlogik +Beispiel + +Ein Gerät besteht aus einem Bauteil A, einem Bauteil B und einem roten Licht. Folgendes ist bekannt: +1. Bauteil A oder Bauteil B (oder beide) sind kaputt. +2. Wenn Bauteil A kaputt ist, dann ist auch Bauteil B kaputt. +3. Wenn Bauteil B kaputt ist und das rote Licht leuchtet, dann ist Bauteil A nicht kaputt. +4. Das rote Licht leuchtet. + +Zur Formalisierung verwenden wir folgende Abkürzungen: +- RL (rotes Licht leuchtet), +- AK (Bauteil A kaputt), +- BK (Bauteil B kaputt), +- $\vee$ (oder), +- $\rightarrow$ (wenn, dann), +- $\wedge$ (und) und +- $\lnot$ (nicht). + +Damit können wir unser Wissen kompakter hinschreiben: +1. $AK \vee BK$ +2. $AK \rightarrow BK$ +3. $(BK \wedge RL)\rightarrow \lnot AK$ +4. $RL$ + +Aus den vier Aussagen lassen sich weitere Aussagen neue Aussagen bilden +5. Falls $AK$ gilt, so folgt aus $AK\rightarrow BK$, dass $BK$ gilt. +6. Falls $BK$ gilt, so gilt natürlich $BK$. +7. Da $AK \vee BK$ gilt, folgt aus (5) und (6), dass $BK$ in jedem Fall gilt. +8. Es gilt auch $RL$. +9. Also gilt $BK\wedge RL$ (aus (7) und (8)). +10. Es gilt auch $(BK \wedge RL)\rightarrow\lnot AK$. +11. Also gilt $\lnot AK$ (aus (9) und (10)). + +Damit sind wir überzeugt, dass das Bauteil A heil ist. + +Den Beweis, dass das Teil A heil ist, werden wir als "Beweisbaum" formalisieren: + +![](Assets/Logik-Beweisbaum.png) + +In der Aussagenlogik gehen wir von "Aussagen" aus, denen wir (zumindest prinzipiell) Wahrheitswerte zuordnen können. + +## Beispiele +- Die Summe von 3 und 4 ist 7. +- Jana reagierte aggressiv auf Martins Behauptungen. +- Jede gerade natürliche Zahl>2 ist Summe zweier Primzahlen. +- Alle Marsmenschen mögen Pizza mit Pepperoni. +- Albert Camus était un écrivain français. +- In theory, practically everything is possible. + +Für diese Aussagen verwenden wir dieatomaren Formeln $p,q,r$ bzw. $p_0,p_1,...$ + +Die Aussagen werden durch "Operatoren" verbunden. Beispiele +- ... und... +- ... oder... +- nicht... +- wenn... dann... +- entweder... oder... , aber nicht beide. +- mehr als die Hälfte der Aussagen ... gilt. + +Für solche zusammengesetzten Aussagen verwenden wir $\varphi,\psi$ usw. + +Durch die Wahl der erlaubten Operatoren erhält man unterschiedliche "Logiken". + +Da der Wahrheitswert einer zusammengesetzten Aussage nur vom Wahrheitswert der Teilaussagen abhängen soll, sind Operatoren wie "weil" oder "obwohl" nicht zulässig. + + +## Syntax der Aussagenlogik +Eine atomare Formel hat die Form $p_i$ (wobei $i\in\mathbb{N}=\{0,1,...\}$). +Formeln werden durch folgenden induktiven Prozess definiert: +1. Alle atomaren Formeln und $\bot$ sind Formeln. +2. Falls $\varphi$ und $\psi$ Formeln sind, sind auch $(\varphi\wedge\psi),(\varphi\wedge\psi)$($\varphi \rightarrow\psi$)und $\lnot\varphi$Formeln. +3. Nichts ist Formel, was sich nicht mittels der obigen Regeln erzeugen läßt. + +Beispielformel: $\lnot((\lnot p_4 \vee p_1)\wedge\bot)$ + +Bezeichnungen: +- Falsum: $\bot$ +- Konjunktion: $\wedge$ +- Disjunktion: $\vee$ +- Implikation: $\rightarrow$ +- Negation: $\lnot$ + +Abkürzungen +$p,q,r...$ statt $p_0,p_1,p_2...$ + +$(\bigvee_{i=1}^n \varphi_i$ statt $(...((\varphi_1\vee\varphi_2)\vee\varphi_3)\vee...\vee\varphi_n)$ + +$(\bigwedge_{i=1}^n \varphi_i)$ statt $(...((\varphi_1\wedge\varphi_2)\wedge\varphi_3)\wedge...\wedge\varphi_n)$ + +$(\varphi \leftrightarrow \psi)$ statt $((\varphi\rightarrow\psi)\wedge(\psi\rightarrow\varphi))$ + + +Präzedenz der Operatoren: +- $\leftrightarrow$ bindet am schwächsten +- $\rightarrow$... +- $\vee$... +- $\wedge$... +- $\lnot$ bindet am stärksten + +Es gilt also z.B.: $(\alpha\leftrightarrow\beta\vee\lnot\gamma\rightarrow\sigma\wedge\lnot\eta) = (\alpha\leftrightarrow ((\beta\vee\lnot\gamma)\rightarrow(\sigma\wedge\lnot\eta)))$ + +Dennoch: Zu viele Klammern schaden i.A. nicht. + + +## Natürliches Schließen +Ein (mathematischer) Beweis zeigt, wie die Behauptung aus den Voraussetzungen folgt. +Analog zeigt ein "Beweisbaum" (= "Herleitung" = "Deduktion"), wie eine Formel der Aussagenlogik aus Voraussetzungen (ebenfalls Formeln der Aussagenlogik) folgt. +Diese "Deduktionen" sind Bäume, deren Knoten mit Formeln beschriftet sind: +- an der Wurzel steht die Behauptung (= Konklusion $\varphi$) +- an den Blättern stehen Voraussetzungen (= Hypothesen oder Annahmen aus $\Gamma$) +- an den inneren Knoten stehen "Teilergebnisse" und "Begründungen" + +![](Assets/Logik-deduktionsbaum.png) + +## Konstruktion von Deduktionen +Aus der Annahme der Aussage $\varphi$ folgt $\varphi$ unmittelbar: eine triviale Deduktion + +$\varphi$ mit Hypothesen $\{\varphi\}$ und Konklusion $\varphi$. + +Folgend werden wir +- überlegen, wie aus "einfachen mathematischen Beweisen" umfangreichere entstehen können und +- parallel dazudefinieren, wie aus einfachen Deduktionen umfangreichere konstruiert werden können. + +### Konjunktion +#### Konjunktionseinführung in math. Beweisen +Ein mathematischer Beweis einer Aussage "$\varphi$ und $\psi$" sieht üblicherweise so aus: +- "Zunächst zeige ich $\varphi$: ... (hier steckt die eigentliche Arbeit) +- Jetzt zeige ich $\psi$: ... (nochmehr eigentliche Arbeit) +- Also haben wir "$\varphi$ und $\psi$" gezeigt. qed" + +#### Konjunktionseinführung (ausführlich) +Ist D eine Deduktion von $\varphi$ mit Hypothesen aus $\Gamma$ und ist E eine Deduktion von $\psi$ mit Hypothesen aus $\Gamma$, so ergibt sich die folgende Deduktion von $\varphi\wedge\psi$ mit Hypothesen aus $\Gamma$: + +![](Assets/Logik-konjunktionseinführung.png) + +Kurzform: $\frac{\varphi\quad\psi}{\varphi\wedge\psi} (\wedge I)$ + +#### Konjunktionselimination (ausführlich) +Ist D eine Deduktion von $\varphi\wedge\psi$ mit Hypothesen aus $\Gamma$, so ergeben sich die folgenden Deduktionen von $\varphi$ bzw. von $\psi$ mit Hypothesen aus $\Gamma$: + +![](Assets/Logik-Konjunktionselimination.png) + +Kurzform: $\frac{\varphi\wedge\psi}{\varphi} (\wedge E_1) \quad\quad \frac{\varphi\wedge\psi}{\psi} (\wedge E_2)$ + +#### Beispiel +Wir zeigen $\varphi\wedge\psi$ unter der Hypothese $\psi\wedge\varphi$:... + +![](Assets/Logik-Deduktionsbeispiel.png) + +Dies ist eine Deduktion mit Konklusion $\varphi\wedge\psi$ und Hypothese $\psi\wedge\varphi$ (zweimal verwendet). + +### Implikation +#### Implikationseinführung in math. Beweisen +Ein mathematischer Beweis einer Aussage "Aus $\varphi$ folgt $\psi$" sieht üblicherweise so aus: +- "Angenommen, $\varphi$ gilt. +- Dann ... (hier steckt die eigentliche Arbeit). +- Damit gilt $\psi$. +- Also haben wir gezeigt, dass $\psi$ aus $\varphi$ folgt. qed" + +Die Aussage $\varphi$ ist also eine "temporäre Hypothese". + +#### Implikationseinführung (ausführlich) +Ist D eine Deduktion von $\psi$ mit Hypothesen aus $\Gamma\cup\{\varphi\}$, so ergibt sich die folgende Deduktion von $\varphi\rightarrow\psi$ mit Hypothesen aus $\Gamma$: + +![](Assets/Logik-Implikationseinführung.png) + +Kurzform +$[\varphi]$ +$\vdots$ +$\frac{\psi}{\varphi\rightarrow\psi} (\rightarrow I)$ + +Beispiel: ... Dies ist eine Deduktion von $\varphi\rightarrow\varphi$ ohne Hypothesen. + +#### Implikationselimination in math. Beweisen +Ein mathematischer Beweis einer Aussage "$\psi$ gilt" über eine Hilfsaussage sieht so aus: +- "Zunächst zeigen wir, dass $\varphi$ gilt: ... +- Dann beweisen wir, dass $\psi$ aus $\varphi$ folgt: ... +- Also haben wir $\psi$ gezeigt. qed" + +#### Implikationselimination oder modus ponens (ausführlich) +Ist D eine Deduktion von $\varphi$ mit Hypothesen aus $\Gamma$ und ist E eine Deduktion von $\varphi\rightarrow\psi$ mit Hypothesen aus $\Gamma$, so ergibt sich die folgende Deduktion von $\psi$ mit Hypothesen aus $\Gamma$: + +![](Assets/Logik-Implikationselimination.png) + +Kurzform: $\frac{\varphi\quad \varphi\rightarrow\psi}{\psi} (\rightarrow E)$ + +#### Beispiel +![](Assets/Logik-Implikationseleimination-beispiel.png) + +Bemerkung: die Indizes 1, 2 und 3 machen deutlich, welche Hypothese bei welcher Regelanwendung gestrichen wurde. Deduktionen können recht groß werden. + +Diese Deduktion hat keine Hypothesen! + + +### Disjunktion +#### Disjunktionselimination oder Fallunterscheidung in math. Beweisen +Ein mathematischer Beweis einer Aussage "$\sigma$ gilt" mittels Fallunterscheidung sieht üblicherweise so aus: +- "Zunächst zeigen wir, dass $\varphi\vee\psi$ gilt: ... +- Gilt $\varphi$, so gilt $\sigma$, denn ... +- Gilt $\psi$, so gilt ebenfalls $\sigma$, denn ... +- Also haben wir gezeigt, dass $\sigma$ gilt. qed" + +Die Aussagen $\varphi$ und $\psi$ sind also wieder "temporäre Hypothesen". + +#### Disjunktionselimination oder Fallunterscheidung (ausführlich) +Ist D eine Deduktion von $\varphi\vee\psi$ mit Hypothesen aus $\Gamma$, ist E eine Deduktion von $\sigma$ mit Hypothesen aus $\Gamma\cup\{\varphi\}$und ist F eine Deduktion von $\sigma$ mit Hypothesen aus $\Gamma\cup\{\psi\}$, so ergibt sich die folgende Deduktion von $\sigma$ mit Hypothesen aus $\Gamma$: + +![](Assets/Logik-Disjunktionselimination.png) + +Disjunktionselimination Kurzform: +$\quad [\psi] \quad[\varphi]$ +$\quad \vdots \quad\vdots$ +$\frac{\varphi\vee\psi \quad\sigma \quad\sigma}{\sigma} (\vee E)$ + +Disjunktionseinführung (Kurzform) +$\frac{\varphi}{\varphi\vee\psi} (\vee I_1) \quad \frac{\psi}{\varphi\vee\psi} (\vee I_2)$ + +### Negation +#### Negationseinführung in math. Beweisen +Ein mathematischer Beweis einer Aussage "$\varphi$ gilt nicht" sieht so aus: +- "Angenommen,$\varphi$gilt. +- Dann folgt $0=1$, denn .... Mit anderen Worten, dies führt zu einem Widerspruch. +- Also haben wir gezeigt, dass $\varphi$ nicht gilt. qed" +- +Die Aussage $\varphi$ ist also wieder eine "temporäre Hypothese". + +#### Negationseinführung (ausführlich) +Ist D eine Deduktion von $\bot$ mit Hypothesen aus $\Gamma\cup\{\varphi\}$, so ergibt sich die folgende Deduktion von $\lnot\varphi$ mit Hypothesen aus $\Gamma$: + +![](Assets/Logik-Negationseinführung.png) + +Kurzform: +$[\varphi]$ +$\vdots$ +$\frac{\bot}{\lnot\varphi} (\lnot I)$ + +#### Negationselimination (ausführlich) +Ist D eine Deduktion von $\lnot\varphi$ mit Hypothesen aus $\Gamma$ und ist E eine Deduktion von $\varphi$ mit Hypothesen aus $\gamma$, so ergibt sich die folgende Deduktion von $\bot$ mit Hypothesen aus $\Gamma$: + +![](Assets/Logik-Negationselimination.png) + +Kurzform: $\frac{\lnot\varphi \quad \varphi}{\bot} (\lnot E)$ + +### Falsum +Hat man "$0=1$" bewiesen, so ist man bereit, alles zu glauben: ex falso sequitur quodlibet + +ausführlich: Ist D eine Deduktion von $\bot$ mit Hypothesen aus $\Gamma$, so ergibt sich die folgende Deduktion von $\varphi$ mit Hypothesen aus $\Gamma$: + +![](Assets/Logik-Falsumeinführung.png) + +Kurzform: $\frac{\bot}{\varphi} (\bot)$ + +#### math. Widerspruchsbeweis +Ein indirekter Beweis einer Aussage "$\varphi$ gilt" sieht üblicherweise so aus: +- "Angenommen, $\varphi$ gilt nicht, d.h. $\lnot\varphi$ gilt. +- Dann folgt $0=1$, d.h. ein Widerspruch. +- Also haben wir gezeigt, dass $\varphi$ gilt. qed" + +Die Aussage $\lnot\varphi$ ist also wieder eine "temporäre Hypothese". + +#### reductio ad absurdum (ausführlich) +Ist D eine Deduktion von $\bot$ mit Hypothesen aus $\Gamma\cup\{\lnot\varphi\}$, so ergibt sich die folgende Deduktion von $\varphi$ mit Hypothesen aus $\Gamma$: + +![](Assets/Logik-reductio-ad-absurdum.png) + +Kurzform: +$[\lnot\varphi]$ +$\vdots$ +$\frac{\bot}{\varphi} (raa)$ + +## Regeln des natürlichen Schließens +> Definition +> +> Für eine Formelmenge $\Gamma$ und eine Formel $\varphi$ schreiben wir $\Gamma\Vdash\varphi$ wenn es eine Deduktion gibt mit Hypothesen aus $\Gamma$ und Konklusion $\varphi$. Wir sagen "$\varphi$ ist eine syntaktische Folgerung von $\Gamma$". +> +> Eine Formel $\varphi$ ist ein Theorem, wenn $\varnothing\Vdash\varphi$ gilt. + +### Bemerkung +$\Gamma\Vdash\varphi$ sagt (zunächst) nichts über den Inhalt der Formeln in $\Gamma\cup\{\varphi\}$ aus, sondern nur über die Tatsache, dass $\varphi$ mithilfe des natürlichen Schließens aus den Formeln aus $\Gamma$ hergeleitet werden kann. + +Ebenso sagt "$\varphi$ ist Theorem" nur, dass $\varphi$ abgeleitet werden kann, über "Wahrheit" sagt dieser Begriff (zunächst) nichts aus. + +### Satz +Für alle Formeln $\varphi$ und $\psi$ gilt $\{\lnot(\varphi\vee\psi)\}\Vdash\lnot\varphi\wedge\lnot\psi$. + +Beweis: Wir geben eine Deduktion an... +- $\{\lnot\varphi\wedge\lnot\psi\}\Vdash\lnot(\varphi\vee\psi)$ + ![](Assets/Logik-beispiel-1.png) +- $\{\lnot\varphi\vee\lnot\psi\}\Vdash\lnot(\varphi\wedge\psi)$ + ![](Assets/Logik-beispiel-2.png) +- $\{\varphi\vee\psi\} \Vdash \psi\vee\varphi$ + ![](Assets/Logik-beispiel-3.png) + +### Satz +Für jede Formel $\varphi$ ist $\lnot\lnot\varphi\rightarrow\varphi$ ein Theorem. + +Beweis: Wir geben eine Deduktion mit Konklusion $\lnot\lnot\varphi\rightarrow\varphi$ ohne Hypothesen an... + +![](Assets/Logik-beispiel-5.png) + +### Satz +Für jede Formel $\varphi$ ist $\varphi\vee\lnot\varphi$ ein Theorem. + +Beweis: Wir geben eine Deduktion mit Konklusion $\varphi\vee\lnot\varphi$ ohne Hypothesen an... + +![](Assets/Logik-beispiel-6.png) + +Bemerkung: Man kann beweisen, dass jede Deduktion der letzten beiden Theoreme die Regel (raa) verwendet, sie also nicht "intuitionistisch" gelten. + +### Satz +$\{\lnot(\varphi\wedge\psi)\}\Vdash\lnot\varphi\vee\lnot\psi$ + +![](Assets/Logik-beispiel-4.png) + +## Semantik +Formeln sollen Verknüpfungen von Aussagen widerspiegeln, wir haben dies zur Motivation der einzelnen Regeln des natürlichen Schließens genutzt. +Aber die Begriffe "syntaktische Folgerung" und "Theorem" sind rein syntaktisch definiert. + +Erst die jetzt zu definierende "Semantik" gibt den Formeln "Bedeutung". + +Idee der Semantik: wenn man jeder atomaren Formel $p_i$ einen Wahrheitswertzuordnet, so kann man den Wahrheitswert jeder Formel berechnen. + +Es gibt verschiedene Möglichkeiten, Wahrheitswerte zu definieren: +- zweiwertige oder Boolesche Logik $B=\{0,1\}$: Wahrheitswerte "wahr"=1 und "falsch"= 0 +- dreiwertige Kleene-Logik $K_3=\{0,\frac{1}{2},1\}$: zusätzlicher Wahrheitswert "unbekannt"$=\frac{1}{2}$ +- Fuzzy-Logik $F=[0,1]$: Wahrheitswerte sind "Grad der Überzeugtheit" +- unendliche Boolesche Algebra $B_R$= Menge der Teilmengen von $\mathbb{R}$; $A\subseteq\mathbb{R}$ ist "Menge der Menschen, die Aussage für wahr halten" +- Heyting-Algebra $H_R$= Menge der offenen Teilmengen von $\mathbb{R}$ + - Erinnerung: $A\subseteq\mathbb{R}$ offen, wenn $\forall a\in A\exists\epsilon >0:(a-\epsilon,a+\epsilon)\subseteq A$, d.h., wenn $A$ abzählbare Vereinigung von offenen Intervallen $(x,y)$ ist. + +Beispiele: +- offen: $(0,1), \mathbb{R}_{>0}, \mathbb{R}\backslash\{0\}, \mathbb{R}\backslash\mathbb{N}$ +- nicht offen: $[1,2), \mathbb{R}_{\geq 0}, \mathbb{Q}, \mathbb{N}, \{\frac{1}{n} | n\in\mathbb{N}\}, \mathbb{R}\backslash\mathbb{Q}$ + + +Sei W eine Menge von Wahrheitswerten.\\ +Eine W-Belegung ist eine Abbildung $B:V\rightarrow W$, wobei $V\subseteq\{p_0 ,p_1 ,...\}$ eine Menge atomarer Formeln ist. + +Die W-Belegung $B:V\rightarrow W$ paßt zur Formel $\phi$, falls alle atomaren Formeln aus $\phi$ zu V gehören. + +Sei nun B eine W-Belegung. Was ist der Wahrheitswert der Formel $p_0\vee p_1$ unter der Belegung B? + +Zur Beantwortung dieser Frage benötigen wir eine Funktion $\vee_W :W\times W\rightarrow W$ (analog für $\wedge,\rightarrow,\lnot$). + +## Wahrheitswertebereiche +> Definition: Sei W eine Menge und $R\subseteq W\times W$ eine binäre Relation. +- R ist reflexiv, wenn $(a,a)\in R$ für alle $a\in W$ gilt. +- R ist antisymmetrisch, wenn $(a,b),(b,a)\in R$ impliziert, dass $a=b$ gilt (für alle $a,b\in W$). +- R ist transitive, wenn $(a,b),(b,c)\in R$ impliziert, dass $(a,c)\in R$ gilt (für alle $a,b,c\in W$). +- R ist eine Ordnungsrelation, wenn R reflexiv, antisymmetrisch und transitiv ist. In diesem Fall heißt das Paar $(W,R)$ eine partiell geordnete Menge. + +Beispiel +1. Sei $\leq$ übliche Ordnung auf $\mathbb{R}$und $W\subseteq\mathbb{R}$. Dann ist $(W,\leq)$ partiell geordnete Menge. +2. Sei $X$ eine Menge und $W\subseteq P(X)$. Dann ist $(W,\subseteq)$ partiell geordnete Menge. +3. Sei $W=P(\sum ∗)$ und $\leq_p$ die Relation "es gibt Polynomialzeitreduktion" (vgl. "Automaten, Sprachen und Komplexität"). Diese Relation ist reflexiv, transitiv, aber nicht +antisymmetrisch (denn $3-SAT\leq_p HC$ und $HC\leq_p_3-SAT$). + +> Definition: Sei $(W,\leq)$ partiell geordnete Menge, $M\subseteq W$ und $a\in W$. +- a ist obere Schranke von $M$, wenn $m\leq a$ für alle $m\in M$ gilt. +- a ist kleinste obere Schranke oder Supremum von $M$, wenn $a$ obere Schranke von $M$ ist und wenn $a\leq b$ für alle oberen Schranken $b$ von $M$ gilt. Wir schreiben in diesem Fall $a=sup \ M$. +- a ist untere Schranke von $M$, wenn $a\leq m$ für alle $m\in M$ gilt. +- a ist größte untere Schranke oder Infimum von $M$, wenn a untere Schranke von $M$ ist und wenn $b\leq a$ für alle unteren Schranken $b$ von $M$ gilt. Wir schreiben in diesem Fall $a=inf\ M$. + +Beispiel +1. betrachte $(W,\leq)$ mit $W=\mathbb{R}$ und $\leq$ übliche Ordnung auf $\mathbb{R}$. + - Dann gelten $sup[0,1] = sup(0,1) =1$. + - $sup\ W$ existiert nicht (denn $W$ hat keine obere Schranke). +2. betrachte $(W,\subseteq)$ mit $X$ Menge und $W =P(X)$. + - $sup\ M=\bigcup_{A\in M} A$ für alle $M\subseteq W$ +3. betrachte $(W,\subseteq)$ mit $W=\{\{0\},\{1\},\{0,1,2\},\{0,1,3\}\}$. + - $sup\{\{0\},\{0,1,2\}\}=\{0,1,2\}$ + - $\{0,1,2\}$ und $\{0,1,3\}$ sind die oberen Schranken von $M=\{\{0\},\{1\}\}$, aber $M$ hat kein Supremum + +> Definition: Ein (vollständiger) Verband ist eine partiell geordnete Menge $(W,\leq)$, in der jede Menge $M\subseteq W$ ein Supremum $sup\ M$ und ein Infimum $inf\ M$ hat. +In einem Verband $(W,\leq)$ definieren wir: +- $0_W = inf\ W$ und $1_W= sup\ W$ +- $a\wedge_W b= inf\{a,b\}$ und $a\vee_W b= sup\{a,b\}$ für $a,b\in W$ + +Bemerkung: In jedem Verband $(W,\leq)$ gelten $0_W= sup\ \varnothing$ und $1_W= inf\ \varnothing$ (denn jedes Element von $W$ ist obere und untere Schranke von $\varnothing$). + +> Definition: Ein Wahrheitswertebereich ist ein Tupel $(W,\leq,\rightarrow W,\lnot W)$, wobei $(W,\leq)$ ein Verband und $\rightarrow W:W^2 \rightarrow W$ und $\lnot W:W\rightarrow W$ Funktionen sind. + +### Beispiel +- Der Boolesche Wahrheitswertebereich B ist definiert durch die Grundmenge $B=\{0,1\}$, die natürliche Ordnung $\leq$ und die Funktionen $\lnot_B (a) = 1-a$, $\rightarrow_B(a,b) = max(b, 1 -a)$. Hier gelten: + - $0_B=0$, $1_B= 1$, + - $a\wedge_B b= min(a,b)$, $a\vee_B b= max(a,b)$ +- Der Kleenesche Wahrheitswertebereich $K_3$ ist definiert durch die Grundmenge $K_3=\{0,\frac{1}{2},1\}$ mit der natürlichen Ordnung $\leq$ und durch die Funktionen $\lnot_{K_3} (a) = 1 -a $, $\rightarrow_{K_3} (a,b) = max(b, 1-a)$. Hier gelten: + - $\lnot_{K_3} = 0$, $1_{K_3} = 1$ + - $a\wedge_{K_3} b= min(a,b)$, $a\vee_{K_3} b= max(a,b)$ +- Der Wahrheitswertebereich F der Fuzzy-Logik ist definiert durch die Grundmenge $F=[0,1]\subseteq\mathbb{R}$ mit der natürlichen Ordnung $\leq$ und durch die Funktionen $\lnot_F (a) = 1-a$, $\rightarrow_F (a,b) = max(b, 1-a)$. Hier gelten: + - $0_F= 0$, $1_F= 1$ + - $a\wedge_F b= min(a,b)$, $a\vee_F b= max(a,b)$ +- Der Boolesche Wahrheitswertebereich $B_R$ ist definiert durch die Grundmenge $B_R=\{A|A\subseteq \mathbb{R}\}$ mit der Ordnung $\subseteq$ und durch die Funktionen $\lnot_{B_R} (A) =\mathbb{R}\backslash A$, $\rightarrow_{B_R} (A,B) = B\cup\mathbb{R}\backslash A$. Hier gelten: + - $0_{B_R}=\varnothing$, $1_{B_R}=\mathbb{R}$ + - $A\wedge_{B_R} B=A\cap B$, $A\vee_{B_R} B=A\cup B$ +- Der Heytingsche Wahrheitswertebereich $H_R$ ist definiert durch die Grundmenge $H_{mathbb{R}} =\{A\subseteq\mathbb{R} | \text{A ist offen}\}$, die Ordnung $\subseteq$ und durch die Funktionen $\lnot_{H_R} (A) = Inneres(\mathbb{R}\backslash A)$, $\rightarrow_{H_R} (A,B) =Inneres(B\cup \mathbb{R}\backslash A)$. Hier gelten: + - $0_{H_R}=\varnothing$, $1_{H_R}=\mathbb{R}$ + - $A\wedge_{H_R} B= A\cap B$, $A\vee_{H_R} B=A\cup B$ + - Erinnerung: $Inneres(A) =\{a\in A|\exists \epsilon > 0 : (a-\epsilon,a+\epsilon)\subseteq A\}$ + - Beispiele: $Inneres((0,1))=(0,1)=Inneres([0,1]),Inneres(N)=\varnothing,Inneres(\mathbb{R}_{\geq 0}) = \mathbb{R}_{> 0}$ + + +Sei W ein Wahrheitswertebereich und B eine W-Belegung. Induktiv über den Formelaufbau definieren wir den Wahrheitswert $\hat{B}(\phi)\in W$ jeder zu $B$ passenden Formel $\phi$: +- $\hat{B}(\bot) = 0_W$ +- $\hat{B}(p) = B(p)$ falls $p$ eine atomare Formel ist +- $\hat{B}((\phi\wedge \psi )) = \hat{B}(\phi)\wedge_W \hat{B}(\psi )$ +- $\hat{B}((\phi\vee \psi )) = \hat{B}(\phi)\vee_W \hat{B}(\psi )$ +- $\hat{B}((\phi\rightarrow \psi )) = \rightarrow W(\hat{B}(\phi),\hat{B}(\psi ))$ +- $\hat{B}(\lnot\phi) = \lnot W(\hat{B}(\phi))$ + +Wir schreiben im folgenden $B(\phi)$ anstatt $\hat{B}(\phi)$. + +Beispiel: Betrachte die Formel $\phi= ((p\wedge q)\rightarrow (q\wedge p))$. +- Für eine beliebige B-Belegung $B:\{p,q\}\rightarrow B$ gilt $B((p\wedge q)\rightarrow (q\wedge p)) = max(B(q\wedge p), 1 -B(p\wedge q)) = max(min(B(q),B(p)), 1 -min(B(p),B(q))) = 1 = 1_B$ +- Für die $K_3$-Belegung $B:\{p,q\}\rightarrow K_3$ mit $B(p) =B(q) = \frac{1}{2}$} gilt $B((p\wedge q)\rightarrow (q\wedge p)) = max(B(q\wedge p), 1 -B(p\wedge q))= max(min(B(q),B(p)), 1 -min(B(p),B(q))) = \frac{1}{2} \not= 1_{K_3}$ +- analog gibt es eine F-Belegung $B:\{p,q\}\rightarrow F$, so dass $B((p\wedge q)\rightarrow (q\wedge p)) \not = 1_F$ gilt. +- Für eine beliebige $H_{mathbb{R}}$-Belegung $B:\{p,q\}\rightarrow H_R$ gilt $B((p\wedge q)\rightarrow (q\wedge p)) = Inneres(B(q\wedge p)\cup \mathbb{R}\backslash B(p\wedge q)) = Inneres((B(q)\cap B(p))\cup \mathbb{R}\backslash (B(p)\cap B(q))) = Inneres(\mathbb{R}) = \mathbb{R} = 1_{H_R}$ + +## Folgerung und Tautologie +Sei W ein Wahrheitswertebereich. +Eine Formel $\phi$ heißt eine W-Folgerung der Formelmenge $\Gamma$, falls für jede W-Belegung B, die zu allen Formeln aus $\Gamma \cup\{\phi\}$ paßt, gilt: + $inf\{B(\gamma )|\gamma \in \Gamma \}\leq B(\phi)$ + +Wir schreiben $\Gamma \Vdash W\phi$, falls $\phi$ eine W-Folgerung von $\Gamma$ ist. + +Bemerkung: Im Gegensatz zur Beziehung $\Gamma \vdash \phi$, d.h. zur syntaktischen Folgerung, ist $\Gamma \Vdash W \phi$ eine semantische Beziehung. + +Eine W-Tautologie ist eine Formel $\phi$ mit $\varnothing \Vdash W\phi$, d.h. $B(\phi) = 1_W$ für alle passenden W-Belegungen B (denn $inf\{\hat{B}(\gamma )|\gamma \in \varnothing \}= inf \varnothing = 1_W)$. + +Wahrheitstafel für den Booleschen Wahrheitswertebereich B: + +| RL | AK | BK | $AK\vee BK$ | $AK\rightarrow BK$ | $(BK\wedge RL)\rightarrow\lnot AK$ | RL | $\lnot AK$ | +| --- | --- | --- | ----------- | ------------------ | ---------------------------------- | --- | ---------- | +| 0 | 0 | 0 | 0 | 1 | 1 | 0 | 1 | +| 0 | 0 | 1 | 1 | 1 | 1 | 0 | 1 | +| 0 | 1 | 0 | 1 | 0 | 1 | 0 | 0 | +| 0 | 1 | 1 | 1 | 1 | 1 | 0 | 0 | +| 1 | 0 | 0 | 0 | 1 | 1 | 1 | 1 | +| 1 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | +| 1 | 1 | 0 | 1 | 0 | 1 | 1 | 0 | +| 1 | 1 | 1 | 1 | 1 | 0 | 1 | 0 | + + +Wir erhalten also $\{(AK\vee BK),(AK\rightarrow BK), ((BK\wedge RL)\rightarrow \lnot AK),RL\} \Vdash_B \lnot AK$ +und können damit sagen: + +"Wenn die Aussagen "Bauteil A oder Bauteil B ist kaputt" und "daraus, dass Bauteil A kaputt ist, folgt, dass Bauteil B kaputt ist" und... wahr sind, ... dann kann man die Folgerung ziehen: die Aussage "das Bauteil A ist heil" ist wahr." + +Erinnerung aus der ersten Vorlesung: $\{(AK\vee BK),(AK\rightarrow BK), ((BK\wedge RL)\rightarrow \lnot AK),RL\} \vdash \lnot AK$ + +Beispiel +Sei $\phi$ beliebige Formel mit atomaren Formeln in V. +- Sei $B:V\rightarrow B$ eine B-Belegung. Dann gilt + + $B(\lnot\lnot\phi\rightarrow\phi) = \rightarrow B(\lnot B\lnot B(B(\phi)),B(\phi)) = max(B(\phi), 1 -( 1 -( 1 -B(\phi)))) = max(B(\phi), 1 -B(\phi)) = 1 = 1_B$. + + Also ist $\lnot\lnot\phi\rightarrow\phi$ eine B-Tautologie (gilt ebenso für den Wahrheitswertebereich $B_R$). +- Sei $B:V\rightarrow H_R$ eine $H_R$-Belegung mit $B(\phi) =R\backslash\{0\}$. Dann gelten + - $B(\lnot\phi) = Inneres(\mathbb{R}\backslash B(\phi)) = Inneres(\{0\}) =\varnothing$ + - $B(\lnot\lnot\phi) = Inneres(\mathbb{R}\backslash B(\lnot\phi)) = Inneres(\mathbb{R}) = \mathbb{R}$ + - $B(\lnot\lnot\phi\rightarrow\phi) = \rightarrow_{H_R} (B(\lnot\lnot\phi),B(\phi)) = \rightarrow_{H_R} (\mathbb{R},\mathbb{R}\backslash \{0\}) = Inneres(\mathbb{R}\backslash\{0\}\cup\mathbb{R}\backslash\mathbb{R}) = \mathbb{R}\backslash\{0\}\not =\mathbb{R}= 1_{H_R}$ + + Also ist $\lnot\lnot\phi\rightarrow\phi$ keine $H_R$-Tautologie (gilt ebenso für die Wahrheitswertebereiche $K_3$ und $F$). +- Sei $B:V\rightarrow B$ eine B-Belegung. Dann gilt + + $B(\phi\vee\lnot\phi) = max(B(\phi), 1 -B(\phi)) = 1 = 1_B$. + + Also ist $\phi\vee\lnot\phi$ eine B-Tautologie (gilt ebenso für den Wahrheitswertebereich $B_R$). +- Sei $B:V\rightarrow H_R$ eine $H_R$-Belegung mit $B(\phi)=\mathbb{R}\backslash\{0\}$. Dann gilt + $B(\phi\vee\lnot\phi) = B(\phi)\cup B(\lnot\phi) = \mathbb{R}\backslash\{0\}\cup \varnothing \not= 1_{H_R}$. + + Also ist $\phi\vee\lnot\phi$ keine $H_R$-Tautologie (gilt ebenso für die Wahrheitswertebereiche $K_3$ und $F$). +- Sei $B:V\rightarrow B$ eine B-Belegung. Dann gilt + + $B(\lnot\phi\rightarrow\bot) = \rightarrow_B(B(\lnot\phi$),B(\bot)) = max(0,1-B(\lnot \phi)) = 1 -( 1 -B(\phi)) =B(\phi)$. + + Also haben wir $\{\lnot\phi\rightarrow\bot\}\Vdash B\phi$ und $\{\phi\}\Vdash B\lnot \phi\rightarrow\bot$. + - Ebenso erhält man: + - $\{\lnot\phi\rightarrow\bot\}\Vdash_{K_3} \phi$ + - $\{\phi\}\Vdash_{K_3} \lnot\phi\rightarrow\bot$ + - $\{\lnot\phi\rightarrow\bot\}\Vdash_F\phi$ + - $\{\phi\}\Vdash F\lnot\phi\rightarrow\bot$ +- Sei $B:D\rightarrow H_R$ eine $H_R$-Belegung mit $B(\phi) =\mathbb{R}\backslash\{0\}$. Dann gilt + $B(\lnot\phi\rightarrow\bot) = Inneres(B(\bot )\cup \mathbb{R}\backslash B(\lnot\phi))= Inneres(\varnothing \cup \mathbb{R}\backslash\varnothing)= \mathbb{R} \not\supseteq B(\phi)$. + + also $\{\lnot\phi\rightarrow\bot\}\not\Vdash_{H_R} \phi$. + + Es gilt aber $\{\phi\}\Vdash_{H_R}\lnot \phi\rightarrow\bot$. + +Zusammenfassung der Beispiele + +| | B | $B_R$ | $K_3$ | F | $H_R$ | | +| -------------------------------------------------- | --- | ----- | ----- | --- | ----- | ------------------------------------------------- | +| $\varnothing\Vdash_W\lnot\lnot\phi\rightarrow\phi$ | √ | √ | - | - | - | $\varnothing\vdash \lnot\lnot\phi\rightarrow\phi$ | +| $\varnothing\Vdash_W\phi\vee\lnot\phi$ | √ | √ | - | - | - | $\varnothing\vdash\phi\vee\lnot\phi$ | +| $\{\lnot\phi\rightarrow\bot\}\Vdash_W\phi$ | √ | √ | √ | √ | - | $\{\lnot\phi\rightarrow\bot\}\vdash\phi$ | +| $\{\phi\}\Vdash_W\lnot\phi\rightarrow\bot$ | √ | √ | √ | √ | √ | $\{\phi\}\vdash\lnot\phi\rightarrow\bot$ | + +- $√$ in Spalte W:W-Folgerung gilt +- $-$ in Spalte W:W-Folgerung gilt nicht + + +> Überblick: Wir haben definiert +- $\Gamma\vdash\phi$ syntaktische Folgerung + - Theorem ("hypothesenlos ableitbar") +- $\Gamma\Vdash_W \phi$ (semantische) W-Folgerung + - W-Tautologie ("wird immer zu $1_W$ ausgewertet") + +Frage: Was ist die Beziehung zwischen diesen Begriffen, insbes. zwischen "Theorem" und "W-Tautologie"? Da z.B. B-Folgerung $\not =K_3$-Folgerung, hängt die Anwort von W ab. + +## Korrektheit +Können wir durch mathematische Beweise zu falschen Aussagenkommen? + +Können wir durch das natürliche Schließen zu falschen Aussagen kommen? + +Existiert eine Menge $\Gamma$ von Formeln und eine Formel $\varphi$ mit $\Gamma\vdash\varphi$ und $\Gamma\not\Vdash_W \varphi$? Für welche Wahrheitswertebereiche W? + +Frage für diese Vorlesung: Für welche Wahrheitswertebereiche W gilt +$\Gamma\vdash\varphi\Rightarrow\Gamma\vdash_W \varphi$ +bzw. +$\varphi$ ist Theorem $\Rightarrow\varphi$ ist W-Tautologie? + +Beispiel: Betrachte den Kleeneschen Wahrheitswertebereich $K_3$. +- Sei $p$ atomare Formel. + $\frac{[p]^4}{p\rightarrow p}$ + Also gilt $\varnothing\vdash p\rightarrow p$, d.h. $p\rightarrow p$ ist Theorem. +- Sei $B$ $K_3$-Belegung mit $B(p)=\frac{1}{2}$. Dann gilt $B(p\rightarrow p) = max(B(p), 1-B(p)) =\frac{1}{2}$, also $inf\{B(\gamma)|\gamma\in\varnothing\}= 1 >\frac{1}{2} = B(p\rightarrow p)$. + Damit haben wir gezeigt $\varnothing\not\Vdash_{K_3} p\rightarrow p$. + +Die Implikation $\Gamma\vdash\varphi\Rightarrow\Gamma\vdash_W \varphi$ gilt also NICHT für den Kleeneschen Wahrheitswertebereich $W=K_3$ und damit auch NICHT für den Wahrheitswertebereich der Fuzzy-Logik $F$. + +> Korrektheitslemma für nat. Schließen & Wahrheitswertebereich B +> +> Sei $D$ eine Deduktion mit Hypothesen in der Menge $\Gamma$ und Konklusion $\varphi$. Dann gilt $\Gamma\vdash_B \varphi$, d.h. $inf\{B(\gamma)|\gamma\in\Gamma\}\leq B(\varphi)$ für alle passenden B-Belegungen $B$. + +Beweis: Induktion über die Größe der Deduktion $D$ (d.h. Anzahl der Regelanwendungen). +- I.A.: die kleinste Deduktion $D$ hat die Form $\varphi$ mit Hypothese $\varphi$ und Konklusion $\varphi$. Sei $B$ passendeB-Belegung. Hypothesen von $D$ in $\Gamma\Rightarrow\varphi\in\Gamma\Rightarrow inf\{B(\gamma)|\gamma\in\Gamma\}\leq B(\varphi)\Rightarrow\Gamma\vdash_B \varphi$ +- I.V.: Behauptung gelte für alle Deduktionen, die kleiner sind als $D$. +- I.S.: Wir unterscheiden verschiedene Fälle, je nachdem, welche Regel als letzte angewandt wurde. + - $(\wedge I)$ Die Deduktion hat die Form $\frac{\alpha\quad\beta}{\alpha\wedge\beta}$ + mit $\varphi=\alpha\wedge\beta$. Sei $B$ passende B-Belegung. Nach IV gelten $inf\{B(\gamma)|\gamma\in\Gamma\}\leq B(\alpha)$ und $inf\{B(\gamma)|\gamma\in\Gamma\}\leq B(\beta)$ + und damit + $inf\{B(\gamma)|\gamma\in\Gamma\}\leq B(\alpha)\wedge_B B(\beta)=B(\alpha\wedge\beta) =B(\varphi)$. + Da $B$ beliebig war, haben wir $\Gamma\vdash_B \varphi$ gezeigt. + - $(\vee E)$ Die Deduktion $D$ hat die Form $\frac{\alpha\vee\beta\quad\phi\quad\phi}{\phi}$ + Also gibt es Deduktion $E$ mit Hypothesen in $\Gamma$ und Konklusion $\alpha\vee\beta$ und Deduktionen $F$ und $G$ mit Hypothesen in $\Gamma\cup\{\alpha\}$ bzw. $\Gamma\cup\{\beta\}$ und Konklusion $\varphi$. Sei $B$ passende B-Belegung. Nach IV gelten + $inf\{B(\gamma)|\gamma\in\Gamma\}\leq B(\alpha\vee\beta)$ (1) + $inf\{B(\gamma)|\gamma\in\Gamma\cup\{\alpha\}\}\leq B(\varphi)$ (2) + $inf\{B(\gamma)|\gamma\in\Gamma\cup\{\beta\}\}\leq B(\varphi)$ (3) + Wir unterscheiden zwei Fälle: + - $B(\alpha)\leq B(\beta)$: + $inf\{B(\gamma)|\gamma\in\Gamma\}\leq B(\alpha\vee\beta) =B(\alpha)\vee_B B(\beta) =B(\beta)$ impliziert + $inf\{B(\gamma)|\gamma\in\Gamma\}= inf\{B(\gamma)|\gamma\in\Gamma\cup\{\beta\}\}\leq B(\varphi)$ + - $B(\alpha)>B(\beta)$: analog + Da $B$ beliebig war, haben wir $\Gamma\vdash_B \varphi$ gezeigt. + - $(\rightarrow I)$ Die DeduktionDhat die Form $\frac{\beta}{\alpha\rightarrow\beta}$ + mit $\varphi=\alpha\rightarrow\beta$. Sei $B$ eine passende B-Belegung. Nach IV gilt + $inf\{B(\gamma)|\gamma\in\Gamma\cup\{\alpha\}\}\leq B(\beta)$ + Wir unterscheiden wieder zwei Fälle: + - $B(\alpha)=0:inf\{B(\gamma)|\gamma\in\Gamma\}\leq 1 =\rightarrow_B(B(\alpha),B(\beta)) = B(\alpha\rightarrow\beta) =B(\varphi)$ + - $B(\alpha)=1:inf\{B(\gamma)|\gamma\in\Gamma\}=inf\{B(\gamma)|\gamma\in\Gamma\cup\{\alpha\}\}\leq B(\beta) =\rightarrow_B (B(\alpha),B(\beta)) = B(\alpha\rightarrow\beta) =B(\varphi)$ + Da $B$ beliebig war, habe wir $\Gamma\vdash_B \varphi$ gezeigt. + - $(raa)$ Die DeduktionDhat die Form $\frac{\bot}{\phi}$ + Sei $B$ eine passende B-Belegung. Nach IV gilt $inf\{B(\gamma)|\gamma\in\Gamma\cup\{\lnot\varphi\}\}\leq B(\bot) = 0$. + Wir unterscheiden wieder zwei Fälle: + - $inf\{B(\gamma)|\gamma\in\Gamma\}=0$: dann gilt $inf\{B(\gamma)|\gamma\in\Gamma\}\leq B(\varphi)$. + - $inf\{B(\gamma)|\gamma\in\Gamma\}=1$: Wegen $inf\{B(\gamma)|\gamma\in\Gamma\cup\{\lnot\varphi\}\}=0$ folgt $0 =B(\lnot\varphi)=\lnot_B (B(\varphi))$ und daher $B(\varphi)=1\geq inf\{B(\gamma)|\gamma\in\Gamma\}$. + Da $B$ beliebig war, haben wir $\Gamma\vdash_B \varphi$ gezeigt. + +Ist die letzte Schlußregel in der Deduktion $D$ von der Form $(\wedge I), (\vee E), (\rightarrow I)$ oder $(raa)$, so haben wir die Behauptung des Lemmas gezeigt. Analog kann dies für die verbleibenden Regeln getan werden. + +> Korrektheitssatz für natürliches Schließen & Wahrheitswertebereich $B$ +> +> Für jede Menge von Formeln $\Gamma$ und jede Formel $\varphi$ gilt $\Gamma\vdash\varphi\Rightarrow\Gamma\vdash_B\varphi$. + +Beweis: Wegen $\Gamma\vdash\varphi$ existiert eine Deduktion $D$ mit Hypothesen in $\Gamma$ und Konklusion $\varphi$. Nach dem Korrektheitslemma folgt $\Gamma\vdash_B \varphi$. + + +> Korollar: Jedes Theorem ist eine B-Tautologie. + +> Korrektheitssatz für natürliches Schließen & Wahrheitswertebereich $B$ +> +> Für jede Menge von Formeln $\Gamma$ und jede Formel $\varphi$ gilt $\Gamma\vdash\varphi\Rightarrow\Gamma\vdash_{B_\mathbb{R}}\varphi$. + +Beweis: +1. Variante: verallgemeinere den Beweis von Korrektheitslemma und Korrektheitssatz für $B$ auf $B_\mathbb{R}$ (Problem: wir haben mehrfach ausgenutzt, dass $B=\{0,1\}$ mit $0<1$) +2. Variante: Folgerung aus Korrektheitssatz für $B$. + +> Korollar: Jedes Theorem ist eine $B_\mathbb{R}$-Tautologie. + +> Korrektheitslemma für nat. Schließen & Wahrheitswertebereich $H_{mathbb{R}}$ +> +> Sei $D$ eine Deduktion mit Hypothesen in der Menge $\Gamma$ und Konklusion $\varphi$, die die Regel $(raa)$ nicht verwendet. Dann gilt $\Gamma\vdash_{H_\mathbb{R}}\varphi$. + +Beweis: ähnlich zum Beweis des Korrektheitslemmas für den Wahrheitswertebereich B. Nur die Behandlung der Regel $(raa)$ kann nicht übertragen werden. + +Beispiel: Sei $p$ eine atomare Formel. +![](Assets/Logik-beispiel-7.png) +Also gilt $\{\lnot\lnot p\}\vdash p$, d.h. $p$ ist syntaktische Folgerung von $\lnot\lnot p$. +- Sei $B$ $H_{mathbb{R}}$-Belegung mit $B(p)=\mathbb{R}\backslash\{0\}$. +- $\Rightarrow B(\lnot\lnot p) =\mathbb{R}\not\subseteq \mathbb{R}\backslash\{0\}=B(p)$ +- $\Rightarrow\lnot\lnot p\not\Vdash_{H_{mathbb{R}}} p$, d.h. $p$ ist keine $H_{mathbb{R}}$ -Folgerung von $\lnot\lnot p$. + +> Korrektheitssatz für nat. Schließen & Wahrheitswertebereich $H_{mathbb{R}}$ +> +> Für jede Menge von Formeln $\Gamma$ und jede Formel $\varphi$ gilt $\Gamma\vdash\varphi$ ohne $(raa)$ $\Rightarrow\Gamma\vdash_{H_{mathbb{R}}}\varphi$. + +> Korollar: Jedes $(raa)$-frei herleitbare Theorem ist eine $H_{mathbb{R}}$-Tautologie. + +Folgerung: Jede Deduktion der Theoreme $\lnot\lnot\varphi\rightarrow\varphi$ und $\varphi\vee\lnot\varphi$ ohne Hypothesen verwendet $(raa)$. + + +## Vollständigkeit +Können wir durch mathematische Beweise zu allen korrekten Aussagen kommen? + +Können wir durch das natürliche Schließen zu allen korrekten Aussagen kommen? + +Existiert eine Menge $\Gamma$ von Formeln und eine Formel $\varphi$ mit $\Gamma\vdash_W\varphi$ und $\Gamma\not\vdash\varphi$? Für welche Wahrheitswertebereiche $W$? + +Frage für diese Vorlesung: Für welche Wahrheitswertebereiche $W$ gilt $\Gamma\vdash_W \varphi\Rightarrow\Gamma\vdash\varphi$ bzw. $\varphi$ ist $W$-Tautologie $\Rightarrow\varphi$ ist Theorem? + +### Plan +- Sei $W$ einer der Wahrheitswertebereiche $B,K_3 ,F ,B_\mathbb{R}, H_{mathbb{R}}$. +- z.z. ist $\Gamma\vdash_W\varphi\Rightarrow\Gamma\vdash\varphi$. +- dies ist äquivalent zu $\Gamma\not\vdash\varphi\Rightarrow\Gamma\not\Vdash_W \varphi$. +- hierzu gehen wir folgendermaßen vor: + - $\Gamma \not\Vdash_W\varphi$ + - $\Leftrightarrow$ $\Gamma\cup\{\lnot\varphi\}$ konsistent + - $\Rightarrow$ $\exists\Delta\subseteq\Gamma\cup\{\lnot\varphi\}$ maximal konsistent + - $\Rightarrow$ $\Delta$ erfüllbar + - $\Rightarrow$ $\Gamma\cup\{\lnot\varphi\}$ erfüllbar + - $\Leftrightarrow$ $\Gamma\not\Vdash_B \varphi$ + - $\Rightarrow$ $\Gamma\not\Vdash\varphi$ + +### Konsistente Mengen +> Definition +> +> Sei $\Gamma$ eine Menge von Formeln. $\Gamma$ heißt inkonsistent, wenn $\Gamma\vdash\bot$ gilt. Sonst heißt $\Gamma$ konsistent. + +> Lemma +> +> Sei $\Gamma$ eine Menge von Formeln und $\varphi$ eine Formel. Dann gilt $\Gamma\not\vdash\varphi \Leftrightarrow \Gamma\cup\{\lnot\varphi\}$ konsistent. + +Beweis: Wir zeigen "$\Gamma\vdash\varphi\Leftrightarrow \Gamma\cup\{\lnot\varphi\}$ inkonsistent": +- Richtung "$\Rightarrow$", gelte also $\Gamma \vdash \varphi$. + - $\Rightarrow$ es gibt Deduktion $D$ mit Hypothesen in $\Gamma$ und Konklusion $\varphi$ + - $\Rightarrow$ Wir erhalten die folgende Deduktion mit Hypothesen in $\Gamma\cup\{\lnot\varphi\}$ und Konklusion $\bot$: $\frac{\lnot\varphi\quad\varphi}{\bot}$ + - $\Rightarrow\Gamma\cup\{\lnot\varphi\}\vdash\bot$, d.h.$\Gamma\cup\{\lnot\varphi\}$ ist inkonsistent. +- Richtung "$\Leftarrow$", sei also $\Gamma\cup\{\lnot\varphi\}$ inkonsistent. + - $\Rightarrow$ Es gibt Deduktion $D$ mit Hypothesen in $\Gamma\cup\{\lnot\varphi\}$ und Konklusion $\bot$. + - $\Rightarrow$ Wir erhalten die folgende Deduktion mit Hypothesen in $\Gamma$ und Konklusion $\varphi$: $\frac{\bot}{\varphi}$ + - $\Gamma\vdash\varphi$ + +### Maximal konsistente Mengen +> Definition +> +> Eine Formelmenge $\Delta$ ist maximal konsistent, wenn sie konsistent ist und wenn gilt "$\sum\supseteq\Delta$ konsistent $\Rightarrow\sum = \Delta$". + +> Satz +> +> Jede konsistente Formelmenge $\Gamma$ ist in einer maximal konsistenten Formelmenge $\Delta$ enthalten. + +Beweis: Sei $\varphi_1,\varphi_2,...$ eine Liste aller Formeln (da wir abzählbar viele atomare +Formeln haben, gibt es nur abzählbar viele Formeln) + +Wir definieren induktiv konsistente Mengen $\Gamma_n$: +- Setze $\Gamma_1 = \Gamma$ +- Setze $\Gamma_{n+1}= \begin{cases} \Gamma_n\cup\{\varphi_n\}\quad\text{ falls diese Menge konsistent} \\ \Gamma_n \quad\text{sonst}\end{cases}$ + +Setze nun $\Delta =\bigcup_{n\geq 1} \Gamma_n$. +1. Wir zeigen indirekt, dass $\Delta$ konsistent ist: Angenommen, $\Delta\vdash\bot$. + - $\Rightarrow$ Es gibt Deduktion $D$ mit Konklusion $\bot$ und endlicher Menge von Hypothesen $\Delta'\subseteq\Delta$. + - $\Rightarrow$ Es gibt $n\geq 1$ mit $\Delta'\subseteq\Gamma_n$ + - $\Rightarrow \Gamma_n\vdash\bot$, zu $\Gamma_n$ konsistent. Also ist $\Delta$ konsistent. +2. Wir zeigen indirekt, dass $\Delta$ maximal konsistent ist. Sei also $\sum\supseteq\Delta$ +konsistent. Angenommen, $\sum\not=\Delta$. + - $\Rightarrow$ es gibt $n\in N$ mit $\varphi_n\in\sum\backslash\Delta$ + - $\Rightarrow \Gamma_n\cup\{\varphi_n\}\subseteq\Delta\cup\sum= \sum$ konsistent. + - $\Rightarrow \varphi_n \in\Gamma_{n+1}\subseteq \Delta$, ein Widerspruch, d.h. $\Delta$ ist max. konsistent. + +> Lemma 1 +> +> Sei $\Delta$ maximal konsistent und gelte $\Delta\vdash\varphi$. Dann gilt $\varphi\in\Delta$. + +Beweis: +1. Zunächst zeigen wir indirekt, dass $\Delta\cup\{\varphi\}$ konsistent ist: + - Angenommen, $\Delta\cup\{\varphi\}\vdash\bot$. + - $\Rightarrow$ $\exists$ Deduktion $D$ mit Hypothesen in $\Delta\cup\{\varphi\}$ und Konklusion $\bot$. + - $\Delta\vdash \varphi \Rightarrow \exists$ Deduktion $E$ mit Hypothesen in $\Delta$ und Konklusion $\varphi$. + - $\Rightarrow$ Wir erhalten die folgende Deduktion: $\frac{\Delta \frac{\Delta}{\varphi}}{\bot}$ + + Also $\Delta\vdash\bot$, ein Widerspruch zur Konsistenz von $\Delta$. Also ist $\Delta\cup\{\varphi\}$ konsistent. + +2. Da $\Delta\cup\{\varphi\}\supseteq\Delta$ konsistent und $\Delta$ maximal konsistent ist, folgt $\Delta=\Delta\cup\{\varphi\}$, d.h. $\varphi\in\Delta$. + +> Lemma 2 +> +> Sei $\Delta$ maximal konsistent und $\varphi$ Formel. Dann gilt $\varphi\not\in\Delta\Leftrightarrow\lnot\varphi\in\Delta$. + +Beweis: +- Zunächst gelte $\lnot\varphi\in\Delta$. Angenommen, $\varphi\in\Delta$. Dann haben wir die Deduktion $\frac{\lnot\varphi\quad\varphi}{\bot}$ und damit $\Delta\vdash\bot$, was der Konsistenz von $\Delta$ widerspricht. +- Gelte nun $\varphi\not\in\Delta$. + - $\Rightarrow$ $\Delta(\Delta\cup\{\varphi\}\Rightarrow\Delta\cup\{\varphi\}$ inkonsistent (da $\Delta$ max. konsistent) + - $\Rightarrow$ Es gibt Deduktion $D$ mit Hypothesen in $\Delta\cup\{\varphi\}$ &Konklusion $\bot$. + - $\Rightarrow$ Wir erhalten die folgende Deduktion: $\frac{\bot}{\lnot\varphi}$ + - $\Rightarrow$ $\Delta\vdash\lnot\varphi\Rightarrow\lnot\varphi\in\Delta$ (nach Lemma 1) + +## Erfüllbare Mengen + +> Definition +> +> Sei $\Gamma$ eine Menge von Formeln. $\Gamma$ heißt erfüllbar, wenn es eine passende B-Belegung $B$ gibt mit $B(\gamma) = 1_B$ für alle $\gamma\in\Gamma$. + +Bemerkung +- Die Erfüllbarkeit einer endlichen Menge $\Gamma$ ist entscheidbar: + - Berechne Menge $V$ von in $\Gamma$ vorkommenden atomaren Formeln + - Probiere alle B-Belegungen $B:V\rightarrow B$ durch +- Die Erfüllbarkeit einer endlichen Menge $\Gamma$ ist NP-vollständig (Satz von Cook) + +> Satz +> Sei $\Delta$ eine maximal konsistente Menge von Formeln. Dann ist $\Delta$ erfüllbar. + +Beweis: Definiere eine B-Belegung $B$ mittels $B(p_i) = \begin{cases} 1_B \quad\text{ falls } p_i\in\Delta \\ 0_B \quad\text{ sonst. } \end{cases}$ +Wir zeigen für alle Formeln $\varphi: B(\varphi) = 1_B \Leftarrow\Rightarrow\varphi\in\Delta$ (*) + +Der Beweis erfolgt per Induktion über die Länge von $\varphi$. + +1. I.A.: hat $\varphi$ die Länge 1, so ist $\varphi$ atomare Formel. Hier gilt (*) nach Konstruktion von $B$. +2. I.V.: Gelte (*) für alle Formeln der Länge $1$. $\Rightarrow$ Es gibt Formeln $\alpha$ und $\beta$ der Länge$ Lemma +> +> Sei $\Gamma$ eine Menge von Formeln und $\varphi$ eine Formel. Dann gilt $\Gamma\not\Vdash_B\varphi\Leftarrow\Rightarrow\Gamma\cup\{\lnot \varphi\}$ erfüllbar. + +Beweis: $\Gamma\not\Vdash_B\varphi$ +$\Leftarrow\Rightarrow$ es gibt passende B-Belegung $B$ mit $inf\{B(\gamma)|\gamma\in\Gamma\} \not\leq_B B(\varphi)$ +$\Leftarrow\Rightarrow$ es gibt passende B-Belegung $B$ mit $inf\{B(\gamma)|\gamma\in\Gamma\}= 1_B$ und $B(\varphi)=0_B$ +$\Leftarrow\Rightarrow$ es gibt passende B-Belegung $B$ mit $B(\gamma) = 1_B$ für alle $\gamma\in\Gamma$ und $B(\lnot\varphi) = 1_B$ +$\Leftarrow\Rightarrow \Gamma\cup\{\lnot\varphi\}$ erfüllbar + +> Beobachtung: +> Sei $W$ einer der Wahrheitswertebereiche $B, K_3, F, H_R$ und $B_R,\Gamma$ eine Menge von Formeln und $\varphi$ eine Formel. Dann gilt $\Gamma\Vdash W\varphi\Rightarrow\Gamma\Vdash B\varphi$. + +Beweis: Sei $B$ beliebige B-Belegung, die zu jeder Formel in $\Gamma\cup\{\varphi\}$ paßt. definiere W-Belegung $B_W$ durch $B_W(pi) = \begin{cases} 1_W \quad\text{ falls } B(p_i) = 1_B \\ 0_W \quad\text{ sonst} \end{cases}$. +per Induktion über die Formelgröße kann man für alle Formeln $\psi$, zu denen $B$ paßt, zeigen: +$B_W(\psi) = \begin{cases} 1_W \quad\text{ falls } B(\psi) = 1_B \\ 0_W \quad\text{ sonst.} \end{cases}$ (*) + +Wir unterscheiden zwei Fälle: +- $inf\{B(\gamma)|\gamma\in\Gamma\}= 1_B \Rightarrow inf\{B_W(\gamma)|\gamma\in\Gamma\} = 1_W$ (wegen (*)) + $\Rightarrow 1_W = B_W(\varphi)$ (wegen $\Gamma\Vdash_W\varphi$) + $\Rightarrow 1_B = B(\varphi)$ (wegen (*)) + $\Rightarrow inf\{B(\gamma)|\gamma\in\Gamma\} = 1_B \leq B(\varphi)$ und +- $inf\{B(\gamma)|\gamma\in\Gamma\} \not= 1_B \Rightarrow inf\{B(\gamma)|\gamma\in\Gamma\}= 0_B$ + $\Rightarrow inf\{B(\gamma)|\gamma\in\Gamma\}= 0_B \leq B(\varphi)$. + +Da $B$ beliebig war, gilt $\Gamma\Vdash_B \varphi$. + +> Satz (Vollständigkeitssatz) +> +> Sei $\Gamma$ eine Menge von Formeln, $\varphi$ eine Formel und $W$ einer der Wahrheitswertebereiche $B,K_3 , F, B_R$ und $H_R$. Dann gilt $\Gamma\Vdash_W\varphi \Rightarrow \Gamma\vdash\varphi$. +> Insbesondere ist jede W-Tautologie ein Theorem. + +Beweis: indirekt +- $\Gamma\not\Vdash$ +- $\Gamma\cup\{\lnot\varphi\}$ konsistent +- $\exists\Delta\supseteq\Gamma\cup\{\lnot\varphi\}$ maximal konsistent +- $\Rightarrow\Delta$ erfüllbar +- $\Gamma\cup\{\lnot\varphi\}$ erfüllbar +- $\Gamma\not\Vdash_B \varphi$ +- $\Gamma\not\Vdash_W \varphi$ + +## Vollständigkeit und Korrektheit +> Satz +> +> Seien $\Gamma$ eine Menge von Formeln und $\varphi$ eine Formel. Dann gilt $\Gamma\vdash\varphi\Leftarrow\Rightarrow\Gamma\Vdash_B \varphi$. +> Insbesondere ist eine Formel genau dann eine B-Tautologie, wenn sie ein Theorem ist. + +Beweis: Folgt unmittelbar aus Korrektheitssatz und Vollständigkeitssatz. + +> Bemerkung: +> - gilt für jede "Boolesche Algebra", z.B. $B_R$ +> - $\Gamma\vdash\varphi$ ohne ($raa$) $\Leftarrow\Rightarrow\Gamma\Vdash_{H_R} \varphi$ (Tarksi 1938) + + +### Folgerung 1: Entscheidbarkeit +> Satz: die Menge der Theoreme ist entscheidbar. + +Beweis: Sei $\varphi$ Formel und $V$ die Menge der vorkommenden atomaren Formeln. Dann gilt $\varphi$ Theorem +- $\Leftarrow\Rightarrow\varphi$ B-Tautologie +- $\Leftarrow\Rightarrow$ für alle Abbildungen $B:V\rightarrow\{0_B, 1_B\}$ gilt $B(\varphi) = 1_B$ + +Da es nur endlich viele solche Abbildungen gibt und $B(\varphi)$ berechnet werden kann, ist dies eine entscheidbare Aussage. + +### Folgerung 2: Äquivalenzen und Theoreme +> Definition +> +> Zwei Formeln $\alpha$ und $\beta$ heißen äquivalent $(\alpha\equiv\beta)$, wenn für alle passenden B-Belegungen $B$ gilt: $B(\alpha) =B(\beta)$. + +> Satz: Es gelten die folgenden Äquivalenzen: +> 1. $p_1 \vee p_2 \equiv p_2 \vee p_1$ +> 2. $(p_1 \vee p_2 )\vee p_3 \equiv p_1 \vee (p_2 \vee p_3 )$ +> 3. $p_1 \vee (p_2 \wedge p_3 )\equiv (p_1 \vee p_2 )\wedge (p_1 \vee p_3 )$ +> 4. $\lnot(p_1 \vee p_2 )\equiv\lnot p_1 \wedge\lnot p_2$ +> 5. $p_1 \vee p_1 \equiv p_1$ +> 6. $(p_1 \wedge \lnot p_1 )\vee p_2 \equiv p_2$ +> 7. $\lnot\lnot p_1\equiv p_1$ +> 8. $p_1 \wedge\lnot p_1 \equiv\bot$ +> 9. $p_1 \vee\lnot p_1 \equiv\lnot\bot$ +> 10. $p_1 \rightarrow p_2 \equiv \lnot p_1 \vee p_2$ + +Beweis: Wir zeigen nur die Äquivalenz (3): +Sei $B$ beliebige B-Belegung, die wenigstens auf $\{p_1, p_2, p_3\}$ definiert ist. +Dazu betrachten wir die Wertetabelle: +| $B(p_1)$ | $B(p_2)$ | $B(p_3)$ | $B(p_1\vee(p_2\wedge p_3))$ | $B((p_1\vee p_2)\wedge(p_1 \vee p_3 ))$ | +| -------- | -------- | -------- | --------------------------- | --------------------------------------- | +| $0_B$ | $0_B$ | $0_B$ | $0_B$ | $0_B$ | +| $0_B$ | $0_B$ | $1_B$ | $0_B$ | $0_B$ | +| $0_B$ | $1_B$ | $0_B$ | $0_B$ | $0_B$ | +| $0_B$ | $1_B$ | $1_B$ | $1_B$ | $1_B$ | +| $1_B$ | $0_B$ | $0_B$ | $1_B$ | $1_B$ | +| $1_B$ | $0_B$ | $1_B$ | $1_B$ | $1_B$ | +| $1_B$ | $1_B$ | $0_B$ | $1_B$ | $1_B$ | +| $1_B$ | $1_B$ | $1_B$ | $1_B$ | $1_B$ | + +Die anderen Äquivalenzen werden analog bewiesen. + +Aus dieser Liste von Äquivalenzen können weitere hergeleitet werden: + +Beispiel: Für alle Formeln $\alpha$ und $\beta$ gilt $\lnot(\alpha\wedge\beta)\equiv\lnot\alpha\vee\lnot\beta$. + +Beweis: $\lnot(\alpha\wedge\beta) \equiv \lnot(\lnot\lnot\alpha\wedge\lnot\lnot\beta) \equiv \lnot\lnot(\lnot\alpha\vee\lnot\beta) \equiv \lnot\alpha\vee\lnot\beta$ + +> Bemerkung +> Mit den üblichen Rechenregeln für Gleichungen können aus dieser Liste alle gültigen Äquivalenzen hergeleitet werden. + +#### Zusammenhang zw. Theoremen und Äquivalenzen +> Satz +> +> Seien $\alpha$ und $\beta$ zwei Formeln. Dann gilt $\alpha\equiv\beta\Leftarrow\Rightarrow(\alpha\leftrightarrow\beta)$ ist Theorem. + +Beweis: $\alpha\equiv\beta$ +- $\Leftarrow\Rightarrow$ für alle passenden B-Belegungen $B$ gilt $B(\alpha)=B(\beta)$ +- $\Leftarrow\Rightarrow \{\alpha\}\Vdash_B\beta$ und $\{\beta\}\Vdash_B \alpha$ +- $\Leftarrow\Rightarrow \{\alpha\}\vdash\beta$ und $\{\beta\}\vdash\alpha$ (nach Korrektheits- und Vollständigkeitssatz) + +es bleibt z.z., dass dies äquivalent zu $\varnothing\vdash(\alpha\leftrightarrow\beta)$ ist. +- $\Rightarrow$: Wir haben also Deduktionen mit Hypothesen in $\{\alpha\}$ bzw. in $\{\beta\}$ und Konklusionen $\beta$ bzw.$\alpha$. Es ergibt sich eine hypothesenlose Deduktion von $\alpha\leftrightarrow\beta$: + ![](Assets/Logik-deduktion-1.png) +- $\Leftarrow$: Wir haben also eine hypothesenlose Deduktion von $\alpha\leftrightarrow\beta$. Es ergeben sich die folgenden Deduktionen mit Hypothesen $\beta$ bzw. $\alpha$ und Konklusionen $\alpha$ bzw. $\beta$: + ![](Assets/Logik-deduktion-2.png) + +> Satz +> +> Sei $\alpha$ eine Formel. Dann gilt $\alpha$ ist Theorem $\Leftarrow\Rightarrow\alpha\equiv\lnot\bot$. + +Beweis: $\alpha$ ist Theorem +- $\Leftarrow\Rightarrow\alpha$ ist B-Tautologie (Korrektheits- und Vollständigkeitssatz) +- $\Leftarrow\Rightarrow$ für alle passenden B-Belegungen $B$ gilt $B(\alpha) = 1_B$ +- $\Leftarrow\Rightarrow$ für alle passenden B-Belegungen $B$ gilt $B(\alpha) =B(\lnot\bot)$ +- $\Leftarrow\Rightarrow\alpha\equiv\lnot\bot$ + +### Folgerung 3: Kompaktheit +> Satz +> +> Sei $\Gamma$ eine u.U. unendliche Menge von Formeln und $\varphi$ eine Formel mit $\Gamma\Vdash_B\varphi$. Dann existiert $\Gamma′\subseteq\Gamma$ endlich mit $\Gamma′\Vdash_B \varphi$. + +Beweis: $\Gamma\Vdash_B\varphi$ +- $\Rightarrow\Gamma\vdash\varphi$ (nach dem Vollständigkeitssatz) +- $\Rightarrow$ es gibt Deduktion von $\varphi$ mit Hypothesen $\gamma_1,...,\gamma_n\in\Gamma$ +- $\Rightarrow\Gamma′=\{\gamma_1,...,\gamma_n\}\subseteq\Gamma$ endlich mit $\Gamma′\vdash\varphi$ +- $\Rightarrow\Gamma′\Vdash_B\varphi$ (nach dem Korrektheitssatz). + +> Folgerung (Kompaktheits- oder Endlichkeitssatz) +> +> Sei $\Gamma$ eine u.U. unendliche Menge von Formeln. Dann gilt $\Gamma$ unerfüllbar $\Leftarrow\Rightarrow\exists\Gamma′\subseteq\Gamma$ endlich: $\Gamma′$ unerfüllbar + +Beweis: $\Gamma$ unerfüllbar +- $\Leftarrow\Rightarrow\Gamma\cup\{\lnot\bot\}$ unerfüllbar +- $\Leftarrow\Rightarrow\Gamma\Vdash_B\bot$ +- $\Leftarrow\Rightarrow$ es gibt $\Gamma′\subseteq\Gamma$ endlich: $\Gamma′\Vdash_B\bot$ +- $\Leftarrow\Rightarrow$ es gibt $\Gamma′\subseteq\Gamma$ endlich: $\Gamma′\cup\{\lnot\bot\}$ unerfüllbar +- $\Leftarrow\Rightarrow$ es gibt $\Gamma′\subseteq\Gamma$ endlich: $\Gamma′$ unerfüllbar + + +### 1. Anwendung des Kompaktheitsatzes: Färbbarkeit +> Definition +> +> Ein Graph ist ein Paar $G=(V,E)$ mit einer Menge $V$ und $E\subseteq\binom{V}{2} =\{X\subseteq V:|V$\Vdash$ 2 \}$. +> Für $W\subseteq V$ sei $G\upharpoonright_W= (W,E\cap\binom{W}{2})$ der von $W$ induzierte Teilgraph. +> Der Graph G ist 3-färbbar, wenn es eine Abbildung $f:V\rightarrow\{1,2,3\}$ mit $f(v)\not=f(w)$ für alle $\{v,w\}\in E$. + +Bemerkung: Die 3-Färbbarkeit eines endlichen Graphen ist NP-vollständig + +> Satz +> Sei $G= (N,E)$ ein Graph. Dann sind äquivalent +> 1. $G$ ist 3-färbbar. +> 2. Für jede endliche Menge $W\subseteq N$ ist $G\upharpoonright_W$ 3-färbbar. + +Beweis: +- $1.\Rightarrow 2.$ trivial +- $2.\Rightarrow 1.$ Sei nun, für alle endlichen Menge $W\subseteq N$, der induzierte Teilgraph $G\upharpoonright_W$ 3-färbbar. + +Wir beschreiben zunächst mit einer unendlichen Menge $\Gamma$ von Formeln, dass eine 3-Färbung existiert: +- atomare Formeln $p_{n,c}$ für $n\in N$ und $c\in\{1,2,3\}$ (Idee: der Knoten n hat die Farbe c) +- $\Gamma$ enthält die folgenden Formeln: + - für alle $n\in N:p_{n, 1} \vee p_{n, 2} \vee p_{n, 3}$ (der Knoten n ist gefärbt) + - für alle $n\in N:\bigwedge_{1\leq c< d \leq 3} \lnot(p_{n,c} \wedge p_{n,d})$ (der Knoten n ist nur mit einer Farbe gefärbt) + - für alle $\{m,n\}\in E: \bigwedge_{1\leq c\leq 3} \lnot(p_{m,c} \wedge p_{n,c})$ (verbundene Knoten m und n sind verschieden gefärbt) + + +Behauptung: Jede endliche Menge $\Delta\subseteq\Gamma$ ist erfüllbar. + +Begründung: +- Da $\Delta$ endlich ist, existiert endliche Menge $W\subseteq N$, so dass jede atomare Formel in $\Delta$ die Form $p_{n,c}$ für ein $n\in W$ und ein $c\in\{1,2,3\}$ hat. +- Nach Annahme existiert $f_W:W\rightarrow\{1,2,3\}$ mit $f_W(m) \not=f(n)$ f.a. $\{m,n\}\in E\cap\binom{W}{2}$. +- Definiere $B:\{p_{n,c}|n\in W, 1 \leq c\leq 3\}\rightarrow\{0,1\}$ durch $B(p_{n,c}) = \begin{cases} 1 \quad\text{ falls } f_W(n) = c \\ 0 \quad\text{ sonst.} \end{cases}$ +- Diese Belegung erfüllt $\Delta$, d.h. $\Delta$ ist erfüllbar, womit die Behauptung gezeigt ist. + +Nach dem Kompaktheitssatz ist also $\Gamma$ erfüllbar. +Sei $B$ erfüllende Belegung. Für $n\in N$ existiert genau ein $c\in\{1,2,3\}$ mit $B(p_{n,c}) =1$. Setze $f(n) =c$. Dann ist $f$ eine gültige Färbung des Graphen $G$. + +### 2. Anwendung des Kompaktheitsatzes: Parkettierungen +Idee: Gegeben ist eine Menge von quadratischen Kacheln mit gefärbten Kanten. Ist es möglich, mit diesen Kacheln die gesamte Ebene zu füllen,so dass aneinanderstoßende Kanten gleichfarbig sind? + +Berühmtes Beispiel: Mit diesen 11 Kacheln kann die Ebene gefüllt werden, aber dies ist nicht periodisch möglich. +![](Assets/Logik-parkettierung-1.png) + +> Definition +> +> Ein Kachelsystem besteht aus einer endlichen Menge C von "Farben" und einer Menge K von Abbildungen $\{N,O,S,W\}\rightarrow C$ von "Kacheln". +> Eine Kachelung von $G\subseteq Z\times Z$ ist eine Abbildung $f:G\rightarrow K$ mit +> - $f(i,j)(N) =f(i,j+ 1 )(S)$ für alle $(i,j),(i,j+ 1 )\in G$ +> - $f(i,j)(O) =f(i+ 1 ,j)(W)$ für alle $(i,j),(i+ 1 ,j)\in G$ + +> Satz +> +> Sei $K$ ein Kachelsystem. Es existiert genau dann eine Kachelung von $Z\times Z$, wenn für jedes $n\in N$ eine Kachelung von $\{(i,j) :|i|,|j| \leq n\}$ existiert. + +Beweis: +- $\Rightarrow$: trivial +- $\Leftarrow$: Wir beschreiben zunächst mit einer unendlichen Menge $\Gamma$ von Formeln, dass eine Kachelung existiert: + atomare Formeln $p_{k,i,j}$ für $k\in K$ und $i,j\in Z$ (Idee: an der Stelle $(i,j)$ liegt die Kachel $k$, d.h. $f(i,j) =k$) + Für alle $(i,j)\in Z$ enthält $\Gamma$ die folgenden Formeln: + - eine der Kacheln aus $K$ liegt an der Stelle $(i,j):\bigvee_{k\in K} p_{k,i,j}$ + - es liegen nicht zwei verschiedene Kacheln an der Stelle $(i,j): \bigwedge_{k,k′\in K,k\not=k′} \lnot(p_{k,i,j}\wedge p_{k′,i,j})$ + - Kacheln an Stellen $(i,j)$ und $(i,j+1)$ "passen übereinander": $\bigvee_{k,k′\in K,k(N)=k′(S)} (p_{k,i,j}\wedge p_{k′,i,j+1})$ + - Kacheln an Stellen $(i,j)$ und $(i+1,j)$ "passen nebeneinander": $\bigvee_{k,k′\in K,k(W)=k′(O)} (p_{k,i,j}\wedge p_{k′,i+1,j})$ + +Sei nun $\Delta\subseteq\Gamma$ endlich. +- $\Rightarrow$ es gibt $n\in N$, so dass $\Delta$ nur atomare Formeln der Form $p_{k,i,j}$ mit $|i|,|j|\leq n$ enthält. +- Voraussetzung $\Rightarrow$ es gibt Kachelung $g:\{(i,j) :|i|,|j| \leq n\}\rightarrow K$ für $k\in K$ und $|i|,|j|\leq n$ definiere $B(p_{k,i,j}) = \begin{cases} 1_B \quad\text{ falls } g(i,j) =k \\ 0_B \quad\text{ sonst} \end{cases}$ +- $\Rightarrow B(\sigma) = 1_B$ für alle $\sigma\in\Delta$ (da $g$ Kachelung) +- Also haben wir gezeigt, dass jede endliche Teilmenge von $\Gamma$ erfüllbar ist. +- Kompaktheitssatz $\Rightarrow$ es gibt B-Belegung $B$ mit $B(\gamma) = 1_B$ für alle $\gamma\in\Gamma$ +- $\Rightarrow$ es gibt Abbildung $f:Z\times Z\rightarrow K$ mit $f(i,j) =k \Leftarrow\Rightarrow B(p_{k,i,j}) = 1_B$. +- Wegen $B\Vdash\Gamma$ ist dies eine Kachelung. + +Weitere Anwendungen des Kompaktheitsatzes +- abz. partielle Ordnungen sind linearisierbar +- abz. Gleichungssystem über $\mathbb{Z}_2$ lösbar $\Leftarrow\Rightarrow$ jedes endliche Teilsystem lösbar +- Heiratsproblem +- Kőnigs Lemma (Übung) +- ... + +Bemerkung: Der Kompaktheitssatz gilt auch, wenn die Menge der atomaren Formeln nicht abzählbar ist. Damit gelten die obigen Aussagen allgemeiner: +- 3-Färbbarkeit: beliebige Graphen +- Linearisierbarkeit: beliebige partielle Ordnungen +- Lösbarkeit: beliebig große Gleichungssysteme über $\mathbb{Z}_2$ +- ... + + +## Erfüllbarkeit +> Erfüllbarkeitsproblem +> +> Eingabe: Formel $\Gamma$ +> +> Frage: existiert eine B-Belegung $B$ mit $B(\Gamma) = 1_B$. + +- offensichtlicher Algorithmus: probiere alle Belegungen durch (d.h. stelle Wahrheitswertetabelle auf)$\rightarrow$ exponentielle Zeit +- "Automaten, Sprachen und Komplexität": das Problem ist NP-vollständig +- nächstes Ziel:spezielle Algorithmen für syntaktisch eingeschränkte Formeln $\Gamma$ +- Spätere Verallgemeinerung dieser Algorithmen (letzte Vorlesung des Logik-Teils von "Logik und Logikprogrammierung") bildet Grundlage der logischen Programmierung. + +### Hornformeln (Alfred Horn, 1918-2001) +> Definition +> +> Eine Hornklausel hat die Form $(\lnot\bot\wedge p_1\wedge p_2\wedge ... \wedge p_n)\rightarrow q$ für $n\geq 0$, atomare Formeln $p_1 ,p_2 ,... ,p_n$ und $q$ atomare Formel oder $q=\bot$. +> Eine Hornformel ist eine Konjunktion von Hornklauseln. + +Schreib- und Sprechweise +- $\{p_1,p_2 ,... ,p_n\}\rightarrow q$ für Hornklausel $(\lnot\bot\wedge p_1 \wedge p_2 \wedge ...\wedge p_n)\rightarrow q$ + insbes. $\varnothing\rightarrow q$ für $\lnot\bot\rightarrow q$ +- $\{(M_i\rightarrow q_i)| 1 \leq i\leq n\}$ für Hornformel $\bigwedge_{1 \leq i \leq n} (M_i\rightarrow q_i)$ + +Bemerkung, in der Literatur auch: +- $\{\lnot p_1,\lnot p_2 ,... ,\lnot p_n,q\}$ für $\{p_1 ,... ,p_n\}\rightarrow q$ mit $q$ atomare Formel +- $\{\lnot p_1,\lnot p_2 ,... ,\lnot p_n\}$ für $\{p_1 ,... ,p_n\}\rightarrow\bot$ +- $\Box$ für $\varnothing\rightarrow\bot$, die "leere Hornklausel" + +### Markierungsalgorithmus +- Eingabe: eine endliche Menge $\Gamma$ von Hornklauseln. +1. while es gibt in $\Gamma$ eine Hornklausel $M\rightarrow q$, so dass alle $p\in M$ markiert sind und $q$ unmarkierte atomare Formel ist: + do markiere $q$ (in allen Hornklauseln in $\Gamma$) +2. if $\Gamma$ enthält eine Hornklausel der Form $M\rightarrow\bot$, in der alle $p\in M$ markiert sind + then return "unerfüllbar" + else return "erfüllbar" + +Beweis einer Folgerung: Beispiel +- Ziel ist es, die folgende Folgerung zu zeigen: $\{(AK\vee BK),(AK\rightarrow BK),(BK\wedge RL\rightarrow\lnot AK),RL\}\Vdash\lnot AK$ +- Lemma: man muß Unerfüllbarkeit der folgenden Menge zeigen: $\{(AK\vee BK),(AK\rightarrow BK),(BK\wedge RL\rightarrow \lnot AK),RL,\lnot\lnot AK\}$ +- Dies ist keine Menge von Hornklauseln! +- Idee: ersetze $BK$ durch $\lnot BH$ in allen Formeln. +- Ergebnis: + - Aus $AK\vee BK$ wird $\lnot BH\vee AK\equiv BH\rightarrow AK\equiv\{BH\}\rightarrow AK$. + - Aus $AK\rightarrow BK$ wird $AK\rightarrow\lnot BH\equiv\lnot AK\vee\lnot BH\equiv AK\wedge BH\rightarrow\bot\equiv\{AK,BH\} \rightarrow\bot$. + - Aus $BK\wedge RL\rightarrow\lnot AK$ wird $\lnot BH\wedge RL\rightarrow\lnot AK\equiv BH\vee\lnot RL\vee\lnot AK\equiv RL\wedge AK\rightarrow BH\equiv\{RL,AK\}\rightarrow BH$ + - $RL\equiv (\varnothing\rightarrow RL)$ + - $\lnot\lnot AK\equiv (\varnothing\rightarrow AK)$ +- Wir müssen also zeigen, dass die folgende Menge von Hornklauseln unerfüllbar ist: + $\{\{BH\}\rightarrow AK,\{AK,BH\}\rightarrow\bot,\{RL,AK\}\rightarrow BH,\varnothing\rightarrow RL,\varnothing\rightarrow AK\}$ + +Der Markierungsalgorithmus geht wie folgt vor: +1. Runde: markiere $RL$ aufgrund der Hornklausel $\varnothing\rightarrow RL$ +2. Runde: markiere $AK$ aufgrund der Hornklausel $\varnothing\rightarrow AK$ +3. Runde: markiere $BH$ aufgrund der Hornklausel $\{RL,AK\}\rightarrow BH$ + +dann sind keine weiteren Markierungen möglich. + +In der Hornklausel $\{AK,BH\}\rightarrow\bot$ sind alle atomaren Formeln aus $\{AK,BH\}$ markiert. Also gibt der Algorithmus aus, dass die Menge von Hornklauseln nicht erfüllbar ist. + +Nach unserer Herleitung folgern wir, dass das Teil $A$ heil ist. + +1. Der Algorithmus terminiert: + in jedem Durchlauf der while-Schleife wird wenigstens eine atomare Formel markiert. Nach endlich vielen Schritten terminiert die Schleife also. +2. Wenn der Algorithmus eine atomare Formelqmarkiert und wenn $B$ eine B-Belegung ist, die $\Gamma$ erfüllt, dann gilt $B(q) = 1_B$. + Beweis: wir zeigen induktiv über $n$: Wenn $q$ in einem der ersten $n$ Schleifendurchläufe markiert wird, dann gilt $B(q) = 1_B$. + - I.A. Die Aussage gilt offensichtlich für $n=0$. + - I.S. werde die atomare Formel $q$ in einem der ersten $n$ Schleifendurchläufe markiert. Dann gibt es eine Hornklausel $\{p_1,p_2 ,... ,p_k\}\rightarrow q$, so dass $p_1 ,... ,p_k$ in den ersten $n-1$ Schleifendurchläufen markiert wurden. Also gilt $B(p_1)=...=B(p_k) = 1_B$ nach IV. + Da $B$ alle Hornformeln aus $\Gamma$ erfüllt, gilt insbesondere $B(\{p_1 ,p_2 ,... ,p_k\}\rightarrow q) = 1_B$ und damit $B(q) = 1_B$. +3. Wenn der Algorithmus "unerfüllbar" ausgibt, dann ist $\Gamma$ unerfüllbar. + Beweis: indirekt, wir nehmen also an, dass der Algorithmus "unerfüllbar" ausgibt, $B$ aber eine B-Belegung ist, die $\Gamma$ erfüllt. + Sei $\{p_1 ,... ,p_k\}\rightarrow\bot$ die Hornklausel aus $\Gamma$, die die Ausgabe "unerfüllbar" verursacht (d.h. die atomaren Formeln $p_1 ,... ,p_k$ sind markiert). + Nach 2. gilt $B(p_1) =...=B(p_k) = 1_B$, also $B(\{p_1 ,p_2 ,... ,p_k\}\rightarrow\bot) = 0_B$ im Widerspruch zur Annahme, dass $B$ alle Hornklauseln aus $\Gamma$ erfüllt. + Also kann es keine erfüllende B-Belegung von $\Gamma$ geben. +4. Wenn der Algorithmus "erfüllbar" ausgibt, dann erfüllt die folgende B-Belegung alle Formeln aus $\Gamma$: + $B(p_i)=\begin{cases} 1_B \quad\text{ der Algorithmus markiert } p_i \\ 0_B \quad\text{ sonst} \end{cases}$ + Beweis: + - Sei $M\rightarrow q$ eine beliebige Hornklausel aus $\Gamma$. + - Ist ein $p\in M$ nicht markiert, so gilt $B(\bigwedge_{p\in M} p) = 0_B$ und damit $B(M\rightarrow q) = 1_B$. + - Sind alle $p\in M$ markiert, so wird auch $q$ markiert, also $B(q) = 1_B$ und damit $B(M\rightarrow q) = 1_B$. + - Gilt $q=\bot$, so existiert unmarkiertes $p\in M$ (da der Algorithmus sonst "unerfüllbar" ausgegeben hätte), also $B(M\rightarrow\bot) = 1_B$ wie im ersten Fall. + Also gilt $B(M\rightarrow q) = 1_B$ für alle Hornklauseln aus $\Gamma$, d.h. $\Gamma$ ist erfüllbar. + +> Satz +> +> Sei $\Gamma$ endliche Menge von Hornklauseln. Dann terminiert der Markierungsalgorithmus mit dem korrekten Ergebnis. + +Beweis: Die Aussagen 1.-4. beweisen diesen Satz. + +Bemerkungen: +- Mit einer geeigneten Implementierung läuft der Algorithmusin linearer Zeit. +- Wir haben sogar gezeigt, dass bei Ausgabe von "erfüllbar" eine erfüllende B-Belegung berechnet werden kann. + +### SLD-Resolution +> Definition +> +> Sei $\Gamma$ eine Menge von Hornklauseln. Eine SLD-Resolution aus $\Gamma$ ist eine Folge $(M_0\rightarrow\bot,M_1\rightarrow\bot,... ,M_m\rightarrow\bot)$ von Hornklauseln mit +> - $(M_0\rightarrow\bot)\in\Gamma$ +> - für alle $0\leq n Lemma A +> +> Sei $\Gamma$ eine (u.U. unendliche) Menge von Hornklauseln und $(M_0\rightarrow\bot, M_1\rightarrow\bot,... , M_m\rightarrow\bot)$ eine SLD-Resolution aus $\Gamma$ mit $M_m=\varnothing$. Dann ist $\Gamma$ nicht erfüllbar. + +Beweis: +- indirekt: angenommen, es gibt B-Belegung $B$ mit $B(N\rightarrow q) = 1_B$ für alle $(N\rightarrow q)\in\Gamma$. +- Wir zeigen für alle $0\leq n\leq m$ per Induktion über n: es gibt $p\in M_n$ mit $B(p) = 0_B$ (4) +- I.A.: $n=0:(M_0 \rightarrow\bot,...)$ SLD-Resolution $\Rightarrow(M_0\rightarrow\bot)\in\Gamma$ + - $\Rightarrow B(M_0\rightarrow\bot) = 1_B$ + - $\Rightarrow$ es gibt $p\in M_0$ mit $B(p) = 0_B$ +- I.V.: sei $n Lemma B +> +> Sei $\Gamma$ eine (u.U. unendliche) unerfüllbare Menge von Hornklauseln. Dann existiert eine SLD-Resolution $(M_0\rightarrow\bot,...,M_m\rightarrow\bot)$ aus $\Gamma$ mit $M_m=\varnothing$. + +Beweis: Endlichkeitssatz: es gibt $\Delta\subseteq\Gamma$ endlich und unerfüllbar. Bei Eingabe von$\Delta$ terminiert Markierungsalgorithmus mit "unerfüllbar" +- $r\geq 0...$ Anzahl der Runden +- $q_i...$ Atomformel, die in $i$ Runde markiert wird $(1\leq i\leq r)$ + +Behauptung: Es gibt $m\leq r$ und SLD-Resolution $(M_0\rightarrow\bot,...,M_m\rightarrow\bot)$ aus $\Delta$ mit $M_m=\varnothing$ und $M_n\subseteq\{q_1,q_2,... ,q_{r-n}\}$ f.a. $0\leq n\leq m$. (5) + +Beweis der Behauptung: Wir konstruieren die Hornklauseln $M_i\rightarrow\bot$ induktiv: +- I.A.: Da der Markierungsalgorithmus mit "unerfüllbar" terminiert, existiert eine Hornklausel $(M_0\rightarrow\bot)\in\Gamma$ mit $M_0\subseteq\{q_1,... ,q_{r- 0}\}$. $(M_0\rightarrow\bot)$ ist SLD-Resolution aus $\Delta$, die (5) erfüllt. +- I.V.: Sei $n\leq r$ und $(M_0\rightarrow\bot,... ,M_n\rightarrow\bot)$ SLD-Resolution, so dass (5) gilt. +- I.S.: wir betrachten drei Fälle: + 1. Fall $M_n=\varnothing$: mit $m:=n$ ist Beweis der Beh. abgeschlossen. + 2. Fall $n=r$: Nach (5) gilt $M_n\subseteq\{q_1,...,q_{r-n}\}=\varnothing$. Mit $m:=n$ ist der Beweis der Beh. abgeschlossen. + 3. Fall $n Satz +> +> Sei $\Gamma$ eine (u.U. unendliche) Menge von Hornklauseln. Dann sind äquivalent: +> 1. $\Gamma$ ist nicht erfüllbar. +> 2. Es gibt eine SLD-Resolution $(M_0\rightarrow\bot,M_1\rightarrow\bot,... ,M_m\rightarrow\bot)$ aus $\Gamma$ mit $M_m=\varnothing$. + +Beweis: Folgt unmittelbar aus Lemmata A und B. + +Beispiel: $\Gamma=\{\{a,b\}\rightarrow\bot,\{a\}\rightarrow c, \{b\}\rightarrow c,\{c\}\rightarrow a,\varnothing\rightarrow b$; alle SLD-Resolutionen aus$\Gamma$ kann man durch einen Baum beschreiben: +![](Assets/Logik-beispiel-11.png) + +Die Suche nach einer SLD-Resolution mit $M_m=\varnothing$ kann grundsätzlich auf zwei Arten erfolgen: +- Breitensuche: + - findet SLD-Resolution mit $M_m=\varnothing$ (falls sie existiert), da Baum endlich verzweigend ist (d.h. die Niveaus sind endlich) + - hoher Platzbedarf, da ganze Niveaus abgespeichert werden müssen (in einem Binärbaum der Tiefe $n$ kann es Niveaus der Größe $2^n$ geben) +- Tiefensuche: + - geringerer Platzbedarf (in einem Binärbaum der Tiefe $n$ hat jeder Ast die Länge $\leq n$) + - findet existierende SLD-Resolution mit $M_m=\varnothing$ nicht immer (siehe Beispiel) + +## Zusammenfassung Aussagenlogik +- Das natürliche Schließen formalisiert die "üblichen" Argumente in mathematischen Beweisen. +- Unterschiedliche Wahrheitswertebereiche formalisieren unterschiedliche Vorstellungen von "Wahrheit". +- Das natürliche Schließen ist vollständig und korrekt für den Booleschen Wahrheitswertebereich. +- Der Markierungsalgorithmus und die SLD-Resolution sind praktikable Verfahren, um die Erfüllbarkeit von Hornformeln zu bestimmen. + +# Kapitel 2: Prädikatenlogik + +Beispiel: Graphen +![](Assets/Logik-prädikatenlogik-graph.png) +Um über diesen Graphen Aussagen in der Aussagenlogik zu machen, verwenden wir Formeln $\varphi_{i,j}$ für $1\leq i,j\leq 9$ mit $\varphi_{i,j}=\begin{cases} \lnot\bot\quad\text{ falls} (v_i,v_j) Kante\\ \bot\quad\text{ sonst}\end{cases}$ +- Die aussagenlogische Formel $\bigvee_{1\leq i,j\leq 9} \varphi_{i,j}$ sagt aus, dass der Graph eine Kante enthält. +- Die aussagenlogische Formel $\bigwedge_{1\leq i\leq 9} \bigvee_{1\leq j\leq 9} \varphi_{i,j}$ sagt aus, dass jeder Knoten einen Nachbarn hat +- Die aussagenlogische Formel $\bigvee_{1\leq i,j,k\leq 9 verschieden} \varphi_{i,j}\wedge\varphi_{j,k}\wedge\varphi_{k,i}$ sagt aus, dass der Graph ein Dreieck enthält. +Man kann so vorgehen, wenn der Graph bekannt und endlich ist. Sollen analoge Aussagen für einen anderen Graphen gemacht werden, so ist die Kodierungsarbeit zu wiederholen. + +Beispiel: Datenbanken +- Im folgenden reden wir über die Studenten und die Lehrenden in Veranstaltungen zur Theoretischen Informatik in diesem Semester. Betrachte die folgenden Aussagen: + - Jeder ist Student oder wissenschaftlicher Mitarbeiter oder Professor. + - Dietrich Kuske ist Professor. + - Kein Student ist Professor. + - Jeder Student ist jünger als jeder Professor. + - Es gibt eine Person, die an den Veranstaltungen "Logik und Logikprogrammierung" und "Algorithmen und Datenstrukturen" teilnimmt. + - Es gibt eine Person, die kein wissenschaftlicher Mitarbeiter ist und nicht an beiden Veranstaltungen teilnimmt. + - Jeder Student ist jünger als die Person, mit der er am besten über Informatik reden kann. +- Um sie in der Aussagenlogik machen zu können, müssen wir atomare Aussagen für "Hans ist Student", "Otto ist jünger als Ottilie" usw. einführen. Dies ist nur möglich, wenn + 1. alle involvierten Personen bekannt sind und fest stehen und + 2. es nur endlich viele involvierte Personen gibt. +- Sollen analoge Aussagen für das vorige oder das kommende Jahr gemacht werden, so ist die gesamte Kodierungsarbeit neu zu machen. + + +## Kodierung in einer "Struktur" +- Grundmenge: Die Studenten und die Lehrenden in Veranstaltungen zur Theoretischen Informatik in diesem Sommersemester +- Teilmengen: + - $S(x)$ "x ist Student" + - $LuLP(x)$ "x nimmt an der Veranstaltung LuLP teil" + - $AuD(x)$ "x nimmt an der Veranstaltung AuD teil" + - $Pr(x)$ "x ist Professor" + - $WM(x)$ "x ist wissenschaftlicher Mitarbeiter" +- Relationen: + - $J(x,y)$ "x ist jünger als y" +- Funktion: + - $f(x)$ ist diejenige Person (aus dem genannten Kreis), mit der x am besten über Informatik reden kann. +- Konstante: + - $dk$ Dietrich Kuske + +Die in der Aussagenlogik nur schwer formulierbaren Aussagen werden nun +- Für alle $x$ gilt $S(x)\vee WM(x)\vee Pr(x)$ +- $Pr(dk)$ +- Für alle $x$ gilt $S(x)\rightarrow\lnot Pr(x)$ +- Für alle $x$ und $y$ gilt $(S(x)\wedge Pr(y))\rightarrow J(x,y)$ +- Es gibt ein $x$ mit $LuLP(x)\wedge AuD(x)$ +- Es gibt ein $x$ mit $((\lnot LuLP(x)\vee\lnot AuD(x))\wedge\lnot WM(x))$ +- Für alle $x$ gilt $S(x)\rightarrow J(x,f(x))$ + +Bemerkung: Diese Formulierungen sind auch brauchbar, wenn die Grundmenge unendlich ist. Sie sind auch unabhängig vom Jahr (im nächsten Jahr können diese Folien wieder verwendet werden). + +Ziel +- Wir wollen in der Lage sein, über Sachverhalte in "Strukturen" (Graphen, Datenbanken, relle Zahlen, Gruppen... ) zu reden. +- Dabei soll es "Relationen" geben, durch die das Enthaltensein in einer Teilmenge oder Beziehungen zwischen Objekten ausgedrückt werden können (z.B. $S(x),J(x,y),...$ ) +- Weiter soll es "Funktionen" geben, durch die Objekte (oder Tupel von Objekten) auf andere Objekte abgebildet werden (z.B. $f$) +- Nullstellige Funktionen (ohne Argumente): Konstante (z.B. $dk$) + +Fragen +- Nach welchen Regeln bildet man korrekte Formeln? +- Was ist eine Struktur? +- Wann hat eine Aussage in einer Struktur eine Bedeutung (ist "sinnvoll")? +- Wann "gilt" eine Aussage in einer Struktur? +- Gibt es Formeln, die in allen Strukturen gelten? +- Kann man solche Formeln algorithmisch identifizieren? Gibt es einen Beweiskalkül wie das natürliche Schließen oder die SLD-Resolution? +- ......... + +## Syntax der Prädikatenlogik +Formeln machen Aussagen über Strukturen. Dabei hat es keinen Sinn zu fragen, ob eine Formel, die über Studenten etc. redet, im Graphen $G$ gilt. + +> Definition +> +> Eine Signatur ist ein Tripel $\sum=(\Omega, Rel,ar)$, wobei $\Omega$ und $Rel$ disjunkte Mengen von Funktions- und Relationsnamen sind und $ar:\Omega\cup Rel\rightarrow\mathbb{N}$ eine Abbildung ist. + +Beispiel: $\Omega=\{f,dk\}$ mit $ar(f) =1,ar(dk)=0$ und $Rel=\{S,LuLP,AuD,Pr,WM,J\}$ mit $ar(S) =ar(LuLP) =ar(AuD) =ar(Pr) =ar(WM) =1 undar(J) = 2$ bilden die Signatur der Datenbank von vorhin. +- typische Funktionsnamen: $f, g, a, b...$ mit $ar(f),ar(g) > 0$ und $ar(a) =ar(b) = 0$ +- typische Relationsnamen: $R,S,...$ + +> Definition +> +> Die Menge der Variablen ist $Var=\{x_0,x_1 ,...\}$. + +> Definition +> +> Sei $\sum$ eine Signatur. Die Menge $T_{\sum}$ der $\sum$-Terme ist induktiv definiert: +> 1. Jede Variable ist ein Term, d.h. $Var\subseteq T_{\sum}$ +> 2. ist $f\in\Omega$ mit $ar(f)=k$ und sind $t_1,...,t_k\in T_{\sum}$, so gilt $f(t_1,...,t_k)\in T_{\sum}$ +> 3. Nichts ist $\sum$-Term, was sich nicht mittels der obigen Regeln erzeugen läßt. + +Beispiel:In der Signatur der Datenbank von vorhin haben wir u.a. die folgenden Terme: +- $x_1$ und $x_8$ +- $f(x_0)$ und $f(f(x_3))$ +- $dk()$ und $f(dk())$ - hierfür schreiben wir kürzer $dk$ bzw. $f(dk)$ + + +> Definition +> +> Sei $\sum$ Signatur. Die atomaren $\sum$-Formeln sind die Zeichenketten der Form +> - $R(t_1,t_2,...,t_k)$ falls $t_1,t_2,...,t_k\in T_{\sum}$ und $R\in Rel$ mit $ar(R)=k$ oder +> - $t_1=t_2$ falls $t_1,t_2\in T_{\sum}$ oder +> - $\bot$. + +Beispiel: In der Signatur der Datenbank von vorhin haben wir u.a. die folgenden atomaren Formeln: +- $S(x_1)$ und $LuLP(f(x4))$ +- $S(dk)$ und $AuD(f(dk))$ + +> Definition +> +> Sei $\sum$ Signatur. $\sum$-Formeln werden durch folgenden induktiven Prozeß definiert: +> 1. Alle atomaren $\sum$-Formeln sind $\sum$-Formeln. +> 2. Falls $\varphi$ und $\Psi$ $\sum$-Formeln sind, sind auch $(\varphi\wedge\Psi)$,$(\varphi\vee\Psi)$ und $(\varphi\rightarrow\Psi)$ $\sum$-Formeln. +> 3. Falls $\varphi$ eine $\sum$-Formel ist, ist auch $\lnot\varphi$ eine $\sum$-Formel. +> 4. Falls $\varphi$ eine $\sum$-Formel und $x\in Var$, so sind auch $\forall x\varphi$ und $\exists x\varphi$ $\sum$-Formeln. +> 5. Nichts ist $\sum$-Formel, was sich nicht mittels der obigen Regeln erzeugen läßt. + +Ist die Signatur $\sum$ aus dem Kontext klar, so sprechen wir einfach von Termen, atomaren Formeln bzw.Formeln. + +Beispiel:In der Signatur der Datenbank von vorhin haben wir u.a. die folgenden Formeln: +- $\forall x_0 (S(x_0)\vee WM(x_0)\vee Pr(x_0))$ +- $Pr(dk)$ +- $\forall x_3 (S(x_3)\rightarrow\lnot Pr(x_3))$ +- $\forall x_0 \forall x_2 ((S(x_0)\wedge Pr(x_2))\rightarrow J(x_0,x_2))$ +- $\exists x_1 (LuLP(x_1)\wedge AuD(x_1))$ +- $\exists x_2 ((\lnot LuLP(x_2)\vee\lnot AuD(x_2))\wedge\lnot WM(x_2))$ +- $\forall x_1 (S(x_1)\rightarrow J(x_1,f(x_1)))$ + +Wir verwenden die aus der Aussagenlogik bekannten Abkürzungen, z.B. steht $\varphi\leftrightarrow\Psi$ für $(\varphi\rightarrow\Psi)\wedge(\Psi\rightarrow\varphi)$. + +Zur verbesserten Lesbarkeit fügen wir mitunter hinter quantifizierten Variablen einen Doppelpunkt ein, z.B. steht $\exists x\forall y:\varphi$ für $\exists x\forall y\varphi$ + +Ebenso verwenden wir Variablennamen $x$,$y$,$z$ u.ä. + +Präzedenzen: $\lnot,\forall x,\exists x$ binden am stärksten + +Beispiel: $(\lnot\forall x:R(x,y)\wedge\exists z:R(x,z))\rightarrow P(x,y,z)$ steht für $((\lnot(\forall x:R(x,y))\wedge\exists z:R(x,z))\rightarrow P(x,y,z))$ + +## Aufgabe +Im folgenden seien +- $P$ ein-stelliges, $Q$ und $R$ zwei-stellige Relationssymbole, +- $a$ null-stelliges und $f$ ein-stelliges Funktionssymbol und +- $x,y$ und $z$ Variable. + +Welche der folgenden Zeichenketten sind Formeln? +| | | +| --------------------------------------------- | ---- | +| $\forall x P(a)$ | ja | +| $\forall x\exists y(Q(x,y)\vee R(x))$ | nein | +| $\forall x Q(x,x)\rightarrow\exists x Q(x,y)$ | ja | +| $\forall x P(f(x))\vee\forall$ x Q(x,x)$ | ja | +| $\forall x(P(y)\wedge\forall y P(x))$ | ja | +| $P(x) \rightarrow\exists x Q(x,P(x))$ | nein | +| $\forall f\exists x P(f(x))$ | nein | + +> Definition +> +> Sei $\sum$ eine Signatur. Die Menge $FV(\varphi)$ der freien Variablen einer $\sum$-Formel $\varphi$ ist induktiv definiert: +> - Ist $\varphi$ atomare $\sum$-Formel, so ist $FV(\varphi)$ die Menge der in $\varphi$ vorkommenden Variablen. +> - $FV(\varphi\Box\Psi) =FV(\varphi)\cup FV(\Psi)$ für $\Box\in\{\wedge,\vee,\rightarrow\}$ +> - $FV(\lnot\varphi) =FV(\varphi)$ +> - $FV(\exists x\varphi) =FV(\forall x\varphi) =FV(\varphi)\backslash\{x\}$. +> Eine $\sum$-Formel $\varphi$ ist geschlossen oder ein $\sum$-Satz, wenn $FV(\varphi)=\varnothing$ gilt. + +Was sind die freien Variablen der folgenden Formeln? Welche Formeln sind Sätze? +| | freie Variablen? | Satz? | +| ----------------------------------------------------------------------- | ---------------- | ----- | +| $\forall x P(a)$ | nein | ja | +| $\forall x Q(x,x)\rightarrow\exists x Q(x,y)$ | y | nein | +| $\forall x P(x)\vee\forall x Q(x,x)$ | nein | ja | +| $\forall x(P(y)\wedge\forall y P(x))$ | y | nein | +| $\forall x(\lnot\forall y Q(x,y)\wedge R(x,y))$ | y | nein | +| $\exists z(Q(z,x)\vee R(y,z))\rightarrow\exists y(R(x,y)\wedge Q(x,z))$ | x,y,z | nein | +| $\exists x(\lnot P(x)\vee P(f(a)))$ | nein | ja | +| $P(x)\rightarrow\exists x P(x)$ | x | nein | +| $\exists x\forall y((P(y)\rightarrow Q(x,y))\vee\lnot P(x))$ | x | nein | +| $\exists x\forall x Q(x,x)$ | nein | ja | + +Semantik der Prädikatenlogik +- Erinnerung: Die Frage "Ist die aussagenlogische Formel $\varphi$ wahr oder falsch?" war sinnlos, denn wir wissen i.a. nicht, ob die atomaren Aussagen wahr oder falsch sind. +- Analog: Die Frage "Ist die prädikatenlogische Formel $\varphi$ wahr oder falsch?" ist sinnlos, denn wir wissen bisher nicht, über welche Objekte, über welche "Struktur" $\varphi$ spricht. + +> Definition +> +> Sei $\sum$ eine Signatur. Eine $\sum$-Struktur ist ein Tupel $A=(U_A,(f^A)_{f\in\Omega},(R^A)_{R\in Rel})$, wobei +> - $U_A$ eine nichtleere Menge, das Universum, +> - $R^A\supseteq U_A^{ar(R)}$ eine Relation der Stelligkeit $ar(R)$ für $R\in Rel$ und +> - $f^A:U_A^{ar(f)}\rightarrow U_A$ eine Funktion der Stelligkeit $ar(f)$ für $f\in\Omega$ ist. + +Bemerkung: $U_A^0=\{()\}$. +- Also ist $a^A:U_A^0\rightarrow U_A$ für $a\in\Omega$ mit $ar(a)=0$ vollständig gegeben durch $a^A(())\in U_A$. Wir behandeln 0-stellige Funktionen daher als Konstanten. +- Weiterhin gilt $R^A=\varnothing$ oder $R^A=\{()\}$ für $R\in Rel$ mit $ar(R)=0$. + +Beispiel: Graph +- Sei $\sum=(\Omega ,Rel,ar)$ mit $\Omega=\varnothing ,Rel=\{E\}$ und $ar(E)=2$ die Signatur der Graphen. +- Um den Graphen als $\sum$-Struktur $A=(UA,EA)$ zu betrachten, setzen wir + - $UA=\{v_1,v_2,...,v_9\}$ und + - $EA=\{(v_i,v_j)|(v_i,v_j) ist Kante\}$ + +Im folgenden sei $\sum$ eine Signatur, A eine $\sum$-Struktur und $\rho:Var\rightarrow U_A$ eine Abbildung (eine Variableninterpretation). +Wir definieren eine Abbildung $\rho′:T\sum\rightarrow U_A$ induktiv für $t\in T_{\sum}$: +- ist $t\in Var$, so setze $\rho′(t) =\rho(t)$ +- ansonsten existieren $f\in\Omega$ mit $ar(f)=k$ und $t_1,...,t_k\in T_{\sum}$ mit $t=f(t_1,...,t_k)$. Dann setze $\rho′(t) =f^A(\rho′(t_1),...,\rho′(t_k))$. +Die Abbildung $\rho′$ ist die übliche "Auswertungsabbildung". +Zur Vereinfachung schreiben wir auch $\rho(t)$ an Stelle von $\rho′(t)$. + +Beispiel: +- Seien $A=(R,f^A,a^A)$ mit $f^A$ die Subtraktion und $a$ nullstelliges Funktionssymbol mit $a^A=10$. Seien weiter $x,y\in Var$ mit $\rho(x)=7$ und $\rho(y)=-2$. Dann gilt $\rho(f(a,f(x,y))) =\rho(a)-(\rho(x)-\rho(y)) =a^A-(\rho(x)-\rho(y)) = 1$ +- Seien $A= (Z,f^A,a^A)$ mit $f^A$ die Maximumbildung, $a$ nullstelliges Funktionssymbol mit $a^A=10$. Seien weiter $x,y\in Var$ mit $\rho(x)=7$ und $\rho(y)=-2$. In diesem Fall gilt $\rho(f(a,f(x,y))) = max(\rho(a),max(\rho(x),\rho(y)) = max(a^A,max(\rho(x),\rho(y))) = 10$ + +Bemerkung: Wir müssten also eigentlich noch vermerken, in welcher Struktur $\rho(t)$ gebildet wird - dies wird aber aus dem Kontext immer klar sein. + +Für eine $\sum$-Formel $\varphi$ definieren wir die Gültigkeit in einer $\sum$-Struktur $A$ unter der Variableninterpretation $\rho$ (in Zeichen: $A\Vdash_\rho\varphi$) induktiv: +- $A\Vdash_\rho\bot$ gilt nicht. +- $A\Vdash_\rho R(t_1,...,t_k)$ falls $(\rho(t_1),...,\rho(t_k))\in R^A$ für $R\in Rel$ mit $ar(R)=k$ und $t_1,...,t_k\in T_{\sum}$. +- $A\Vdash_\rho t_1 =t_2$ falls $\rho(t_1) =\rho(t_2)$ für $t_1,t_2\in T_{\sum}$. + +Für $\sum$-Formeln $\varphi$ und $\Psi$ und $x\in Var$: +- $A\Vdash_p \varphi\wedge\Psi$ falls $A\Vdash_p\varphi$ und $A\Vdash_p \Psi$. +- $A\Vdash_p \varphi\vee\Psi$ falls $A\Vdash_p\varphi$ oder $A\Vdash_p\Psi$ . +- $A\Vdash_p \varphi\rightarrow\Psi$ falls nicht $A\Vdash_p\varphi$ oder $A\Vdash_p\Psi$ . +- $A\Vdash_p \lnot\varphi$ falls $A\Vdash_p \varphi$ nicht gilt. +- $A\Vdash_p \exists x\varphi$ falls ??? +- $A\Vdash_p \forall x\varphi$ falls ??? + +Für $x\in Var$ und $a\in U_A$ sei $\rho[x\rightarrow a]:Var\rightarrow U_A$ die Variableninterpretation, für die gilt $(\rho[x\rightarrow a])(y) = \begin{cases} \rho(y) \quad\text{ falls } x\not=y \\ a \quad\text{ sonst } \end{cases}$ +- $A\Vdash_p \exists x\varphi$ falls es $a\in U_A$ gibt mit $A\Vdash_{p[x\rightarrow a]}\varphi$. +- $A\Vdash_p \forall x\varphi$ falls $A\Vdash_{p[x\rightarrow a]}\varphi$ für alle $a\in U_A$. + +> Definition +> +> Sei $\sum$ eine Signatur, $\varphi$ eine $\sum$-Formel, $\Delta$ eine Menge von $\sum$-Formeln und $A$ eine $\sum$-Struktur. +> - $A\Vdash\varphi$ ($A$ ist Modell von $\varphi$) falls $A\Vdash_p\varphi$ für alle Variableninterpretationen $\rho$ gilt. +> - $A\Vdash\Delta$ falls $A\Vdash\Psi$ für alle $\Psi\in\Delta$. + + +Aufgaben +- Sei $A$ die Struktur, die dem vorherigen Graphen entspricht +- Welche der folgenden Formeln $\varphi$ gelten in $A$, d.h. für welche Formeln gilt $A\Vdash_p\varphi$ für alle Variableninterpretationen $\rho$? + 1. $\exists x\exists y:E(x,y)$ + 2. $\forall x\exists y:E(x,y)$ + 3. $\exists x\forall y:(x\not=y\rightarrow E(x,y))$ + 4. $\forall x\forall y:(x\not=y\rightarrow E(x,y))$ + 5. $\exists x\exists y\exists z:(E(x,y)\wedge E(y,z)\wedge E(z,x))$ +- In der Prädikatenlogik ist es also möglich, die Eigenschaften vom Anfang des Kapitels auszudrücken, ohne den Graphen direkt in die Formel zu kodieren. + +> Definition +> +> Sei $\sum$ eine Signatur, $\varphi$ eine $\sum$-Formel, $\Delta$ eine Menge von $\sum$-Formeln und $A$ eine $\sum$-Struktur. +> - $\Delta$ ist erfüllbar, wenn es $\sum$-Struktur $B$ und Variableninterpretation $\rho:Var\rightarrow U_B$ gibt mit $B\Vdash_\rho\Psi$ für alle $\Psi\in\Delta$. +> - $\varphi$ ist semantische Folgerung von $\Delta(\Delta\Vdash\varphi)$ falls für alle $\sum$-Strukturen $B$ und alle Variableninterpretationen $\rho:Var\rightarrow U_B$ gilt: +> Gilt $B\Vdash_\rho\Psi$ für alle $\Psi\in\Delta$, so gilt auch $B\Vdash_\rho \varphi$. +> - $\varphi$ ist allgemeingültig, falls $B\Vdash \rho\varphi$ für alle $\sum$-Strukturen $B$ und alle Variableninterpretationen $\rho$ gilt. + +Bemerkung: $\varphi$ allgemeingültig gdw. $\varnothing\Vdash\varphi$ gdw. $\{\lnot\varphi\}$ nicht erfüllbar. Hierfür schreiben wir auch $\Vdash\varphi$. + +Beispiel: Der Satz $\varphi=(\forall x:R(x)\rightarrow\forall x:R(f(x)))$ ist allgemeingültig. + +Beweis: Sei $\sum$ Signatur, so dass $\varphi$ $\sum$-Satz ist. Sei $A$ $\sum$-Struktur und $\rho$ Variableninterpretation. Wir betrachten zwei Fälle: +1. Falls $A\not\Vdash_\rho\forall x R(x)$, so gilt $A\Vdash_p\varphi$. +2. Wir nehmen nun $A\Vdash_p\forall x R(x)$ an. Sei $a\in U_A$ beliebig und $b=f^A(a)$. + $A\Vdash_p\forall x R(x) \Rightarrow A\Vdash_{p[x\rightarrow b]} R(x) \Rightarrow RA\owns (p[x\rightarrow b])(x) = b = f^A(a) = (\rho[x\rightarrow a])(f(x)) \Rightarrow A\Vdash_{p[x\rightarrow a]}R(f(x))$. + Da $a\in U_A$ beliebig war, haben wir also $A\Vdash_p\forall x:R(f(x))$. + Also gilt auch in diesem Fall $A\Vdash_p\varphi$. +Da $A$ und $\rho$ beliebig waren, ist $\varphi$ somit allgemeingültig. + +Beispiel: +- Der Satz $\varphi =\exists x(R(x)\rightarrow R(f(x)))$ ist allgemeingültig. +- Beweis: Sei $\sum$ Signatur, so dass $\varphi$ $\sum$-Satz ist. Sei $A$ $\sum$-Struktur und $\rho$ Variableninterpretation. Wir betrachten wieder zwei Fälle: + 1. Angenommen, $R^A=U_A$. Sei $a\in U_A$ beliebig. + - $\Rightarrow f^A(a)\in R^A$ + - $\Rightarrow A\Vdash_{p[x\rightarrow a]} R(f(x))$ + - $\Rightarrow A\Vdash_{p[x\rightarrow a]} R(x)\rightarrow R(f(x))$ + - $\Rightarrow A\Vdash_p\varphi$. + 2. Ansonsten existiert $a\in U_A\backslash R^A$. + - $\Rightarrow A\not\Vdash_{p[x\rightarrow a]} R(x)$ + - $\Rightarrow A\Vdash_{p[x\rightarrow a]} R(x)\rightarrow R(f(x))$ + - $\Rightarrow A\Vdash_p \varphi$. + Da $A$ und $\rho$ beliebig waren, ist $\varphi$ somit allgemeingültig. + +Aufgabe +| | allgemeingültig | erfüllbar | unerfüllbar | +| -------------------------------------------------------------------- | --------------- | --------- | ----------- | +| $P(a)$ | nein | ja | nein | +| $\exists x:(\lnot P(x)\vee P(a))$ | ja | ja | nein | +| $P(a)\rightarrow\exists x:P(x)$ | ja | ja | nein | +| $P(x)\rightarrow\exists x:P(x)$ | ja | ja | nein | +| $\forall x:P(x)\rightarrow\exists x:P(x)$ | ja | ja | nein | +| $\forall x:P(x)\wedge\lnot\forall y:P(y)$ | nein | nein | ja | +| $\forall x:(P(x,x)\rightarrow\exists x\forall y:P(x,y))$ | nein | ja | nein | +| $\forall x\forall y:(x=y\rightarrow f(x) =f(y))$ | ja | ja | nein | +| $\forall x\forall y:(f(x) =f(y)\rightarrow x=y)$ | nein | ja | nein | +| $\exists x\exists y\exists z:(f(x) =y\wedge f(x) =z\wedge y \not=z)$ | nein | nein | ja | +| $\exists x\forall x:Q(x,x)$ | nein | ja | nein | + +## Substitutionen +> Definition +> +> Eine Substitution besteht aus einer Variable $x\in Var$ und einem Term $t\in T_{\sum}$, geschrieben $[x:=t]$. + +Die Formel $\varphi[x:=t]$ ist die Anwendung der Substitution $[x:=t]$ auf die Formel $\varphi$. Sie entsteht aus $\varphi$, indem alle freien Vorkommen von $x$ durch $t$ ersetzt werden. Sie soll das über $t$ aussagen, was $\varphi$ über $x$ ausgesagt hat. +Dazu definieren wir zunächst induktiv, was es heißt, die freien Vorkommen von $x$ im Term $s\in T_{\sum}$ zu ersetzen: +- $x[x:=t] =t$ +- $y[x:=t] =y$ für $y\in Var\backslash\{x\}$ +- $(f(t_1 ,...,t_k))[x:=t] =f(t_1 [x:=t],...t_k[x:=t])$ für $f\in\Omega$ mit $ar(f) =k$ und $t_1,...,t_k\in T_{\sum}$ + +> Lemma +> +> Seien $\sum$ Signatur, $A$ $\sum$-Struktur, $\rho:Var\rightarrow U_A$ Variableninterpretation, $x\in Var$ und $s,t\in T_{\sum}$. Dann gilt $\rho(s[x:=t])=\rho[x\rightarrow \rho(t)](s)$. + +Beweis: Induktion über den Aufbau des Terms $s$ (mit $\rho′=\rho[x\rightarrow \rho(t)]$ ): +- $s=x:\rho(s[x:=t])=\rho(t) =\rho′(x) =\rho′(s)$ +- $s\in Var\backslash\{x\}:\rho(s[x:=t])=\rho(s) =\rho′(s)$ +- $s=f(t_1 ,...,t_k):\rho((f(t_1 ,...,t_k))[x:=t])= \rho(f(t_1[x:=t],...,t_k[x:=t]))= f^A(\rho(t_1[x:=t]),...,\rho(t_k[x:=t])) = f^A(\rho′(t_1),...,\rho′(t_k))= \rho′(f(t_1 ,...,t_k))=\rho′(s)$ + +Die Definition von $s[x:=t]$ kann induktiv auf $\sum$-Formeln fortgesetzt werden: +- $(t_1 =t_2 )[x:=t] = (t_1 [x:=t] =t_2 [x:=t])$ für $t_1 ,t_2 \in T_{\sum}$ +- $(R(t_1 ,...,t_k))[x:=t] =R(t_1 [x:=t],...,t_k[x:=t])$ für $R\in Rel$ mit $ar(R) =k$ und $t_1 ,...,t_k\in T_{\sum}$ +- $\bot[x:=t] =\bot$ + +Für $\sum$ -Formeln $\varphi$ und $\Psi$ und $y\in Var$: +- $(\varphi\Box\Psi)[x:=t]=\varphi [x:=t]\Box\Psi[x:=t]$ für $\Box\in\{\wedge,\vee,\rightarrow\}$ +- $(\lnot\varphi)[x:=t] = \lnot(\varphi[x:=t])$ +- $(Qy\varphi)[x:=t] = \begin{cases} Qy\varphi[x:=t] \quad\text{ falls } x\not=y \\ Qy\varphi \quad\text{ falls } x=y \end{cases} \text{ für } Q\in\{\exists,\forall\}$. + +Beispiel: $(\exists x P(x,f(y))\vee\lnot\forall yQ(y,g(a,h(z))))[y:=f(u)] = (\exists x P(x,f(f(u)))\vee\lnot\forall yQ(y,g(a,h(z))))$ + +$\varphi [x:=t]$ "soll das über $t$ aussagen, was $\varphi$ über $x$ ausgesagt hat." + +Gegenbeispiel: Aus $\exists y$ $Mutter(x) =y$ mit Substitution $[x:=Mutter(y)]$ wird $\exists y$ Mutter$(Mutter(y)) =y$. + +> Definition +> +> Sei $[x:=t]$ Substitution und $\varphi$ $\sum$-Formel. Die Substitution $[x:=t]$ heißt für $\varphi$ zulässig, wenn für alle $y\in Var$ gilt: $y$ Variable in $t\Rightarrow\varphi$ enthält weder $\exists y$ noch $\forall y$ + +> Lemma +> +> Sei $\sum$ Signatur, A $\sum$-Struktur, $\rho:Var\rightarrow U_A$ Variableninterpretation, $x\in Var$ und $t\in T_{\sum}$. Ist die Substitution $[x:=t]$ für die $\sum$-Formel $\varphi$ zulässig, so gilt $A\Vdash_p\varphi [x:=t]\Leftrightarrow A\Vdash_{p[x\rightarrow \rho(t)]}\varphi$. + +Beweis: Induktion über den Aufbau der Formel $\varphi$ (mit $\rho'=\rho[x\rightarrow \rho(t)])$: +- $\varphi = (s_1 =s_2)$: + - $A\Vdash_p(s_1 =s_2)[x:=t] \Leftrightarrow A\Vdash_p s_1[x:=t] =s_2[x:=t]$ + - $\Leftrightarrow \rho(s_1[x:=t]) =\rho(s_2[x:=t])\Leftrightarrow \rho'(s_1) =\rho'(s_2)$ + - $\Leftrightarrow A\Vdash_{p′} s_1 =s_2$ + - andere atomare Formeln analog +- $\varphi =\varphi_1\wedge\varphi_2$: + - $A\Vdash_p(\varphi_1\wedge\varphi_2)[x:=t] \Leftrightarrow A\Vdash_p\varphi_1 [x:=t]\wedge\varphi_2[x:=t]$ + - $\Leftrightarrow A\Vdash_p\varphi_1[x:=t]$ und $A\Vdash_p\varphi_2[x:=t]$ + - $\Leftrightarrow A\Vdash_{p′}\varphi_1$ und $A\Vdash_{p′}\varphi_2$ + - $\Leftrightarrow A\Vdash_{p′}\varphi_1\wedge\varphi_2$ + - $\varphi=\varphi_1\vee\varphi_2,\varphi =\varphi_1\rightarrow\varphi_2$ und $\varphi=\lnot\psi$ analog +- $\varphi=\forall y\psi$: + - Wir betrachten zunächst den Fall $x=y$: + - $A\Vdash_p(\forall x\psi)[x:=t]\Leftrightarrow A\Vdash_p\forall x\psi \Leftrightarrow A\Vdash_{p′}\forall x\psi$ (denn $x\not\in FV(\forall x\psi)$ ) + - Jetzt der Fall $x\not=y$: + - Für $a\in U_A$ setze $\rho_a=\rho[y\rightarrow a]$. Da $[x:=t]$ für $\varphi$ zulässig ist, kommt $y$ in $t$ nicht vor. Zunächst erhalten wir + - $\rho_a[x\rightarrow \rho_a(t)] = \rho_a[x\rightarrow \rho(t)]$ da $y$ nicht in $t$ vorkommt + - $=\rho[y\rightarrow a][x\rightarrow \rho(t)] = \rho[x\rightarrow \rho(t)][y\rightarrow a]$ da $x\not=y$ + - Es ergibt sich $A\Vdash_p(\forall y\psi)[x:=t]\Leftrightarrow A\Vdash_p\forall y(\psi[x:=t])$ (wegen $x\not=y$) + - $\Leftrightarrow A\Vdash_{pa}\psi[x:=t]$ für alle $a\in U_A$ + - $\Leftrightarrow A\Vdash_{pa[x\rightarrow \rho_a(t)]}\psi$ für alle $a\in U_A$ + - $\Leftrightarrow A\Vdash_{p[x\rightarrow \rho(t)][y\rightarrow a]}\psi$ für alle $a\in U_A$ + - $\Leftrightarrow A\Vdash_{p[x\rightarrow \rho(t)]}\forall y\psi$ +- $\varphi=\exists y\psi$ : analog + +## Natürliches Schließen +Wir haben Regeln des natürlichen Schließens für aussagenlogische Formeln untersucht und für gut befunden. Man kann sie natürlich auch für prädikatenlogische Formeln anwenden. + +Beispiel: Für alle $\sum$-Formel $\varphi$ und $\psi$ gibt es eine Deduktion mit Hypothesen in $\{\lnot\varphi\wedge\lnot\psi\}$ und Konklusion $\lnot(\varphi\vee\psi)$: ![](Assets/Logik-deduktion-konklusion.png) + +## Korrektheit +Können wir durch mathematische Beweise zu falschen Aussagen kommen? Können wir durch das natürliche Schließen zu falschen Aussagen kommen? Existiert eine Menge $\Gamma$ von $\sum$-Formeln und eine $\sum$-Formel $\varphi$ mit $\Gamma\vdash\varphi$ und +$\Gamma\not\Vdash\varphi$? + +Frage: Gilt $\Gamma\vdash\varphi\Rightarrow \Gamma\Vdash\varphi$ bzw. $\varphi$ ist Theorem $\Rightarrow\varphi$ ist allgemeingültig? + +Der Beweis des Korrektheitslemmas für das natürliche Schließen kann ohne große Schwierigkeiten erweitert werden. Man erhält + +> Lemma V0 +> +> Sei $\sum$ eine Signatur, $\Gamma$ eine Menge von $\sum$-Formeln und $\varphi$ eine $\sum$-Formel. +> Sei weiter $D$ eine Deduktion mit Hypothesen in $\Gamma$ und Konklusion $\varphi$, die die Regeln des natürlichen Schließens der Aussagenlogik verwendet. Dann gilt $\Gamma\Vdash\varphi$. + +Umgekehrt ist nicht zu erwarten, dass aus $\Gamma\Vdash\varphi$ folgt, dass es eine Deduktion mit Hypothesen in $\Gamma$ und Konklusion $\varphi$ gibt, denn die bisher untersuchten Regeln erlauben keine Behandlung von $=,\forall$ bzw. $\exists$. Solche Regeln werden wir jetzt einführen. + +Zunächst kümmern wir uns um Atomformeln der Form $t_1 =t_2$. Hierfür gibt es die zwei Regeln $(R)$ und $(GfG)$: + +> Reflexivität (ausführlich) +> +> Für jeden Termt ist $\frac{}{t=t}$ eine hypothesenlose Deduktion mit Konklusion $t=t$. ![](Assets/Logik-reflexivität-kurz.png) + +> Gleiches-für-Gleiches in mathematischen Beweisen +> +> ,,Zunächst zeige ich, dass $s$ die Eigenschaft $\varphi$ hat:... +> Jetzt zeige ich $s=t$:... +> Also haben wir gezeigt, dass $t$ die Eigenschaft $\varphi$ hat. qed'' +> +> Gleiches-für-Gleiches (ausführlich) +> Seien $s$ und $t$ Terme und $\varphi$ Formel, so dass die Substitutionen $[x:=s]$ und $[x:=t]$ für $\varphi$ zulässig sind. Sind $D$ und $E$ Deduktionen mit Hypothesen in $\Gamma$ und Konklusionen $\varphi[x:=s]$ bzw. $s=t$, so ist das folgende eine Deduktion mit Hypothesen in $\Gamma$ und Konklusion $\varphi[x:=t]$: ![](Assets/Logik-gleiches-für-gleiches-ausführlich.png) +> +> Gleiches-für-Gleiches (Kurzform) +> ![](Assets/Logik-gleiches-für-gleiches-kurz.png) +> Bedingung: über keine Variable aus $s$ oder $t$ wird in $\varphi$ quantifiziert + +Die folgenden Beispiele zeigen, dass wir bereits jetzt die üblichen Eigenschaften der Gleichheit (Symmetrie, Transitivität, Einsetzen) folgern können. + +Beispiel: Seien $x$ Variable, $s$ Term ohne $x$ und $\varphi=(x=s)$. +- Da $\varphi$ quantorenfrei ist, sind die Substitutionen $[x:=s]$ und $[x:=t]$ für $\varphi$ zulässig. +- Außerdem gelten $\varphi[x:=s] = (s=s)$ und $\varphi[x:=t] = (t=s)$. +- Also ist das folgende eine Deduktion: ![](Assets/Logik-deduktion-beispiel.png) +- Für alle Termesundthaben wir also $\{s=t\}\vdash t=s$. + +Beispiel: Seien $x$ Variable, $r,s$ und $t$ Terme ohne $x$ und $\varphi=(r=x)$. +- Da $\varphi$ quantorenfrei ist, sind die Substitutionen $[x:=s]$ und $[x:=t]$ für $\varphi$ zulässig. +- Außerdem gelten $\varphi[x:=s]=(r=s)$ und $\varphi[x:=t]=(r=t)$. +- Also ist das folgende eine Deduktion: ![](Assets/Logik-deduktion-beispiel-2.png) +- Für alle Terme $r,s$ und $t$ haben wir also $\{r=s,s=t\}\vdash r=t$. + +Beispiel: Seien $x$ Variable, $s$ und $t$ Terme ohne $x$,$f$ einstelliges Funktionssymbol und $\varphi=(f(s)=f(x))$. +- Da $\varphi$ quatorenfrei ist, sind die Substitutionen $[x:=s]$ und $[x:=t]$ für $\varphi$ zulässig. +- Außerdem gelten $\varphi[x:=s]=(f(s)=f(s))$ und $\varphi[x:=t]=(f(s)=f(t))$. +- Also ist das folgende eine Deduktion: ![](Assets/Logik-deduktion-beispiel-3.png) + +> Lemma V1 +> +> Sei $\sum$ eine Signatur, $\Gamma$ eine Menge von $\sum$-Formeln und $\varphi$ eine $\sum$-Formel. +> Sei weiter $D$ eine Deduktion mit Hypothesen in $\Gamma$ und Konklusion $\varphi$, die die Regeln des natürlichen Schließens der Aussagenlogik, $(R)$ und $(GfG)$ verwendet. Dann gilt $\Gamma\Vdash\varphi$. + +Beweis: Wir erweitern den Beweis des Korrektheitslemmas bzw. des Lemmas V0, der Induktion über die Größe der Deduktion $D$ verwendete. +- Wir betrachten nur den Fall, dass $D$ die folgende Form hat: ![](Assets/Logik-lemma-v1-beweis.png) +- Da dies Deduktion ist, sind die Substitutionen $[x:=s]$ und $[x:=t]$ für $\varphi$ +zulässig, d.h. in $\varphi$ wird über keine Variable aus $s$ oder $t$ quantifiziert. +- $E$ und $F$ kleinere Deduktionen $\Rightarrow\Gamma\Vdash\varphi[x:=s]$ und $\Gamma\Vdash s=t$ +- Seien A $\sum$-Struktur und $\rho$ Variableninterpretation mit $A\Vdash_p\gamma$ für alle $\gamma\in\Gamma$. + - $\Rightarrow A\Vdash_p\varphi[x:=s]$ und $A\Vdash_p s=t$ + - $\Rightarrow A\Vdash_{p[x\rightarrow \rho(s)]}\varphi$ und $\rho(s) =\rho(t)$ + - $\Rightarrow A\Vdash_{p[x\rightarrow \rho(t)]}\varphi$ + - $\Rightarrow A\Vdash_p \varphi[x:=t]$ +- Da $A$ und $\rho$ beliebig waren mit $A\Vdash_p\gamma$ für alle $\gamma\in\Gamma$ haben wir $\Gamma\Vdash\varphi[x:=t]$ gezeigt. + +### $\forall$ in math. Beweisen +Ein mathematischer Beweis einer Aussage "für alle $x$ gilt $\varphi$" sieht üblicherweise so aus: + "Sei $x$ beliebig, aber fest. Jetzt zeige ich $\varphi$ (hier steckt die eigentliche Arbeit). Da $x$ beliebig war, haben wird "für alle $x$ gilt $\varphi$" gezeigt. qed" + +> $\forall$ -Einführung +> +> Sei $D$ eine Deduktion mit Hypothesen in $\Gamma$ und Konklusion $\varphi$ und sei $x$ eine Variable, die in keiner Formel aus $\Gamma$ frei vorkommt. Dann ist das folgende eine Deduktion +mit Hypothesen in $\Gamma$ und Konklusion $\forall x\varphi: \frac{\phi}{\forall x\varphi}$ +> +> Bedingung: $x$ kommt in keiner Hypothese frei vor + +> Lemma V2 +> +> Sei $\sum$ eine Signatur, $\Gamma$ eine Menge von $\sum$-Formeln und $\varphi$ eine $\sum$-Formel. +> Sei weiter $D$ eine Deduktion mit Hypothesen in $\Gamma$ und Konklusion $\varphi$, die die Regeln des natürlichen Schließens der Aussagenlogik, (R), (GfG) und ($\forall$ -I) verwendet. Dann gilt $\Gamma\Vdash\varphi$. + +Beweis: Betrachte die folgende Deduktion $D$ +- Insbesondere ist $x$ keine freie Variable einer Formel aus $\Gamma$ und es gilt nach IV $\Gamma\Vdash\varphi$ +- Sei nun $A$ $\sum$-Struktur und $\rho$ Variableninterpretation mit $A\Vdash_p y$ für alle $y\in\Gamma$. +- Zu zeigen ist $A\Vdash_p \forall x\varphi$: + - Sei also $a\in U_A$ beliebig. + - $\Rightarrow$ für alle $y\in\Gamma$ gilt $A\Vdash_{p[x\rightarrow a]} y$ da $x\not\in FV(y)$ und $A\Vdash_p y$ + - $\Rightarrow A\Vdash_{\rho[x\rightarrow a]}\varphi$ + - Da $a\in U_A$ beliebig war, haben wir $A\Vdash_\rho\forall x\varphi$ gezeigt +- Da $A$ und $\rho$ beliebig waren mit $A\Vdash_\rho\Gamma$ für alle $\gamma\in\Gamma$ haben wir also $\Gamma\Vdash\forall x\varphi$ gezeigt. + +### $\forall$ -Elimination in math. Beweisen +Ein mathematischer Beweis einer Aussage "t erfüllt $\varphi$" kann so aussehen: + "Zunächst zeige ich $\forall x\varphi$ (hier steckt die eigentliche Arbeit). Damit erfüllt insbesondere $t$ die Aussage$\varphi$ , d.h., wir haben "$t$ erfüllt $\varphi$" gezeigt. qed" + +> $\forall$ -Elimination +> +> Sei $D$ eine Deduktion mit Hypothesen in $\Gamma$ und Konklusion $\forall x\varphi$ und seit Term, so dass Substitution [x:=t] für $\varphi$ zulässig ist. +> Dann ist das folgende eine Deduktion mit Hypothesen in $\Gamma$ und Konklusion $\varphi[x:=t]:\frac{\forall x\varphi}{\varphi[x:=t]}$ +> +> Bedingung: über keine Variable aus $t$ wird in $\varphi$ quantifiziert + +> Lemma V3 +> +> Sei $\sum$ eine Signatur, $\Gamma$ eine Menge von $\sum$-Formeln und $\varphi$ eine $\sum$-Formel. +> Sei weiter $D$ eine Deduktion mit Hypothesen in $\Gamma$ und Konklusion $\varphi$, die die Regeln des natürlichen Schließens der Aussagenlogik, (R), (GfG), ($\forall$-I) und ($\forall$-E) verwendet. > Dann gilt $\Gamma\Vdash\varphi$. + +Beweis: Analog zum Beweis von Lemma V2. + +### $\exists$ in math. Beweisen +Ein Beweis von "$\sigma$ gilt" kann so aussehen: + "Zunächst zeige ich $\exists x\varphi$ (hier steckt Arbeit). Jetzt zeige ich, dass $\sigma$ immer gilt, wenn$\varphi$ gilt (mehr Arbeit). Damit gilt $\sigma$. qed" + +> $\exists$ -Elimination +> +> Sei $\Gamma$ eine Menge von Formeln, die die Variable $x$ nicht frei enthalten und enthalte die Formel $\sigma$ die Variabel $x$ nicht frei. Wenn $D$ eine Deduktion mit Hypothesen in $\Gamma$ und Konklusion $\exists x\varphi$ und $E$ eine Deduktion mit Hypothesen in $\Gamma $\cup$\{\varphi\}$ und Konklusion $\sigma$ ist, dann ist das folgende eine Deduktion mit Hypothesen in $\Gamma$ und Konklusion $\sigma:\frac{\exists x\varphi \quad\quad \sigma}{\sigma}$ +> +> Bedingung: $x$ kommt in den Hypothesen und in $\sigma$ nicht frei vor + +> Lemma V4 +> Sei $\sigma$ eine Signatur, $\Gamma$ eine Menge von $\sum$-Formeln und $\varphi$ eine $\sigma$ -Formel. +> Sei weiter $D$ eine Deduktion mit Hypothesen in $\Gamma$ und Konklusion $\varphi$, die die Regeln des natürlichen Schließens der Aussagenlogik, (R), (GfG), ($\forall$-I), ($\forall$-E) und ($\exists$-E) verwendet. Dann gilt $\Gamma\Vdash\varphi$. + +Beweis: Sei $D$ die folgende Deduktion +- Insbesondere kommt $x$ in den Formeln aus $\Gamma\cup\{\sigma\}$ nicht frei vor. Außerdem gelten nach IV $\Gamma\Vdash\exists x\varphi$ und $\Gamma\cup\{\varphi\}\Vdash\sigma$. +- Sei nun $A$ $\sigma$-Struktur und $\rho$ Variableninterpretation mit $A\Vdash_\rho\Gamma$ für alle $\gamma\in\Gamma$. +- Zu zeigen ist $A\Vdash_\rho\sigma$: + - Wegen $A\Vdash_\rho\exists x\varphi$ existiert $a\in U_A$ mit $A\Vdash_{\rho[x\rightarrow a]}\varphi$. + - $x$ kommt in Formeln aus $\Gamma$ nicht frei vor $\Rightarrow A\Vdash_{\rho[x\rightarrow a]}\gamma$ für alle $\gamma\in\Gamma$. + - Aus $\Gamma\cup\{\varphi\}\Vdash\sigma$ folgt $A\Vdash_{\rho[x\rightarrow a]}\sigma$. + - Da $x\not\in FV(\sigma)$ erhalten wir $A\Vdash_\rho \sigma$. +- Da $A$ und $\rho$ beliebig waren mit $A\Vdash_\rho\gamma$ für alle $\gamma\in\Gamma$ haben wir also $\Gamma\Vdash\sigma$ gezeigt. + +### $\exists$ -Einführung in math. Beweisen +Ein mathematischer Beweis einer Aussage "es gibt ein $x$, das $\varphi$ erfüllt" sieht üblicherweise so aus: "betrachte dieses $t$ (hier ist Kreativität gefragt). Jetzt zeige ich, daß $t\varphi$ erfüllt (u.U. harte Arbeit). Also haben wir "es gibt ein $x$, das $\varphi$ erfüllt" gezeigt. qed" + +> $\exists$ -Einführung +> +> Sei die Substitution $[x:=t]$ für die Formel $\varphi$ zulässig. +> Sei weiter $D$ eine Deduktion mit Hypothesen in $\Gamma$ und Konklusion $\varphi[x:=t]$. +> Dann ist das folgende eine Deduktion mit Hypothesen in $\Gamma$ und Konklusion $\exists x\varphi:\frac{\varphi[x:=t]}{\exists x\varphi}$ +> +> Bedingung: über keine Variable in $t$ wird in $\varphi$ quantifiziert + +> Korrektheitslemma für das natürliche Schließen in der Prädikatenlogik +> +> Sei $\sigma$ eine Signatur, $\Gamma$ eine Menge von $\sum$-Formeln und $\varphi$ eine $\sigma$ -Formel. +> Sei weiter $D$ eine Deduktion mit Hypothesen in $\Gamma$ und Konklusion $\varphi$, die die Regeln des natürlichen Schließens der Aussagenlogik, (R), (GfG), ($\forall$-I), ($\forall$-E), ($\exists$ -E) und ($\exists$ -I) verwendet. Dann gilt $\Gamma\Vdash\varphi$. + +Beweis: analog zu obigen Beweisen. + +### Regeln des natürlichen Schließens (Erweiterung) +- ($R$): $\frac{}{t=t}$ +- (GfG): $\frac{\varphi[x:=s] \quad\quad s=t}{\varphi[x:=t]}$ (über keine Variable aus $s$ oder $t$ wird in $\varphi$ quantifiziert) +- ($\forall$-I): $\frac{\varphi}{\forall x\varphi}$ (x nicht frei in Hypothesen) +- ($\forall$-E): $\frac{\forall x\varphi}{\varphi[x:=t]}$ (über keine Variable aus $t$ wird in $\varphi$ quantifiziert) +- ($\exists$-I): $\frac{\varphi [x:=t]}{\exists x\varphi}$ (über keine Variable aus $t$ wird in $\varphi$ quantifiziert) +- ($\exists$-I): $\frac{\exists x\varphi\quad\quad \sigma}{\sigma}$ ($x$ kommt in Hypothesen und $\sigma$ nicht frei vor) + +> Definition +> +> Für eine Menge $\Gamma$ von $\sum$-Formeln und eine $\sum$-Formel $\varphi$ schreiben wir $\Gamma\vdash\varphi$ wenn es eine Deduktion gibt mit Hypothesen in $\Gamma$ und Konklusion $\varphi$. Wir sagen "$\varphi$ ist eine syntaktische Folgerung von $\Gamma$". +> Eine Formel $\varphi$ ist ein Theorem, wenn $\varnothing\vdash\varphi$ gilt. + +Bemerkung: $\Gamma\vdash\varphi$ sagt (zunächst) nichts über den Inhalt der Formeln in $\Gamma\cup\{\varphi\}$ aus, sondern nur über den Fakt, dass $\varphi$ mithilfe des natürlichen Schließens aus den Formeln aus $\Gamma$ hergeleitet werden kann. +Ebenso sagt "$\varphi$ ist Theorem" nur, dass $\varphi$ abgeleitet werden kann, über "Wahrheit" sagt dieser Begriff (zunächst) nichts aus. +Wir haben aber "en passant" das folgende gezeigt: + +> Korrektheitssatz +> +> Für eine Menge von $\sum$-Formeln $\Gamma$ und eine $\sum$-Formel $\varphi$ gilt $\Gamma\vdash\varphi \Rightarrow \Gamma\Vdash\varphi$. + +Beispiel: Seien $\varphi$ Formel und $x$ Variable. Dann gelten $\{\lnot\exists x\varphi\}\Vdash\forall x\lnot\varphi$ und $\{\forall x\lnot\varphi\}\Vdash\lnot\exists x\varphi$. +- Beweis: ![](Assets/Logik-korrekheitssatz.png) + +Beispiel: Seien $\varphi$ Formel und $x$ Variable. Dann gelten $\{\lnot\forall x\varphi\}\Vdash \exists x\lnot\varphi$ und $\{\exists x\lnot\varphi\}\Vdash\lnot\forall x\varphi$. +- Beweis: ![](Assets/Logik-beispiel-korrekheitssatz.png) + +## Vollständigkeit +Können wir durch mathematische Beweise zu allen korrekten Aussagen kommen? +Können wir durch das natürliche Schließen zu allen korrekten Aussagen kommen? + +Existiert eine Menge $\Gamma$ von $\sum$-Formeln und eine $\sum$-Formel $\varphi$ mit $\Gamma\Vdash\varphi$ und $\Gamma\not\vdash\varphi$? + +Frage: Gilt $\Gamma\Vdash\varphi \Rightarrow \Gamma\vdash\varphi$ bzw. $\varphi$ ist allgemeingültig $\Rightarrow\varphi$ ist Theorem? + +Plan: +- z.z. ist $\Gamma\Vdash\varphi \Rightarrow \Gamma\vdash\varphi$. +- dies ist äquivalent zu $\Gamma\not\vdash\varphi \Rightarrow \Gamma\not\Vdash\varphi$. +- hierzu geht man folgendermaßen vor: + - $\Gamma\not\vdash\varphi$ + - $\Leftrightarrow \Gamma\cup\{\lnot\varphi\}$ konsistent + - $\Rightarrow \exists\Delta\supseteq\Gamma\cup\{\lnot\varphi\}$ maximal konsistent + - $\Rightarrow \exists\Delta^+ \supseteq\Delta$ maximal konsistent mit Konkretisierung + - $\Rightarrow \Delta^+$ erfüllbar + - $\Rightarrow \Delta$ erfüllbar + - $\Rightarrow \Gamma\cup\{\lnot\varphi\}$ erfüllbar + - $\Leftrightarrow \Gamma\cup\{\lnot\varphi\}$ + +> Definition +> +> Eine Menge $\Delta$ von Formeln hat Konkretisierungen, wenn für alle $\exists x\varphi\in\Delta$ ein variablenloser Term $t$ existiert mit $\varphi[x:=t]\in\Delta$. + +> Satz +> +> Sei $\Delta$ eine maximal konsistente Menge von $\sum$-Formeln. Dann existiert eine Signatur $\sum^+ \supseteq\sum$ und eine maximal konsistente Menge von $\sum^+$-Formeln mit Konkretisierungen, so dass $\Delta\subseteq\Delta^+$. + +Beweis: Wir konstruieren induktiv Signaturen $\sum_n$, maximal konsistente Menge von $\sum_n$-Formeln $\Delta_n$ und konsistente Mengen von $\sum_{n+1}$-Formeln $\Delta′_{n+1}$ mit +- $\sum =\sum_0 \subseteq\sum_1 \subseteq\sum_2...$ und +- $\Delta = \Delta_0 \subseteq \Delta′_1 \subseteq\Delta_1 \subseteq\Delta′_2...$ +und setzen dann +- $\sum^+ =\bigcup_{n\geq 0} \sum_n$ und $\Delta^+ = \bigcup_{n\geq 0} \Delta_n$ + +1. IA: $\sum_0 := \sum$ , $\Delta_0:=\Delta$ +2. IV: Sei $n\geq 0$ und $\Delta_n$ maximal konsistente Menge von $\sum_n$-Formeln. $\psi=\exists x\varphi$, ein "neues" Konstantensymbol $c_{\psi}$ +3. IS: $\sum_{n+1}$: alle Symbole aus $\sum_n$ und, für jede Formel $\psi\in\Delta_n$ der Form $\Delta′_{n+1}:= \Delta_n\cup\{\varphi[x:=c_{\psi}]|\psi=\exists x\varphi\in\Delta_n\}$ + - ohne Beweis: $\Delta′_{n+1}$ ist konsistent + - Idee: Ist $\varphi$ $\sum_n$-Formel mit $\Delta′_{n+1}\vdash\varphi$, so gilt $\Delta_n\vdash\varphi$. + - Konsistenz von $\Delta′_{n+1}$ folgt mit $\varphi=\bot$ + - Analog zum Satz aus Vorlesung 4 existiert $\Delta_{n+1}\supseteq \Delta'_{n+1}$ maximal konsistent +- Damit ist die Konstruktion der Signaturen $\sum_n$ und der maximal konsistenten Mengen $\Delta_n$ von $\sum_n$-Formeln abgeschlossen. +- noch z.z.: $\Delta^+$ hat Konkretisierungen und ist maximal konsistent + - $\Delta^+$ hat Konkretisierungen: Sei $\psi=\exists x\varphi\in\Delta^+$ + - $\Rightarrow$ es gibt $n\geq 0$ mit $\psi\in\Delta_n$ + - $\Rightarrow \varphi[x:=c_{\psi}]\in\Delta′_{n+1}\subseteq \Delta_{n+1}\subseteq\Delta^+$. + - Konsistenz: (indirekt) angenommen, $\Delta^+\vdash\bot$ + - Da jede Deduktion endlich ist, existiert $\Gamma\subseteq\Delta^+$ endlich mit $\Gamma\vdash\bot$. + - $\Rightarrow$ es gibt $n\geq 0$ mit $\Gamma\subseteq\Delta_n$ + - $\Rightarrow \Delta_n\vdash\bot$ - im Widerspruch zur Konsistenz von $\Delta_n$. + - maximale Konsistenz: (indirekt) angenommen, $\Delta^+$ ist nicht maximal konsistent + - $\Rightarrow$ es gibt $\Gamma\not\subseteq\Delta^+$ konsistent + - $\Rightarrow$ es gibt $\varphi\in\Gamma\backslash\Delta^+$ + - $\Rightarrow$ $\Delta^+\cup\{\varphi\}\subseteq\Gamma$ konsistent + - $\varphi$ ist $\sum^+$-Formel $\Rightarrow$ es gibt $n\geq 0$, so dass $\varphi$ eine $\sum_n$-Formel ist. + - $\Delta_n$ maximal konsistente Menge von $\sum_n$-Formeln + - $\Rightarrow$ $\varphi\in\Delta_n\subseteq\Delta^+$ oder $\lnot\varphi\in\Delta_n\subseteq\Delta^+$ + - $\Rightarrow$ $\lnot\varphi\in\Delta^+\subseteq\Gamma$ + - Also $\varphi,\lnot\varphi\in\Gamma$, im Widerspruch zur Konsistenz von $\Gamma$. + +> Satz +> +> Sei $\Delta^+$ maximal konsistente Menge von $\sum^+$-Formeln mit Konkretisierungen. Dann ist $\Delta^+$ erfüllbar. + +Beweisidee: Sei $T$ die Menge der variablenlosen $\sum^+$-Terme. Auf $T$ definieren wir eine Äquivalenzrelation $∼$ durch $s∼t\Leftrightarrow \Delta^+\vdash(s=t)\Leftrightarrow (s=t)\in\Delta^+$ +Sei $A$ die folgende $\sum^+$-Struktur: +- $U_A:=T/∼$ ist die Menge der $∼$-Äquivalenzklassen +- $R^A=\{([t_1],...,[t_k])|t_1 ,...,t_k\in T,R(t_1,...,t_k)\in\Delta^+\}$ für alle Relationssymbole R aus $\sum^+$ +- $f^A([t_1],...,[t_k]) = [f(t_1,...,t_k)]$ für alle $t_1,...,t_k\in T$ und alle Funktionssymbole $f$ aus $\sum^+$ (Bemerkung: dies ist wohldefiniert) +Dann gilt tatsächlich $A\Vdash\Delta^+$. + +> Satz: Vollständigkeitssatz der Prädikatenlogik +> +> Sei $\Gamma$ eine Menge von $\sum$-Formeln und $\varphi$ eine $\sum$-Formel. Dann gilt $\Gamma\Vdash\varphi \Rightarrow \Gamma\vdash\varphi$. +> Insbesondere ist jede allgemeingültige Formel ein Theorem. + +Beweis:indirekt +- $\Gamma\not\vdash\varphi$ +- $\Gamma\cup\{\lnot\varphi\}$ konsistent +- $\Gamma\cup\{\lnot\varphi\}$ erfüllbar +- $\exists\Delta\supseteq\Gamma\cup\{\lnot\varphi\}$ maximal konsistent +- $\exists\Delta^+\supseteq\Delta$ maximal konsistent mit Konkretisierungen +- $\Delta^+$ erfüllbar +- $\Delta$ erfüllbar +- $\Gamma\not\Vdash\varphi$ + +Bemerkung +- Dieser Satz ist (im wesentlichen) der berühmte Gödelsche Vollständigkeitssatz von 1930. +- Der obige Beweis wurde von Leon Henkin 1949 veröffentlicht. + +Wir haben gleichzeitig gezeigt: +> Satz +> +> Sei $\Gamma$ höchstens abzählbar unendliche und konsistente Menge von Formeln. Dann hat $\Gamma$ ein höchstens abzählbar unendliches Modell. + +Beweis: $\Gamma$ konsistent heißt $\Gamma\not\vdash\bot$. Obiger Beweis gibt ein Modell $A$ von $\Gamma\cup\{\lnot\bot\}$ an. Wir zeigen, dass diese Struktur $A$ höchstens abzählbar unendlich ist: +- Sei $\sum$ Signatur der Relations- und Funktionssymbole aus $\Gamma$. +- $|\Gamma|\leq \mathbb{N}_0 \Rightarrow |\sum|\leq \mathbb{N}_0$ +- $\Rightarrow |\sum_n|\leq \mathbb{N}_0$ und $|\Delta_n|\leq \mathbb{N}_0$ für alle $n\geq 0$ +- $\Rightarrow |\sum^+|,|\Delta^+| \leq\mathbb{N}_0$ +- $\Rightarrow |T| \leq\mathbb{N}_0$ +- $\Rightarrow A$ hat $\leq\mathbb{N}_0$ viele Elemente +- $\Rightarrow \Gamma\cup\{\lnot\bot\}$ hat ein höchstens abzählbar unendliches Modell +- $\Rightarrow \Gamma$ hat ein höchstens abzählbar unendliches Modell + +## Vollständigkeit und Korrektheit für die Prädikatenlogik +> Satz +> +> Seien $\Gamma$ eine Menge von $\sum$-Formeln und $\varphi$ eine $\sum$-Formel. Dann gilt $\Gamma\vdash\varphi\Leftrightarrow \Gamma\Vdash\varphi$. +> Insbesondere ist eine $\sum$-Formel genau dann allgemeingültig, wenn sie ein Theorem ist. + +Beweis: Folgt unmittelbar aus Korrektheitssatz und Vollständigkeitssatz. + +### Folgerung 1: Kompaktheit +> Satz +> +> Seien $\Gamma$ eine u.U. unendliche Menge von $\sum$-Formeln und $\varphi$ eine $\sum$-Formel mit $\Gamma\Vdash\varphi$. Dann existiert $\Gamma'\subseteq\Gamma$ endlich mit $\Gamma'\Vdash\varphi$. + +Beweis: $\Gamma\Vdash\varphi$ +- $\Gamma\vdash\varphi$ (nach dem Vollständigkeitssatz) +- es gibt Deduktion von $\varphi$ mit Hypothesen $\gamma_1,...,\gamma_n\in\Gamma$ +- $\Gamma′=\{\gamma_1,...,\gamma_n\}\subseteq\Gamma$ endlich mit $\Gamma′\vdash\varphi$ +- $\Gamma′\vdash\varphi$ (nach dem Korrektheitssatz). + +> Folgerung (Kompaktheits- oder Endlichkeitssatz) +> +> Sei $\Gamma$ eine u.U. unendliche Menge von $\sum$-Formeln. Dann gilt $\Gamma$ erfüllbar $\Leftrightarrow \forall\Gamma′\subseteq\Gamma$ endlich: $\Gamma′$ erfüllbar + +Beweis: +- $\Gamma$ unerfüllbar +- $\Leftrightarrow \Gamma\cup\{\lnot\bot\}$ unerfüllbar +- $\Leftrightarrow \Gamma\Vdash\bot$ +- $\Leftrightarrow$ es gibt $\Gamma′\subseteq\Gamma$ endlich: $\Gamma′\Vdash\bot$ +- $\Leftrightarrow$ es gibt $\Gamma′\subseteq\Gamma$ endlich: $\Gamma′\cup\{\lnot\bot\}$ unerfüllbar +- $\Leftrightarrow$ es gibt $\Gamma′\subseteq\Gamma$ endlich: $\Gamma′$ unerfüllbar + +> Satz +> +> Sei $\Delta$ eine u.U. unendliche Menge von $\sum$-Formeln, so dass für jedes $n\in\mathbb{N}$ eine endliche Struktur $A_n$ mit $A_\Vdash\Delta$ existiert, die wenigstens $n$ Elemente hat. +> Dann existiert eine unendliche Struktur $A$ mit $A\Vdash\Delta$. + +Beweis: für $n\in\mathbb{N}$ setze $\varphi_n=\exists x_1 \exists x_2 ...\exists x_n \bigwedge_{1\leq i< j \leq n} x_i \not= x_j$ +- und $\Gamma =\Delta\cup\{\varphi_n | n\geq 0\}$. +- Für $\Gamma′\subseteq\Gamma$ endlich existiert $n\in\mathbb{N}$ mit $\varphi_m\not\in\Gamma′$ für alle $m\geq n$ +- $\Rightarrow A_n\Vdash\Gamma′$, d.h. jede endliche Teilmenge von $\Gamma$ ist erfüllbar. +- $\Rightarrow$ es gibt Struktur $A$ mit $A\Vdash\Gamma$ +- $\Rightarrow$ A hat $\geq n$ Elemente (für alle $n\in\mathbb{N}$) + +### Folgerung 2: Löwenheim-Skolem +> Frage: Gibt es eine Menge $\Gamma$ von $\sum$-Formeln, so dass für alle Strukturen $A$ gilt: $A\Vdash\Gamma \Leftrightarrow A\cong (\mathbb{R},+,*, 0 , 1 )$? + +> Satz von Löwenheim-Skolem +> +> Sei $\Gamma$ erfüllbare und höchstens abzählbar unendliche Menge von $\sum$-Formeln. Dann existiert ein höchstens abzählbar unendliches Modell von $\Gamma$. + +Beweis: +- $Gamma$ erfüllbar $\Rightarrow \Gamma\not\Vdash\bot$ +- $\Rightarrow$ $\Gamma\not\vdash\bot$, d.h. $\Gamma$ konsistent +- $\Rightarrow \Gamma$ hat ein höchstens abzählbar unendliches Modell. + +Die Frage auf der vorherigen Folie muß also verneint werden: +- angenommen, $\Gamma$ wäre eine solche Menge +- $\Rightarrow |\Gamma|\leq \mathbb{N}_0$ +- $\Rightarrow \Gamma$ hat ein höchstens abzählbar unendliches Modell $A$ +- $\Rightarrow A\not\cong (\mathbb{R},+,*, 0 , 1 )$ + + +### Folgerung 3: Semi-Entscheidbarkeit +> Satz +> +> Die Menge der allgemeingültigen $\sum$-Formeln ist semi-entscheidbar. + +Beweis:Sei$\varphi$ $\sum$-Formel. Dann gilt +- $\varphi$ allgemeingültig +- $\Leftrightarrow \varphi$ Theorem +- $\Leftrightarrow$ Es gibt hypothesenlose Deduktion mit Konklusion $\varphi$ + +Ein Semi-Entscheidungsalgorithmus kann also folgendermaßen vorgehen: +Teste für jede Zeichenkette $w$ nacheinander, ob sie hypothesenlose Deduktion mit Konklusion $\varphi$ ist. Wenn ja, so gib aus "$\varphi$ ist allgemeingültig". Ansonsten gehe zur nächsten Zeichenkette über. + +### Der Satz von Church +Jetzt zeigen wir, daß dieses Ergebnis nicht verbessert werden kann: Die Menge der allgemeingültigen $\sum$-Formeln ist nicht entscheidbar. +Wegen $\varphi$ allgemeingültig $\Leftrightarrow\lnot\varphi$ unerfüllbar reicht es zu zeigen, dass die Menge der erfüllbaren Sätze nicht entscheidbar ist. +Genauer zeigen wir dies sogar für "Horn-Formeln": + +> Definition +> +> Eine Horn-Formel ist eine Konjunktion von $\sum$-Formeln der Form +> $\forall x_1 \forall x_2 ...\forall x_n((\lnot\bot \wedge\alpha_1\wedge\alpha_2\wedge...\wedge\alpha_m)\rightarrow\beta)$, +> wobei $\alpha_1,...,\alpha_m$ und $\beta$ atomare $\sum$-Formeln sind. + +Unser Beweis reduziert die unentscheidbare Menge PCP auf die Menge der erfüllbaren Horn-Formeln. + +Im folgenden sei also $I=((u_1,v_1),(u_2,v_2),...,(u_k,v_k))$ ein Korrespondenzsystem und $A$ das zugrundeliegende Alphabet. +Hieraus berechnen wir eine Horn-Formel $\varphi_I$, die genau dann erfüllbar ist, wenn $I$ keine Lösung hat. +Wir betrachten die Signatur $\sum= (\Omega,Rel,ar)$ mit +- $\Omega=\{e\}\cup\{f_a|a\in A\}$ mit $ar(e) =0$ und $ar(f_a) =1$ für alle $a\in A$. +- $Rel=\{R\}$ mit $ar(R)=2$. + +Zur Abkürzung schreiben wir $f_{a_1 a_2 ...a_n} (x)$ für $f_{a_1}(f_{a_2}(...(f_{a_n}(x))...))$ für alle $a_1,a_2,...,a_n\in A$ und $n\geq 0$ (insbes. steht $f_{\epsilon}(x)$ für $x$). + +Zunächst betrachten wir die folgende Horn-Formel $\psi_I$: +- $\wedge \bigwedge_{1\leq j \leq k}^{R(e,e)} \forall x,y(R(x,y)\rightarrow R(f_{u_j}(x),f_{v_j}(y)))$ +- $\wedge \bigwedge_{a\in A} \forall x(e=f_a(x)\rightarrow \bot)$ + +Beispiel: Betrachte die $\sum$-Struktur $A$ mit Universum $U_A=A^*$ +- $e^A=\epsilon$ +- $f_a^A(u) =au$ +- $R^A=\{(u_{i1} u_{i2} ...u_{in},v_{i1} v_{i2} ...v_{in})|n\geq 0 , 1\geq i_1,i_2,...,i_n\geq k\}$ +- Für $u,v\in A^*$ gilt $f_u^A(v) =uv$. +- Dann gilt $A\Vdash \psi_I$. + +> Lemma +> +> Angenommen, das Korrespondenzsystem $I$ hat keine Lösung. Dann ist die Horn-Formel $\varphi_I=\psi_I \wedge \forall x(R(x,x)\rightarrow x=e)$ erfüllbar. + +Beweis: Sei $A$ die obige Struktur mit $A\Vdash\psi_I$. +- Um $A\Vdash\forall x(R(x,x)\rightarrow x=e)$ zu zeigen, sei $w\in U_A$ beliebig mit $(w,w)\in R^A$. +- Die Definition von $R^A$ sichert die Existenz von $n\geq 0$ und $1\leq i_1,i_2,...,i_n\leq k$ mit $u_{i1} u_{i2}...u_{in}=w=v_{i1} v_{i2} ...v_{in}$. +- Da $I$ keine Lösung hat, folgt $n=0$ und damit $w=\epsilon$. + +> Lemma +> +> Sei $B$ Struktur mit $B\Vdash\psi_I$. Dann gilt $(f_{u_{i_1} u_{i_2} ...u_{i_n}}^B (e^B),f_{v_{i_1} v_{i_2}...v_{i_n}}^B(e^B))\in R^B$ für alle $n\geq 0, 1\leq i_1,i_2,...,i_n \leq k$. + +Beweis: per Induktion über $n\geq 0$. +- IA: für $n=0$ gelten $f_{u_{i_1} u_{i_2} ...u_{i_n}}^B(e^B) =e^B$ und $f_{v_{i_1} v_{i_2}...v_{i_n}}^B(e^B) =e^B$ + - und damit $(f_{u_{i_1} u_{i_2} ...u_{i_n}}^B(e^B), f_{v_{i_1} v_{i_2}...v_{i_n}}^B(e^B) \in R^B$ + - wegen $B\Vdash\psi_I$. +- IS: Seien $n>0$ und $1\leq i_1 ,i_2 ,...,i_n\leq k$. + - Mit $u=u_{i2} u_{i3} ...u_{in}$ und $v=v_{i2} v_{i3} ...v_{in}$ gilt nach IV $(f_u^B(e^B),f_v^B(e^B))\in R^B$. Wegen $B\Vdash\psi_I$ folgt $f_{u_{i_1} u_{i_2} ...u_{i_n}}^B(e^B), f_{v_{i_1} v_{i_2}...v_{i_n}}^B(e^B) = (f_{u_{i1}}^B (f_u^B(e^B)),f_{v_{i1}}^B (f_v^B(e^B)))\in RB$. + +> Lemma +> +> Angenommen, $(i_1,...,i_n)$ ist eine Lösung von $I$. Dann ist die $\sum$-Formel $\varphi_I$ unerfüllbar. + +> Satz +> +> Die Menge der unerfüllbaren Horn-Formeln ist nicht entscheidbar. + +Beweis: Die Abbildung $I\rightarrow\varphi_I$ ist berechenbar. + +Nach den vorherigen Lemmata ist sie eine Reduktion von PCP auf die Menge der unerfüllbaren Horn-Formeln. Da PCP unentscheidbar ist (vgl. Automaten, Sprachen und Komplexität), ist die Menge der unerfüllbaren Horn-Formeln unentscheidbar. + +> Folgerung (Church 1936) +> +> Die Menge der allgemeingültigen $\sum$-Formeln ist nicht entscheidbar. + +Beweis: Eine $\sum$-Formel $\varphi$ ist genau dann unerfüllbar, wenn $\lnot\varphi$ allgemeingültig ist. Also ist $\varphi\rightarrow\lnot\varphi$ eine Reduktion der unentscheidbaren Menge der unerfüllbaren $\sum$-Formeln auf die Menge der allgemeingültigen $\sum$-Formeln, die damit auch unentscheidbar ist. + +Allgemeingültige $\sum$-Formeln gelten in allen Strukturen. Was passiert, wenn wir uns nur auf "interessante" StrukturenAeinschränken (z.B. auf eine konkrete), d.h. wenn wir die Theorie $Th(A)$ von $A$ betrachten? + + +## Theorie der natürlichen Zahlen +> Definition +> +> Sei $A$ eine Struktur. Dann ist $Th(A)$ die Menge der prädikatenlogischen $\sum$-Formeln $\varphi$ mit $A\Vdash\varphi$. Diese Menge heißt die(elementare) Theorie von $A$. + +Beispiel: Sei $N= (N,\leq,+,*, 0 , 1 )$. Dann gelten +- $(\forall x\forall y:x+y=y+x)\in Th(N)$ +- $(\forall x\exists y:x+y= 0 )\not\in Th(N)$ +- aber $(\forall x\exists y:x+y= 0 )\in Th((Z,+, 0 ))$. + +> Lemma +> +> Die Menge $Th(N)$ aller Sätze $\varphi$ mit $N\Vdash\varphi$ ist nicht entscheidbar. + +> Zahlentheoretisches Lemma +> +> Für alle $n\in N,x_0,x_1,...,x_n\in N$ existieren $c,d\in N$, so dass für alle $0\leq i\leq n$ gilt: $x_i=c\ mod ( 1 +d*(i+ 1 ))$. + +Beweis:Setze $m= max\{n,x_0,x_1 ,...,x_n\}$ und $d=2*3*4...(m+1)$. Dann sind die Zahlen $1+d, 1+d*2,..., 1 +d*(n+1)$ paarweise teilerfremd. Nach dem Chinesischen Restsatz folgt die Existenz +einer natürlichen Zahl $c$. + +Bemerkung: Es gibt $\sum$-Formeln +- $mod(x_1,x_2 ,y)$ mit $N\Vdash_{\alpha} mod \Leftrightarrow \alpha (x_1) mod\alpha (x_2) =\alpha (y)$. +- $γ(x_1 ,x_2 ,x_3 ,y)$ mit $N\Vdash_{\alpha} γ\Leftrightarrow \alpha(x_1) mod(1+\alpha(x_2)*(\alpha (x3)+1)) =\alpha (y)$. + +> Satz +> +> Sei $A$ eine Struktur, so dass $Th(A)$ semi-entscheidbar ist. Dann ist $Th(A)$ entscheidbar. + +> Korollar +> Die Menge $TH(N)$ der Aussagen $\varphi$ mit $N\Vdash\varphi$ ist nicht semi-entscheidbar. + +> Korollar (1. Gödelscher Unvollständigkeitssatz) +> +> Sei $Gamma$ eine semi-entscheidbare Menge von Sätzen mit $N\Vdash\gamma$ für alle $\gamma\in\Gamma$. Dann existiert ein Satz $\varphi$ mit $\Gamma\not\vdash\varphi$ und $\Gamma\not\vdash\lnot\varphi$ (d.h. "$\Gamma$ ist nicht vollständig"). + +## 2. Semi Entscheidungsverfahren für allgemeingültige Formeln +bekanntes Verfahren mittels natürlichem Schließen: Suche hypothesenlose Deduktion mit Konklusion $\psi$. + +Jetzt alternatives Verfahren, das auf den Endlichkeitssatz der Aussagenlogik zurückgreift: +- Berechne aus $\sum$-Formel $\psi$ eine Menge E von aussagenlogischen Formeln mit $E$ unerfüllbar $\Leftrightarrow\lnot\psi$ unerfüllbar $\Leftrightarrow\psi$ allgemeingültig +- Suche endliche unerfüllbare Teilmenge $E'$ von $E$ + +Kern des Verfahrens ist es also, aus $\sum$-Formel $\varphi$ eine Menge $E$ aussagenlogischer Formeln zu berechnen mit $\varphi$ unerfüllbar $\Leftrightarrow$ E unerfüllbar. + +Hierzu werden wir die Formel $\varphi$ zunächst in zwei Schritten (Gleichungsfreiheit und Skolem-Form) vereinfachen, wobei die Formel erfüllbar bzw unerfüllbar bleiben muss. + +> Definition +> +> Zwei $\sum$-Formeln $\varphi$ und $\psi$ heißen erfüllbarkeitsäquivalent, wenn gilt: $\varphi$ ist erfüllbar $\Leftrightarrow\psi$ ist erfüllbar + +Unsere Vereinfachungen müssen also erfüllbarkeitsäquivalente Formeln liefern. + +### Elimination von Gleichungen +> Definition +> +> Eine $\sum$-Formel ist gleichungsfrei, wenn sie keine Teilformel der Form $s=t$ enthält. + +Ziel: aus einer $\sum$ Formel $\varphi$ soll eine erfüllbarkeitsäquivalente gleichungsfreue Formel $\varphi'$ berechnet werden + +Bemerkung: Man kann i.a. keine äquivalente gleichungsfreie Formel $\varphi'$ angeben, da es eine solche z.B. zu $\varphi=(\forall x\forall y:x=y)$ nicht gibt. + +Idee: Die Formel $\varphi'$ entsteht aus $\varphi$, indem alle Teilformeln der Form $x=y$ durch $GI(x,y)$ ersetzt werden, wobei $GI$ ein neues Relationssymbol ist. + +Notationen +- Sei $\sum=(\Omega,Rel,ar)$ endliche Signatur und $\varphi$ $\sum$-Formel +- $\sum_{GI} = (\Omega, Rel\bigcup^+\{GI\},ar_{GI})$ mit $ar_{GI}(f)$ für alle $f\in\Omega\cup Rel$ und $ar_{GI}(GI)=2$ +- Für eine $\sum$-Formel $\varphi$ bezeichnet $\varphi_{GI}$ die $\sum_{GI}$-Formel, die aus $\varphi$ entsthet, indem alle Vorkommen und Teilformen $s=t$ durch $GI(s,t)$ ersetzt werden. + +Behauptung: $\varphi$ erfüllbar $\Rightarrow \varphi_{GI}$ erfüllbar + +Behauptung: es gilt nicht $\varphi$ erfüllbar $\Leftarrow\varphi_{GI}$ erfüllbar + +> Definition +> +> Sei A eine $\sum$-Struktur und $\sim$ eine binäre Relation auf $U_A$. Die Relation $\sim$ heißt Kongruenz auf A, wenn gilt: +> - $\sim$ ist eine Äquivalentrelation (d.h. reflexiv, transitiv und symmetrisch) +> - für alle $f\in\Omega$ mit $k=ar(f)$ und alle $a_1,b_1,...,a_k,b_k\in U_A$ gilt $a_1\sim b_1,a_2\sim b_2,...,a_k\sim b_k\Rightarrow f^A(a_1,...,a_k)\sim f^A(b_1,...,b_k)$ +> - für alle $R\in Rel$ mit $k=ar(R)$ und alle $a_1,b_1,...,a_k,b_k\in U_A$ gilt $a_1\sim b_1,...,a_k\sim b_k,(a_1,...,a_k)\in R^A\Rightarrow (b_1,...,b_k)\in R^A$. + +> Definition +> +> Sei $A$ eine $\sum$-Struktur und $\sim$ eine Kongruenz auf A. +> 1. Für $a\in U_A$ sei $[a]=\{b\in U_A|a\sim b\}$ die Äquivalenzklasse von a bzgl $\sim$. +> 2. Dann definieren wir den Quotienten $B=A\backslash \sim$ von $A$ bzgl $\sim$ wie folgt: +> - $U_B=U_A\backslash\sim = \{[a]|a\in U_A\}$ +> - Für jedes $f\in\Omega$ mit $ar(f)=k$ und alle $a_1,...,a_k\in\U_A$ setzten wir $f^B([a_1],...,[a_k])=[f^A(a_1,...,a_k)]$ +> - für jede $R\in Rel$ mit $ar(R)=k$ setzten wir $R^B=\{([a_1],[a_2],...,[a_k])|(a_1,...,a_k)\in R^A\}$ +> 3. Sei $p:Var\rightarrow U_A$ Variableninterpretation. Dann definieren die Variableninterpretation $p\backslash\sim: Var\rightarrowU_B:x\rightarrow[p(x)]$. + +Veranschaulichung: ![](Assets/Logik-variableninterpretation-beispiel.png) + +> Lemma 1 +> +> Sei A Struktur, $p:Var\rightarrow U_A$ Variableninterpretation und $\sim$ Kongruenz. Seien weiter $B=A\backslash\sim$ und $p_B=p\backslash\sim$. Dann gilt für jeden Term $:[p(t)]=p_B(t)$ + +Beweis: per Induktion über den Aufbau des Terms t + +> Lemma 2 +> +> Sei $A$ $\sum$-Struktur, $\sim$ Kongruenz und $B=A\backslash\sim$. Dann gilt für alle $R\in Rel$ mit $k=ar(R)$ und alle $c_1,...,c_k\in U_A$: $([c_1],[c_2],...,[c_k])\in R^B\Leftrightarrow (c_1,c_2,...,c_k)\in R^A$ + +> Satz +> +> Seien $A$ $\sum_{GI}$-Struktur und $p:Var\rightarrow U_A$ Variableninterpretation, so dass $\sim=GI^A$ Kongruenz auf A ist. +> Seien $B=A\backslash\sim$ und $p_B=p\backslash\sim$. +> Dann gilt für alle $\sum$-Formeln $\varphi: A\Vdash_p \varphi_{GI} \Leftrightarrow B\Vdash_{p_B} \varphi$ + +Beweis: per Induktion über den Aufbau der Formel $\varphi$ + +> Lemma +> +> Aus einer endlichen Signatur $\sum$ kann ein gleichungsfreuer Horn-Satz $Kong_{\sum}$ über $\sum_{GI}$ berechnet werden, so dass für alle $\sum_{GI}$-Strukturen $A$ gilt: $A\Vdash Kong_{\sum} \Leftrightarrow GI^A$ ist eine Kongruenz + +> Satz +> +> Aus einer endlichen Signatur $\sum$ und einer $\sum$-Formel $\varphi$ kann eine gleichungsfreie und erfüllbarkeitsäquivalente $\sum_{GI}$-Formel $\varphi'$ berechnet werden. Ist $\varphi$ Horn Formel, so ist auch $\varphi'$ Horn Formel. + +Beweis: Setzte $\varphi' =\varphi_{GI}\wedge Kong_{\sum}$ und zeige: $\varphi$ erfüllbar $\Leftrightarrow \varphi'$ erfüllbar. + +## Skolemform +Ziel: Jede $\sum$-Formel $\varphi$ ist erfüllbarkeitsäquivalent zu einer $\sum$′-Formel $\varphi′=\forall x_1\forall x_2 ...\forall x_k \psi$, wobei $\psi$ kein Quantoren enthält, $\varphi′$ heißt in Skolemform. + +Bemerkung: Betrachte die Formel $\exists x\exists y E(x,y)$. Es gibt keine Formel in Skolemform, die hierzu äquivalent ist. + +2 Schritte: +1. Quantoren nach vorne (d.h. Pränexform) +2. Existenzquantoren eliminieren + +> Definition +> +> Zwei $\sum$-Formeln $\varphi$ und $\psi$ sind äquivalent (kurz:$\varphi\equiv\psi$), wenn für alle $\sum$-Strukturen $A$ und alle Variableninterpretationen $\rho$ gilt: $A\Vdash_\rho\psi \Lefrightarrow $\Leftrightarrow$ A\Vdash_\rho\psi$. + +> Lemma +> +> Seien $Q\in\{\exists ,\forall\}$ und $\oplus\in\{\wedge,\vee,\rightarrow,\leftarrow\}$. Sei $\varphi= (Qx \alpha)\oplus\beta$ und sei $y$ eine Variable, die weder in $\alpha$ noch in $\beta$ vorkommt. Dann gilt +> $\varphi \equiv \begin{cases} Qy(\alpha[x:=y]\oplus\beta) \text{ falls } \oplus\in\{\wedge,\vee,\leftarrow\}\\ \forall y(\alpha[x:=y]\rightarrow\beta) \text{ falls } \oplus=\rightarrow,Q=\exists \\ \exists y(\alpha[x:=y]\rightarrow\beta) \text{ falls }\oplus=\rightarrow,Q=\forall\end{cases}$ + +Notwendigkeit der Bedingung "$y$ kommt weder in $\alpha$ noch in $\beta$ vor": +- $(\exists x:f(x) \not =f(y))\wedge\beta \not\equiv\exists y: (f(y) \not =f(y)\wedge\beta)$ +- $(\exists x:\lnot P(x))\wedge P(y)\not\equiv \exists y: (\lnot P(y) \wedge P(y))$ + +> Lemma +> +> Seien $Q\in\{\exists,\forall\}$ und $\oplus\in\{\wedge,\vee,\rightarrow,\leftarrow\}$. Sei $\varphi= (Qx\alpha)\oplus\beta$ und sei $y$ eine Variable, die weder in $\alpha$ noch in $\beta$ vorkommt. Dann gilt $\varphi\equiv\begin{cases} Qy(\alpha[x:=y]\oplus\beta) \text{ falls }\oplus\in\{\wedge,\vee,\leftarrow\} \\ \forall y(\alpha[x:=y]\rightarrow\beta) \text{ falls }\oplus=\rightarrow,Q=\exists \\ \exists y(\alpha[x:=y]\rightarrow\beta) \text{ falls }\oplus=\rightarrow,Q=\forall \end{cases}$ + +Beweis: (für den Fall $Q=\exists$ und $\oplus=\wedge$) +- Seien $A$ $\sum$-Struktur und $\rho$ Variableninterpretation. +- Für $a\in U_A$ setze $\rho_a:=\rho[y\rightarrow a]$. +- Dann gilt $\rho_a[x\rightarrow \rho_a(y)](z) =\rho[x\rightarrow a](z)$ für alle $z\not=y$ + + +Wir erhalten also +- $A\vdash_\rho (\exists x\alpha)\wedge\beta$ +- $\Leftrightarrow A\vdash_\rho (\exists x\alpha) $ und $A\vdash_\rho \beta$ +- $\Leftrightarrow$ (es gibt $a\in U_A$ mit $A\vdash_{\rho[x\rightarrow a]}\alpha$) und (es gilt $A\vdash_\rho \beta$) +- $\Leftrightarrow$ es gibt $a\in U_A$ mit ($A\vdash_{\rho[x\rightarrow a]}\alpha$ und $A\vdash_\rho \beta$) +- $\Leftrightarrow$ es gibt $a\in U_A$ mit + - $A\vdash_{\rho_a[x\rightarrow \rho_a(y)]}\alpha$ (da $y$ in $\alpha$ nicht vorkommt) + - $A\vdash_{\rho_a} \beta$ (da $y$ in $\beta$ nicht vorkommt) +- $\Leftrightarrow$ es gibt $a\in U_A$ mit + - $A\vdash_{\rho_a} \alpha[x:=y]$ + - $A\vdash_{\rho_a} \beta$ +- $\Leftrightarrow$ es gibt $a\in U_A$ mit $A\vdash_{\rho[y\rightarrow a]}\alpha[x:=y]\wedge\beta$ +- $\Leftrightarrow A\vdash_\rho \exists y(\alpha[x:=y]\wedge\beta)$ + +> Satz +> +> Aus einer endlichen Signatur $\sum$ und einer $\sum$-Formel $\varphi$ kann eine äquivalente $\sum$-Formel $\varphi′=Q_1 x_1 Q_2 x_2 ...Q_k x_k \psi$ (mit $Q_i\in\{\exists,\forall\},\psi$ quantorenfrei und $x_i$ paarweise verschieden) berechnet werden. Eine Formel $\varphi′$ dieser Form heißt Pränexform. +> Ist $\varphi$ gleichungsfrei, so ist auch $\varphi′$ gleichungsfrei. + +Beweis: Der Beweis erfolgt induktiv über den Aufbau von $\varphi$: +- I.A. $\varphi$ ist atomare Formel: Setze $\varphi′=\varphi$. +- I.S. + - $\varphi=\lnot\psi$ : Nach I.V. kann Formel in Pränexform $\psi\equiv Q_1 x_1 Q_2 x_2 ...Q_m x_m \psi′$ berechnet werden. Mit $\forall=\exists$ und $\exists=\forall$ setze $\varphi′=Q_1 x_1 Q_2 x_2 ...Q_m x_m\lnot\psi′$. + - $\varphi=\exists x\psi$: Nach I.V. kann Formel in Pränexform $\psi\equiv Q_1 x_1 Q_2 x_2 ...Q_m x_m \psi′$ berechnet werden. Setze $\varphi′= \begin{cases} \exists x Q_1 x_1 Q_2 x_2 ...Q_m x_m\psi′\text{ falls }x\not\in\{x_1,x_2,...,x_m\}\\ Q_1 x_1 Q_2 x_2 ...Q_m x_m\psi′\text{ sonst}\end{cases}$ + - $\varphi=\alpha\wedge\beta$: Nach I.V. können Formeln in Pränexform $\alpha\equiv Q_1 x_1 Q_2 x_2 ...Q_mx_m \alpha_0; \beta\equiv Q_1′y_1 Q_2′y_2 ...Q_n′y_n \beta_0$ berechnet werden. + +Ziel: Berechnung einer erfüllbarkeitsäquivalenten Formel in Skolemform + +Idee: +1. wandle Formel in Pränexform um +2. eliminiere $\exists$-Quantoren durch Einführen neuer Funktionssymbole + +Konstruktion: Sei $\varphi=\forall x_1\forall x_2...\forall x_m\exists y\psi$ Formel in Pränexform (u.U. enthält $\psi$ weitere Quantoren). Sei $g\not\in\Omega$ ein neues m-stelliges Funktionssymbol. +Setze $\varphi′=\forall x_1\forall x_2...\forall x_m \psi[y:=g(x_1,...,x_m)]$. +Offensichtlich hat $\varphi$′einen Existenzquantor weniger als $\varphi$. Außerdem ist $\varphi′$ keine $\sum$-Formel (denn sie verwendet $g\not\in\Omega$), sondern Formel über einer erweiterten Signatur. + +> Lemma +> +> Die Formeln $\varphi$ und $\varphi′$ sind erfüllbarkeitsäquivalent. + +Beweis: "$\Leftarrow$" Sei $A′$ Struktur und $\rho′$ Variableninterpretation mit $A′\vdash_{\rho′}\varphi′$. Wir zeigen $A′\vdash_{\rho′}\varphi$. Hierzu seien $a_1,...,a_m\in U_{A′}$ beliebig. + +> Satz +> +> Aus einer Formel $\varphi$ kann man eine erfüllbarkeitsäquivalente Formel $\varphi$ in Skolemform berechnen. Ist $\varphi$ gleichungsfrei, so auch $\varphi$. + +Beweis: Es kann zu $\varphi$ äquivalente Formel $\varphi_0 =Q_1 x_1 Q_2 x_2 ...Q_{\iota} x_{\iota} \psi$ in Pränexform berechnet werden (mit $n\leq {\iota} $ Existenzquantoren). Durch wiederholte Anwendung des vorherigen Lemmas erhält man Formeln $\varphi_1,\varphi_2,...\varphi_n$ mit +- $\varphi_i$ und $\varphi_{i+1}$ sind erfüllbarkeitsäquivalent +- $\varphi_{i+1}$ enthält einen Existenzquantor weniger als $\varphi_i$ +- $\varphi_{i+1}$ ist in Pränexform +- ist $\varphi_i$ gleichungsfrei, so auch $\varphi_{i+1}$ + +Dann ist $\bar{\varphi}=\varphi_n$ erfüllbarkeitsäquivalente (ggf. gleichungsfreie) Formel in Skolemform. + +## Herbrand-Strukturen und Herbrand-Modelle +Sei $\sum= (\Omega,Rel,ar)$ eine Signatur. Wir nehmen im folgenden an, dass $\Omega$ wenigstens ein Konstantensymbol enthält. + +Das Herbrand-Universum $D(\sum)$ ist die Menge aller variablenfreien $\sum$-Terme. + +Beispiel: $\Omega =\{b,f\}$ mit $ar(b) =0$ und $ar(f) =1$. Dann gilt $D(\sum) =\{b,f(b),f(f(b)),f(f(f(b))),...\}$ + +Eine $\sum$-Struktur $A=(UA,(fA)f\in\Omega,(RA)R\in Rel)$ ist eine Herbrand-Struktur, falls folgendes gilt: +1. $UA=D(\sum)$, +2. für alle $f\in\Omega$ mit $ar(f)=k$ und alle $t_1,t_2,...,t_k\in D(\sum)$ ist $f^A(t_1,t_2,...,t_k) =f(t_1,t_2,...,t_k)$. + +Für jede Herbrand-Struktur $A$, alle Variableninterpretationen $\rho$ und alle variablenfreien Terme $t$ gilt dann $\rho(t) =t$. + +Ein Herbrand-Modell von $\varphi$ ist eine Herbrand-Struktur, die gleichzeitig ein Modell von $\varphi$ ist. + +> Satz +> +> Sei $\varphi$ eine gleichungsfreie Aussage in Skolemform. $\varphi$ ist genau dann erfüllbar, wenn $\varphi$ ein Herbrand-Modell besitzt. + +Beweis: +- Falls $\varphi$ ein Herbrand-Modell hat, ist $\varphi$ natürlich erfüllbar. +- Sei nun $\varphi=\forall y_1...\forall y_n\psi$ erfüllbar. Dann existieren eine $\sum$-Struktur $A=(U_A,(f^A)_{f\in\Omega},(R^A)_{R\in Rel})$ und eine Variableninterpretation $\rho$ mit $A\vdash_\rho \varphi$. + +#### Plan des Beweises +Wir definieren eine Herbrand-Struktur $B=(D(\sum),(f^B)_{f\in\Omega},(R^B)_{R\in Rel})$: +- Seien $f\in\Omega$ mit $ar(f)=k$ und $t_1,...,t_k\in D(\sum)$. Um eine Herbrand-Struktur $B$ zu konstruieren setzen wir $f^B(t_1,...,t_k) =f(t_1,...,t_k)$ +- Sei $R\in Rel$ mit $ar(R)=k$ und seien $t_1,...,t_k\in D(\sum)$. Dann setze $(t_1,...,t_k)\in RB:\Leftrightarrow (\rho(t_1),...,\rho(t_k))\in RA$. + +Sei $\rho_B:Var \rightarrow D(\sum)$ beliebige Variableninterpretation. + +##### Behauptung 1: +Ist $\psi$ eine quantoren- und gleichungsfreie Aussage, so gilt $A\vdash_\rho\psi \Leftrightarrow B\vdash_{\rhoB} \psi$. Diese Behauptung wird induktiv über den Aufbau von $\psi$ gezeigt. + +##### Intermezzo +Behauptung 1 gilt nur für quantorenfreie Aussagen + +$\sum = (\Omega,Rel,ar)$ mit $\Omega =\{a\},ar(a) =0$ und $Rel=\{E\},ar(E) =2$. +Betrachte die Formel $\varphi=\forall x(E(x,x)\wedge E(a,a))$ in Skolemform. +$A\vdash_\rho \varphi$ mit $U^A=\{a^A,m\}$ und $E^A=\{(m,m),(a^A,a^A)\}$. +Die konstruierte Herbrand-Struktur $B:U_B=D(\sum) =\{a\}$ und $E^B=\{(a,a)\}$. + +Betrachte nun die Formel $\psi=\forall x,y E(x,y)$. Dann gilt $B\vdash_{\rhoB}\psi$ und $A\not\vdash_\rho \psi$. + +Für allgemeine Formeln in Skolemform (also u.U. mit Quantoren) können wir also Behauptung 1 nicht zeigen, sondern höchstens die folgende Abschwächung. + +##### Behauptung 2: +Ist $\psi$ eine gleichungsfreie Aussage in Skolemform, so gilt $A\vdash_\rho \psi \Rightarrow B\vdash_{\rhoB}\psi$. +(hieraus folgt dann $B\vdash_{\rhoB}\varphi$ wegen $A\vdash_\rho \varphi$) + +Diese Behauptung wird induktiv über die Anzahl $n$ der Quantoren in $\psi$ bewiesen. + +## Die Herbrand-Expansion +verbleibende Frage: Wie erkennt man, ob eine gleichungsfreie Aussage in Skolemform ein Herbrand-Modell hat? + +Beispiel: Seien $\sum=(\{a,f\},\{P,R\},ar)$ und $\varphi=\forall x\forall$ y (P(a,x)\wedge\lnot R(f(y)))$. +Jedes Herbrand-Modell A von $\varphi$ +- hat als Universum das Herbrand-Universum $D(\sum)=\{a,f(a),f^2 (a),...\}=\{f^n(a)|n\geq 0\}$ +- erfüllt $f^A(f^n(a))= f^{n+1} (a)$ für alle $n\geq 0$ + +Um ein Herbrand-Modell zu konstruieren, müssen (bzw. können) wir für alle Elemente $s,t,u\in D(\sum)$ unabhängig und beliebig wählen, ob $(s,t)\in P^A$ und $u\in R^A$ gilt. +Wir fassen dies als "aussagenlogische B-Belegung" B der "aussagenlogischen atomaren Formeln" $P(s,t)$ bzw. $R(u)$ auf. + +Jede solche aussagenlogische B-Belegung $B$ definiert dann eine Herbrand-Struktur $A_B$: +- $P^{A_B} = \{(s,t)\in D(\sum)^2 |B(P(s,t))= 1\}$ +- $R^{A_B} = \{u\in D(\sum) |B(R(u))= 1\}$ + +Mit $\varphi=\forall x\forall y(P(a,x)\wedge\lnot R(f(y)))$ gilt dann $A_B \Vdash_\rho \varphi$ +- $\Leftrightarrow A_B \Vdash_{\rho[x\rightarrow f^m(a)][y\rightarrow f^n(a)]} P(a,x)\wedge\lnot R(f(y))$ f.a. $m,n\geq 0$ +- $\Leftrightarrow (a,fm(a))\in P^{A_B}$ und $f^{n+1}(a)\not\in R^{A_B}$ f.a. $m,n\geq 0$ +- $\Leftrightarrow B(P(a,f^m(a)))= 1$ und $B(R(f^{n+1} (a)))= 0$ f.a. $m,n\geq 0$ +- $\Leftrightarrow B(P(a,f^m(a))\wedge\lnot R(f^{n+1} (a)))= 1$ f.a. $m,n\geq 0$ + +Also hat $\varphi$ genau dann ein Herbrand-Modell, wenn es eine erfüllende B-Belegung $B$ der Menge aussagenlogischer Formeln $E(\varphi)=\{P(a,f^m(a))\wedge\lnot R(f^{n+1}(a)) | m,n\geq 0\}$ gibt. + +Beispiellösung: Setzt $B(P(s,t))= 1$ und $B(R(s))= 0$ für alle $s,t\in D(\sum)$. + +Diese B-Belegung erfüllt $E(\varphi)$ und "erzeugt" die Herbrand-Struktur $A_B$ mit $P^{A_B}=D(\sum)^2$ und $R^{A_B}=\varnothing$. + +Nach obiger Überlegung gilt $A_B\Vdash\varphi$, wir haben also ein Herbrand-Modell von $\varphi$ gefunden. + + +Sei $\varphi=\forall y_1\forall y_2...\forall y_n\psi$ gleichungsfreie Aussage in Skolemform. + +Ziel: Konstruktion einer Menge aussagenlogischer Formeln, die genau dann erfüllbar ist, wenn $\varphi$ ein Herbrand-Modell hat. + +Die Herbrand-Expansion von $\varphi$ ist die Menge der Aussagen $E(\varphi)=\{\psi[y_1:=t_1][y_2:=t_2]...[y_n:=t_n]|t_1,t_2,...,t_n\in D(\sum)\}$ + +Die Formeln von $E(\varphi)$ entstehen also aus $\psi$, indem die (variablenfreien) Terme aus $D(\sum)$ in jeder möglichen Weise in $\psi$ substituiert werden. + +Wir betrachten die Herbrand-Expansion von $\varphi$ im folgenden als eine Menge von aussagenlogischen Formeln. + +Die atomaren Formeln sind hierbei von der Gestalt $P(t_1,...,t_k)$ für $P\in Rel$ mit $ar(P)=k$ und $t_1,...,t_k\in D(\sum)$. + +> Konstruktion +> +> Sei $B:\{P(t_1,...,t_k)|P\in Rel,k=ar(P),t_1,...,t_k\in D(\sum)\}\rightarrow B$ eine +B-Belegung. Die hiervon induzierte Herbrand-Struktur $A_B$ ist gegeben durch $P^{A_B} = \{(t_1,...,t_k)|t_1,...,t_k\in D(\sum),B(P(t_1,...,t_k))= 1\}$ für alle $P\in Rel$ mit $ar(P)=k$. + +> Lemma +> +> Für jede quantoren- und gleichungsfreie Aussage $\alpha$ und jede Variableninterpretation $\rho$ in $A_B$ gilt $A_B\Vdash_\rho\alpha \Leftrightarrow B(\alpha)= 1$. + +Beweis: +- per Induktion über den Aufbau von $\alpha$ +- I.A. $\alpha$ ist atomar, d.h. $\alpha= P(t_1,...,t_k)$ mit $t_1,...,t_k$ variablenlos $A_B\Vdash_\rho \alpha\Leftrightarrow (\rho(t_1),\rho(t_2),...,\rho(t_k))\in P^{A_B}\Leftarrow B(\alpha)= 1$ +- I.S. + - $\alpha=\beta\wedge\gamma: A_B\Vdash_\rho \alpha\Leftrightarrow A_B \Vdash_\rho\beta$ und $A_B\Vdash_\rho\gamma \Leftrightarrow B(\beta)=B(\gamma)= 1 \Leftrightarrow B(\alpha)= 1$ + - $\alpha=\beta\vee\gamma$: analog + - $\alpha=\beta\rightarrow\gamma$: analog + - $\alpha=\lnot\beta$: analog + +> Lemma +> +> Sei $\varphi=\forall y_1 \forall y_2 ...\forall y_n\psi$ gleichungsfreie Aussage in Skolemform. Sie hat genau dann ein Herbrand-Modell, wenn die Formelmenge $E(\varphi)$ (im aussagenlogischen Sinn) erfüllbar ist. + +Beweis: Seien $A$ Herbrand-Struktur und $\rho$ Variableninterpretation. Sei $B$ die B-Belegung mit $B(P(t_1,...,t_k))= 1\Leftrightarrow(t_1,...,t_k)\in P^A$ für alle $P\in Rel$ mit $k=ar(P)$ und $t_1,...,t_k\in D(\sum)$. Dann gilt $A=A_B$. + +> Satz von Gödel-Herbrand-Skolem +> +> Sei $\varphi$ gleichungsfreie Aussage in Skolemform. Sie ist genau dann erfüllbar, wenn die Formelmenge $E(\varphi)$ (im aussagenlogischen Sinn) erfüllbar ist. + +Beweis: $\varphi$ erfüllbar $\Leftrightarrow$ $\varphi$ hat ein Herbrand-Modell $\Leftrightarrow$ $E(\varphi)$ ist im aussagenlogischen Sinne erfüllbar. + +> Satz von Herbrand +> +> Eine gleichungsfreie Aussage $\varphi$ in Skolemform ist genau dann unerfüllbar, wenn es eine endliche Teilmenge von $E(\varphi)$ gibt, die (im aussagenlogischen Sinn) unerfüllbar ist. +> +> (Jacques Herbrand (1908-1931)) + +Beweis: $\varphi$ unerfüllbar $\Leftrightarrow$ $E(\varphi)$ unerfüllbar $\Leftrightarrow$ es gibt $M\subseteq E(\varphi)$ endlich und unerfüllbar + + +## Algorithmus von Gilmore +Sei $\varphi$ gleichungsfreie Aussage in Skolemform und sei $\alpha_1,\alpha_2,\alpha_3,...$ eine Aufzählung von $E(\varphi)$. + +Eingabe: $\varphi$ +``` +n:=0; +repeat n := n +1; +until { alpha_1, alpha_2,..., alpha_n } ist unerfüllbar; + (dies kann mit Mitteln der Aussagenlogik, z.B. Wahrheitswertetabelle, getestet werden) +Gib "unerfüllbar" aus und stoppe. +``` + +Folgerung: Sei $\varphi$ eine gleichungsfreie Aussage in Skolemform. Dann gilt: +- Wenn die Eingabeformel $\varphi$ unerfüllbar ist, dann terminiert der Algorithmus von Gilmore und gibt "unerfüllbar" aus. +- Wenn die Eingabeformel $\varphi$ erfüllbar ist, dann terminiert der Algorithmus von Gilmore nicht, d.h. er läuft unendlich lange. + +Beweis: unmittelbar mit Satz von Herbrand + +Zusammenfassung: alternative Semi-Entscheidungsverfahren für die Menge der allgemeingültigen Formeln. +- Berechne aus $\psi$ eine zu $\lnot\psi$ erfüllbarkeitsäquivalente gleichungsfreie Formel $\varphi$ in Skolemform. +- Suche mit dem Algorithmus von Gilmore nach einer endlichen Teilmenge $E′$ von $E(\varphi)$, die unerfüllbar ist. + + +## Berechnung von Lösungen +Beispiel + - $\gamma = \forall x,y (R(x,f(y))\wedge R(g(x),y))$ + - $\varphi = \forall x,yR(x,y)$ +- Gilt $\{\gamma\}\Vdash\varphi$? nein, denn $A\Vdash\gamma\wedge\lnot\varphi$ mit + - $A=(\mathbb{N},f^A,g^A,R)$ + - f^A(n)=g^A(n)=n+1$ für alle $n\in\mathbb{N}$ + - $R^A = \mathbb{N}^2 \backslash\{( 0 , 0 )\}$ +- Gibt es variablenfreie Terme $s$ und $t$ mit $\{\gamma\}\Vdash R(s,t)$? + - ja: z.B. $(s,t)=(g(f(a)),g(a))$ oder $(s,t)=(g(a),g(a))$ oder $(s,t)=(a,f(b))$ +- Kann die Menge aller Termpaare $(s,t)$ (d.h. aller "Lösungen") mit $\{\gamma\}\Vdash R(s,t)$ effektiv und übersichtlich angegeben werden? + - Wegen $\{\gamma\}\Vdash R(s,t) \Leftrightarrow\gamma\wedge\lnot R(s,t)$ unerfüllbar ist die gesuchte Menge der variablenfreien Terme $(s,t)$ semi-entscheidbar, d.h. durch eine Turing-Maschine beschrieben. +- Im Rest des Logikteils der Vorlesung "Logik und Logikprogrammierung" wollen wir diese Menge von Termpaaren "besser" beschreiben (zumindest in einem Spezialfall, der die Grundlage der logischen Programmierung bildet). + +> Erinnerung +> +> Eine Horn-Klausel der Prädikatenlogik ist eine Aussage der Form $\forall x_1\forall x_2...\forall x_n ((\lnot\bot\wedge\alpha_1 \wedge\alpha_2 \wedge...\wedge\alpha_m)\rightarrow\beta)$, mit $m\geq 0$, atomaren Formeln $\alpha_1,...,\alpha_m$ und $\beta$ atomare Formel oder $\bot$. + +Aufgabe: +$\varphi_1,...,\varphi_n$ gleichungsfreie Horn-Klauseln, $\psi(x_1,x_2,...,x_{\iota} )=R(t_1,...,t_k)$ atomare Formel, keine Gleichung. Bestimme die Menge der Tupel $(s_1,...,s_{\iota} )$ von variablenfreien Termen mit $\{\varphi_1,...,\varphi_n\}\Vdash\psi(s_1,...,s_{\iota} )=R(t_1,...,t_k)[x_1:=s_1]...[x_{\iota} :=s_{\iota} ]$, d.h., für die die folgende Formel unerfüllbar ist: $\bigwedge_{1\leq i\leq n} \varphi_i \wedge \lnot\psi(s_1,...,s_{\iota} ) \equiv \bigwedge_{1\leq i\leq n} \varphi_i\wedge(\psi(s_1,...,s_{\iota} )\rightarrow\bot)$ + +Erinnerung +- Eine Horn-Formel der Prädikatenlogik ist eine Konjunktion von Horn-Klauseln der Prädikatenlogik. +- Eine Horn-Klausel der Aussagenlogik ist eine Formel der Form $(\lnot\bot\wedge q_1\wedge q_2 \wedge...\wedge q_m)\rightarrow r$ mit $m\geq 0$, atomaren Formeln $q_1,q_2,...,q_m, r$ atomare Formel od. $\bot$. + +Beobachtung +- Wir müssen die Unerfüllbarkeit einer gleichungsfreien Horn-Formel der Prädikatenlogik testen. +- Ist $\varphi$ gleichungsfreie Horn-Klausel der Prädikatenlogik, so ist $E(\varphi)$ eine Menge von Horn-Klauseln der Aussagenlogik. + +Schreib- und Sprechweise +- $\{\alpha_1,\alpha_2,...,\alpha_n\}\rightarrow\beta$ für Horn-Klausel der Prädikatenlogik $(\lnot\bot\wedge\alpha_1 \wedge\alpha_2\wedge...\wedge\alpha_n)\rightarrow\beta$ insbes. $\varnothing\rightarrow\beta$ für $\lnot\bot\rightarrow\beta$ +- $\{(N_i\rightarrow\beta_i) | 1\leq i\leq m\}$ für Horn-Formel $\bigwedge_{1\leq i\leq m} (N_i\rightarrow\beta_i)$ + +Folgerung: Sei $\varphi =\bigwedge_{1\leq i\leq n} \varphi_i$ gleichungsfreie Horn-Formel der Prädikatenlogik. Dann ist $\varphi$ genau dann unerfüllbar, wenn $\bigcup_{1\leq i\leq n} E(\varphi_i)$ im aussagenlogischen Sinne unerfüllbar ist. + +Beweis: Für $1\leq i\leq n$ sei $\varphi_i=\forall x_1^i,x_2^i,...,x_{m_i}^i \psi_i$. +Zur Vereinfachung nehme wir an, daß die Variablen $x_j^i$ für $1\leq i\leq n$ und $1\leq j\leq m_i$ paarweise verschieden sind. + +Folgerung: Eine gleichungsfreie Horn-Formel der Prädikatenlogik $\varphi=\bigwedge_{1\leq i\leq n} \varphi_i$ ist genau dann unerfüllbar, wenn es eine SLD-Resolution $(M_0\rightarrow\bot,M_1\rightarrow\bot,...,M_m\rightarrow\bot)$ aus $\bigcup_{1\leq i\leq n} E(\varphi_i)$ mit $M_m =\varnothing$ gibt. + +## Substitutionen +Eine verallgemeinerte Substitution $\sigma$ ist eine Abbildung der Menge der Variablen in die Menge aller Terme, so daß nur endlich viele Variable $x$ existieren mit $\sigma(x) \not=x$. + +Sei $Def(\sigma)=\{x\ Variable|x\not =\sigma(x)\}$ der Definitionsbereich der verallgemeinerten Substitution $\sigma$. Für einen Term $t$ definieren wir den Term $t\sigma$ (Anwendung der verallgemeinerten Substitution $\sigma$ auf den Term $t$) wie folgt induktiv: +- $x\sigma=\sigma(x)$ +- $[f(t_1 ,... ,t_k)]\sigma=f(t_1\sigma,... ,t_k\sigma)$ für Terme $t_1,... ,t_k,f\in\Omega$ und $k=ar(f)$ +Für eine atomare Formel $\alpha=P(t_1 ,... ,t_k)$ (d.h. $P\in Rel,ar(P) =k,t_1 ,... ,t_k$ Terme) sei $\alpha\sigma = P(t_1\sigma,... ,t_k\sigma)$ + +Verknüpfungvon verallgemeinerten Substitutionen: Sind $\sigma_1$ und $\sigma_2$ verallgemeinerte Substitutionen, so definieren wir eine neue verallgemeinerte Substitution $\sigma_1 \sigma_2$ durch $(\sigma_1 \sigma_2)(x) = (x\sigma_1)\sigma_2$. + +Beispiel: Sei $x$ Variable und $t$ Term. Dann ist $\sigma$ mit +$\sigma(y) =\begin{cases} t \quad\text{ falls } x=y \\ y \quad\text{ sonst }\end{cases}$ +eine verallgemeinerte Substitution. Für alle Terme $s$ und alle atomaren Formeln $\alpha$ gilt +$s\sigma=s[x:=t]$ und $\alpha\sigma=\alpha[x:=t]$. +Substitutionen sind also ein Spezialfall der verallgemeinerten Substitutionen. + +Beispiel: Die verallgemeinerte Substitution $\sigma$ mit $Def(\sigma)=\{x,y,z\}$ und $\sigma(x) =f(h(x′)), \sigma(y) =g(a,h(x′)), \sigma(z) =h(x′)$ ist gleich der verallgemeinerten Substitution $[x:=f(h(x′))] [y:=g(a,h(x′))] [z:=h(x′)] = [x:=f(z)] [y:=g(a,z)] [z:=h(x′)]$. +Es kann sogar jede verallgemeinerte Substitution $\sigma$ als Verknüpfung von Substitutionen der Form $[x:=t]$ geschrieben werden. +Vereinbarung: Wir sprechen ab jetzt nur von "Substitutionen", auch wenn wir "verallgemeinerte Substitutionen" meinen. + +> Lemma +> +> Seien $\sigma$ Substitution, $x$ Variable und $t$ Term, so dass +> - (i) $x\not\in Def(\sigma)$ und +> - (ii) $x$ in keinem der Terme $y\sigma$ mit $y\in Def(\sigma)$ vorkommt. +> Dann gilt $[x:=t]\sigma=\sigma[x:=t\sigma]$. + +Beispiele: Im folgenden sei $t=f(y)$. +- Ist $\sigma=[x:=g(z)]$, so gilt $x[x:=t]\sigma=t\sigma=t\not=g(z) =g(z)[x:=t\sigma] =x\sigma[x:=t\sigma]$. +- Ist $\sigma= [y:=g(x)]$, so gilt $y[x:=t]\sigma=y\sigma=g(x) \not=g(f(g(x)))= g(x) [x:=t\sigma] =y\sigma[x:=t\sigma]$. +- Ist $\sigma= [y:=g(z)]$, so gelten $Def([x:=t]\sigma) =\{x,y\}=Def(\sigma[x:=t\sigma]),[x:=t]\sigma(x) =f(g(z)) =\sigma[x:=t\sigma]$ und $[x:=t]\sigma(y) =\sigma(z) =\sigma[x:=t\sigma]$, also $[x:=t]\sigma=\sigma[x:=t\sigma]$. + +Beweis: Wir zeigen $y[x:=t]\sigma=y\sigma[x:=t\sigma]$ für alle Variablen $y$. +- $y=x$: Dann gilt $y[x:=t]\sigma=t\sigma$. Außerdem $y\sigma=x$ wegen $y=x\not\in Def(\sigma)$ und damit $y\sigma[x:=t\sigma]=x[x:=t\sigma]=t\sigma$. +- $y\not =x$: Dann gilt $y[x:=t]\sigma=y\sigma$ und ebenso $y\sigma[x:=t\sigma]=y\sigma$, da $x$ in $y\sigma$ nicht vorkommt. + +## Unifikator/Allgemeinster Unifikator +Gegeben seien zwei gleichungsfreie Atomformeln $\alpha$ und $\beta$. Eine Substitution $\sigma$ heißt Unifikator von $\alpha$ und $\beta$, falls $\alpha\sigma=\beta\sigma$. + +Ein Unifikator $\sigma$ von $\alpha$ und $\beta$ heißt allgemeinster Unifikator von $\alpha$ und $\beta$, falls für jeden Unifikator $\sigma′$ von $\alpha$ und $\beta$ eine Substitution $\tau$ mit $\sigma′=\sigma \tau$ existiert. + +Aufgabe: Welche der folgenden Paare $(\alpha,\beta)$ sind unifizierbar? +| $\alpha$ | $\beta$ | Ja | Nein | +| ------------------- | ---------------- | --- | ---- | +| $P(f(x))$ | $P(g(y))$ | | +| $P(x)$ | $P(f(y))$ | | +| $Q(x,f(y))$ | $Q(f(u),z)$ | | +| $Q(x,f(y))$ | $Q(f(u),f(z))$ | | +| $Q(x,f(x))$ | $Q(f(y),y)$ | | +| $R(x,g(x),g^2 (x))$ | $R(f(z),w,g(w))$ | | + +### Zum allgemeinsten Unifikator +Eine Variablenumbenennung ist eine Substitution $\rho$, die $Def(\rho)$ injektiv in die Menge der Variablen abbildet. + +> Lemma +> +> Sind $\sigma_1$ und $\sigma_2$ allgemeinste Unifikatoren von $\alpha$ und $\beta$, so existiert eine Variablenumbenennung $\rho$ mit $\sigma_2=\sigma_1 \rho$. + +Beweis: $\sigma_1$ und $\sigma_2$ allgemeinste Unifikatoren $\Rightarrow$ es gibt Substitutionen $\tau_1$ und $\tau_2$ mit $\sigma_1\tau_1 =\sigma_2$ und $\sigma_2\tau_2 =\sigma_1$. +Definiere eine Substitution $\rho$ durch: +$\rho(y) =\begin{cases} y\tau_1 \quad\text{ falls es x gibt, so dass y in } x\sigma_1 \text{ vorkommt}\\ y \quad\text{ sonst }\end{cases}$ +Wegen $Def(\rho)\subseteq Def(\tau_1)$ ist $Def(\rho)$ endlich, also $\rho$ eine Substitution. +- Für alle Variablen $x$ gilt dann $x\sigma_1 \rho=x\sigma_1 \tau_1 =x\sigma_2$ und daher $\sigma_2 =\sigma_1 \rho$. +- Wir zeigen, dass $\rho(y)$ Variable und $\rho$ auf $Def(\rho)$ injektiv ist: Sei $y\in Def(\rho)$. Dann existiert Variable $x$, so dass $y$ in $x\sigma_1$ vorkommt. Es gilt $x\sigma_1 =x\sigma_2\tau_2=x\sigma_1\tau_1\tau_2$, und damit $y=y\tau_1 \tau_2 =y\rho \tau_2 =\rho(y)\tau_2$, d.h. $\rho(y)$ ist Variable, die Abbildung $\rho:Def(\rho)\rightarrow\{z|z\ Variable\}$ ist invertierbar (durch $\tau_2$) und damit injektiv. + +### Unifikationsalgorithmus +- Eingabe: Paar$(\alpha,\beta)$ gleichungsfreier Atomformeln $\sigma:=$ Substitution mit $Def(\sigma)=\varnothing$ (d.h. Identität) +- while $\alpha\sigma\not =\beta\sigma$ do + - Suche die erste Position, an der sich $\alpha\sigma$ und $\beta\sigma$ unterscheiden + - if keines der beiden Symbole an dieser Position ist eine Variable + - then stoppe mit "nicht unifizierbar" + - else sei $x$ die Variable und $t$ der Term in der anderen Atomformel (möglicherweise auch eine Variable) + - if $x$ kommt in $t$ vor + - then stoppe mit "nicht unifizierbar" + - else $\sigma:=\sigma[x:=t]$ +- endwhile +- Ausgabe: $\sigma$ + +> Satz +> +> - (A) Der Unifikationsalgorithmus terminiert für jede Eingabe. +> - (B) Wenn die Eingabe nicht unifizierbar ist, so terminiert der Unifikationsalgorithmus mit der Ausgabe "nicht unifizierbar". +> - (C) Wenn die Eingabe $(\alpha,\beta)$ unifizierbar ist, dann findet der Unifikationsalgorithmus einen allgemeinsten Unifikator von $\alpha$ und $\beta$. + +(C) besagt insbesondere, daß zwei unifizierbare gleichungsfreie Atomformeln (wenigstens) einen allgemeinsten Unifikator haben. Nach dem Lemma oben haben sie also genau einen allgemeinsten Unifikator (bis auf Umbenennung der Variablen). + +Die drei Teilaussagen werden in getrennten Lemmata bewiesen werden. + +> Lemma (A) +> Der Unifikationsalgorithmus terminiert für jede Eingabe($\alpha$, $\beta$). + +Beweis: Wir zeigen, daß die Anzahl der in $\alpha\sigma$ oder $\beta\sigma$ vorkommenden Variablen in jedem Durchlauf der while-Schleife kleiner wird. +Betrachte hierzu einen Durchlauf durch die while-Schleife. +Falls der Algorithmus in diesem Durchlauf nicht terminiert, so wird $\sigma$ auf $\sigma[x:=t]$ gesetzt. +Hierbei kommt $x$ in $\alpha\sigma$ oder in $\beta\sigma$ vor und der Term $t$ enthält $x$ nicht. +Also kommt $x$ weder in $\alpha\sigma[x:=t]$ noch in $\beta\sigma[x:=t]$ vor. + +> Lemma (B) +> Wenn die Eingabe nicht unifizierbar ist, so terminiert der Unifikationsalgorithmus mit der Ausgabe "nicht unifizierbar". + +Beweis: Sei die Eingabe $(\alpha,\beta)$ nicht unifizierbar. +Falls die Bedingung $\alpha\sigma\not=\beta\sigma$ der while-Schleife irgendwann verletzt wäre, so wäre $(\alpha,\beta)$ doch unifizierbar (denn $\sigma$ wäre ja ein Unifikator). +Da nach Lemma (A) der Algorithmus bei Eingabe $(\alpha,\beta)$ terminiert, muss schließlich "nicht unifizierbar" ausgegeben werden. + +> Lemma (C1) +> Sei $\sigma′$ ein Unifikator der Eingabe $(\alpha,\beta)$, so dass keine Variable aus $\alpha$ oder $\beta$ auch in einem Term aus $\{y\sigma′|y\in Def(\sigma′)\}$ vorkommt. Dann terminiert der Unifikationsalgorithmus erfolgreich und gibt einen Unifikator $\sigma$ von $\alpha$ und $\beta$ aus. Außerdem gibt es eine Substitution $\tau$ mit $\sigma′=\sigma\tau$. + +Beweis: +- Sei $N\in\mathbb{N}$ die Anzahl der Durchläufe der while-Schleife (ein solches $N$ existiert, da der Algorithmus nach Lemma (A) terminiert). +- Sei $\sigma_0$ Substitution mit $Def(\sigma_0) =\varnothing$, d.h. die Identität. Für $1\leq i\leq N$ sei $\sigma_i$ die nach dem $i$-ten Durchlauf der while-Schleife berechnete Substitution $\sigma$. +- Für $1\leq i\leq N$ sei $x_i$ die im $i$-ten Durchlauf behandelte Variable $x$ und $t_i$ der entsprechende Term $t$. +- Für $0\leq i\leq N$ sei $\tau_i$ die Substitution mit $\tau_i(x)=\sigma′(x)$ für alle $x\in Def(\tau_i) =Def(\sigma′)\backslash\{x_1,x_2,...,x_i\}$. + +Behauptung: +1. Für alle $0\leq i\leq N$ gilt $\sigma′=\sigma_i\tau_i$. +2. Im $i$-ten Durchlauf durch die while-Schleife $(1\leq i\leq N)$ terminiert der Algorithmus entweder erfolgreich (und gibt die Substitution $\sigma_N$ aus) oder der Algorithmus betritt die beiden else-Zweige. +3. Für alle $0\leq i\leq N$ enthalten $\{\alpha\sigmai,\beta\sigma_i\}$ und $T_i=\{y\tau_i|y\in Def(\tau_i)\}$ keine gemeinsamen Variablen. + +Aus dieser Behauptung folgt tatsächlich die Aussage des Lemmas: +- Nach (2) terminiert der Algorithmus erfolgreich mit der Substitution $\sigma_N$. Daher gilt aber $\alpha\sigma_N=\beta\sigma_N$, d.h. $\sigma_N$ ist ein Unifikator. +- Nach (1) gibt es auch eine Substitution $\tau_n$ mit $\sigma′=\sigma_N\tau_n$. + +> Lemma (C) +> Sei die Eingabe $(\alpha,\beta)$ unifizierbar. Dann terminiert der Unifikationsalgorithmus erfolgreich und gibt einen allgemeinsten Unifikator $\sigma$ von $\alpha$ und $\beta$ aus. + +Beweis: Sei $\sigma′$ ein beliebiger Unifikator von $\alpha$ und $\beta$. Sei $Y=\{y_1,y_2,... ,y_n\}$ die Menge aller Variablen, die in $\{y\sigma′|y\in Def(\sigma′)\}$ vorkommen. +Sei $Z=\{z_1,z_2,...,z_n\}$ eine Menge von Variablen, die weder in $\alpha$ noch in $\beta$ vorkommen. +Sei $\rho$ die Variablenumbenennung mit $Def(\rho)=Y\cup Z,\rho(y_i) =z_i$ und $\rho(z_i)=y_i$ für alle $1\leq i\leq n$. +Dann ist auch $\sigma′\rho$ ein Unifikator von $\alpha$ und $\beta$ und keine Variable aus $\alpha$ oder $\beta$ kommt in einem der Terme aus $\{y\sigma′\rho|y\in Def(\sigma′)\}$ vor. +Nach Lemma (C1) terminiert der Unifikationsalgorithmus erfolgreich mit einem Unifikator $\sigma$ von $\alpha$ und $\beta$, so dass es eine Substitution $\tau$ gibt mit $\sigma′\rho=\sigma\tau$. +Also gilt $\sigma′=\sigma(\tau\rho^{-1})$. +Da $\sigma′$ ein beliebiger Unifikator von $\alpha$ und $\beta$ war und da die Ausgabe $\sigma$ des Algorithmus nicht von $\sigma′$ abhängt, ist $\sigma$ also ein allgemeinster Unifikator. + +> Satz +> +> - (A) Der Unifikationsalgorithmus terminiert für jede Eingabe. +> - (B) Wenn die Eingabe nicht unifizierbar ist, so terminiert der Unifikationsalgorithmus mit der Ausgabe "nicht unifizierbar". +> - (C) Wenn die Eingabe $(\alpha,\beta)$ unifizierbar ist, dann findet der Unifikationsalgorithmus immer einen allgemeinsten Unifikator von $\alpha$ und $\beta$. + +(C) besagt insbesondere, daß zwei unifizierbare gleichungsfreie Atomformeln(wenigstens) einen allgemeinsten Unifikator haben. Damit haben sie aber genau einen allgemeinsten Unifikator (bis auf Umbenennung der Variablen). + +## Prädikatenlogische SLD-Resolution +Erinnerung +- Eine Horn-Klausel der Prädikatenlogik ist eine Aussage der Form $\forall x_1 \forall x_2... \forall x_n ((\lnot\bot \wedge\alpha_1 \wedge\alpha_2 \wedge...\wedge\alpha_m)\rightarrow\beta)=\Psi$ mit $m\geq 0$, atomaren Formeln $\alpha_1,...,\alpha_m$ und $\beta$ atomare Formel oder $\bot$. Sie ist definit, wenn $\beta\not =\bot$. +- $E(\varphi) =\{\Psi[x_1 :=t_1 ][x_2 :=t_2 ]...[x_n:=tn]|t_1 ,t_2 ,...,t_n\in D(\sigma)\}$ +- Eine Horn-Klausel der Aussagenlogik ist eine Formel der Form $(\lnot\bot\wedge q_1 \wedge q_2 \wedge... \wedge q_m)\rightarrow r$ mit $m\geq 0$, atomaren Formeln $q_1,q_2,...,q_m,r$ atomare Formel oder $\bot$. + +Schreib- und Sprechweise: +Für die Horn-Klausel der Prädikatenlogik $\forall x_1...\forall x_n(\lnot\bot \wedge \alpha_1 \wedge \alpha_2 \wedge...\wedge \alpha_m)\rightarrow\beta$ schreiben wir kürzer $\{\alpha_1,\alpha_2,...,\alpha_m\}\rightarrow\beta$. +insbes. $\varnothing\rightarrow\beta$ für $\forall x_1...\forall x_n(\lnot\bot\rightarrow\beta)$ + +Erinnerung: +Sei $\Gamma$ eine Menge von Horn-Klauseln der Aussagenlogik. Eine aussagenlogische SLD-Resolution aus $\Gamma$ ist eine Folge $(M_0 \rightarrow\bot,M_1 \rightarrow\bot,...,M_m\rightarrow\bot)$ von Hornklauseln mit +- $(M_0\rightarrow\bot)\in\Gamma$ und +- für alle $0\leq n Definition +> +> Sei $\Gamma$ eine Menge von gleichungsfreien Horn-Klauseln der Prädikatenlogik. Eine SLD-Resolution aus $\Gamma$ ist eine Folge $((M_0\rightarrow\bot,\sigma_0),(M_1\rightarrow\bot,\sigma_1),...,(M_m\rightarrow\bot,\sigma_m))$ von Horn-Klauseln und Substitutionen mit +> - $(M_0\rightarrow\bot)\in\Gamma$ und $Def(\sigma_0)=\varnothing$ +> - für alle $0\leq n - $(N\cup\{\alpha\})\rho$ und $M_n$ variablendisjunkt sind, +> - $\sigma_{n+1}$ ein allgemeinster Unifikator von $\alpha\rho$ und $Q$ ist und +> - $M_{n+1} = (M_n\Q\cup N\rho)\sigma_{n+1}$. + +Ziel: +Seien $\Gamma=\{\varphi_1,...,\varphi_n\}$ Menge gleichungsfreier Horn-Klauseln, $\Psi(x_1,x_2 ,...,x_{\iota}) =R(t_1 ,...,t_k)$ atomare Formel, keine Gleichung und $(s_1,...,s_{\iota})$ Tupel variablenloser Terme. +Dann sind äquivalent: +1. $\Gamma\Vdash\Psi(s_1,...,s_{\iota}). +2. Es gibt eine SLD-Resolution $((M_n\rightarrow\bot,\sigma_n))_{0\leq n\leq m}$ aus $\Gamma\cup\{M_0\rightarrow\bot\}$ mit $M_0=\{\Psi(x_1,...,x_{\iota})\}$ und $M_m=\varnothing$ und eine Substitution $\tau$, so dass $s_i=x_i\sigma_0 \sigma_1 ...\sigma_m\tau$ für alle $1\leq i\leq \iota$ gilt. + +> Lemma +> +> Sei $\Gamma$ Menge von gleichungsfreien Horn-Klauseln der Prädikatenlogik und $(M_n \rightarrow\bot,\sigma_n))_{0\leq n\leq m}$ eine SLD-Resolution aus $\Gamma\cup\{M_0\rightarrow\bot\}$ mit $M_m=\varnothing$. +> Dann gilt $\Gamma\Vdash\Psi\sigma_0 \sigma_1\sigma_2...\sigma_m$ für alle $\Psi\in M_0$. + +Konsequenz: +$\Gamma=\{\varphi_1,...,\varphi_n\},M_0 =\{\Psi(x_1,...,x_{\iota})\},\tau$ Substitution, so dass $s_i=x_i \sigma_0 \sigma_1 \sigma_2 ...\sigma_m \tau$ variablenlos für alle $1\leq i \leq \iota$. Nach dem Lemma gilt also $\Gamma \Vdash\Psi(x_1,...,x_{\iota})\sigma_0 ...\sigma_m$ und damit $\Gamma\Vdash\Psi(x_1 ,...,x_{\iota} )\sigma_0 ...\sigma_m\tau=\Psi(s_1,...,s_{\iota} )$. +Die Implikation $(2)\Rightarrow (1)$ des Ziels folgt also aus diesem Lemma. + +> Lemma +> +> Sei $\Gamma$ eine Menge von definiten gleichungsfreien Horn-Klauseln der Prädikatenlogik, sei $M\rightarrow\bot$ eine gleichungsfreie Horn-Klausel und sei $\nu$ Substitution, so dass $M\nu$ variablenlos ist und $\Gamma\Vdash M\nu$ gilt. Dann existieren eine prädikatenlogische SLD-Resolution $((M_n \rightarrow\bot,\sigma_n))_{0 \leq n\leq m}$ und eine Substitution $\tau$ mit $M_0=M,M_m=\varnothing$ und $M_0 \sigma_0 \sigma_1... \sigma_m \tau=M_{\nu}$. + +Konsequenz: +$\Gamma=\{\varphi_1,...,\varphi_n\},M=\{\psi(x_1 ,...,x_{\iota})\},s_1,...,s_\iota}$ variablenlose Terme, so dass $\{\varphi_1 ,...,\varphi_n\}\Vdash\psi(s_1,...,s_{\iota}) =\psi(x_1 ,...,x_{\iota})\nu$ mit $\nu(x_i)=s_i$. Dann existieren SLD-Resolution und Substitution $\tau$ mit $M_0\sigma 0...\sigma_m\tau=M\nu=\{\psi (s_1,...,s_{\iota} )\}$. +Die Implikation $(1)\Rightarrow (2)$ des Ziels folgt also aus diesem Lemma. + + +> Satz +> +> Sei $\Gamma$ eine Menge von definiten gleichungsfreien Horn-Klauseln der Prädikatenlogik, sei $M\rightarrow\bot$ eine gleichungsfreie Horn-Klausel und sei $\nu$ Substitution, so dass $M\nu$ variablenlos ist. Dann sind äquivalent: +> - $\Gamma\Vdash M\nu$ +> - Es existieren eine SLD-Resolution $((M_n\rightarrow\bot,\sigma_n))_{0\leq n\leq m}$ aus $\Gamma\cup\{M\nu\rightarrow\bot\}$ und eine Substitution $\tau$ mit $M_0=M,M_m=\varnothing$ und $M_0\sigma_0\sigma_1...\sigma_m\tau=M\nu$. + +Konsequenz: +$\Gamma =\{\varphi_1,...,\varphi_n\},M_0 =\{\psi(x_1,...,x_{\iota})\}=\{R(t_1,t_2,...,t_k)\}$. Durch SLD-Resolutionen können genau die Tupel variablenloser Terme gewonnen werden, für die gilt: +$\{\varphi_1,...,\varphi_n\}\Vdash\psi (s_1,...,s_{\iota})$ + +## Zusammenfassung Prädikatenlogik +- Das natürliche Schließen formalisiert die "üblichen" Argumente in mathematischen Beweisen. +- Das natürliche Schließen ist vollständig und korrekt. +- Die Menge der allgemeingültigen Formeln ist semi-entscheidbar, aber nicht entscheidbar. +- Die Menge der Aussagen, die in $(\mathbb{N},+,*,0,1)$ gelten, ist nicht semi-entscheidbar. +- Die SLD-Resolution ist ein praktikables Verfahren, um die Menge der "Lösungen" $(s_1,...,s_{\iota})$ von $\Gamma\Vdash\psi(s_1,...,s_{\iota})$ zu bestimmen (wobei $\Gamma$ Menge von gleichungsfreien Horn-Klauseln und $\psi$ Konjunktion von gleichungsfreien Atomformeln sind. + +# Logische Programmierung +## Einführung in die Künstliche Intelligenz (KI) +Ziel: Mechanisierung von Denkprozessen + +Grundidee (nach G.W. Leibniz) +1. lingua characteristica - Wissensdarstellungssprache +2. calculus ratiocinator - Wissensverarbeitungskalkül + +**Teilgebiete der KI** +- Wissensrepräsentation +- maschinelles Beweisen (Deduktion) +- KI-Sprachen: Prolog, Lisp +- Wissensbasierte Systeme +- Lernen (Induktion) +- Wissensverarbeitungstechnologien (Suchtechniken, fallbasiertes Schließen, Multiagenten-Systeme) +- Sprach- und Bildverarbeitung + +## Logische Grundlagen +### PROLOG - ein "Folgerungstool" +Sei $M$ eine Menge von Aussagen, $H$ eine Hypothese. + +$H$ folgt aus $M(M \Vdash H)$, falls jede Interpretation, die zugleich alle Elemente aus $M$ wahr macht (jedes Modell von M), auch $H$ wahr macht. +Für endliche Aussagenmengen $M=\{A_1, A_2, ... , A_n\}$ bedeutet das: +$M \Vdash H$, gdw. $ag(\bigwedge_{i=1}^n A_i\rightarrow A)$ bzw. (was dasselbe ist) $kt(\bigwedge_{i=1}^n A_i \wedge \lnot A)$ + +### Aussagen in PROLOG: HORN-Klauseln des PK1 +![](Assets/Logik-prolog-horn.png) + +$A(X_1,...,X_n), A_i(X_1,...,X_n)$ quantorfreie Atomformeln, welche die allquantifizierten Variablen $X_1,...,X_n$ enthalten können + +Varianten / Spezialfälle +1. Regeln (vollständige HORN-Klauseln) + $\forall X_1... \forall X_n(A(X_1,...,X_n)\leftarrow \bigwedge_{i=1}^n A_i(X_1,...,X_n))$ +2. Fakten (HORN-Klauseln mit leerem Klauselkörper) + $\forall X_1...\forall X_n(A(X_1,...,X_n)\leftarrow true)$ +3. Fragen (HORN-Klauseln mit leerem Klauselkopf) + $\forall X_1...\forall X_n(false \leftarrow \bigwedge_{i=1}^n A_i(X_1,...,X_n))$ +4. leere HORN-Klauseln (mit leeren Kopf & leerem Körper) + $false\leftarrow true$ + + +Effekte der Beschränkung auf HORN-Logik +1. Über HORN-Klauseln gibt es ein korrektes und vollständiges Ableitungsverfahren. + - $\{K_1, ...,K_n\} \Vdash H$ , gdw. $\{K_1,...,K_n\} \vdash_{ROB} H$ +1. Die Suche nach einer Folge von Resolutionsschritten ist algorithmisierbar. + - Das Verfahren "Tiefensuche mit Backtrack" sucht systematisch eine Folge, die zur leeren Klausel führt. + - Rekursive und/oder metalogische Prädikate stellen dabei die Vollständigkeit in Frage. +3. Eine Menge von HORN-Klauseln mit nichtleeren Klauselköpfen ist stets erfüllbar; es lassen sich keine Widersprüche formulieren. + - $K_1 \wedge K_2...\wedge K_n \not= false$ + +Die systematische Erzeugung von (HORN-) Klauseln +1. Verneinungstechnischen Normalform (VTNF): $\lnot$ steht nur vor Atomformeln + - $\lnot\lnot A\equiv A$ +2. Erzeugung der Pränexen Normalform (PNF): $\forall, \exists$ stehen vor dem Gesamtausdruck + - $\forall X A(X) \rightarrow B \equiv \exists X(A(X)\rightarrow B)$ + - $\exists X A(X) \rightarrow B \equiv \forall X(A(X)\rightarrow B)$ +3. Erzeugung der SKOLEM‘schen Normalform (SNF): $\exists$ wird eliminiert + Notation aller existenzquantifizierten Variablen als Funktion derjenigen allquantifizierten Variablen, in deren Wirkungsbereich ihr Quantor steht. Dies ist keine äquivalente - , wohl aber eine die Kontradiktorizität erhaltende Umformung. +4. Erzeugung der Konjunktiven Normalform (KNF) + Durch systematische Anwendung des Distributivgesetzes $A\vee (B\wedge C)\equiv (A\vee B)\wedge(A\vee C)$ lässt sich aus der SNF $\forall X_1...\forall X_n A(X_1,...,X_n)$ stets die äquivalente KNF $\forall X_1...\forall X_n((L_1^1\vee...\vee L_1^{n_1})\wedge...\wedge(L_m^1\vee...\vee L_m^{n_m}))$ erzeugen. Die $L_i^k$ sind unnegierte oder negierte Atomformeln und heißen positive bzw. negative Literale. +5. Erzeugung der Klauselform (KF) + Jede der Elementardisjunktionen $(L_1^j \vee...\vee L_1^{j_k})$ der KNF kann man als äquivalente Implikation (Klausel) $(L_i^j \vee...\vee L_i^{j_m})\leftarrow(L_1^{j_{m+1}}\wedge ...\wedge L_1^{j_k})$ notieren, indem man alle positiven Literale $L_i^j,...,L_i^{j_m}$ disjunktiv verknüpft in den DANN-Teil (Klauselkopf) und alle negativen Literale $L_i^{j_{m+1}},...,L_i^{j_k}$ konjunktiv verknüpft in den WENN-Teil (Klauselkörper) notiert. +6. Sind die Klauseln aus Schritt 5. HORN? + In dem Spezialfall, dass alle Klauselköpfe dabei aus genau einem Literal bestehen, war die systematische Erzeugung von HORN-Klauseln erfolgreich; anderenfalls gelingt sie auch nicht durch andere Verfahren. + Heißt das etwa, die HORN-Logik ist eine echte Beschränkung der Ausdrucksfähigkeit? Richtig, das heißt es. + +Im Logik-Teil dieser Vorlesung lernten Sie eine Resolutionsmethode für Klauseln kennenlernen +- ... deren Algorithmisierbarkeit allerdings an der "kombinatorischen Explosion" der Resolutionsmöglichkeiten scheitert, aber ... +- ... in der LV "Inferenzmethoden" können Sie noch ein paar "Tricks" kennenlernen, die "Explosion" einzudämmen + + +### Inferenz in PROLOG: Resolution nach ROBINSON +gegeben: +- Menge von Regeln und Fakten M $M=\{K_1,...,K_n\}$ +- negierte Hypothese $\lnot H$ $\lnot H\equiv \bigwedge_{i=1}^m H_i \equiv false \rightarrow \bigwedge_{i=1}^m H_i$ + +Ziel: Beweis, dass $M \Vdash H$. $kt(\bigwedge_{i=1}^n K_i \wedge \lnot H)$ + +Eine der Klauseln habe die Form $A\leftarrow \bigwedge_{k=1}^p B_k$. ($A,B_k$- Atomformeln) + +Es gebe eine Substitution (Variablenersetzung) $\nu$ für die $A$ und eines der $H_i$ (etwa $H_l$) vorkommenden Variablen, welche $A$ und $H_l$ syntaktisch identisch macht. + +$M\equiv \bigwedge_{i=1}^n K_i\wedge \lnot(\bigwedge_{i=1}^m H_i)$ ist kontradiktorisch ($kt\ M‘$), gdw. $M‘$ nach Ersetzen von $H$ durch $\bigwedge_{i=1}^{l-1}\nu(H_i)\wedge\bigwedge_{k=1}^p\nu(B_k)\wedge\bigwedge_{i=l+1}^m \nu(H_i)$ noch immer kontradiktorisch ist. + +Jetzt wissen wir also, wie man die zu zeigende Kontradiktorizität auf eine andere - viel kompliziertere Kontradiktorizität zurückführen kann. +Für $p=0$ und $m=1$ wird es allerdings trivial. +Die sukzessive Anwendung von Resolutionen muss diesen Trivialfall systematisch herbeiführen: + +> Satz von ROBINSON +> +> $M'\equiv\bigwedge_{i=1}^n K_i\wedge \lnot H$ ist kontradiktorisch ($kt\ M‘$), gdw. durch wiederholte Resolutionen in endlich vielen Schritten die negierte Hypothese $\lnot H\equiv false \leftarrow H$ durch die leere Klausel $false\leftarrow true$ ersetzt werden kann. + +Substitution +- Eine (Variablen-) Substitution $\nu$ einer Atomformel $A$ ist eine Abbildung der Menge der in $A$ vorkommenden Variablen $X$ in die Menge der Terme (aller Art: Konstanten, Variablen, strukturierte Terme). +- Sie kann als Menge von Paaren $[Variable,Ersetzung]$ notiert werden: $\nu=\{[x,t]: x\in X, t=\nu(x)\}$ +- Für strukturierte Terme wird die Substitution auf deren Komponenten angewandt: $\nu(f(t_1,...,t_n)) = f(\nu(t_1),...,\nu(t_n))$ +- Verkettungsoperator $\circ$ für Substitutionen drückt Hintereinander-anwendung aus: $\sigma\circ\nu(t)=\sigma(\nu(t))$ +- Substitutionen, die zwei Terme syntaktisch identisch machen, heißen Unifikator: $\nu$unifiziert zwei Atomformeln (oder Terme) $s$ und $t$ (oder: heißt Unifikator von $s$ und $t$), falls dessen Einsetzung $s$ und $t$ syntaktisch identisch macht. + +#### Unifikation +Zwei Atomformeln $p(t_{11},...,t_{1n})$ und $p_2(t_{21},...,t_{2n})$ sind unifizierbar, gdw. +- sie die gleichen Prädikatensymbole aufweisen ($p_1= p_2$), +- sie die gleichen Stelligkeiten aufweisen ($n = m$) und +- die Terme $t_{1i}$ und $t_{2i}$ jeweils miteinander unifizierbar sind. + +Die Unifizierbarkeit zweier Terme richtet sich nach deren Sorte: +1. Zwei Konstanten $t_1$ und $t_2$ sind unifizierbar, gdw. $t_1= t_2$ +2. Zwei strukturierte Terme $f(t_{11},...,t_{1n})$ und $f(t_{21},...,t_{2n})$ sind unifizierbar, gdw. + - sie die gleichen Funktionssymbole aufweisen ($f_1= f_2$), + - sie die gleichen Stelligkeiten aufweisen ($n=m$) und + - die Terme $t_{1i}$ und $t_{2i}$ jeweils miteinander unifizierbar sind. +3. Eine Variable $t_1$ ist mit einer Konstanten oder einem strukturierten Term $t_2$ unifizierbar. $t_1$ wird durch $t_2$ ersetzt (instanziert): $t_1:= t_2$ +4. Zwei Variablen $t_1$ und $_2$ sind unifizierbar und werden gleichgesetzt: $t_1:=t_2$ bzw. $t_2:= t_1$ + +Genügt "irgendein" Unifikator? +- ein Beispiel + - $K_1: p(A,B)\leftarrow q(A)\wedge r(B)$ + - $K_2:q(c)\leftarrow true$ + - $K_3:r(d)\leftarrow true$ + - $\lnot H: false\leftarrow p(X,Y)$ +- Unifikatoren für $H_1^0$ und Kopf von $K_1$: + - $\nu^1 = \{[X,a],[Y,b],[A,a],[B,b]\}$ + - $\nu^2 =\{[X,a],[Y,B],[A,a]\}$ + - $\nu^3 =\{[X,A],[Y,b],[B,b]\}$ + - $\nu^4=\{[A,X],[B,Y]\}$ ... +- Obwohl $\{K_1, K_2, K_3\}\Vdash H$, gibt es bei Einsetzung von $\nu^1$, $\nu^2$ und $\nu^3$ keine Folge von Resolutionsschritten, die zur leeren Klausel führt. +- Bei Einsetzung von $\nu^4$ hingegen gibt es eine solche Folge. +- Die Vollständigkeit des Inferenzverfahrens hängt von der Wahl des "richtigen" Unifikators ab. +- Dieser Unifikator muss möglichst viele Variablen variabel belassen. Unnötige Spezialisierungen versperren zukünftige Inferenzschritte. +- Ein solcher Unifikator heißt **allgemeinster Unifikator** bzw. "most general unifier" (m.g.u.). + +> Allgemeinster Unifikator +> +> Eine Substitution heißt allgemeinster Unifikator (most general unfier; m.g.u.) zweier (Atomformeln oder) Terme $s$ und $t$ ($\nu= m.g.u.(s,t)$), gdw. +> 1. die Substitution $\nu$ ein Unifikator von $s$ und $t$ ist und +> 2. für jeden anderen Unifikator $\sigma$ von $s$ und $t$ eine nichtleere und nicht identische Substitution $\tau$ existiert, so dass $\sigma=\tau\circ\nu$ ist. +> graphisch betrachtet: ![](Assets/Logik_allgemeinster-unifikator.png) + +Der Algorithmus zur Berechnung des m.g.u. zweier Terme $s$ und $t$ verwendet Unterscheidungsterme: Man lese $s$ und $t$ zeichenweise simultan von links nach rechts. Am ersten Zeichen, bei welchem sich $s$ und $t$ unterscheiden, beginnen die Unterscheidungsterme $s*$ und $t*$ und umfassen die dort beginnenden (vollständigen) Teilterme. + +Algorithmus zur Bestimmung des allgemeinsten Unifikators 2er Terme + +- input: s, t +- output: Unifizierbarkeitsaussage, ggf. $\nu= m.g.u.( s , t )$ +- $i:=0;\nu_i:=\varnothing;s_i:=s; t_i=t$ +- Start: $s_i$ und $t_i$ identisch? + - ja $\Rightarrow$ s und t sind unifizierbar, $\nu=\nu_i=m.g.u.(s,t)$ (fertig) + - nein $\Rightarrow$ Bilde die Unterscheidungsterme $s_i^*$ und $t_i^*$ + - $s_i^*$ oder $t_i^*$ Variable? + - nein $\Rightarrow$ $s$ und $t$ sind nicht unifizierbar (fertig) + - ja $\Rightarrow$ sei (o.B.d.A.) $s_i^*$ eine Variable + - $s_i^* \subseteq t_i^*$? (enthält $t_i^*$ die Variable $s_i^*$?) + - ja $\Rightarrow$ $s$ und $t$ sind nicht unifizierbar (fertig) + - nein $\Rightarrow$ + - $\nu':=\{[s,t']: [s,t]\in\nu, t':=t|_{s*\rightarrow t*}\}\cup \{[s_i^*, t_i^*]\}$ + - $s':=\nu'(s_i); t':=\nu'(t_i); i:=i+1;$ + - $\nu_i:=\nu'; s_i:=s'; t_i:=t';$ + - gehe zu Start + +## Logische Programmierung +### Einordnung des logischen Paradigmas +![](Assets/Logik-logische-programmierung-einordnung.png) + +"deskriptives" Programmierparadigma = +1. Problembeschreibung + - Die Aussagenmenge $M =\{K_1,...,K_n\}$, über denen gefolgert wird, wird in Form von Fakten und Regeln im PK1 notiert. + - Eine mutmaßliche Folgerung (Hypothese) $H$ wird in Form einer Frage als negierte Hypothese hinzugefügt. +2. (+) Programmverarbeitung + - Auf der Suche eines Beweises für $M \Vdash H$ werden durch mustergesteuerte Prozedur-Aufrufe Resolutions-Schritte zusammengestellt. + - Dem "Programmierer" werden (begrenzte) Möglichkeiten gegeben, die systematische Suche zu beeinflussen. + +### Syntax +Syntax von Klauseln +| | Syntax | Beispiel | +| ----- | ---------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- | +| Fakt | praedikatensymbol(term,...term). | liefert(xy_ag,motor,vw). | +| Regel | praedikatensymbol(term,...term) :- praedikatensymbol(term,...term) ,... , praedikatensymbol(term,...term). | konkurrenten(Fa1,Fa2) :- liefert(Fa1,Produkt,_),liefert(Fa2,Produkt,_). | +| Frage | ?- praedikatensymbol(term,...term) , ... ,praedikatensymbol(term,...term). | ?- konkurrenten(ibm,X), liefert(ibm,_,X). | + +Syntax von Termen +| | | Syntax | Beispiele | +| ------------------- | ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- | --------------------- | +| Konstante | Name | Zeichenfolge, beginnend mit Kleinbuchstaben, die Buchstaben, Ziffern und \_ enthalten kann. | otto\_1 , tisch, hund | +| | beliebige Zeichenfolge in "..." geschlossen | "Otto", "r@ho" | +| | Sonderzeichenfolge | €%&§$€ | +| Zahl | Ziffernfolge, ggf. mit Vorzeichen, Dezimalpunkt und Exponentendarstellung | 3, -5, 1001, 3.14E-12 | +| Variable | allg. | Zeichenfolge, mit Großbuchstaben oder \_ beginnend | X, Was, _alter | +| anonym | Unterstrich | \_ | +| strukturierter Term | allg. | funktionssymbol( term , ... , term ) | nachbar(chef(X)) | +| Liste | leere Liste | [ ] | +| | $[term | restliste]$ | $[mueller | [mayer | []]]$ | +| | $[term , term , ... , term ]$ | $[ mueller, mayer, schulze ]$ | + +BACKUS-NAUR-Form +- PROLOG-Programm ::= Wissensbasis Hypothese +- Wissensbasis ::= Klausel | Klausel Wissensbasis +- Klausel ::= Fakt | Regel +- Fakt ::= Atomformel. +- Atomformel ::= Prädikatensymbol (Termfolge) +- Prädikatensymbol ::= Name +- Name ::= Kleinbuchstabe |Kleinbuchstabe Restname | "Zeichenfolge" | Sonderzeichenfolge +- RestName ::= Kleinbuchstabe | Ziffer | _ | Kleinbuchstabe RestName | Ziffer RestName | _ RestName +- ... + +### PROLOG aus logischer Sicht +Was muss der Programmierer tun? +- Formulierung einer Menge von Fakten und Regeln (kurz: Klauseln), d.h. einer Wissensbasis $M\equiv\{K_1,...,K_n\}$ +- Formulierung einer negierten Hypothese (Frage, Ziel) $\lnot H\equiv\bigwedge_{i=1}^m H_i \equiv false\leftarrow \bigwedge_{i=1}^m H_i$ + +Was darf der Programmierer erwarten? +- Dass das "Deduktionstool" PROLOG $M \Vdash H$ zu zeigen versucht, d.h. $kt(\bigwedge_{i=1}^n K_i\wedge \lnot H)$ ) +- ..., indem systematisch die Resolutionsmethode auf $\lnot H$ und eine der Klauseln aus $M$ angewandt wird, solange bis $\lnot H\equiv false\leftarrow true$ entsteht + +#### Formulierung von Wissensbasen +1. Beispiel 1 (BSP1.PRO) +- Yoshihito und Sadako sind die Eltern von Hirohito. + - vater_von(yoshihito,hirohito). + - mutter_von(sadako,hirohito). +- Kuniyoshi und Chikako sind die Eltern von Nagako. + - vater_von(kunioshi,nagako). + - mutter_von(chikako,nagako). +- Akihito‘s und Hitachi‘s Eltern sind Hirohito und Nagako. + - vater_von(hirohito,akihito). + - vater_von(hirohito,hitachi). + - mutter_von(nagako,akihito). + - mutter_von(nagako,hitachi). +- Der Großvater ist der Vater des Vaters oder der Vater der Mutter. + - grossvater_von(G,E) :- vater_von(G,V), vater_von(V,E). + - grossvater_von(G,E) :-vater_von(G,M),mutter_von(M,E). +- Geschwister haben den gleichen Vater und die gleiche Mutter. + - geschwister(X,Y) :- vater_von(V,X), vater_von(V,Y), mutter_von(M,X), mutter_von(M,Y). + +Visual Prolog benötigt aber einen Deklarationsteil für Datentypen und Aritäten der Prädikate, der für die o.g. Wissensbasis so aussieht: +``` +domains + person = symbol +predicates + vater_von(person,person) % bei nichtdeterministischen Prädikaten + mutter_von(person,person). % kann man "nondeterm" vor das + grossvater_von(person,person) % Prädikat schreiben, um die + geschwister(person,person) % Kompilation effizienter zu machen +clauses + < Wissensbasis einfügen und Klauseln gleichen Kopfprädikates gruppieren> +goal + < Frage ohne "?-" einfügen> +``` + +2. Beispiel 2 (BSP2.PRO) +- Kollegen Meier und Müller arbeiten im Raum 1, Kollege Otto im Raum 2 und Kollege Kraus im Raum 3. + - arbeitet_in(meier,raum_1). + - arbeitet_in(mueller,raum_1). + - arbeitet_in(otto,raum_2). + - arbeitet_in(kraus,raum_3). +- Netzanschlüsse gibt es in den Räumen 2 und 3. + - anschluss_in(raum_2). + - anschluss_in(raum_3). +- Ein Kollege ist erreichbar, wenn er in einem Raum mit Netzanschluss arbeitet. + - erreichbar(K) :- arbeitet_in(K,R),anschluss_in(R). +- 2 Kollegen können Daten austauschen, wenn sie im gleichen Raum arbeiten oder beide erreichbar sind. + - koennen_daten_austauschen(K1,K2) :- arbeitet_in(K1,R),arbeitet_in(K2,R). + - koennen_daten_austauschen(K1,K2) :- erreichbar(K1),erreichbar(K2). + +Deklarationsteil +``` +domains + person, raum: symbol +predicates + arbeitet_in(person,raum) + ansluss_in(raum) + erreichbar(person) + koennen_daten_austauschen(person,person) +clauses + ... +goal + ... +``` + +#### Verarbeitung Logischer Programme +##### Veranschaulichung ohne Unifikation +![](Assets/Logik-prolog-ohne-unifikation.png) + +Tiefensuche mit Backtrack: +Es werden anwendbare Klauseln für das erste Teilziel gesucht. Gibt es ... +- ... genau eine, so wird das 1. Teilziel durch deren Körper ersetzt. +- ... mehrere, so wird das aktuelle Ziel inklusive alternativ anwendbarer Klauseln im Backtrack-Keller abgelegt und die am weitesten oben stehende Klausel angewandt. +- ... keine (mehr), so wird mit dem auf dem Backtrack-Keller liegendem Ziel die Bearbeitung fortgesetzt. + +Dies geschieht solange, bis +- das aktuelle Ziel leer ist oder +- keine Klausel (mehr) anwendbar ist und der Backtrack-Keller leer ist. + + +##### Veranschaulichung mit Unifikation +![](Assets/Logik-prolog-mit-unifikation.png) + +Zusätzliche Markierung der Kanten mit der Variablenersetzung (dem Unifikator). + + +### PROLOG aus prozeduraler Sicht +Beispiel: die "Hackordnung" +1. chef_von(mueller,mayer). +2. chef_von(mayer,otto). +3. chef_von(otto,walter). +4. chef_von(walter,schulze). +5. weisungsrecht(X,Y) :- chef_von(X,Y). +6. weisungsrecht(X,Y) :- chef_von(X,Z), weisungsrecht(Z,Y). + +> Deklarative Interpretation +In einem Objektbereich $I=\{mueller, mayer, schulze, ...\}$ bildet das Prädikat $weisungsrecht(X,Y)$ $[X,Y]$ auf wahr ab, gdw. +- das Prädikat $chef_von(X,Y)$ das Paar $[X,Y]$ auf wahr abbildet oder +- es ein $Z\in I$ gibt, so dass + - das Prädikat $chef_von(X,Z)$ das Paar $[X,Z]$ auf wahr abbildet und + - das Prädikat $weisungsrecht(Z,Y)$ das Paar $[Z,Y]$ auf wahr abbildet. + +> Prozedurale Interpretation +Die Prozedur $weisungsrecht(X,Y)$ wird abgearbeitet, indem +1. die Unterprozedur $chef_von(X,Y)$ abgearbeitet wird. Im Erfolgsfall ist die Abarbeitung beendet; anderenfalls werden +2. die Unterprozeduren $chef_von(X,Z)$ und $weisungsrecht(Z,Y)$ abgearbeitet; indem systematisch Prozedurvarianten beider Unterprozeduren aufgerufen werden.Dies geschieht bis zum Erfolgsfall oder erfolgloser erschöpfender Suche. + + +| deklarative Interpretation | prozedurale Interpretation | +| ---------------------------------- | -------------------------- | +| Prädikat | Prozedur | +| Ziel | Prozeduraufruf | +| Teilziel | Unterprozedur | +| Klauseln mit gleichem Kopfprädikat | Prozedur-varianten | +| Klauselkopf | Prozedurkopf | +| Klauselkörper | Prozedurrumpf | + +Die Gratwanderung zwischen Wünschenswertem und technisch Machbarem erfordert mitunter "Prozedurales Mitdenken", um +1. eine gewünschte Reihenfolge konstruktiver Lösungen zu erzwingen, +2. nicht terminierende (aber - deklarativ, d.h. logisch interpretiert - völlig korrekte) Programme zu vermeiden, +3. seiteneffektbehaftete Prädikate sinnvoll einzusetzen, +4. (laufzeit-) effizienter zu programmieren und +5. das Suchverfahren gezielt zu manipulieren. + +Programm inkl. Deklarationsteil (BSP3.PRO) +``` +domains + person = symbol +predicates + chef_von(person,person) + weisungsrecht(person,person) +clauses + chef_von(mueller,mayer). + chef_von(mayer,otto). + chef_von(otto,walter). + chef_von(walter,schulze). + weisungsrecht(X,Y) :- chef_von(X,Y). + weisungsrecht(X,Y) :- chef_von(X,Z), weisungsrecht(Z,Y). +goal + weisungsrecht(Wer,Wem). +``` + +Prädikate zur Steuerung der Suche nach einer Folge von Resolutionsschritten! + +!(cut) +Das Prädikat $!/0$ ist stets wahr. In Klauselkörpern eingefügt verhindert es ein Backtrack der hinter $!/0$ stehenden Teilziele zu den vor $!/0$ stehenden Teilzielen sowie zu alternativen Klauseln des gleichen Kopfprädikats. Die Verarbeitung von $!/0$ schneidet demnach alle vor der Verarbeitung verbliebenen Lösungswege betreffenden Prozedur ab. + +Prädikate zur Steuerung der Suche: $!/0$ +![](Assets/Logik-prädikate-suche.png) + + +Prädikate zur Steuerung der Suche nach einer Folge von Resolutionsschritten +**fail** +Das Prädikat $fail/0$ ist stets falsch. In Klauselkörpern eingefügt löst es ein Backtrack aus bzw. führt zum Misserfolg, falls der Backtrack-Keller leer ist, d.h. falls es keine verbleibenden Lösungswege (mehr) gibt. +![BSP4.PRO](Assets/Logik-prädikate-suche-fail.png) +![BSP4.PRO](Assets/Logik-prädikate-suche-fail-2.png) + +### Listen und rekursive Problemlösungsstrategien +Listen +1. $[]$ ist eine Liste. +2. Wenn $T$ ein Term und $L$ eine Liste ist, dann ist + 1. $[T|L]$ eine Liste. + 2. $T.L$ eine Liste. (ungebräuchlich) + 3. $.(T,L)$ eine Liste. (ungebräuchlich) + Das erste Element $T$ heißt Listenkopf, $L$ heißt Listenkörper oder Restliste. +3. Wenn $t_1, ... ,t_n$ Terme sind, so ist $[t_1,...,t_n]$ eine Liste. +4. Weitere Notationsformen von Listen gibt es nicht. + + + +Listen als kompakte Wissensrepräsentation: ein bekanntes Beispiel (BSP5.PRO) +- arbeiten_in([meier, mueller], raum_1). + - arbeitet_in(meier, raum_1). + - arbeitet_in(mueller, raum_1). +- arbeitet_in(otto, raum_2). + - arbeiten_in([otto], raum_2 ). +- arbeitet_in(kraus, raum_3). + - arbeiten_in([kraus], raum_3 ). +- anschluesse_in([raum_2, raum_3]). + - anschluss_in(raum_2). + - anschluss_in(raum_3). + +**Rekursion** in der Logischen Programmierung +Eine Prozedur heißt (direkt) rekursiv, wenn in mindestens einem der Klauselkörper ihrer Klauseln ein erneuter Aufruf des Kopfprädikates erfolgt. +Ist der Selbstaufruf die letzte Atomformel des Klauselkörpers der letzten Klausel dieser Prozedur - bzw. wird er es durch vorheriges "Abschneiden" nachfolgender +Klauseln mit dem Prädikat $!/0$ - , so spricht man von Rechtsrekursion ; anderenfalls von Linksrekursion. +Eine Prozedur heißt indirekt rekursiv, wenn bei der Abarbeitung ihres Aufrufes ein erneuter Aufruf derselben Prozedur erfolgt. + +Wissensverarbeitung mit Listen: (BSP5.PRO) +- erreichbar(K) :- arbeitet_in(K,R), anschluss_in(R). + - erreichbar(K) :- anschluesse_in(Rs), member(R, Rs), arbeiten_in(Ks, R), member(K, Ks). +- koennen_daten_austauschen(K1,K2) :- arbeitet_in(K1,R),arbeitet_in(K2,R). + - koennen_daten_austauschen(K1,K2) :- arbeiten_in(Ks,_),member(K1,Ks), member(K2,Ks). +- koennen_daten_austauschen(K1,K2) :- erreichbar(K1),erreichbar(K2). + - koennen_daten_austauschen(K1,K2) :- erreichbar(K1),erreichbar(K2). + +BSP5.PRO +``` +domains + person, raum = symbol + raeume = raum* + personen = person* +predicates + arbeiten_in(personen, raum) + anschluesse_in(raeume) + erreichbar(person) + koennen_daten_austauschen(person,person) + member(person,personen) + member(raum,raeume) +clauses + ... (siehe oben) + member(E,[E|_]). + member(E,[_|R]) :- member(E,R). +goal + erreichbar(Wer). +``` + +**Unifikation 2er Listen** +1. Zwei leere Listen sind (als identische Konstanten aufzufassen und daher) miteinander unifizierbar. +1. Zwei nichtleere Listen $[K_1|R_1]$ und $[K_2|R_2]$ sind miteinander unifizierbar, wenn ihre Köpfe ($K_1$ und $K_2$) und ihre Restlisten ($R_1$ und $R_2$) jeweils miteinander unifizierbar sind. +3. Eine Liste $L$ und eine Variable $X$ sind miteinander unifizierbar, wenn die Variable selbst nicht in der Liste enthalten ist. Die Variable $X$ wird bei erfolgreicher Unifikation mit der Liste $L$ instanziert: $X:=L$. + + +**Differenzlisten:** eine intuitive Erklärung +Eine Differenzliste $L_1 - L_2$ besteht aus zwei Listen $L_1$ und $L_2$ und wird im allgemeinen als $[L_1,L_2]$ oder (bei vorheriger Definition eines pre- bzw. infix notierten Funktionssymbols +-/2) als $-(L_1,L_2)$ bzw. $L_1-L_2$ notiert. + +Sie wird (vom Programmierer, nicht vom PROLOG-System!) als eine Liste interpretiert, deren Elemente sich aus denen von $L_1$ abzüglich derer von $L_2$ ergeben. Differenzlisten verwendet man typischerweise, wenn häufig Operationen am Ende von Listen vorzunehmen sind. + +Eine Definition +1. Die Differenz aus einer leeren Liste und einer (beliebigen) Liste ist die leere Liste: $[] - L = []$ +2. Die Differenz aus einer Liste $[E|R]$ und der Liste $L$, welche $E$ enthält, ist die Liste $D$, +wenn die Differenz aus $R$ und $L$ (abzügl. $E$) die Liste $D$ ist: $[E|R]-L = D$, wenn $E\in L$ und $R-(L-[E]) = D$ +3. Die Differenz aus einer Liste $[E|R]$ und einer Liste $L$, welche $E$ nicht enthält, ist die Liste $[E|D]$, wenn die Differenz aus $R$ und $L$ die Liste $D$ ist: $[E|R] - L = [E|D]$, wenn $E\in L$ und $R-L=D$ + +Differenzlisten: Ein Interpreter $interpret(Differenzliste,Interpretation)$ (BSP6.PRO) +1. $interpret([[],_],[]).$ +2. $interpret([[E|R],L] , D ) :- loesche(E , L, L1),! , interpret( [ R , L1 ] , D ).$ +3. $interpret([[E|R],L] , [E|D] ) :- interpret([R,L],D).$ +4. $loesche(E, [E|R], R) :-!.$ +5. $loesche(E, [K|R], [K|L]) :- loesche(E,R,L).$ + +### Prolog-Fallen +#### Nicht terminierende Programme +Ursache: "ungeschickt" formulierte (direkte oder indirekte) Rekursion + +##### Alternierende Zielklauseln +Ein aktuelles Ziel wiederholt sich und die Suche nach einer Folge von Resolutionsschritten endet nie: +1. $liegt_auf(X,Y) :- liegt_unter(Y,X).$ +2. $liegt_unter(X,Y) :- liegt_auf(Y,X).$ +- $?- liegt_auf( skript, pult ).$ +- logisch korrekte Antwort: nein +- tatsächliche Antwort: keine +Logische Programmierung + +oder die Suche nach Resolutionsschritten endet mit einem Überlauf des Backtrack-Kellers: (BSP8.PRO) +1. $liegt_auf(X,Y) :- liegt_unter(Y,X).$ +2. $liegt_auf( skript , pult ).$ +3. $liegt_unter(X,Y) :- liegt_auf(Y,X).$ +- $?- liegt_auf( skript , pult ).$ +- logisch korrekte Antwort: ja +- tatsächliche Antwort: keine + +##### Expandierende Zielklauseln +Das erste Teilziel wird in jeden Resolutionsschritt durch mehrere neue Teilziele ersetzt; die Suche endet mit einem Speicherüberlauf: (BSP9.PRO) +1. $liegt_auf( notebook , pult ).$ +2. $liegt_auf( skript , notebook ).$ +3. $liegt_auf(X,Y) :- liegt_auf(X,Z), liegt_auf(Z,Y).$ +- $?- liegt_auf( handy , skript ).$ +- logisch korrekte Antwort: nein +- tatsächliche Antwort: keine + +Auch dieses Beispiel lässt sich so erweitern, dass die Hypothese offensichtlich aus der Wissensbasis folgt, die Umsetzung der Resolutionsmethode aber die Vollständigkeit zerstört: +1. $liegt_auf( notebook , pult ).$ +2. $liegt_auf( skript , notebook ).$ +3. $liegt_auf(X,Y) :- liegt_auf(X,Z), liegt_auf(Z,Y).$ +4. $liegt_auf( handy , skript ).$ +- $?- liegt_auf( handy , pult ).$ +- logisch korrekte Antwort: ja +- tatsächliche Antwort: keine + +Auch dieses Beispiel zeigt, dass das Suchverfahren "Tiefensuche mit Backtrack" die Vollständigkeit des Inferenzverfahrens zerstört. + +#### Metalogische Prädikate und konstruktive Lösungen +Das Prädikat $not/1$ hat eine Aussage als Argument und ist somit eine Aussage über eine Aussage, also metalogisch. +I.allg. ist $not/1$ vordefiniert, kann aber mit Hilfe von $call/1$ definiert werden. $call/1$ hat Erfolg, wenn sein Argument - als Ziel interpretiert - Erfolg hat. + +Beispiel (BSP10.PRO): +1. $fleissig(horst).$ +2. $fleissig(martin).$ +3. $faul(X) :- not( fleissig(X) ).$ +4. $not(X) :- call(X), !, fail.$ +5. $not( _ ).$ +- $?- faul(horst).$ Antwort: nein +- $?- faul(alex).$ Antwort: ja +- $?- faul(Wer).$ Antwort: nein + +Widerspruch ... und Beweis der Unvollständigkeit durch Metalogik + +### Typische Problemklassen für die Anwendung der Logischen Programmierung +#### Rekursive Problemlösungsstrategien +> Botschaft 1 +> Man muss ein Problem nicht in allen Ebenen überblicken, um eine Lösungsverfahren zu programmieren. Es genügt die Einsicht, +> 1. wie man aus der Lösung eines einfacheren Problems die Lösung des präsenten Problems macht und +> 2. wie es im Trivialfall zu lösen ist. + +**Türme von Hanoi** +Es sind N Scheiben von der linken Säule auf die mittlere Säule zu transportieren, wobei die rechte Säule als Zwischenablage genutzt wird. Regeln: +1. Es darf jeweils nur eine Scheibe transportiert werden. +2. Die Scheiben müssen mit fallendem Durchmesser übereinander abgelegt werden. + +(doppelt) rekursive Lösungsstrategie: +- $N = 0:$ Das Problem ist gelöst. +- $N > 0:$ + 1. Man löse das Problem für N-Scheiben, die von der Start-Säule zur Hilfs-Säule zu transportieren sind. + 2. Man lege eine Scheibe von der Start- zur Ziel-Säule. + 3. Man löse das Problem für N-Scheiben, die von der Hilfs-Säule zur Ziel-Säule zu transportieren sind. + +Prädikate +- $hanoi(N)$ löst das Problem für N Scheiben +- $verlege(N,Start,Ziel,Hilf)$ verlegt N Scheiben von Start nach Ziel unter Nutzung von Hilf als Ablage + +Die Regeln zur Kodierung der Strategie (BSP11.PRO) +- $hanoi( N ) :- verlege( N , s1 , s2 , s3 ).$ +- $verlege( 0 , _ , _ , _ ).$ +- $verlege( N , S , Z , H ) :-$ + - $N1 = N - 1,$ + - $verlege( N1 , S , H , Z ),$ + - $write("Scheibe von ", S," nach ", Z),$ + - $verlege( N1 , H , Z , S ).$ + +#### Sprachverarbeitung mit PROLOG +> Botschaft 2 +> Wann immer man Objekte mit Mustern vergleicht, z.B. +> 1. eine Struktur durch "Auflegen von Schablonen" identifiziert, +> 2. Gemeinsamkeiten mehrerer Objekte identifiziert, d.h. "eine Schablone entwirft" oder +> 3. "gemeinsame Beispiele für mehrere Schablonen" sucht, +> mache man sich den Unifikations-Mechanismus zu nutzen. + +- Eine kontextfreie Grammatik (Chomsky-Typ 2) besteht aus + 1. einem Alphabet A, welches die terminalen (satzbildenden) Symbole enthält + 2. einer Menge nichtterminaler (satzbeschreibender) Symbole N (= Vokabular abzüglich des Alphabets: $N = V \backslash A$) + 3. einer Menge von Ableitungsregeln $R\subseteq N\times (N\cup A)^*$ + 4. dem Satzsymbol $S\in N$ +- ... und in PROLOG repräsentiert werden durch + 1. 1-elementige Listen, welche zu satzbildenden Listen komponiert werden: $[der],[tisch],[liegt],...$ + 2. Namen, d.h. mit kleinem Buchstaben beginnende Zeichenfolgen: $nebensatz,subjekt,attribut,...$ + 3. PROLOG-Regeln mit $l\in N$ im Kopf und $r\in(N\cup A)^*$ im Körper + 4. einen reservierten Namen: $satz$ + +Ein Ableitungsbaum beschreibt die grammatische Struktur eines Satzes. Seine Wurzel ist das Satzsymbol, seine Blätter in Hauptreihenfolge bilden den Satz. +![](Assets/Logik-ableitungsbaum-beispiel.png) + +1. Alphabet $ministerium, rektorat, problem, das, loest, ignoriert, verschaerft$ +2. nichtterminale Symbole $satz, subjekt, substantiv, artikel, praedikat,objekt$ +3. Ableitungsregeln (in BACKUS-NAUR-Form) + - $satz ::= subjekt praedikat objekt$ + - $subjekt ::= artikel substantiv$ + - $objekt ::= artikel substantiv$ + - $substantiv ::= ministerium | rektorat | problem$ + - $artikel ::= das$ + - $praedikat ::= loest | ignoriert | verschaerft$ +4. Satzsymbol $satz$ + +Verketten einer Liste von Listen +``` +% die Liste ist leer +verkette( [ ] , [ ] ) . + +% das erste Element ist eine leere Liste +verkette( [ [ ] | Rest ] , L ) :- + verkette( Rest , L ). + +% das erste Element ist eine nichtleere Liste +verkette([ [K | R ] | Rest ] , [ K | L ] ) :- + verkette( [ R | Rest ] , L ).4 +``` + +#### Die "Generate - and - Test" Strategie +> Botschaft 3 +> Es ist mitunter leichter (oder überhaupt erst möglich), für komplexe Probleme +> 1. eine potentielle Lösung zu "erraten" und dazu +> 2. ein Verfahren zu entwickeln, welches diese Lösung auf Korrektheit testet, +> als zielgerichtet die korrekte Lösung zu entwerfen. Hierbei kann man den Backtrack-Mechanismus nutzen. + +Strategie: Ein Prädikat $moegliche_loesung(L)$ generiert eine potentielle Lösung, welche von einem Prädikat $korrekte_loesung(L)$ geprüft wird: +- Besteht $L$ diesen Korrektheitstest, ist eine Lösung gefunden. +- Fällt $L$ bei diesem Korrektheitstest durch, wird mit Backtrack das Prädikat $moegliche_loesung(L)$ um eine alternative potentielle Lösung ersucht. +(vgl.: Lösen NP-vollständiger Probleme, Entscheidung von Erfüllbarkeit) + +ein Beispiel: konfliktfreie Anordnung von $N$ Damen auf einem $N\times N$ Schachbrett (BSP13.PRO) +- eine Variante: Liste strukturierter Terme + - $[dame(Zeile,Spalte),...,dame(Zeile,Spalte)]$ + - $[dame(1,2), dame(2,4), dame(3,1), dame(4,3) ]$ +- noch eine Variante: Liste von Listen + - $[[Zeile, Spalte] , ... , [Zeile,Spalte] ]$ + - $[ [1,2] , [2,4] , [3,1] , [4,3] ]$ +- ... und noch eine (in die Wissensdarstellung etwas "natürliche" Intelligenz investierende, den Problemraum enorm einschränkende) Variante: Liste der Spaltenindizes + - $[ Spalte_zu_Zeile_1, ..., Spalte_zu_Zeile_N ]$ + - $[ 2, 4, 1, 3 ]$ + +#### Heuristische Problemlösungsmethoden +> Botschaft 4 +> Heuristiken sind +> 1. eine Chance, auch solche Probleme einer Lösung zuzuführen, für die man keinen (determinierten) Lösungsalgorithmus kennt und +> 2. das klassische Einsatzgebiet zahlreicher KI-Tools - auch der Logischen Programmierung. + +Was ist eine Heuristik? Worin unterscheidet sich eine heuristische Problemlösungsmethode von einem Lösungsalgorithmus? + +Heuristiken bewerten die Erfolgsaussichten alternativer Problemlösungsschritte. Eine solche Bewertung kann sich z.B. ausdrücken in +- einer quantitativen Abschätzung der "Entfernung" zum gewünschten Ziel oder der "Kosten" für das Erreichen des Ziels, +- einer quantitativen Abschätzung des Nutzens und/oder der Kosten der alternativen nächsten Schritte, +- eine Vorschrift zur Rangordnung der Anwendung alternativer Schritte, z.B. durch Prioritäten oder gemäß einer sequenziell abzuarbeitenden Checkliste. + +Ein Beispiel: Das Milchgeschäft meiner Großeltern in den 40er Jahren +- Der Milchhof liefert Milch in großen Kannen. +- Kunden können Milch nur in kleinen Mengen kaufen. +- Es gibt nur 2 Sorten geeichter Schöpfgefäße; sie fassen 0.75 Liter bzw. 1.25 Liter. +- Eine Kundin wünscht einen Liter Milch. +1. Wenn das große Gefäß leer ist, dann fülle es. +2. Wenn das kleine Gefäß voll ist, dann leere es. +3. Wenn beides nicht zutrifft, dann schütte so viel wie möglich vom großen in das kleine Gefäß. + +Prädikat $miss_ab(VolGr, VolKl, Ziel, InhGr, InhKl)$ mit +- VolGr - Volumen des großen Gefäßes +- VolKl - Volumen des kleinen Gefäßes +- Ziel - die abzumessende (Ziel-) Menge +- InhGr - der aktuelle Inhalt im großen Gefäß +- InhKl - der aktuelle Inhalt im kleinen Gefäß + +Beispiel-Problem: $?- miss_ab( 1.25 , 0.75 , 1 , 0 , 0 )4$ + +#### Pfadsuche in gerichteten Graphen +> Botschaft 5 +> 1. Für die systematische Suche eines Pfades kann der Suchprozess einer Folge von Resolutionsschritten genutzt werden. Man muss den Suchprozess nicht selbst programmieren. +> 2. Für eine heuristische Suche eines Pfades gilt Botschaft 4: Sie ist das klassische Einsatzgebiet zahlreicher KI-Tools - auch der Logischen Programmierung. + +Anwendungen +- Handlungsplanung, z.B. + - Suche einer Folge von Bearbeitungsschritten für ein Produkt, eine Dienstleistung, einen "Bürokratischen Vorgang" + - Suche eines optimalen Transportweges in einem Netzwerk von Straßen-, Bahn-, Flugverbindungen +- Programmsynthese = Handlungsplanung mit ... + - ... Schnittstellen für die Datenübergabe zwischen "Handlungsschritten" (= Prozeduraufrufen) und + - ... einem hierarchischen Prozedurkonzept, welches die Konfigurierung von "Programmbausteinen" auf mehreren Hierarchie-Ebenen + +Ein Beispiel: Suche einer zeitoptimalen Flugverbindung (BSP15.PRO) +- Repräsentation als Faktenbasis $verbindung(Start,Zeit1,Ziel,Zeit2,Tag).$ +- Start - Ort des Starts +- Zeit1 - Zeit des Starts +- Ziel - Ort der Landung +- Zeit2 - Zeit der Landung +- Tag - 0, falls Zeit1 und Zeit2 am gleichen Tag und 1 ansonsten +- möglich: + - $verbindung(fra,z(11,45),ptb,z(21,0),0).$ + - $verbindung(fra,z(11,15),atl,z(21,25),0).$ + - $verbindung(ptb,z(24,0),orl,z(2,14),1).$ + - $verbindung(atl,z(23,30),orl,z(0,54),1).$ + +In einer dynamischen Wissensbasis wird die bislang günstigste Verbindung in Form eines Faktes $guenstigste([ v(Von,Zeit1,Nach,Zeit2,Tag), ... ], Ankunftszeit, Tag ).$ festgehalten und mit den eingebauten Prädikaten $assert()$ - zum Einfügen des Faktes - und $retract ()$ - zum Entfernen des Faktes - bei Bedarf aktualisiert. +Zum Beispiel $guenstigste([v(fra,z(11,45),ptb,z(21,00),0),v(ptb,z(24,0),orl,z(2,14),1)],z(2,14),1).$ erklärt den Weg über Pittsburgh zum bislang günstigsten gefundenen Weg. + +#### "Logeleien" als Prolog-Wissensbasen +> Botschaft 6 +> 1. "Logeleien" sind oft Aussagen über Belegungen von Variablen mit endlichem Wertebereich, ergänzt um eine Frage zu einem nicht explizit gegebenen Wert. +> 2. Dabei handelt es sich um Grunde um eine Deduktionsaufgabe mit einer Hypothese zu einem mutmaßlichen Wert der gesuchten Variablen. Deshalb ist es oft auch mit dem "Deduktionstool" Prolog lösbar, denn Prolog tut im Grunde nichts anderes als ein ziel-gerichtetes "Durchprobieren" legitimer Deduktionsschritte im "Generate - and - Test" - Verfahren. + +Beispiel das "Zebra-Rätsel"(BSP16.PRO): +1. Es gibt fünf Häuser. +2. Der Engländer wohnt im roten Haus. +3. Der Spanier hat einen Hund. +4. Kaffee wird im grünen Haus getrunken. +5. Der Ukrainer trinkt Tee. +6. Das grüne Haus ist (vom Betrachter aus gesehen) direkt rechts vom weißen Haus. +7. Der Raucher von Atem-Gold-Zigaretten hält Schnecken als Haustiere. +8. Die Zigaretten der Marke Kools werden im gelben Haus geraucht. +9. Milch wird im mittleren Haus getrunken. +10. Der Norweger wohnt im ersten Haus. +11. Der Mann, der Chesterfields raucht, wohnt neben dem Mann mit dem Fuchs. +12. Die Marke Kools wird geraucht im Haus neben dem Haus mit dem Pferd. +13. Der Lucky-Strike-Raucher trinkt am liebsten Orangensaft. +14. Der Japaner raucht Zigaretten der Marke Parliament. +15. Der Norweger wohnt neben dem blauen Haus. + +Jedes Haus ist in einer anderen Farbe gestrichen und jeder Bewohner hat eine andere Nationalität, besitzt ein anderes Haustier, trinkt ein von den anderen Bewohnern verschiedenes Getränk und raucht eine von den anderen Bewohnern verschiedene Zigarettensorte. Fragen: +- Wer trinkt Wasser? +- Wem gehört das Zebra? +``` +loesung(WT, ZB) :- + haeuser(H), nationen(N), getraenke(G), tiere(T), zigaretten(Z),aussagentest(H,N,G,T,Z), !, wassertrinker(N,G,WT), zebrabesitzer(N,T,ZB). +tiere(X) :- permutation([fuchs, hund, schnecke, pferd, zebra],X). +nationen([norweger|R]) :- permmutation([englaender, spanier, ukrainer, japaner], R). % erfüllt damit Aussage 10 +getraenke(X) :- permutation([kaffee, tee, milch, osaft, wasser], X), a9(X). % erfüllt damit Aussage 9 +zigaretten(X) :- permmutation([atemgold,kools,chesterfield, luckystrike, parliament], X). +haeuser(X) :- permutation([rot, gruen, weiss, gelb, blau], X), a6(X). +% parmutation/2, fuege_ein/3: siehe BSP13-PRO +wassertrinker([WT| _ ], [wasser| _ ], WT ) :- !. +wassertrinker([ _ |R1], [ _ |R2],WT) :- wassertrinker(R1, R2, WT). +zebrabesitzer([ZB| _ ], [zebra| _ ], ZB) :- !. +zebrabesitzer([ _ |R1], [ _ |R2],ZB) :- zebrabesitzer(R1, R2, ZB). +aussagentest(H,N,G,T,Z) :- + a2(H,N), a3(N,T), a4(H,G), a5(N,G), a7(Z,T), a8(H,Z), a11(Z,T), a12(Z,T),a13(Z,G), a14(N,Z), a15(H,N). + +a2([rot| _ ], [englaender| _ ]) :- ! +.a2([ _ |R1], [ _ |R2]) :- a2(R1, R2). +a3([spanier| _ ], [hund| _ ]) :- !. +a3([ _ |R1], [ _ |R2]) :- a3(R1, R2). +a4([gruen| _ ], [kaffee| _ ]) :- !. +a4([ _ |R1], [ _ |R2]) :- a4(R1, R2). +a5([ukrainer| _ ], [tee| _ ]) :- !. +a5([ _ |R1], [ _ |R2]) :- a5(R1, R2). +a6([weiss, gruen| _ ]) :- !. +a6([weiss| _ ]) :- !, fail.a6([ _ |R]) :- a6(R). +a7([atemgold| _ ], [schnecke| _ ]) :- !. +a7([ _ |R1], [ _ |R2]) :- a7(R1, R2). +a8([gelb| _ ], [kools| _ ]) :- !. +a8([ _ |R1], [ _ |R2]) :- a8(R1, R2). +a9([ _ , _ , milch, _ , _ ]). +a11([chesterfield| _ ], [ _ ,fuchs| _ ]) :-!. +a11([ _ , chesterfield| _ ], [fuchs| _ ]) :- !. +a11([ _ |R1], [ _ |R2]) :- a11(R1, R2). +a12([kools| _ ], [ _ , pferd| _ ]) :- !. +a12([ _ , kools| _ ], [pferd| _ ] ) :- !. +a12([ _ |R1], [ _ |R2]) :- a12(R1, R2). +a13([luckystrike| _ ], [osaft| _ ]) :- !. +a13([ _ |R1], [ _ |R2]) :- a13(R1, R2). +a14([japaner| _ ], [parliament| _ ]) :- !. +a14([ _ |R1], [ _ |R2]) :- a14(R1, R2). +%a15([blau| _ ], [ _, norweger| _ ]) :- !. +a15([ _ , blau| _ ], [norweger| _ ]) :- !. +%a15([ _ |R1], [ _ |R2]) :- a15(R1, R2). + +?- loesung(Wassertrinker, Zebrabesitzer). +``` + +Beispiel SUDOKU (BSP17.PRO): +- Liste 9-elementliger Listen, die (von links nach rechts) die Zeilen (von oben nach unten)repräsentieren +- Elemente einer jeden eine Zeile repräsentierenden Liste: + - Ziffer, falls dort im gegebenen Sudoku eine Ziffer steht + - Anonyme Variable andernfalls + +#### Tools für die formale Logik +> Botschaft 7 +> Auch in der formalen Logik gibt es Deduktionsaufgaben, bei der Variablenbelegungen gesucht sind, welche eine Aussage wahr machen: +> 1. Meist geschieht das durch systematische Auswertung der Aussage, wozu das Suchverfahren von Prolog genutzt werden kann. +> 2. Auch hier geht es oft um gesuchte Werte für Variablen. Deshalb ist es oft auch mit dem "Deduktionstool" Prolog lösbar, denn Prolog tut im Grunde nichts anderes als ein ziel-gerichtetes "Durchprobieren" legitimer Deduktionsschritte im "Generate - and - Test" - Verfahren. + +Repräsentation von Aussagen als PROLOG-Term: +- true, false: atom(true), atom(false) +- $A1\wedge A2$: und(A1,A2) +- $A1\vee A2$: oder(A1,A2) +- $\lnot A$: nicht(A) +- $A1\rightarrow A2$: wenndann(A1,A2) +- $A1\leftarrow A2$: dannwenn(A1,A2) +- $A1\leftrightarrow A2$: gdw(A1,A2) + +Erfüllbarkeitstest: +- $?- erfuellbar(gdw(wenndann(nicht(oder(atom(false),atom(X))),atom(Y)), atom(Z))).$ +- X=true, Y=_, Z=true ; steht für 2 Modelle (eines mit Y = true und eines mit Y = false) +- X=false, Y=true, Z=true + +Ketten von Konjunktionen und Disjunktionen als PROLOG-Listen: +- $A1\wedge A2\wedge ... \wedge An$: und verkettung([A1,A2, ..., An]) +- $A1\vee A2\vee ...\vee An$: oder verkettung([A1,A2, ..., An]) + +Erfüllbarkeitstest: +- $?- erfuellbar(undverkettung([true,X,Y,true]))$ +- X = true Y = true +- $?- erfuellbar(oderverkettung([false,X,Y,false]))$ +- X = true Y = _ +- X = _ Y = true + +Repräsentation von Termen als PROLOG-Term: +- Wert: atom() +- $A1\wedge A2$: und(A1,A2) +- $A1\vee A2$: oder(A1,A2) +- $\lnot A$: nicht(A) +- $A1\rightarrow A2$: wenndann(A1,A2) +- $A1\leftarrow A2$: dannwenn(A1,A2) +- $A1\leftrightarrow A2$: gdw(A1,A2) +- $A1\wedge A2\wedge ... \wedge An$: und verkettung([A1,A2, ..., An]) +- $A1\vee A2\vee ...\vee An$: oder verkettung([A1,A2, ..., An]) + +Termauswertung: +- $?- hat_wert(und(atom(0.5),oder(atom(0.7),atom(0.3))),X).$ +- X=0.5 + +Termauswertung unter Vorgabe des Wertebereiches: +- $?- hat_wert([0,0.3, 0.5, 0.7, 1], und(atom(X),oder(atom(0.5),atom(0.7))),Wert).$ +- X=0, Wert=0 +- X=0.3, Wert=0.3 +- X=0.5, Wert=0.5 +- X=0.7, Wert=0.7 +- X=1, Wert=0.7 + diff --git a/Neurobiologische Informationsverarbeitung.md b/Neurobiologische Informationsverarbeitung.md new file mode 100644 index 0000000..5e27bb6 --- /dev/null +++ b/Neurobiologische Informationsverarbeitung.md @@ -0,0 +1,232 @@ +--- +title: Neurobiologische Informationsverarbeitung +--- + +| | hormonal | nerval | +| -- | -- | -- | +| Informations Träger | chem. Substanz = Hormon | Potentialunterschied mit max 130 m/s, Leiter 2.Ordnung (Ionen) | +| Transport | Blut | in abgegrenzten Nervenbahnen | +| Einfluss | diffus, auf viele Empfänger gleichzeitig, Selektion durch Empfindlichkeit (broadcasting) | zu bestimmten genetisch bed. Empfängerzellen | +| Natur der Signale | sehr spezifisch, nur eine bestimmte Information wird vermittelt (Wachstumshormon) | unspezifisch, Spezialität entsteht durch Transport in def. Bahnen (Seh-/Hörbahn) | + +# Rezeptoren (Sinneszellen) +Definition: Zelle, die zur Perzeption von Reizen und zur Weiterleitung der Reizinformation befähigt ist. Sie liefert Informationen über den physikalisch-chemischen Zustand der Umwelt. + +Sinneszelle = Spezifiziert Nervenzelle +- primäre Sinneszelle (mit eigenem Axon) +- sekundäre Sinneszelle (ohne eigenes Axon) + +# On/Off-Zentrum Nerven + +!TODO + +# Def: Rezeptives Feld +Das rezeptive Feld ist eine Fläche mit Rezeptoren, die bei Reizung zur Reaktion eines Neurons führen => Erzeugung Generatorpotential + +# Def: Adaption +Effekt der Verminderung der Rezeptorantwort bei konstantem Reiz +- tonische Verhalten: gleichbleibende AP-Frequenz bei konst. Reiz +- phasisches Verhalten: Starker Anstieg der AP-Frequenz bei Reizänderung +- tonische Rezeptoren: nicht gewöhnend (Schmerz, Kälte) +- phasische Rezeptoren: Tastsinn, Druckrezeptoren + +# Geschmacksqualitäten +süß, salzig, sauer, bitter, !!!!!!umami!!!!! + +# Neuron +kann Informationen leiten und verarbeiten (empfangen können auch andere) +- Dendriten: Hauptansatz für Synapsen, räumliche und Zeitliche Summation + - räumlich: Ankommende Potentiale verschiedener Synapsen + - zeitlich: Nacheinander ankommende Potentiale an einer Synapse +- Soma: Synapsen am Soma meist hemmend +- Axon: myelinisiert oder nicht-myelinisiert + +# Synapsen +chemisch <=> elektrisch (= gap junctions)\ +- elektrisch: + - sehr schnell, z.B. Herzmuskelzellen + - kleiner als chemisch + - stammgeschichtlich älter + - dienen auch anderem Stoffaustausch +- chemisch: + - keine unmittelbare Weiterleitung des Aktionspotentials an einer Synapse (mehrere müssen gleichzeitig aktiv sein) + - unidirektional + - Verzögerung + - Blockierbar durch chem. Substanzen + +# Gliazellen +- Astrozyten (Makroglia): Regulierung der verschiedenen Substanzkonzentrationen (z.B. Transmitterkonzentration), Zwischenspeicher, Versorgung der Nervenzellen +- Oligodentrozyten (Makroglia): Bilden Myelin im Zentralnervensystem (in der peripherie schwammscher Zellen) +- Microglis: + - wandeln sich nach Hirnverletzung zu Rekrophagen (Fresszellen) -> Abbau abgestorbener Bestandteile durch Produktion einer Mydroxilgruppe + - Leitgewebe bei Hinentwicklung + - Starke Verzweigung zur Überwachung + + +# Entstehung Membranpotential +Ruhepotential: ~70-90mV (Zellinneres negativ)\ +1. Diffusionspotential - passiv + - Im Ruhezustand Membran permeabel für K⁺ + - Gleichgewicht aus Konzentrationsgradient und Ladungsgradient + +!TODO zeichnung + + +2. Ionenpumpen - aktiv + - Na⁺ K⁺ Pumpen + - 3Na⁺ aus der Zelle, 2K⁺ in die Zelle, jeweils gegen den Konzentrationsgrad, Verbrauch von 1 ATP zu ADP+P + - Das Ruhepotential wird aktiv aufrechterhalten -> Life-Zero-System + +# Potentialänderung +- Depolarisation: Verminderung des Aktionspotentials (positiver) (Erregung, Excitation) +- Hyperpolarisation: Erhöhung des Aktionspotetials (negativer) (Hemmung, Inhibition) + +Bei Erregung steigt Permeabilität für Na+ an; E_{Na⁺} angestrebt => +55mV + +# gradierte Potential Änderung +- depolarisierender Reiz erhöht Permeabilität für K⁺, Na⁺, Cl⁻ +- Na+ größer Antrieb nach innen aber Ionenpumpen fordern Na⁺ nach außen, solange Schranke nicht überschritten + +# nicht gradierte potential Änderung +- einige Membranstrukturen reagieren auf Reiz über der Schwelle mit nicht abgestelltem Potentialsprung => AP für 1ms +- Axome, Muskelfasern, Drüsen = konduktive Membran +- "Alles oder nichts"-Gesetz: Bei Überschreitung der Schwelle AP gleicher Form und Größe, Lawineneffekt des Einstroms von Na⁺, wird gebremst von Leitfähigkeitserhöhung von K⁺ (Ausstrom) + +Bedingung für AP: g_Na⁺ > g_K⁺ + +# Adaption +Abnahme der Spikefrequenz bei konst. Repolarisation +- ZNS: sehr schnelle Adaption, oft nur ein AP +- Peripherie: mehrere AP + +# Akkomodation +Ausbleiben eines AP bei sehr langsam ansteigender Depolarisation. Na⁺ Kanäle werden inaktiv bevor g_Na⁺ > g_K⁺ + +# Elektrotonische Weiterleitung +passiv, mit Dekrement +- Verlust abhängig von Wiederstand + - Innen: 20-200 Ohm-cm + - Außen: 1,5-3x geringer + - Membran: 10¹⁰ Ohm-cm +- spezifischer Widerstand: !TODO!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + +- Membran verhält sich wie Kondensator => bei Ausbreitung des Potentials muss der Kondensator ungeladen werden -> Zeitkonstante $\tau = R_m * C_m$ +- Dendriten (nur elektrotonische Ausbreitung, hohe Na+ Kanäle) werden zur Peripherie dünner, R_i steigt, \lambda sinkt +- Kabeltheorie nach Rall: Einteilung in Kompartimente mit gleichem \lambda + +# Weiterleitung von APs +- konduktile Leitung ohne Dekrement +- An jeder Membranstelle neuer Erregungsvorgang mit alles oder nichts Prinzip +- Ausbreitung durch Refraktärzeit unidirektional von Reizort weg + +Saltatorische Erregungsleitung: erleichterte Auslösung eines AP an den ranvierschen Schnürringen, Potential "springt" von Ring zu Ring => Raumeinsparung, Geschwindigkeitserhöhung + +# Weiterleitung an Synapsen +- Na⁺ Kanäle unterliegen keiner Deaktivierung, solange aktiv wie Transmitter vorhanden ist +- Second Messenger Systeme: längerfristige Wirkung + +## Ableitung +1. AP an Präsynapse +2. Ca²⁺ strömt in die Zelle -> Vesikel zu präsynaptischer Membran +3. Transmitterfreisetzung ~ AP-Folge +4. Diffusion durch den Spalt +5. Wirkung des Transmitters auf Rezeptor (Na⁺ Kanäle) der postsynaptischen Membran +6. Permeabilitätsänderung in der postsynaptischen Membran + - Na⁺, K⁺: EPSP + - K⁺, CL⁻: IPSP +7. Weiterleitung EPSP/IPSP über elektronische Leitung entlang Dendrit +8. Inaktivierung und Recykling des TP + +# Beeinflussung von Synapsen +- Agomisten: gleiche Wirkung wie Transmitter, aber veränderte Eigenschaften (z.B. kein second-messenger Effekt) +- partielle Agomisten: Bindung an Rezeptor aber nur geringe Leitfähigkeitsänderung +- Antagomisten: Bindug an Rezeptor (Ionenkanal) ohne Leitfähigkeitsänderung + +# Interaktion von Synapsen +- räumliche + zeitliche Integration + - räumlich: EPSP/IPSP verschiedener Synapsen, die z.B. Dendritenbaum ansetzten werden an der postsynaptischen Membran addiert + - zeitlich: die von einer oder mehreren Präsynapsen kurz nacheinander eingehenden Erregungen führen in der postsynaptischen Zelle zu EPSP/IPSP die addiert werden +- prä- und postsynaptische Hemmung + - prä: Synapse: eig. aktiv -> wird gehemmt + - hemmende Synapse ansonsten +- Bahnung: mehrere Synapsen an einem Dendriten; alle gleichzeitig aktiv, fehlt aber ein Dendrit => kein AP = Synapse bahnt Eingang der anderen + +# Veränderung der Effektivität von Synapsen +- tetanische Potenzierung: + - Aktivierung einer Präsynaptische mit Reizserien führt zu einem zunehmend vergrößertem EPSP (syn. Potenzierung), der auch nach längeren Reizserien über alle Enden hinaus festbestehen kann (posttetamische Pot.) (Kurzzeitgedächtnis) +- Langzeitpotenzierung: + - Strukturelle Anpassung während des Lernens + - Prozess besteht auf Wandlungsfähigkeit der Dornen: durch Formänderung, Ab-und Aufbau werden Verb. zu reaktives Axonen gelöst und zu aktiven Fasern hergestellt +- heterosynaptische Potenzierung + - !TODO!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + +# Neuronale Verschaltungsprinzipien +## Divergenz & Konvergenz +- Divergenz: Zur Überschreitung der Schwelle ist ein erregender Eingang nötig +- Konvergenz: Zur Überschreitung der Schwelle sind drei erregende Eingänge nötig +- Divergenz und Konvergenz: gleiche Struktur, Umschaltung zwischen D. und K. über Zentralnervöse Vorgänge + +## Neuronale Erregungskreis +funktionierende Einheit von miteinander verbundenen Neuronen, die sich in ihrer Aktivität gegenseitig beeinflussen + +## neuronale Hemmung +- Schutz vor Informationsüberflutung +- prä- und postsynaptische Hemmung +- Vorwärtshemmung !TODO +- Rückwärtshemmung !TODO +- Streuung !TODO +- laterale Inhibition: Verschaltungsprinzip von Neuronen, bei denm Freiverschaltete Neuronen benachbarte Neuronen hemmen => Kontrastverstärkung + - TODO + - Änderung der Hemmung mit zunehmendem Abstand von benachbarten Neuron -> rezeptive Felder + +# Mexican Hat + +!TODO zeichnung + +Übertragungsfunktion: $g(i)=m_1 e^{\frac{-r²}{B_1²} } - m_2 e^{\frac{-r²}{B_2²}}$ +r: Radius RF; m: max Amplitude; B: breite Gauß; $B_2=k*B_1$ + +| Pass | Beschreibung | Vorraussetzung | +| -- | -- | -- | +| Tiefpass | Grenzfrequenz umso höher je kleiner B¹ | $m_2=0$ $m_1\not=0$ $B_1\not=0$ | +| Hochpass | Grenzfrequenz umso höher je kleiner B² | $m_2\not=0$ $B_1\rightarrow 0$ $B_2\not=0$ | +| Bandpass | Mittelwertunterdrückung, On-Zentrum | $K>1$, $m_1>m_2$, $m_1B_1 = m_2B_2$ | +| Bandpass | Off-Zentrum | $k>1$, §m_1< m_2$ | + +$y_i=\sum_{j=1}^N K_{Sij}*x_j + \sum_{j=1}^N K_{Hij}*x_j$ +$K_{Sij} \in [0,1]$ Streuung +$K_{Hij} \in [-1,1]$ Hemmung + +# Neuronenmodelle +## Statische Modelle +### McCulloch & Pitts +$y=\sum_{j=1}^N \omega_j x_j -s = z$ +kein Lernen, keine Erklärung für Fehlertoleranz + +### statisches Neuronenmodell +$y=f(\sum_{j=1}^N \omega_jx_j -s) = f(z)$ +Modellvereinfachung: Ratenmodell: Impulsfrequenz als analoge mittlere Feuerrate (keine Spikes) + +## Dynamische Modelle +Approximation der Gewichtsfunktion als Alpha-Funktion, Trägheitsverhalten realisiert. +Vereinfachung der Alphafunktion: Anstieg nicht wichtig, nur verzögerter Abfall eventuell mit Überlagerung +$g(i)=\frac{t*e}{t_{peak}} e^{\frac{-t}{t_{peak}}} \Rightarrow g(i)=\frac{1}{\tau}e^{\frac{-t}{\tau}}$ + +## Integrate & Fire Modelle +Eingänge werden summiert, mit Schwelle verglichen und bei Überschreiten wird Spike erzeugt +- Zeit zwischen Stimulus und 1. Spike von Interesse +- Phasenlage zwischen ............. und Hintergrund-Oszillation +- Korrelation/Synchronität: Spikes anderer Neuronen als Referenz + +# Lernen und Gedächtnis +## phyletisches Gedächtnis +Artgedächtnis, angeborenes, primär sensorische und motorische Bereiche der Hirnrinde, in grober Verschaltung des stammgeschichtlich älteren Teils schon bei der Geburt als Essenz der wichtigsten Erfahrungen angelegt - Extrakt der Anpassungsleistung der Art + +## individuelles Gedächtnis +Baut auf phyletischem Gedächtnis auf, Sitz im Assoziationscortex, evolutionär spätere, höhere Komplexität der Netzwerke, entwickelt sich während der ganzen Kindheit und auch noch bei Erwachsenen + +## prozedurales Wissen +Erwerb von Verhaltensweisen "gewusst wie" sensomotorische Intelligenz + +## deklaratives Wissen +Erwerb von Wissen "gewusst was" kognitive Intelligenz \ No newline at end of file diff --git a/Neuroinformatik.md b/Neuroinformatik.md new file mode 100644 index 0000000..1d787ce --- /dev/null +++ b/Neuroinformatik.md @@ -0,0 +1,881 @@ +# NeuroInformatik +Die Lehrveranstaltung vermittelt das erforderliche Methodenspektrum aus theoretischen Grundkenntnissen und praktischen Fähigkeiten zum Verständnis, zur Implementierung und zur Anwendung neuronaler und probabilistischer Techniken des Wissenserwerbs durch Lernen aus Erfahrungsbeispielen sowie zur Informations- und Wissensverarbeitung in massiv parallelen Systemen. Sie vermittelt sowohl Faktenwissen, begriffliches und algorithmisches Wissen. + +Inhaltsübersicht +- Intro: Begriffsbestimmung, Literatur, Lernparadigmen, Haupteinsatzgebiete, Historie +- Neuronale Basisoperationen und Grundstrukturen: + - Neuronenmodelle + - Netzwerkmodelle +- Lernparadigmen und deren klassische Vertreter: + - Unsupervised Learning + - Reinforcement Learning + - Supervised Learning +- Moderne Verfahren für große Datensets + - Deep Neural Networks + +Exemplarische Software-Implementationen neuronaler Netze für unüberwachte und überwachte Lern- und Klassifikationsprobleme (Fokus auf Python). Die Studierenden erwerben somit auch verfahrensorientiertes Wissen, indem für reale Klassifikations- und Lernprobleme verschiedene neuronale Lösungsansätze theoretisch behandelt und praktisch umgesetzt werden. Im Rahmen des Pflichtpraktikums werden die behandelten methodischen und algorithmischen Grundlagen der neuronalen und probabilistischen Informationsverarbeitungs- und Lernprozesse durch die Studierenden mittels interaktiver Demo-Applets vertieft und in Gesprächsgruppen aufgearbeitet. + + +[comment]: <> (Vorlesung 1) +# Intro +## Was ist Künstliche Intelligenz (KI) ? +- Künstliche Intelligenz (KI, englisch Artificial intelligence - AI) ist ein Teilgebiet der Informatik, welches sich mit der Automatisierung intelligenten Verhaltens und dem Maschinellen Lernen befasst. Der Begriff ist nicht eindeutig abgrenzbar, da es bereits an einer genauen Definition von „Intelligenz“ mangelt. (Quelle: Wikipedia) + -bezeichnet den Versuch, bestimmte Entscheidungsstrukturen des Menschen nachzubilden, indem z. B. ein Computer so programmiert wird, dass er relativ eigenständig komplexe Probleme bearbeiten kann. +- Begriff wurde erstmals 1956 vom amerikanischen Informatiker John McCarthy verwendet, der ihn im Projektantrag für die Dartmouth-Konferenz 1956 gebrauchte (Präsentation von Programmen, die Schach und Dame spielten, Theoreme bewiesen sowie Texte interpretierten) + +## Starke vs. Schwache KI +- Schwache KI (Narrow AI): + - zielt darauf ab, konkrete Anwendungsprobleme des menschlichen Denkens und Handelns zu lösen + - Fähigkeit aus Beobachtungen zu lernen ist integraler Bestandteil + - zielt auf die Simulation intelligenten Verhaltens mit Mitteln der Mathematik & Informatik, aber NICHT auf die Schaffung von Bewusstsein oder auf ein tieferes Verständnis von Intelligenz +- Starke KI: + - zielt auf die Schaffung von eigenständigem, maschinellem Bewusstsein und Gewinnung eines Verständnisses von Intelligenz + - muss nicht Gemeinsamkeiten mit dem Menschen haben, wird vermutlich eine andersartige kognitive Architektur aufweisen (Quelle: Wikipedia) + +## Wesentliche Methoden / Konzepte: +- Symbolische Verfahren: Top-down Ansatz (von begrifflicher Ebene): expertenwissen in system packen +- Subsymbolische/Neuronale Verfahren: Bottom-up Ansatz von Daten: nutzt daten in denen "wissen" steckt und lasst durch viele daten richtige entscheidungen (beobachten) enstehen +- Simulationsmethode: simuliert kognitive Prozesse des Menschen +- Phänomenologische Methode: arbeitet rein ergebnisorientiert + +## Techniken der KI +1. **Suchverfahren** z.B. zur Wegfindung (Dijkstra, A*, D*, E*, …) +2. **Planungsverfahren** zur Erstellung optimaler Aktionsfolgen zum Ziel +3. **Optimierungsverfahren** z.B. Hill Climbing, Evolutionäre Algorithmen, Partikelschwarmoptimierung +4. **Logisches Schließen** + − formalisiertes menschliches Wissen (z.B. in Ontologien) + − Induktion: Verallgemeinerung von Beispielen zu Regeln, häufig mit Maschinellem Lernen + - In symbolischen Systeme: Beispiele als auch die induzierten Regeln sind explizit repräsentiert + - In subsymbolischen Systemen: berechenbares Verhalten wird „antrainiert“, erlaubt jedoch keinen/nur schwer Einblick in die erlernten Lösungswege +5. **Approximationsmethoden** aus einer Menge von Daten eine allgemeine Regel ableiten (z.B. Neuronale Netze, Deep Learning) + +## Was ist Maschinelles Lernen? +- Oberbegriff für die „künstliche“ Generierung von Wissen aus Erfahrung + - Ein künstliches System lernt dabei aus Trainingsbeispielen und kann nach Beendigung der Lernphase verallgemeinern. + - Es lernt also nicht einfach die Beispiele auswendig, sondern erkennt Gesetzmäßigkeiten (Regularitäten) in den Lerndaten. + - So kann das System dann auch unbekannte Daten beurteilen. +- Breites Spektrum möglicher Anwendungen in: Diagnoseverfahren, Aktienkursanalyse, Bild- und Sprachverarbeitung, Robotik, Spielstrategien,… +- Art und Mächtigkeit der Wissensrepräsentation: + - symbolisch: Wissen (Beispiele, induzierten Regeln) explizit repräsentiert + - subsymbolisch: Wissen implizit repräsentiert - berechenbares Verhalten wird antrainiert, erlaubt aber kaum Einblick in die erlernten Lösungswege + +## Wichtige Paradigmen des Maschinellen Lernens +Informationsverarbeitungsniveau zu Systemwissen +| \ | **symbolisch** | **subsymbolisch (numerisch)** | +| -------------------------------------------- | :------------: | :---------------------------: | +| explizit strukturiert (regelbasiert) | KI-Systeme | Fuzzy Systeme | +| implizit unstrukturiert (durch lernprozesse) | - | Neuronale Systeme | + + +## Was ist Neuroinformatik +Neuroinformatik – das interdisziplinäre Forschungsgebiet zu den +- am biologischen Vorbild orientierten, +- nicht explizit programmierten aber +- lernfähigen und sich adaptierenden Systemen, die +- ihre eigenen, internen „Algorithmen“ +- in Reaktion auf und in Wechselwirkung mit ihrer sensorisch (visuell, taktil, akustisch, usw.) vermittelten Umwelt entwickeln. += Neural Computing, Konnektionismus, New AI, Brain-like Computing, Deep Learning +*Ziel*: Entwicklung von Maschinenintelligenz durch Nachbildung biologischer Informationsverarbeitungs- und Lernprozesse auf neuronalem Niveau + +[comment]: <> (Vorlesung 2) +## Erste wichtige Grundlagen +### Lernparadigmen +#### Unsupervised Learning (Unüberwachtes Lernen) +Für eine gegebene Menge von Daten wird ohne Lehrer ein Modell, gelernt, das die Daten in kompakter Weise beschreibt . Wichtiges Teilgebiet: Cluster-Verfahren, die die Daten in mehrere Kategorien einteilen, die sich durch charakteristische Muster unterscheiden. + +#### Reinforcement Learning (Verstärkungslernen) +Algorithmus lernt durch Belohnung und Bestrafung eine Taktik, wie in potenziell auftretenden Situationen zu handeln ist, um den Nutzen für den Agenten (Steuerung, Roboter, Spielprogramm) zu maximieren. + +#### Supervised Learning (Lernen mit Lehrer) +Erlernen einer Abbildungsfunktion aus gegebenen Paaren von Ein- und Ausgaben. Während des Lernens stellt ein „Lehrer“ den korrekten +Sollwert zu einer Eingabe bereit. Wichtiges Teilgebiet: automatische Steuerung oder Klassifizierung + +### Einsatzgebiete +#### Klassifikation/Kategorisierung +Zweck: auf Basis von diskret gelabelten Trainingsdaten $x = {(x_1, y_1), (x_2,y_2), ...,(x_n, y_n)}$ soll eine unbekannte, meist nichtlineare Beziehung zwischen den Inputdaten $x_i$ und den Klassenlabeln $y_i$ gelernt werden. Daten entstammen einer unbekannten, Daten generierenden Funktion, deren Funktionsoutput nur diskrete Werte annehmen kann. + Zu beachten! prinzipielle Separierbarkeit des Klassifikationsproblems linear nichtlinear nicht separabel + Einsatzfelder: +- Detektionprobleme (Personen, Gesichter, ...) +- Klassifikationsprobleme (Handschrift, Posen, Gesten, Mimik, Krankheiten, Pflanzen, Tiere, ...) +- Übung: Schwertlilie + +#### Funktionsapproximation / Regression +- Zweck: auf Basis von reelwertig gelabelten Trainingsdaten $x = {(x_1, y_1), (x_2,y_2), ...,(x_n, y_n)}$ soll eine unbekannte, Daten generierende Funktion approximiert werden, deren Funktionsoutput kontinuierlich (reell) ist. +- Lösungsansatz (Idee): jede stetige, mehrdimensionale und nichtlineare Funktion ist durch Überlagerung von Aktivierungsfunktionen mehrerer Neuronen beliebig genau approximierbar +- Einsatzfelder: + - Abbildung hochdimensionaler Inputs auf niedrig-dimensionale kontinuierliche Outputs (z.B. Navigation bei ALVINN) + - Zeitreihenprognose + - Neurocontrol + - Übung: Regression von Wohnhauspreisen + - Trainingsziel: Erlernen der durchschnittlichen Wohnungspreise aus 13 hinterlegten Merkmalen + - Grundlage bildet Sinusfunktion mit überlagertem Rauschen + - 40 Datenpunkte aus Sinusfunktion y=sin x; diese wurden mit Rauschen überlagert y=sin x + noise + - nach Training: reellwertige Ausgabe für beliebige Inputs x möglich + +#### Clusterung bzw. Clusteranalyse +Zweck: strukturentdeckende Analyseverfahren zur Ermittlung von Gruppen (Clustern) von Daten, deren Eigenschaften markante Ähnlichtkeiten aufweisen. Variante des Klassifikationsproblems, nur schwieriger, da die Trainingsdaten hierbei ungelabelt sind. +Hauptanwendungsfelder: +- Gruppenbildung über Daten allgemein +- Datenvisualisierung +- Suche in Datenbanken und Web +- Bildsegmentierung (Video, CT, MRI, …) +- Clustering von Genom Daten +Typ. Vertreter: +- k-Means Algorithmus +- SOFM, Neural Gas +- Expectation-Maximization (EM)-Algorithmus +- Fuzzy C-Means, Mean Shift + +### Einordnung in das Mustererkennungsparadigma +Wichtiger Hinweis: Dies ist das klassische Mustererkennungsparadigma. +Messdaten (Signale, Bilder) aus Sensorik kommt in Problemabhängige und Netzwerkbezogene Datenaufbereitung: +1. Problemspezifische + - Vorverarbeitung + -Schwellwertoperationen + - Filterung + - Inter- /Extrapolation + - Normierungen & Korrekturen + - Segmentierung +2. Merkmalsextraktion + - Merkmalsgewinnung + - Merkmalstransformation + - Skalierung/Normierung + - Unterraumprojektion (Dimensionsreduktion) + - Quellenseparierung + - Merkmalsselektion + - Signifikanzanalyse +3. Netzwerkein- und ausgabekodierung +Die Ausgabe wird auf Klassifikation, Funktionsapproximation oder Clusterung übertragen + +## Historische Entwicklungen +### Nachweis von Einzelneuronen (1905) +Der spanische Neuroanatom Santiago Ramon y Cajal konnte mittels der Golgi-Färbung erstmals nachweisen, dass das Gehirn aus einzelnen, getrennten Zellen (Neuronen) besteht. +Danach wurde eine strukturelle Vielfalt der Neuronentypen entdeckt (30-40 versch Zelltypen), unter anderem Purkinje-, Pyramiden- oder spindelförmige Zellen. + +### Das Hebb'sche Korrelationslernen (1949) +Die synaptische Kopplung zwischen zwei Neuronen ist plastisch und ändert sich proportional zur Korrelation der Aktivitäten des Sender- und des Empfängerneurons, d.h. der prä- und postsynaptischen Aktivitäten. + +$w_{ij}(t+1) = w_{ij}(t) + \Delta w_{ij}(t)$ (Lernen über die Zeit) +$\Delta w_{ij} = \eta * y_i(t)*x_{ij}(t)$ (Das $x_ij$ ist Aktivität des Eingangsneuron, $y_i$ die Aktivität des Empfängerneurons) + +| $y_i/y_j$ | 0 | 1 | +| 0 | 0 | 0 | +| 1 | 0 | + | + +### Erste einfache Neuronenmodelle +In Knoten laufen Informationsprozesse verschiedener Synapsen ein. Diesen Synapsen sind Gewichtungen vorgegeben. Der Knoten bildet aus den gewichteten Eingängen über eine Gesamteingabe und Transferfunktion die Ausgabeakivitäten. Synapsen können Signale nicht verstärken, nur schwächen! + +### Grundstruktur und Lernprinzip eines Multi Layer Perzeptons (MLP) +- Input Layer nehmen Grundfunktion hne Bias auf +- Hidden Layer (1.Schicht) verknüpfen die Input Layer und bewerten mit Bias (bildet Scalarprodukt seiner gewichteten Eingangsinputs). Ermöglicht mathematische Operationen. Wird als Synaptische Matrix bezeichnet +- Output-Layer (2. Schicht) verknüft Ausgangsprodukte der Hidden Layer mit einem eigenem Bias und erstellt selbst Vektoren + +Bsp: 5 Hidden Neuronen + 1 Hidden Bias Neuron + 2 Output Neuronen + 1 Output Bias Neuron = 12 Neuronen/Gewichte +Teach Vektor t: $d = t -y$ +Abbildungsfelder (als skalare Größe): $E=||d||^2$ wird verwendet um Fehler zu minimieren oder zu verhindern +Skalarer Abbildungsfehler (Loss Funktion) wird nach fälschlichen Gewichten abgeleitet: $\frac{\delta E}{\delta w_{ij}} \rightarrow \Delta W^1$ + +### Erlernen der Navigation mittels Expert Cloning +- Kopieren der situationsabhängigen Fahrstrategie eines/mehrerer geübter Fahrer in ein Neuronales Netz +- Nutzung der Approximations und Verallgemeinerungsfähigkeit des Netzes zur Navigation in unbekannten Situationen +- realisiert eine hochkomplexe, nicht explizit algorithmisch fassbare neuronale Funktionsapproximation $\rightarrow$ End-to-End Learning + +$\phi = f(x(t))$ + +#### ALVINN – Prinzipielle Vorgehensweise +1. Vorführphase: + - Experte(n) steuert Fahrzeug entlang einer Anzahl repräsentativer Trajektorien, die die gewünschte Fahrstrategie implizit beschreiben (Beachte: nur mittels der Kamerabilder) $\rightarrow$ bei untersch. Witterungs-, Beleuchtungs- & Straßenverhältnissen + - Synchrone Aufzeichnung der aktuellen Szenenansichten $x(t)$ und des vom Experten gewählten Lenkwinkels $\phi(t)$ + - Vorteil: Datensatz enthält auch die durch Fahrzeugkinematik und sonstige Einflüsse (Straßen-/Reifenzustand) bestimmten Restriktionen während der Fahrt +2. Trainingsphase: + - Approximation der Abbildungsfunktion $\phi (t)=f(x(t))$ mittels Supervised Learning + - Generalisierung von bekannten Trainingssituationen auch auf unbekannte neue Straßenverläufe +3. Recallphase: + - Nachahmung der vom Experten in der Vorführphase verfolgten Fahrweise $\rightarrow$ Experten-Cloning + - topologische Ausgabekodierung $\rigtharrow$ Fuzzyfikation des Lenkwinkels + +- Neuronen fungieren als Detektoren für ganze Straßenverläufe mit verschiedenen Orientierungen oder für die linke bzw. rechte Straßenkante. +- Ein Einzelneuron allein kann die Lenkung nicht korrekt steuern, erst die kollektive Aktivierung aller Neuronen (mit richtigen und falschen lokalen Hypothesen) ermöglicht die feinabgestimmte Steuerung des Fahrzeugs. + +### Überwachtes Lernen als Optimierungsproblem – die „Support Vector Machine“ +- aus der statistischen Lerntheorie hervorgegangenes Lernverfahren +- zur Lösung von Klassifikationsproblemen entwickelt (Vapnik, 1995) +- später auch für Funktionsapproximation/Regression eingesetzt (Vapnik et al., 1997) +- allgemein bessere Generalisierungsfähigkeiten als damals bekannte neuronale Netze, weil ... + +| Neuronales Netz | Support Vector Machine (SVM) | +| ------------------------------------------------------- | ---------------------------------------------------------------------------------------- | +| Training – als Gradientenabstieg über dem Fehlergebirge | Training – als Lösung eines quadratischen Optimierungsproblems mit konvexer Zielfunktion | +| $\rightarrow$ kann in lokalem Minimum enden | $\rightarrow$ sichert Konvergenz zum globalen Minimum | + +#### SVM Grundidee +- Trainingsmuster in Form von Vektoren, die einer von zwei Klassen angehören +- Ermittlung einer optimalen Hyperebene H (Trenngerade, Trennebene), so dass diese + 1. die Trainingsmuster korrekt trennt und dabei + 2. einen möglichst großen Abstand zu den äußeren Datenpunkten der jeweiligen Klasse aufweist +- Der minimale Abstand zwischen der Trennebene und dem nächsten Trainingssample wird als Margin bezeichnet und soll maximal werden $\rigtharrow$ Forderung zur Erzielung guter Generalisierungsleistungen +- Ziel des Algorithmus: Finden einer optimal gelegenen Hyperebene H, bei der der Margin maximal wird $\rightarrow$ erfordert Lösung eines Optimierungsproblems + +[comment]: <> (Vorlesung 3) +### Deep Learning +Konzept und Lernverfahren, das seit etwa 2010 alle Rekorde (Computervision, Sprachverstehen, Robotik, Spielstrategien) in der künstlichen Intelligenz bricht. Kombiniert eigentlich alte Verfahren (neuronale Netze) mit +1. gewaltigen Datenmengen und +2. massiv paralleler Rechenpower $\rightarrow$ Schlüssel zum Erfolg +Im Kern ein unüberwachtes Verfahren für tiefe neuronale Netze zum Lernen von hierarchischen Features der Eingabedaten für schwierigste Klassifikationsaufgaben. + +#### Typische Netzwerkstruktur +Neuronales Netzwerk für Schadstellendetektion +- bis zu 1000 Schichten +- mehrere Mio. freie Parameter (Gewichte), die alle zu trainieren sind +- Einsatz neuartiger Techniken beim Training: Regularisierung, Dropout, Weight Decay, Batch Normalization, usw. + +#### Motivation für Deep Learning +> „Hunderte von Entwicklern und Studenten verbrachten Jahrzehnte damit, per Hand all +die Regeln einzutippen, die Computer brauchen könnten, um Gegenstände anhand ihrer +Merkmale zu unterscheiden“ +> „Sich Merkmalssätze auszudenken, ist schwierig, zeitaufwändig und verlangt nach viel +Fachwissen, da muss man sich natürlich die Frage stellen: Gibt es keinen besseren +Weg?„ (A. Ng, Stanford Univ. / Baidu Research / Coursera ) + +Probleme: +- Design des Merkmalsraumes per Hand: + - erfordert viel Hintergrundwissen über das Klassifikationsproblem und ist zeitintensiv + - Wiederkehrendes Problem: neue Objektklassen benötigen eventuell neue Merkmalsräume +- Meist nur ungelabelte Bilder verfügbar: + - viele Anwendungen haben keine oder kaum gelabelte Daten (z.B. Facebook-Fotos) + - Bilder haben hohen Informationsgehalt $\rightarrow$ auch ohne Label ist viel Information über die betreffende Klasse enthalten + +Ausweg: Deep Learning +- Wesen: + - Lernen von hierarchischen Features der Eingabedaten + - Jede Schicht lernt immer komplexere Features ausgehend von den Features der letzten Schicht +- Vorab-Design der Features ist damit nicht mehr erforderlich +- Direkte Ausnutzung von ungelabelten Daten durch unüberwachtes Lernen +- Bekannte Netzwerkarchitekturen: + - Covolutional Neural Networks (CNN) + - Stacked Auto-Encoder (SAE), Long Short-term Memories (LSTM), ... +- Netzwerkarchitekturen unterstützen auch überwachtes Lernen $\rightarrow$ damit auch Kombination von unüberwachtem mit überwachtem Lernen möglich + +#### Grundidee von Deep Learning +- Phase 1: Unüberwachtes Lernen der Feature-Hierarchie über den Bildern aller Kategorien (unüberwacht – da noch ohne Klassenlabels!) +- Phase 2: Überwachtes Fein-Tuning des Netzes – nun mit gelabelten Daten + +- erste Schicht: orientierte Kanten +- zweite Schicht: Objektteile +- Höhere Schichten: Ganze Objekte + +#### Deep Learning auf GPUs +- CPU: spezialisierte Kerne, für serielle Verarbeitung optimiert +- GPU: einfache Kerne, für parallele Verarbeitung optimiert +- Deep-Learning-Operationen sind meist einfache und leicht parallelisierbare Rechenoperationen (Add. und Mult.) +$\rightarrow$ Nutzung der GPU (z.B. Faltungen in CNN) +Beschleunigung des Lernens um Faktor 20-100 (statt 4 Wochen auf CPU $\rightarrow$ 1 Tag) + +#### “Challenges” beim Deep Learning +- Rolle der verwendeten Daten - gelernte Modelle können “biased” sein + - Beispiel: Gesichtserkenner von Microsoft, IBM, Face++ + - Männl. Gesichter (8,1 % Fehlerrate (FR)) besser erkannt als weibliche (20,6 % FR); Gesichter mit heller Hautfarbe besser erkannt (11,8 % FR) als Personen mit dunkler (19,2 % FR) $\rightarrow$ funktionierten am besten mit männl. Personen heller Haut + - Vermutung: Trainingsdatensatz bestand überproportional aus männlichen Gesichtern mit heller Hautfarbe +- Instabilität bei speziellen Rauschmustern - ”Adversarial Attacks” + - Adversarial Examples sind manipulierte Eingaben (Bilder, Sprache) mit der Fähigkeit, ein Deep Neural Network (DNN) zu täuschen, so dass das DNN die Eingabe falsch kategorisiert. + - Manipulation der Eingabe erfolgt meist durch spezielle Rauschmuster. + - Für den menschlichen Betrachter ist das Rauschen aber völlig irrelevant, hat keinen Einfluss auf die Erkennung. + +##### Adversial Attacks +Motivation: korrekt klassifizierte Bilder so verändern, dass das DNN das veränderte Bild einer falschen Klasse zuordnet, die Veränderung aber für einen Menschen nicht sichtbar ist. Böswilliger Einsatz: +- Täuschung sicherheitskritischer Systeme +- Google Bildersuche: Platzieren von eigenen Angeboten bei beliebten Suchbegriffen +- Manipulation von Assistenzsystemen beim Autonomen Fahren (z.B. Stoppschild als Vorfahrtsschild erkannt) + +# Neuronale Basisoperationen und Grundstrukturen +## Wichtige Neuronenmodelle +### Vorbild: Biologisches Neuron +Neuron: Erregungserzeugender, -leitender und –verarbeitender Grundbaustein des Nervensystems $\rightarrow$ elementarer cortikaler Prozessor. Kommunikation mittels elektr. Impulse (Aktionspotentiale, Spikes), die an Synapsen (Kontaktstellen zwischen zwei Neuronen) in Form chemischer Signale ( Neurotransmitter) weitergeleitet werden. +Wesentliche Informationen sind in +- der Spikerate (Dichte) +- dem Spikezeitpunkt (Phasenlage) +- der Effektivität der synaptischen Verbindung + +#### Struktur und Funktion der wesentlichen Neuronenabschnitte +| Neuronenabschnitte | Informationstechnische Funktion | +| ------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| 1. Synapsen | Gerichtete Informationsübertragung & -speicherung
(Adaptive Analogschalter; D/A-Wandlung der präsynaptischen Spikefolgen in analoge Membranpotentiale) | +| 2. Dendrit | Räumlich-zeitliche Integration & Weiterleitung
(Nichtlineare räumlich-zeitliche Überlagerung der lokalen dendritischen Membranpotentiale; Weiterleitung der lokalen Membranpotentiale (mit Verlusten, Verzögerungen und Laufzeiteffekten)) | +| 3. Soma | Globale räumlich-zeitliche Integration
(Integration aller dendritischen Potentiale zum Soma-Membranpotential) | +| 4. Axonhügel | Störsichere Umkodierung
(A/D-Wandlung des Somapotentials in Spikefolgen; Informationskodierung in Spikerate & Spikezeitpunkt) | +| 5. Axon | Informationsweiterleitung & -verteilung
(sichere, verlustfreie und energieoptimale Weiterleitung; aktive räuml.-zeitliche Umkodierung) | + +#### Das biologische Neuron aus informationstechnischer Sicht +Räumliche Kodierung (Position) $\rightarrow$ Kodierung von Qualitäten (Reizarten) + +Zeitliche Kodierung (Spikedichte, -phase) $\rightarrow$ Kodierung von Quantitäten (Reizintensität) und Synchronisation + +| Axonendigung | Synapse/Dendrit | Soma | Axonhügel/Axon | +| ------------------ | ------------------ | ------------------ | ------------------ | +| zeitkontinuierlich | zeitkontinuierlich | zeitkontinuierlich | zeitkontinuierlich | +| wertediskret | werteanalog | werteanalog | wertediskret | + +#### Abgeleitete Neuronenmodelle +- bislang zahlreiche Neuronenmodelle mit unterschiedlicher Biologietreue und Komplexität entwickelt +- wichtigste Vertreter mit abnehmendem Biologiebezug ↓ aber zunehmender Praxisrelevanz ↑ sind: + 1. Compartment Modell Neuronen (hier nicht weiter behandelt) + 2. Integrate & Fire Neuronen + 3. Dynamische Ratenneuronen (Leaky Integrator) + 4. Statische Ratenneuronen +- bei diesen Neuronenmodelle Vernachlässigung verschiedener biologisch relevanter Aspekte, wie z.B.: + - reale Geometrie des Neurons (mit seinen Verästelungen im Dendriten/Axon) + - Leitungsverzögerungen an den Synapsen und im Dendriten + - nichtlineare Wechselwirkungen zwischen den postsynaptischen Potentialen (PSP) + - der realen Form der präsynaptischen Aktionspotentiale $\rightarrow$ Annahme von Dirac-Impulsen ( δ(t)=1, wenn t = t spike ; δ(t)=0, wenn t ≠ t spike ) + - der realen zeitlichen Funktionalität des Neurons $\rightarrow$ wird komplett in die Synapse verlagert + +### Das Integrate & Fire (I&F) Neuron +- Kommunikation zwischen Neuronen erfolgt über Spikes (zeitkontinuierlich, wertediskret) +- Verarbeitung innerhalb des Neurons erfolgt analog auf Potentialniveau (zeitkontinuierlich, wertekontinuierlich) +- Spikekodierung stellt die Zeit als zusätzliche Kodierungsdimension für neuronale Wahrnehmungsprozesse zur Verfügung: + 1. zeitlicher Abstand von Ereignissen in Bezug zu anderen Ereignissen $\rightarrow$ Phasenlage + 2. Häufigkeit der Ereigniswiederholung $\rightarrow$ Frequenz + 3. Zeitverlauf der Änderung von Aktivitätsparametern $\rightarrow$ Frequenzänderung + +Zeitliche Synchronisation mit I&F-Neuronen +- Gehirn scheint zeitliche Synchronisationsprozesse von Einzelspikes oder Bursts (Spikepakete) als ein Attributierungsmittel zu nutzen +- „virtuelle“ Kopplung zusammengehöriger Neuronen durch zeitliche Phasensynchronisation ihrer Aktivitäten auch über große räumliche Entfernungen +- damit Kennzeichnung der Neuronen eines „Perzepts“ durch synchrones, korreliertes Feuern – Neuronen anderer „Perzepte“ feuern zu diesen unkorreliert $\rightarrow$ „Correlation Theory of Brain Function“ + +Technische Umsetzung von I&F-Neuronen +- präsynaptische Spikes erzeugen gewichtete postsynaptische Potentiale (PSP) +- PSPs werden zeitlich und räumlich integriert $\rightarrow$ Somapotential +- wenn Somapotential >= Schwelle $\rightarrow$ Generierung eines Spike (Aktionspotential) +- Afterhyperpolarisation (AHP) hemmt für bestimmte Zeit weiteres Feuern + +Typische Einsatzfelder von I&F-Neuronen +- in der Computational Neuroscience, wo sie zur systematischen Untersuchung von Gehirnfunktionen verwendet werden +- oft auch für mathematische Analysen von Gehirnfunktionen verwendet +- oft in Simulationen von Neuronalen Netzwerken eingesetzt, da sie durch ihre Einfachheit auch bei großen Netzen mit vielen Neuronen nur wenig Rechenzeit verbrauchen + +[comment]: <> (Vorlesung 4) +### Das formale dynamische Ratenneuron (Leaky Integrator) +- Ein- und Ausgänge werden interpretiert als zeitveränderliche mittlere Spikefrequenzen bzw. Spikeraten -> dynamisches Ratenneuron +- „Leaky Integrator“ steht für einen verlustbehafteten Integrator +- Approximation der Vorgänge an der Synapse (Gewichtsfunktion) als einfache Exponentialfunktion + +#### Aktivierungs- bzw Zustandsfunktion $z(t)$ +- zeitliche Summationseffekte werden vollständig in die Synapsen verlagert +- Annahme identischer Gewichtsfunktionen g(t) in allen Synapsen +- Somapotential (Aktivierung/Zustand) z(t) ergibt sich durch räumliche Summation aller lokalen PSPs $z_i(t)=\sum_{j=1}^1 w_{ij}(x_j(t)*g(t))$ +- Zeitverhalten des Neurons kann im einfachsten Fall beschrieben werden durch eine lineare DGL 1. Ordnung (ohne Herleitung hier): $\tau * z'_i(t)=-z_i(t) + \sum_{j=1}^1 w_{ij}x_j(t)$ + +#### Die Ausgabefunktion $y = f(z)$: +- dient der Umsetzung der internen Aktivierung zi(t) in eine mittlere Output-Spikefrequenz yi(t) +- erfolgt meist in einem nichtlinearen Zusammenhang, da Nachbildung + - einer unteren Schwelle erforderlich, die überschritten werden muss, um ein Neuron überhaupt zum Feuern zu veranlassen + - einer oberen Schwelle erforderlich, die eine maximale Spikefrequenz wegen der vorhandenen Refraktärzeiten modelliert +- Zusammenhänge werden durch nichtlineare Ausgabefunktionen, berücksichtigt, wie z.B. die Fermifunktion (-> Ausgabefunktionen) + +#### Typeische Einsatzfelder +- **Neuronale Oszillatoren** zur zeitlichen Synchronisation von Erkennungsvorgängen +- **Rekurrente Neuronale** Netze zur Speicherung und Erkennung zeitlicher Zusammenhänge + +### Das formale statische Ratenneuron +- Abgeleitet vom dynamischen Ratenmodell - vollständige Vernachlässigung der zeitlichen Funktionalität des Neurons, insbes. der dynamischen Übergangsvorgänge an den Synapsen +- formales statisches Neuron ist dynamisches Neuron im stationären Zustand, d.h. Vernachlässigung der zeitlichen Übergänge infolge Änderungen des Inputs +- Ein- und Ausgänge werden interpretiert als statische mittlere Spikefrequenzen bzw. Spikeraten -> Ratenneuron + $$z_i = \sum_{j=1}^n w_{ji}*x_j$$ +- Einsatz in vielen neuronalen Standardnetzen (z.B. Multilayer Perzeptron - MLP) +- Modell ist für eine biologienahe Modellierung allerdings zu grob + +#### Die Aktivierungs- bzw. Zustandsfunktion +Definition: Lineare oder nichtlineare Abbildungsvorschriften des Eingabevektors x über den Gewichtsvektor $w_i$ auf die Aktivierung $z-i$ des Neurons i + +##### Distanzbasierte Aktivierungen - lokal operierende Aktivierungsfunktionen +Vektornormen: + - Allgemeine p- bzw L-Norm von d: $||d||_p = (\sum_{j=1}^n |d_j|^p)^{\frac{1}{p}}$ + - Betragssummennorm bzw. Manhatten-Norm (L = p = 1): $||d||_1 = \sum_{j=1}^n |d_i|$ + - Euklidische Norm (L = p = 2): $||d||_2 = \sqrt{\sum_{j=1}^n |d_j|^2}$ + - Maximumnorm (L = p = $\infty$): $||d||_{\infty} = max |d_j|$ + +- Euklidische Distanz $z_i(w_i,x)=||x-w_i||$ +- Maximum Norm $z_i(w_i,x)=max|x_j - w_{ij}|$ +- Minimum Norm $z_i(w_i,x)=min|x_j - w_{ij}|$ +- Mahalanobis Distanz $z_i(x,w_i,C_i)= \sqrt{(x-w_i)^T * C_i^{-1} * (x-w_i)}$ mit $w_i=\frac{1}{N}\sum_{p=1}^N x^{(p)}$ und $C_i= \frac{1}{N}\sum_{p=1}^N (x^{(p)} - w_i)(x^{(p)}- w_i)^T$ + +**Mahalanobis Distanz** +- statistisch korrigierte Euklidische Distanz des Vektors x von einem Schätzmodell der Klasse (beschrieben durch w und C) +- w: Mittelwertvektor aller N zur Klasse gehörenden Inputvektoren x(p) der Lernstichprobe +- C: Kovarianzmatrix aller N zur Klasse gehörenden Inputvektoren x(p) der Lernstichprobe, (für mittelwertfreie Inputvektoren wird aus der Kovarianzmatrix die Korrelationsmatrix) + +**Zusammenfassung** Wichtige Aktivierungsfunktionen für Neuronale Netze +- Skalarprodukt $z(x,w)=\sum_{j=1}^n x_jw_j$ +- Euklidische Distanz $z(x,w)=\sum_{j=1}^n \sqrt{\sum_{j=1}^n |x_j - w_j|^2}$ +- Maximum Distanz $z(x,w)=max|x_j-w_j|$ +- Minimum Distanz $z(x,w)=min|x_j-w_j|$ +- Mahalanobis Distanz $(x,w)=\sqrt{(x-w)^T * C^{-1} * (x-w)}$ +- Manhatten Distanz $z(x,w)=\sum_{j=1}^n |x_j - w_j|$ + +#### Die Ausgabefunktion +Grundidee: Wie verhält sich die Ausgangsaktivität $y_i=f(x,w_i)$ (mittlere Spikerate) in Abhängigkeit von der internen Aktivierung $z_i$? + +1. Identitätsfunktion $y_i=z_i$ +2. Stufenfunktion $y_i = f(z_i) = \begin{cases} 0: z_i \leq T \\ 1: z_i > T \end{cases}$ +3. Sigmoid Funktionen (Squashing functions, S-shaped functions) + - Klasse nichtlinearer, kontinuierlicher, stetiger und stetig differenzierbarer Abbildungsfunktionen + - modellieren gut neurophysiologisch beobachtbare Sättigungseffekte + - erlauben parametrische Steuerung der Ausgabefunktion (Schwelle, Steilheit) + - Fermifunktion $y_i=f(z_i,c)= \frac{1}{1+e^{-c*z_i}}$ + - Gut durch maximale Spikerate des biologischen Neurons motiviert -> bis vor wenigen Jahren sehr verbreitet + - für $c > 0$ ist $f(z)$ im gesamten DB monoton wachsend + - Vorteil + + f(z) im gesamten Definitionsbereich $z \in (-\infty, \infty)$ stetig + + f(z) ist stetig differenzierbar + - Nachteil + - Gradienten werden im "Sättigungsbereich" extrem klein + - Ausgabefunktion ist nicht 0-zentriert -> bei nicht zentrierten Daten werden Gradienten der Eingabegewichte immer alle positiv oder alle negativ + - Berechnung der e-Funktion ist rechenaufwändig + - Hyperbol. Tangens $y_i=tanh(z_i)=\frac{e^{z_i}-e^{-z_i}}{e^{z_i}+e^{-z_i}}$ + - f(z) im gesamten DB monoton wachsend + - Vorteile + + f(z) im gesamten Definitionsbereich $z \in (-\infty, \infty)$ stetig + + f(z) ist stetig differenzierbar + + Funktion ist 0-zentriert + - Nachteil + - Gradienten werden im „Sättigungsbereich“ extrem klein + - Berechnung rechenaufwändig +4. Rectified Linear Unit (ReLU) $y_i = f(z_i) = max(0,z_i)$ + - Aktivierung z wird bei 0 gekappt + - Effektive Berechnung: $y_i = f(z_i) = 0,5*z_i + 0,5 * |z_i|$ + - Vorteil + + differenzierbar + + beschleunigt die Konvergenz des Gradientenabstiegs im Vergleich zu Fermi-Funktionen um den Faktor 6 -> wegen des linearen, nicht gesättigten Verlaufs + + lässt sich sehr leicht implementieren und schnell berechnen + - Nachteil + - Ausgabefunktion ist nicht 0-zentriert + - ReLU Neuronen können während des Trainings “sterben” infolge eines starken Gradientenflusses, der zu einem solchen Gewichtsupdate führt, dass das Neuron durch keinen Input mehr aktiviert werden kann -> Ausgabe für alle Inputs 0 -> Lernen nicht mehr! + 4.1 Leaky ReLU $y_i=f(z_i)=max(0,01z_i,z_i)$ + + Neuronen können nicht „sterben“ +5. Gaußfunkion $y_i=f(z_i)=e^{-\frac{z_i^2}{2\sigma ^2}}$ Ableitung: $/frac{dy_i}{dz_i}=-\frac{1}{\sigma ^2}* z_i * y_i$ +6. Radiale Basisfunktion (RBF) $y_i=f_i(x,w_i,\sigma_i)= exp(-\frac{||x-w_i||^2}{2\sigma_i^2})=exp(-\frac{z_i^2}{2\sigma_i^2})$ + - $\sigma_i$: Breite (Standardabweichung) der Gaußverteilung des Neurons + - $w_i^T$: Mittelwertvektor von i + - Jede einzelne Radiale Basis Funktion $f_i$ definiert ein sphärisches rezeptives Feld im Merkmalsraum $R^n$ + - $w_i$ zentriert das rezeptive Feld + - $\sigma_i^2$ lokalisiert das rezeptive Feld +7. Ellipsiodale Basisfunktion (EBF) $y_i=f_i(x,w_i,C_i)=exp(-\frac{1}{2}(x-w_i)^T * C_i^{-1} * (x-w_i))$ + - für beliebige Kovarianzmatrizen des Inputdatensatzes X + - basiert auf der Mahalanobis-Distanz $d_m^2(x, w_i, C_i)$ + +[comment]: <> (Vorlesung 5) +### Das formale statische Neuron als linearer Klassifikator +**Ziel**: +1. Suche nach einer Trenngeraden (Klassengrenze), die Punktemengen trennt +2. Automatische Klassifikation unbekannter Datenpaare durch Bestimmung ihrer Lage bezüglich der Klassengrenze + +**Vorraussetzung**: Trennung der Klassen durch Gerade möglich -> lineare Seprarierbarkeit + +**Bestimmung der Trenngeraden**: +1. Geometrische Bestimmung aus der Datenverteilung +2. Belehrung des Neurons mit kategorisierten Trainingsdaten -> Lernen + +**Implementierungstrick**: zur Verschiebung der Trenngeraden aus dem Ursprung -> Einführung einer variablen Schwelle, die durch ein Bias-Neuron realisiert wird + +**Begrifflichkeit**: +- für $R^2$ -> Trenngeraden +- für $R^3$ -> Trennebenen +- für $R^4$ -> Hyperebenen +- für $R^n$ -> (n-1)-dim. Hyperebenen + +## Wesentliche Neuronentypen und deren Einsatz +1. Statisches Ratenneuron (-> Adaline Netz) + - Skalaproduktaktivierung + - Lineare Ausgabe +2. Statisches Ratenneuron (-> binäres Hopfielnetz) + - Skalaproduktaktivierung + - Binäre Ausgabe +3. Statisches Ratenneuron (-> MLP-Netzwerk) + - Skalaproduktaktivierung + - Ausgabe: Sigmoidfunktion +4. Statisches Ratenneuron (-> RBF-Netzwerk) + - Distanz- /Normaktivierungsfunktion + - Ausgabe: Gaussfunktion +5. Statisches Ratenneuron mit Zeitfenster (-> TDNN-Netzwerk) + - Skalaproduktaktivierung + - Ausgabe: Sigmoidfunktion +6. Dynamisches Ratenneuron (-> Jordan Netz) + - Skalarproduktaktivierung + - Leaky Integrator (PT1 - Verhalten) + - Ausgabe: Sigmoidfunktion +7. Integrate-and-Fire (Spiking) Neuron + - Skalarproduktaktivierung + - Leaky Integrator (PT1 - Verhalten) + - Ausgabe: Delta-Impulse (Spikes) +8. ReLu Neuron (-> Deep Neural Networks) + - Skalarproduktaktivierung + - ReLU Ausgabe + +# Neuronale Netzwerkmodelle +**Aufgabe**: Verbinde die vorhandenen Neuronen in geeigneter Weise, um ein neuronales Netz zu erzeugen +## Typische Netzwerk-Topologien und Begriffe +- homogene oder strukturierte Netzwerke +- vollständige oder partiell-verkoppelte Netzwerke +- feed-forward oder rekurrente Netzwerke +- Netzwerke mit fester oder variabler Neuronenzahl + +Fan-In: mittlere Anzahl der auf ein Neuron konvergierenden Verbindungen\ +Fan-Out: mittlere Anzahl der von einem Neuron abgehenden (divergierenden) Verbind. + +## Homogene vs. Strukturierte Netze +| Homogene Netze | Strukturierte Netze | +| ------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------- | +| sehr formaler und gleichmäßiger Aufbau | erlauben Integration von strukturellem Wissen über spezifische lokale Verschaltungen und lokale räumliche Zusammenhänge (z.B. bei Bildinformationen) | +| reguläre Netzwerkstruktur | zeigen damit einen stark strukturierten Aufbau | +| als feed-forward oder als rekurrente Netze | Gibt es als feed-forward oder auch als rekurrente Netze | +| spezielles strukturelles Wissen über lokale Verschaltungen wird darin nicht berücksichtigt | | +| es gibt kaum biologische Entsprechungen | | + +## Vollständig vs partiell rekurrente Netze +| Vollständig rekurrente Netze | Partiell rekurrente Netze | +| :---------------------------------------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------: | +| jedes Neuron ist mit jedem anderen Neuron des Netzes verschaltet | ein Teil der Neuronen des Netzes koppelt Aktivität in das Netz zurück | +| Einsatz als Autoassoziativspeicher (siehe Kap. B-3) zur Speicherung von Mustern | typischerweise Einsatz zur Repräsentation und Verarbeitung zeitlicher Zusammenhänge in Datensequenzen (z.B. Signalverläufe, Videosequenzen) | +| erlaubt Wiedererkennung (Rekonstruktion) verrauschter oder unvollständiger Eingangsmuster | Einsatz von dynamischen Neuronen als Kontextneuronen | +| | Beispiele: Jordan/Elman Netzwerk | + +## Netze mit fester oder variabler Neuronenzahl +| Feste Neuronenzahl | Variable Neuronenzahl | +| :----------------------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------: | +| Netztopologie (Anzahl Schichten, Neuronen, Verbindungen) vorab definiert | Netztopologie (Anzahl Neuronen und Verbindungen) vorab unbekannt | +| sehr formaler Aufbau mit typischer Schichtabfolge | Netzwerk erhöht oder reduziert die Anzahl der Neuronen und Verbindungen in Abhängigkeit von datenabhängigen internen Repräsentationsfehlern | +| als feed-forward oder als rekurrente Netze | meist als als feed-forward Netze | + +## Das Multi-Layer Perzeptron (MLP) als typisches vollständig verschaltetes Feed-forward Netz + +siehe Bild + +## Convolutional Neural Network (CNN) als typisches strukturiertes Netz +- Neuronen sind so angeordnet, dass sie auf überlappende Bereiche reagieren -> realisieren Faltungen (Convolutions) +- Jede Schicht eines Volumens basiert auf gelernten Faltungskernen -> bildet sogenannte Feature Maps +- Häufig Verwendung von Subsampling-Layern (Pooling (Bündelung)), die die Dimension des Outputs reduzieren und Invarianzleistungen realisieren + +Was sind Faltungsoperationen zwischen den Schichten? +- Neuronen sind lokal verschaltet und teilen sich Gewichte + - reagieren auf überlappende Bereiche des Inputs + - kann als diskrete Faltung interpretiert werden + - Faltung ersetzt Skalarproduktaktivierung +- bilden State-of-the-Art für viele Herausforderungen im Umgang mit Bildern, dafür: + - Erweiterung auf dreidimensionale Datenstrukturen (Farbkanal, Höhe, Breite eines Bildes) + -> lokaler Zusammenhang im Bild bleibt erhalten + +### 1. Faltungs-Schichten +- Neuronen des Volumens (l) sind lokal begrenzt mit dem Vorgängervolumen (l-1) verschaltet +- Skalarproduktaktivierung -> Summe der Faltungsergebnisse über Volumen (l-1) +- Gewichte zwischen Neuronen der Feature-Map -> in Volumen (l) sind geteilt (shared) +- -> identische Verknüpfung für alle Neuronen in einer Feature-Map p +$$z^{l}(p,u,v)= \sum_{k=0}^{m^{l-1}} \sum_{i=0}{d_1-1} \sum_{j=0}^{d_2-1} o^{l-1} (k,u + i,v + j) * w^{(l)} (p,k,i,j)$$ +$$Z^{(l)}(p)= \sum_{k=0}{m^{l-1}} O^{l-1}(k)** W^l(p,k)$$ +"Teilbild I * Filter W" + + +Beispiel für Berechnung einer kompletten Output-Feature-Map +- in CNN: Summation einzelner Faltungsergebnisse +- zusätzlich: gemeinsames Bias-Gewicht 􀡮 für alle Elemente der gleichen Output-Feature-Map und lineare Ausgabe + +**Padding**: Erweitern der Input-Feature-Maps um p Randpixel (z.B. Nullen) + +### 2. Pooling-Schicht +- dient der Bündelung von mehreren semantisch ähnlichen Features zur: + - Verbesserung der Robustheit der gelernten Repräsentationen (Invarianzen) + - Reduzierung des Rechenaufwandes in den anschließenden Schichten +- Output-Volume wird sequentiell über die Ausgaben der einzelnen Feature-Maps bestimmt +- Ausgabe $O_p$ der p-ten Output-Feature-Map: $O^l_p = downsample(O_p^{l-1}, g_l)$ -> Reduktion erfolgt ohne zu lernende Parameter + +Arten Pooling-Schichten +- Max-Pooling: Bestimmung des Maximums pro Pooling-Bereich +- Average-Pooling: Bestimmung der Mittelwerte des Pooling-Bereiches + +- **Stride**: Größe der vertikalen bzw. horizontalen Verschiebung während Bündelung +- **Padding**: Erweitern des Input-Feature-Maps um p Randpixel (z.B. Nullen) + + +# Lernparadigmen und deren klassische Vertreter +## Unsupervised Learning +[comment]: <> (Vorlesung 6) +Wesen: +- Lernen ohne externe Überwachung, d.h. kein expliziter Lehrer +- Lernen erfolgt rein datengetrieben in Abhängigkeit von der Statistik der Inputdaten in der Lernstichprobe +- Beim Lernen wird der kontinuierliche Eingaberaum in eine endliche Anzahl von Zuständigkeitsgebieten (-> Voronoi-Regionen) unterteilt / geclustert. +- Dies erfolgt nicht uniform sondern in Abhängigkeit von der Wahrscheinlichkeitsdichteverteilung (WDV) der Inputdaten +$\rightarrow$ Vektorquantisierung des Eingaberaums + +Ziel des Lernens: fehlerminimale Quantisierung des kontinuierlichen Eingaberaums mittels geeignet platzierter Referenzvektoren $w_r$ in eine endliche Anzahl von diskreten Zuständigkeitsgebieten + +### Vektorquantisierung bzw. Voronoizerlegung +- Anzahl der über den Inputdaten zu positionierenden Referenzvektoren +- dichtere Platzierung in Gebieten mit hoher Inputdichte -> statistischer Lernprozess +- Verbindungslinien zwischen benachbarten Referenzvektoren -> Delaunay-Triangulation +- Regionengrenzen werden durch die Mittelsenkrechten auf diesen Verbindungslinien gebildet -> Voronoi-Tesselation +- Jedes Voronoi-Gebiet bildet eine konvexe Zuständigkeitsregion (abgeschlossen oder unbeschränkt) für den betreffenden Referenzvektor + +#### Optimale Vektorquantisierung +Im $\R^2$ erlaubt nur ein hexagonales Raster fehlerminimale Quantisierung! Suche nach den optimal platzierten Referenzvektoren $w_r$ mit ihren zugehörigen Voronoi-Regionen, die eine Quantisierung des Eingaberaumes mit minimalem Quantisierungsfehler E ermöglichen +$E = \frac{1}{N} \sum_{p=1}^{N} || x-w_{r} ||$ mit r als zuständiges Neuron + +Ermittlung der Lage der Referenzvektoren und der zugehörigen Voronoi-Regionen über unüberwachte Lernprozesse in Neuronalen Netzwerken und mit statistischen Algorithmen. + +#### Typische Vertreter +- Self-Organizing Feature Maps (SOFM) bzw. Kohonen-Maps +– Neural Gas +– Growing Neural Gas (U) +– Learning Vector Quantization (U) +– k-Means-Algorithmus + +### Topografische Merkmalskarten – wichtige Organisationsstrukturen des Gehirns +- Wesentliche Cortexregionen (visuell, auditorisch, somatosensorisch, sensomotorisch) zeigen topografische, d.h. nachbarschaftserhaltende Organisationsprinzipien, z.B. + - Abbildung benachbarter Rezeptoren auf der Retina -> auf benachbarte Neuronen im primären visuellen Cortex + - Abbildung benachbarter Rezeptoren auf der Basilarmembran des Innenohres -> auf benachbarte Neuronen im auditorischen Cortex + - Abbildung benachbarter Rezeptoren auf der Hautoberfläche auf benachbarte Neuronen im somatosensorischen Cortex +- Wesen: räumlich benachbarte Rezeptoren sind mit räumlich benachbarten Neuronen im Cortex verbunden +- Grundprinzip topologischer Abbildungen: Umsetzung von Signalähnlichkeiten im Eingaberaum in Lagenachbarschaften der Neuronen des Ausgaberaumes + +#### Die somatosensorische Projektion – Beispiel einer topologieerhaltende Abbildungen +- Darstellung der Somatotopie im somatosensorischen Cortex SI. +- eingezeichnete Symbole und Beschriftung sollen die räumliche Zuordnung zwischen Körperoberfläche und Cortex verdeutlichen, wie sie mit lokaler elektrischer Hirnreizung bei wachen Patienten ermittelt wurde. +- Das Grundprinzip einer topolgieerhaltenden Abbildung, die Nachbarschaftserhaltung, wird deutlich: Lagenachbarschaften auf der Körperoberfläche werden auf räumliche Nachbarschaften in den zuständigen cortikalen Bereichen abgebildet. + +#### Vorteile nachbarschaftserhaltender Abbildungen +- Lagenachbarschaft ist ein Optimalitätsprinzip der Informationsverarbeitung + - erzeugt den geringsten Kommunikationsaufwand + - garantiert geringste Signallaufzeiten + - damit ist räumliche Kooperation zwischen benachbarten Neuronen möglich -> Robustheit, kollektives, verteiltes „Rechnen“ +- Optimale Ressourcenverteilung bei der Abbildung vom Ein- in den Ausgaberaum +- Ermöglichen bei begrenzten neuronalen Ressourcen eine optimale Quantisierung des Eingabesignalraumes (-> Voronoi-Parzellierung) +- Zuordnung der Voronoi-Regionen erfolgt durch unüberwachte, d.h rein datengetriebene Lernprozesse, die die Wahrscheinlichkeitsdichteverteilung der Inputdaten berücksichtigen. + +### Self-Organizing Feature Maps (SOFM) +Ziel: Selbstorganisation einer topologieerhaltenden Abbildung des n-dimensionalen Eingangsraumes $R^n$ auf eine m-dimensionale neuronale Kohonenkarte $R^m$ mit einer vorgegebenen Gitterstruktur + +#### Der Kohonen-Lernalgorithmus +- Bereitstellung des Trainingsdatensatzes $X = (x^{1}, x^p, ..., x^N)$ +- Festlegung der Netztopologie und der Dimensionalität des Kohenengitters zur Abbildung $R^n \rightarrow R^m$, bestimmt Art der Gewichtsmatrix $W= (w_{rs})$ zwischen Eingangsraum und Kohonenkarte + - a Empfänger-Sender-Schreibweise + - r - Positionsvektor des Neurons in der Kohonenkarte (response) + - s - Positionsvektor des Inputs im Eingangsraum (stimulus) + - b Probleme durch Dimensionsreduktion  Topologiedefekte infolge falsch dimensionierter Kohonengitter (siehe später) +- Festlegung der Präsentationsart der Trainingsdaten (zufällig/ zyklisch) +- Bei Bedarf geeignete Neuzusammenstellung des Trainingsdatensatzes (Reihenfolge, Häufigkeit) +- Festlegung der maximalen Anzahl von Lernzyklen tzyk (bei vollständigen X-Präsentationen) bzw. von Lernschritten $t_{max} =N * t_{zyk}$ +- Festlegung der Lernparameter und Abbruchkriterien + +Ablauf: +1. Gewichtsinitialisierung der $w_rs$: + - ohne a-priori-Wissen über Problem und Eingangsraum meist zufällige Anfangswerte, z.B. $w_{rs}\in [-0.1,+0.1]$ + - mit a-priori-Wissen definierte Anfangswerte (siehe späteres Beispiel TSP) +2. Stimulusauswahl: + - Auswahl eines Inputvektors $x^p$ aus dem Inputdatensatz X +3. Response + - Bestimmung des Best-maching Neurons r´ mit der geringsten euklidischen Distanz zwischen $w_{r´}$ und $x^p$ + $||w_{r'}-x^p|| = min||w_r-x^p||$ + - Festlegung des B-M-Neuron r´ als Zentrum einer lokalen Lernumgebung $h_{rr´}$, beschrieben durch eine geeignete Nachbarschaftsfunktion, z.B. $h_{rr'}=h_0 exp(\frac{||r-r'||^2}{2\sigma^2(t)})$ +4. Stimulusgetriebene Adaption der Gewichte des B-M-Neurons und der Neuronen aus seiner lokalen Nachbarschaft: $w_r(t+1)=w_r(t)+\eta(t) * h_{rr'}(t)(x^p -w_r(t))$ +5. Zeitliche Veränderung der Lernrate $\eta(t)$ und des Nachbarschaftsradius $\sigma(t)$ der Nachbarschaftsfunktion $h_{rr´}(t)$. + Zwei Varianten gebräuchlich: + - konstante Lernrate $\eta(t)=konst.$ + - Verringerung der Lernrate (über Abkühlungsprozess) + rekursives Verfahren sinnvoll: $\sigma(t)=\sigma(t-1)*\alpha$ mit $\alpha=(\frac{\sigma_E}{\sigma_A})^{\frac{1}{t_max}}$ +6. Datensatz X vollständig präsentiert? Nein: next p($p=p+1$ oder $p=rand(N)$) => 2. +7. Abbruchkriterium $t\geq t_{max}$ erfüllt? Nein: next p ($p=1$ oder $p=rand(N)$) => 2. +8. Ende + +Geometrisch interpretiert ist eine 1-D Kohonenkarte zum Ring geschlossen. +Die Neuronen des Kohonengitters sind auf einer 2D-Karte angeordnet. Sie sind mit ihren lokalen Nachbarschaften auch über Kartengrenzen hinweg voll vernetzt, indem die Verbindungen an den Enden umschlagen. Dadurch ergibt sich die Topologie eines Torus. + +##### Visualisierung des SO-Prozesses +- Gewichtungen $w_{rs}$ jedes Neurons (Referenzvektoren) werden als Punkte im Inputraum $R^n$ interpretiert +- unmittelbar im Kohonen-Gitter benachbarte Neuronen können ihre Referenzvektoren im Inputraum durch eine Gerade verbinden +- Abbildungsprobleme bei Dimensionsreduktion $R^n \rightarrow R^m$ mit $m (Vorlesung 7) +##### Einsatzgebiete topologieerhaltender SOFM +Lösung von Optimierungsproblemen – das Traveling Salesman Problem (TSP) + - Gesucht: kürzeste geschlossene Tour durch M vorgegebene Städte + - bei M Städten – durch Permutation (Anordnung der Städte innerhalb der Tour unter Beachtung der Reihenfolge) -> maximal M! verschiedene Touren + - da + - a jede Stadt Ausgangspunkt einer Tour sein kann und + - b jede Tour in zwei verschiedenen Richtungen zurückgelegt werden kann + ergeben sich 2*M Touren mit gleicher Weglänge + - $(M-1)/2$ verschiedene geschlossene Routen + - Rechenaufwand: steigt mit der Fakultät der Problemgröße (Anzahl der Städte) -> wächst damit noch viel stärker als exponentieller Rechenaufwand (für n>6), z.B. + - bei 10 Städten: 181 440 Touren + - bei 20 Städten: 6,08 1016 Touren (selbst auf einer 1 GFLOPS Maschine ca. 35 Tage) + - bei 30 Städten: 4,4 1030 Touren (auf einer 1 GFLOPS Maschine ca. 4000 Mrd. Jahre) (Core i7, 3.4 GHz, 4 Kerne ca. 100 GFLOPS) + - Fazit: TSP ist ein NP-vollständiges Problem, da es exponentiell wachsenden Rechenaufwand hat, für eine Beispiellösung aber schnell, d.h. mit polynomialem Rechenaufwand verifiziert werden kann + - Lösungsansatz mit SOFM: + - Suche nach kürzester Route durch selbstorganisierende Platzierung der Referenzvektoren einer zu einem Ring verschalteten 1D-Neuronenkette im 2D-Inputraum + - Städte fungieren als Inputdaten, die die Verteilung der Voronoi-Regionen sowie der zugehörigen Referenzvektoren bestimmen + - Grundprinzip und Ablauf: + - Jedes Neuron mit 2 Gewichten -> Ortskoordinaten in der Ebene + - Initialisierung der Gewichtsvektoren mit definierten Anfangswerten (Kreisring) mit Anzahl der Neuronen + $$w_{rx}=0,35*cos(\frac{2\pi r}{N})+0,5$$ + $$w_{ry}=0,35*cos(\frac{2\pi r}{N})+0,5$$ + - pro Lernschritt zufällige Auswahl einer Stadt als Input + - Selektion des B-M-Neurons -> Gewichtsadaption für B-M-Neurons & Nachbarn + +Visualisierung semantischer Beziehungen – die semanto-topografische Abbildung + - Grundidee: Nachbildung kognitiver Fähigkeiten durch Erzeugung von neuronalen Karten, die auch semantische Beziehungen zwischen Objektbegriffen widerspiegeln können + - Beispiel: + - Erlernen von Ähnlichkeitsbeziehungen zwischen Tierarten + - Eingabekodierung: Beschreibung der Tierarten über charakteristische Merkmale mittels einer Merkmalsmatrix + - Probleme der SOFM + - Kriterium: Optimalität der Verteilung der Gewichtsvektoren im Eingangssignalraum + Quantisierungsfehler: $E=\frac{1}{N}\sum_{p=1}{N}||x-w_{r'}||$ + - Nachteile des Algorithmus + 1. Lernphase erfordert zunächst erhebliche Zahl von Lernschritten zur Entfaltung des Kohonengitters – Herausbildung einer topologischen Grundordnung des Netzwerkes (-> Zeitaufwand, Kosten) + 2. Topologische Struktur des Kohonengitters muss der topologischen Struktur der zu repräsentierenden „Untermannigfaltigkeit“ des Eingabesignalraumes entsprechen + -> erfordert a priori Informationen (nicht immer vorhanden) über Verteilung der Eingabesignale, z.B. in Häufungsgebieten + -> Struktur des Eingabesignalsraumes kann topologisch derart kompliziert sein, dass Netzdesign praktisch unmöglich ist + - Repräsentationsprobleme bei inhomogen strukturierter Untermannigfaltigkeit des Inputraumes (Verknüpfung von voneinander separierten Unterräumen verschiedener Dimensionalität) + - tritt auf, wenn Topologie des Kohonennetzes von der Topologie der Datenpunktmannigfaltigkeit abweicht -> erzeugt suboptimale Verteilung der Referenzvektoren + - wegen Gitterorganisation des Kohonennetzes ist Positionierung im Raum zwischen den Teilmannigfaltigkeiten möglich -> damit ungenutzte Kodierungsressourcen + - Abbildung weit vom Optimum entfernt, da unvollständige Verwendung des verfügbaren Satzes von Referenzvektoren + +### Das "Neural Gas" Lernparadigma +Unterschiede zum Kohonen-Lernalgorithmus: +- anstatt Verwendung der Nachbarschaftsrelationen der Gewichtsvektoren im externen Kohonengitter – Verwendung der Nachbarschaftsrelationen der Gewichtsvektoren im Eingangssignalraum zur Adjustierung der $w_i$ +- anstatt Verwendung der Distanz des Gewichtsvektors $w_i$ zum Input $x^p$–Bestimmung des „Distanzranges“ des Gewichtsvektors $w_i$ unter Berücksichtigung aller anderen Gewichtsvektoren $w_j$ +Grundprinzip: +- ausschließliche Berücksichtigung von Nachbarschaftsrelationen im Eingangssignalraum -> „gasähnliche“ Dynamik der Gewichtsvektoren (ohne Verankerung in einem festen Gitter) +- Bestimmung einer Distanz- oder Nachbarschaftsrangfolge +- Adjustierung des dem Input ähnlichsten Gewichtsvektors $w_{i0}$ sowie der in der Distanzrangfolge nächsten Gewichtsvektoren -> ergibt eine wesentlich effizientere Quantisierung des Eingabesignalraumes +- Wertung: ermöglicht Generierung einer perfekt topologieerhaltenden Gewichtsverteilung zur Vektorquantisierung des Eingangssignalraumes + +#### "Neural Gas" Lernalgorithmus +1. Initialisierung der Gewichtsvektoren $w_i(i = 1, ..., m)$ +2. Stimulusauswahl: Auswahl eines Inputvektors $x^p$ aus X +3. Response: + Bestimmung der Distanz- oder Nachbarschaftsrangfolge aller m Gewichtsvektoren wi bezüglich des aktuellen $x^p$ + \rightarrow $k_i(x^p, W)$ – Distanzrang von $w_i$ bezüglich $x^p$ ($k_i = 0$ für $w_i^0; k_i = 1$ für $w_i^1$) + \rightarrow jedes $k_i(x^p, W)$ hängt neben $x^p$ von allen anderen aktuellen Referenzvektoren $w_i$ ab -> während des Lernens damit ständige Umordnung der Rangfolge (auch bei gleichen Inputs) +4. Adaption der Referenzvektoren + $$\delta w_i = \eta(t)* h_{\lambda}*(x^p - w_i)$$ +5. Datensatz X vollständig präsentiert? Nein: next $p(p=p+1$ oder p=rand(N)) => 2. +6. Abbruchkriterium $t\geq t_{max\$ erfüllt? Nein: next $p(p=1$ oder p=rand(N)) => 2. +7. Ende + +##### Quantisierung komplexer Inputräume mit NG +Wesen: Lernvorgang zeigt eine gasähnliche Dynamik, d.h. ein Verhalten wie das von Molekülen im Schwerefeld der Untermannigfaltigkeiten mit untereinander abstoßender Kraftwirkung + +Vorteil: gridfreie Netzwerkstruktur und topologische Struktur der Untermannigfaltigkeit passen optimal zusammen -> ergibt eine optimale Verteilung der Referenzvektoren, kein Referenzvektor bleibt ungenutzt + +#### Vergleich zwischen SOFM- und Neural Gas Lernverfahren + +| Kriterien | SOFM | Neural Gas | +| :----------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------: | :-----------------------------------------------------------------------------------------------: | +| Definition der Nachbarschaften | innerhalb des vordefinierten Neuronengitters (n-dim.) | innerhalb des Eingaberaumes | +| Einschränkungen | Dimensionalität des Grids | Keine | +| Probleme bei der Dimensionsreduktion | möglich, recht häufig | prinzipiell keine | +| Wertung | adaptiver Vektorquantisierer, der eine Abbildung von Inputähnlichkeiten auf das Neuronengitter (n-dim.) erzeugt (-> Visualisierung) | perfekter adaptiver Vektorquantisierer, der direkt im Eingaberaum arbeitet (ohne eine Projektion) | + +### Der k-Means Algorithmus als klassischer VQ +Ziel: den Datensatz so in k Partitionen zu teilen, dass die Summe der quadrierten Abweichungen von den Cluster-Schwerpunkten minimal ist. Mathematisch entspricht dies der Optimierung der Funktion $J = \sum_{i=1}^k \sum_{x\in S} || x_j - \mu_i ||^2$ +- Diese Zielfunktion basiert auf der Methode der kleinsten Quadrate, man spricht auch von Clustering durch Varianzminimierung, da die Summe der Varianzen der Cluster minimiert wird. +- Da zudem die quadrierte Euklidische Distanz ist, ordnet k-Means effektiv jeden Datenpunkt dem nächstgelegenen (nach Euklidischer Distanz) Clusterschwerpunkt zu. +- Da die Suche nach der optimalen Lösung schwer ist (NP-schwer), wird im Normalfall ein approximativer Algorithmus verwendet. +- Der am häufigsten verwendete approximative k-Means-Algorithmus ist der Lloyd-Algorithmus, der oft als "der" k-means Algorithmus bezeichnet wird, obwohl Lloyd diesen Namen nicht verwendet hat. +- Lloyd’s Algorithmus besteht aus drei Schritten: + 1. Initialisierung: Wähle k zufällige Mittelwerte (Means) $m_1,..., m_k$ aus dem Datensatz. + 2. Zuordnung: Jedes Datenobjekt $x_j$ wird demjenigen Cluster $S_j$ zugeordnet, bei dem die Cluster-Varianz am wenigsten erhöht wird. + $S_i^{(t)}= {x_j: ||x_j -m_i^{(t)}||^2 \leq ||x_j - m_{i*}^{(t)}||^2 }$ für alle $i*=1,...,k$ + 3. Aktualisierung: Berechne die Mittelpunkte der Cluster neu: + - Die Schritte 2-3 werden dabei so lange wiederholt, bis sich die Zuordnungen nicht mehr ändern. + + +## Reinforcement Learning +[comment]: <> (Vorlesung 8) +### Einordnung und Wesen +- Überbegriff für eine Reihe von Methoden des Maschinellen Lernens, bei denen ein Agent den Nutzen von Aktionsabfolgen in einer Welt bestimmt +- dient dem völlig selbständigen Erlernen komplexer Wahrnehmungs-Handlungs-Zusammenhänge auf Basis einer Handlungsbewertung nur durch ein unspezifisches Leistungsbewertungssignal (Belohnung/Bestrafung) +- zwischen überwachtem und unüberwachtem (datengetrieben) Lernen +- Unterschied zum Supervised Learning: Leistungsbewertungssignal ist nicht instruktiv (spezifisch mit konkreten Hinweisen zur Verbesserung der Abbildung), sondern ausschließlich evaluativ (bewertend) + +$\rightarrow$ „Learning with critic instead of learning with teacher.“ + +Haupteinsatzgebiete: Robotik, optimale Steuerungen, Spielsteuerungen, .... + +### Grundidee +- Entscheidungsmodul (Agent) muss wiederholt Aktionen auswählen, um ein System in gewünschter Weise zu beeinflussen und in einen Zielzustand zu überführen. +- Bei jeder Entscheidung erhält der Agent eine direkte Belohnung / Bestrafung (Reinforcement), wobei sich die erhaltenen Belohnungen über die Zeit akkumulieren. +- Reinforcement Lernen (RL) beschäftigt sich mit dem Problem, durch Lernen solche Entscheidungsstrategien zu finden, die bezüglich dieser akkumulierten Reinforcements optimal sind. +- Ziel ist es, nur mittels lokal optimaler Entscheidungen eine global optimale Strategie zu erhalten. + +### Wo steckt das Wissen im RL-Agenten ? +- In so genannten State-Action Values (Q-Werten), die kodieren, welches long-term Return R erhalten werden kann, wenn man in einem bestimmten State s j eine bestimme Aktion a i ausführt +- Einfachste Form: Tabelle Q( s , a ) +- Fragen und Probleme: + 1. Woher bekommt man die Q-Werte? -> Lernverfahren + 2. Exponentielles Wachstum der Tabellengröße mit der Anzahl der Dimensionen d des State Spaces + +## Q-Learning – der bekannteste RL Algorithmus +On-line Lernverfahren nach [Watkins and Dayan, 1992], das auf einer inkrementellen Verbesserung der Schätzung Q(s,a) mittels “stochastischer Approximation” basiert + + +## Supervised Learning +### Kurzcharakteristik +- Lernverfahren, bei dem gelabelte Daten-Samples $X = {(x_1 , y_1 ), (x_2 ,y_2 ), ...,(x_n , y_n )}$ bzw. $X = {(x_1 , t_1 ), (x_2 ,t_2 ), ...,(x_n , t_n )}$ zur Approximation einer unbekannten, Daten generierenden Funktion genutzt werden. +- Das Labeln der Trainingsdaten erfolgt durch Lehrer meist offline. +- Soll eine unbekannte Funktion approximiert werden, deren Funktionsoutput y nur diskrete Klassen/Kategorien besitzt, dann müssen die Daten-Samples diskret gelabelt werden mit t. -> Klassifikation / Kategorisierung +- Soll eine unbekannte, Daten generierende Funktion approximiert werden, deren Funktionsoutput y kontinuierlich (reell) ist, dann müssen die Daten Samples auch reellwertig gelabelt werden mit t -> Funktionsapproximation / Regression + +### Erlernen von Abbildungen – Das Konzept der Assoziativspeicher +- Wesen: Erlernen von Abbildungen zwischen zu assoziierenden Musterpaaren (x, t) aus der Lernstichprobe +- Wesen: $t=x(Vorr. m=n)$ +- Zweck: Ausgabe des korrekten, ungestörten Inputs (Outputs) x bei Präsentation eines gestörten oder unvollständigen Inputs X* +- Einsatz: Mustervervollständigung, Rauschunterdrückung, Feature Learning in Deep Neural Nets +- Einfachstes Lernverfahren: Hebb‘sches Lernen (Steinbuch‘sche Lernmatrix + +### Der Error-Backpropagation Algorithmus +- Erlaubt eine Verallgemeinerung der auf einschichtige Netze beschränkten Delta-Lernregel auf mehrschichtige Netze mit beliebiger Anzahl von Schichten. +- Problem: Ein direktes Fehlersignal zwischen Teach-Vektor und Output-Vektor des Netzes existiert nur für die Output-Schicht. +- Für alle Hidden-Schichten muss das Fehlersignal von der Output-Schicht zurückpropagiert und rückwirkend aufakkumuliert werden (daher der Name Error-Backpropagation) -> fungiert dann als „internes Fehlersignal“ +- Fehlerakkumulation erfolgt gewichtet mit den vorhandenen „alten“ Gewichten der betreffenden Verbindung. +- erlaubt damit eine rekursive Berechnung der notwendigen Gewichtsänderungen vom Output zum Input. +- Implementierung: damit stets 2 Sätze von Gewichtsparametern erforderlich: + - Satz „alter Gewichte“ zum Generieren der aktuellen, internen Netzaktivität und zum Zurückpropagieren der Fehlersignale + - Satz „neuer Gewichte“, die die Gewichte nach dem Lernschritt kodieren; kommen erst im nächsten Zyklus zum Einsatz, dann wieder als „alte Gewichte“ + +## Verallgemeinerte Delta-Lernregel +### der Error Backpropagation Algorithmus +1. Betrachtung für die Ausgabeschicht L (entspricht Betrachtung nach Delta-Regel) +2. Betrachtung für zwei beliebige Schichten l und l-1 + -> erlaubt rekursive Berechnung für l-schichtige Netze vom Ausgang auf den Eingang + +### Fazit +- verallgemeinerte Delta-Lernregel lässt sich auf beliebige Anzahl von Schichten erweitern +- Fehlerterme berechnen sich rekursiv aus der gewichteten Summe der Delta-Fehler der nachfolgenden Schicht l, multipliziert mit der Ableitung der Ausgabefunktion der aktuellen Schicht l-1 -> ist gut vektorisierbar +- Die zwei prinzipiellen Trainingsmodi können auch hier unterschieden werden: + - Direct Learning: berechnete Gewichtsänderung wird sofort nach der Verarbeitung des Trainingsmusterpaares ausgeführt + - Batch Learning: berechnete Gewichtsänderung wird über alle Musterpaare des Trainingssets akkumuliert und erst nach Verarbeitung aller Musterpaare ausgeführt + +## Ausgabekodierung bei der Klassifikation +- Häufig verwendet: Bei Klassifikationsproblemen Umwandlung der reelwertigen Netzausgaben in eine binäre Ausgabe durch einfache Bestimmung des Maximums zur Markierung der am stärksten aktivierten (und damit erkannten) Klasse/Kategorie +- Häufig benötigt: Klassenzugehörigkeiten, die nicht nur die einzelne Ausgabe (Klasse) sondern auch alle anderen Ausgaben (Klassen) mit berücksichtigen +-> Softmax Ausgabe + +### Softmax Ausgabe +- Spezielle Ausgabefunktion der ganzen Ausgabeschicht statt der bisherigen Ausgabefunktion pro Einzelneuron +- ermöglicht die Schätzung von Klassenzugehörigkeiten +- dazu Abbildung (“Quetschen”) eines N-dimensionalen Vektors von beliebigen reelwertigen Ausgabeaktivitäten auf einen N-dimensionalen Vektor von positiv reelwertigen Ausgaben im Bereich (0, 1), die sich alle zu 1 addieren. + +# Moderne Verfahren für große Datensets + +## Deep Neural Networks + +## Anwendungsbeispiele + + +[comment]: <> (Vorlesung 9) +[comment]: <> (Vorlesung 10) +[comment]: <> (Vorlesung 11) +[comment]: <> (Vorlesung 12) \ No newline at end of file diff --git a/README.md b/README.md index 1aacfc3..b43c4a9 100644 --- a/README.md +++ b/README.md @@ -3,7 +3,7 @@ Mitschriften und selbst angefertigte Unterlagen und Hilfen zu Informatik Vorlesu > Kein Mensch kann Wissen besitzen. Wissen ist frei und muss weitergegeben werden -- Advanced Operating Systems +- [Advanced Operating Systems](Advanced%20Operating%20Systems.md) - [Übung](Advanced%20Operating%20Systems%20-%20Übung.pdf) - [Cheatsheet](Advanced%20Operating%20Systems%20-%20Cheatsheet.pdf) - Quellen/frei nach: [Dr. Peter Amthor](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-praktische-informatik/fachgebiet-verteilte-systeme-und-betriebssysteme/team/peter-amthor) @@ -14,31 +14,33 @@ Mitschriften und selbst angefertigte Unterlagen und Hilfen zu Informatik Vorlesu - [Mind Map](Automaten,%20Sprachen%20und%20Komplexität%20-%20MindMap.pdf) - [Prüfungsvorbereitung](Automaten,%20Sprachen%20und%20Komplexität%20-%20Prüfungsvorbereitung.pdf) - Quellen/frei nach: [Dietrich Kuske](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-theoretische-informatik/fachgebiet-automaten-und-logik/team/prof-d-kuske) -- Betriebssysteme +- [Betriebssysteme](Betriebssysteme.md) - [Flashcards/Karteikarten](Betriebssysteme%20-%20Flashcards.pdf) - [Cheatsheet](Betriebssysteme%20-%20Cheatsheet.pdf) - [Fragenkatalog](Betriebssysteme%20-%20Fragen.md) - Quellen/frei nach: [Dr. Peter Amthor](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-praktische-informatik/fachgebiet-verteilte-systeme-und-betriebssysteme/team/peter-amthor), [Dr. Hans-Albrecht Schindler](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-praktische-informatik/fachgebiet-verteilte-systeme-und-betriebssysteme/team) - [Bildverarbeitung in der Medizin 1](Bildverarbeitung%20in%20der%20Medizin%201.md) - Quellen/frei nach: [Dr.-Ing. Marko Helbig ](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-biomedizinische-technik-und-informatik/bmti/fachgebiete/biosignalverarbeitung/dr-ing-marko-helbig) -- Computergrafik +- [Computergrafik](Computergrafik.md) - [Cheatsheet](Computergrafik%20-%20Cheatsheet.pdf) - Quellen/frei nach: [Prof. Beat Brüderlin, Dr. U. Döring und Tristan Nauber](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-praktische-informatik/fachgebiet-graphische-datenverarbeitung/team) -- Content Verwertungsmodelle +- [Content Verwertungsmodelle](Content%20Verwertungsmodelle.md) - [Cheatsheet](Content%20Verwertungsmodelle%20-%20Cheatsheet.pdf) - Quellen/frei nach: [Prof. Jürgen Nuetzel](http://www.juergen-nuetzel.de/thatsme.html) -- Datenbanksysteme +- [Datenbank Implementierungstechniken](Datenbank%20Implementierungstechniken.md) (nicht vollständig) + - Quellen/frei nach: [Prof. Dr.-Ing. habil. Kai-Uwe Sattler](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-praktische-informatik/fachgebiet-datenbanken-und-informationssysteme/team/kai-uwe-sattler) +- [Datenbanksysteme](Datenbanksysteme.md) - [Fragenkatalog](Datenbanksysteme%20-%20Fragen.md) - [Cheatsheet](Datenbanksysteme%20-%20Cheatsheet.pdf) - Quellen/frei nach: [Prof. Dr.-Ing. habil. Kai-Uwe Sattler](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-praktische-informatik/fachgebiet-datenbanken-und-informationssysteme/team/kai-uwe-sattler) - [Einführung in die Medizinische Informatik](Einführung%20in%20die%20Medizinische%20Informatik.md) - Quellen/frei nach: [Dr.-Ing. Marko Helbig](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-biomedizinische-technik-und-informatik/bmti/fachgebiete/biosignalverarbeitung/dr-ing-marko-helbig) -- Einführung in die Neurowissenschaften +- [Einführung in die Neurowissenschaften](Einführung%20in%20die%20Neurowissenschaften.md) - [Fragenkatalog](Einführung%20in%20die%20Neurowissenschaften%20-%20Fragenkatalog.pdf) - [Kurzüberblick](Einführung%20in%20die%20Neurowissenschaften%20-%20short.pdf) - [Cheatsheet](Einführung%20in%20die%20Neurowissenschaften%20-%20Cheatsheet.pdf) - Quellen/frei nach: [Prof. Dr.-Ing. habil. Jens Haueisen ](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-biomedizinische-technik-und-informatik/bmti/fachgebiete/biomedizinische-technik/institutsleiter-und-fachgebietsleiter-biomedizinische-technik), [M.Sc. Hannes Oppermann](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-biomedizinische-technik-und-informatik/bmti/fachgebiete/biomedizinische-technik/msc-hannes-oppermann-promotionsstudent/zur-person) -- Grundlagen der Biosignalverarbeitung +- [Grundlagen der Biosignalverarbeitung](Grundlagen%20der%20Biosignalverarbeitung.md) - [Cheatsheet](Grundlagen%20der%20Biosignalverarbeitung.pdf) - [Prüfungsvorbereitung](Grundlagen%20der%20Biosignalverarbeitung%20-%20Prüfungsvorbereitung.pdf) - Quellen/frei nach: [Prof. Dr.-Ing. habil. Peter Husar, Dr.-Ing. Marko Helbig, M.Sc. Marc-Patrick Heppner](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-biomedizinische-technik-und-informatik/bmti/fachgebiete/biosignalverarbeitung) @@ -47,13 +49,13 @@ Mitschriften und selbst angefertigte Unterlagen und Hilfen zu Informatik Vorlesu - [Short Paper](Grundlagen%20und%20Diskrete%20Strukturen%20-%20short.pdf) - [Übungsklausur](Grundlagen%20und%20diskrete%20Strukturen%20-%20Prüfungsvorbereitung.pdf) - Quellen/frei nach: [Prof. Dr. Matthias Kriesell](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-mathematik-und-naturwissenschaften/profil/institute-und-fachgebiete/institut-fuer-mathematik/profil/fachgebiet-diskrete-mathematik-und-algebra/team) -- Kryptographie +- [Kryptographie](Kryptographie.md) - [Übung](Kryptographie%20-%20Übung.pdf) - [Cheatsheet](Kryptographie.pdf) - [Prüfungsvorbereitung](Kryptographie%20-%20Prüfungsvorbereitung.pdf) - [Karteikarten](Kryptographie%20-%20Flashcards.pdf) - Quellen/frei nach: [Univ.-Prof. Dr. Martin Dietzfelbinger](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-theoretische-informatik/fachgebiet-komplexitaetstheorie-und-effiziente-algorithmen/team/prof-m-dietzfelbinger) -- Logik und Logikprogrammierung +- [Logik und Logikprogrammierung](Logik%20und%20Logikprogrammierung.md) - [Cheatsheet](Logik%20und%20Logikprogrammierung%20-%20Cheatsheet.pdf) - [Flashcards - Karteikarten für Definitionen](Logik%20und%20Logikprogrammierung%20-%20Flashcards.pdf) - [Prüfungsvorbereitung](Logik%20und%20Logikprogrammierung%20-%20Prüfungsvorbereitung.pdf) @@ -61,8 +63,10 @@ Mitschriften und selbst angefertigte Unterlagen und Hilfen zu Informatik Vorlesu - [Network Security](Network%20Security.md) - [Cheatsheet](Network%20Security%20-%20Cheatsheet.pdf) - Quellen/frei nach: [Prof. Dr.-Ing. Günter Schäfer](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-praktische-informatik/fachgebiet-telematik/rechnernetze/mitarbeiter/prof-guenter-schaefer) -- Neurobiologische Informationsverarbeitung (Mitschrift nicht verfügbar) -- Neuroinformatik (Mitschrift nicht verfügbar) +- [Neurobiologische Informationsverarbeitung](Neurobiologische%20Informationsverarbeitung.md) + - Quellen/frei nach: +- [Neuroinformatik](Neuroinformatik.md) (letzte 2 Kapitel fehlen) + - Quellen/frei nach: [Prof. Dr.-Ing. Horst-Michael Groß ](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-technische-informatik-und-ingenieurinformatik/fachgebiet-neuroinformatik-und-kognitive-robotik/team/mitarbeiter/prof-dr-horst-michael-gross), [Dr.-Ing. Klaus Debes](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-technische-informatik-und-ingenieurinformatik/fachgebiet-neuroinformatik-und-kognitive-robotik/team/mitarbeiter/dr-ing-klaus-debes) - Praktika - [Neuroinformatik](Praktikum%20Neuroinformatik.pdf) - [Labor BMT - Deep Learning](Praktikum%20BMT%20-%20Deep%20Learning%20in%20der%20Biomedizintechnik.pdf) @@ -70,33 +74,33 @@ Mitschriften und selbst angefertigte Unterlagen und Hilfen zu Informatik Vorlesu - [Rechnerarchitekturen 1](Praktikum%20Rechnerarchitekturen%201.pdf) - [Rechnerarchitekturen 2](Praktikum%20Rechnerarchitekturen%202.pdf) - [Schaltsysteme](Praktikum%20Schaltsysteme.pdf) -- Programmierparadigmen +- [Programmierparadigmen](Programmierparadigmen.md) - [Cheatsheet](Programmierparadigmen.pdf) - Quellen/frei nach: [Prof. Dr.-Ing. Günter Schäfer](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-praktische-informatik/fachgebiet-telematik/rechnernetze/mitarbeiter/prof-guenter-schaefer) -- Rechnerarchitekturen 1 (Mitschrift nicht verfügbar) +- [Rechnerarchitekturen 1](Rechnerarchitekturen%201.md) - Quellen/frei nach: [Dr.-Ing. Prof. h. c. Karsten Henke](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-technische-informatik-und-ingenieurinformatik/fachgebiet-integrierte-kommunikationssysteme/team/karsten-henke) -- Rechnerarchitekturen 2 (Mitschrift nicht verfügbar) +- [Rechnerarchitekturen 2](Rechnerarchitekturen%202.md) - Quellen/frei nach: [Dr.-Ing. Prof. h. c. Karsten Henke](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-technische-informatik-und-ingenieurinformatik/fachgebiet-integrierte-kommunikationssysteme/team/karsten-henke) -- Schaltsysteme (Mitschrift nicht verfügbar) +- [Schaltsysteme](Schaltsysteme.md) - Quellen/frei nach: [Dr.-Ing. Prof. h. c. Karsten Henke](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-technische-informatik-und-ingenieurinformatik/fachgebiet-integrierte-kommunikationssysteme/team/karsten-henke) - [Softwareprojekt 2021](Softwareprojekt%202021.md) -- Softwaretechnik 1 +- Softwaretechnik 1 (Mitschrift temporär nicht verfügbar) - [Zusammenfassung](Softwaretechnik%20-%20Cheatsheet.pdf) - [Seminar](Softwaretechnik%20-%20Seminar.pdf) - [Beispiel Flowchart](Softwaretechnik%20Flowchart.tex) - Quellen/frei nach: [Prof. Dr.-Ing. habil. Armin Zimmermann](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-technische-informatik-und-ingenieurinformatik/sse/team/prof-armin-zimmermann), [Dr.-Ing. Ralph Maschotta](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-technische-informatik-und-ingenieurinformatik/sse/team/dr-ralph-maschotta) -- Softwaretechnik 2 +- Softwaretechnik 2 (Mitschrift temporär nicht verfügbar) - [Softwaretechnik 2 Cheatsheet](Softwaretechnik%202%20-%20Cheatsheet.pdf) - Quellen/frei nach: [Prof. Dr.-Ing. habil. Armin Zimmermann](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-technische-informatik-und-ingenieurinformatik/sse/team/prof-armin-zimmermann), [Dr.-Ing. Ralph Maschotta](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-technische-informatik-und-ingenieurinformatik/sse/team/dr-ralph-maschotta) - [Stochastik](Stochastik.md) - [Cheatsheet](Stochastik%20-%20Cheatsheet.pdf) - [Übungsklausur](Stochastik%20-%20Übungsklausur.pdf) - Quellen/frei nach: [Prof. Dr. Thomas Hotz](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-mathematik-und-naturwissenschaften/profil/institute-und-fachgebiete/institut-fuer-mathematik/profil/fachgebiet-wahrscheinlichkeitsrechnung-und-mathematische-statistik/team), [Johannes Christof](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-mathematik-und-naturwissenschaften/profil/institute-und-fachgebiete/institut-fuer-mathematik/profil/lehrgruppe-mathematik/team) -- Systemsicherheit +- [Systemsicherheit](Systemsicherheit.md) - [Cheatsheet](Systemsicherheit%20-%20Cheatsheet.pdf) - [Fragen](Systemsicherheit%20-%20Questions.pdf) - Quellen/frei nach: [Dr. Peter Amthor](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-praktische-informatik/fachgebiet-verteilte-systeme-und-betriebssysteme/team/peter-amthor) -- Telematik 1 +- [Telematik 1](Telematik%201.md) - [Cheatsheet](Telematik%201-%20Cheatsheet.pdf) - Quellen/frei nach: [Prof. Dr.-Ing. Günter Schäfer](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-praktische-informatik/fachgebiet-telematik/rechnernetze/mitarbeiter/prof-guenter-schaefer), [M.Sc. Martin Backhaus](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-praktische-informatik/fachgebiet-telematik/rechnernetze/mitarbeiter/m-sc-martin-backhaus) @@ -134,7 +138,7 @@ Eine kleine Beschreibung für Leute die noch nie auf Github zusammengearbeitet h - Erstelle ein `pull request` damit deine Änderungen in dieses Repository übernommen werden können. Dies kannst du über dein Github Dashboard machen. ## Bild- und Textrechte -Der Inhalt aller vorhandenen Dokumente beruht auf den Mitschriften besuchter Vorlesungen. Bilder werden von uns selbst erstellt, unter ausführlicher Quellangabe oder unter dem Vorlesungstitel verwendet. Es werden keine Bücher kopiert oder anderweitig Copyright verletzt, wir arbeiten mit bestem Wissen und Gewissen; ob der Professor abgeschrieben hat können wir nicht vorhersehen. +Der Inhalt aller vorhandenen Dokumente beruht auf den Mitschriften besuchter Vorlesungen. Bilder werden von uns selbst erstellt, unter ausführlicher Quellangabe oder unter dem Vorlesungstitel verwendet. Es werden keine Bücher kopiert oder anderweitig Copyright verletzt, wir arbeiten mit bestem Wissen und Gewissen; ob der Professor abgeschrieben hat können wir nicht vorhersehen. Die Verletzung des Copyright oder anderer Rechte Dritter wird mit einem Ausschluss aus dem Repository gehandhabt. Sollte Ihnen ein Verstoß auffallen, geben Sie uns bitte umgehend Bescheid, wir werden jedem Fall nachgehen. *Update*: auf Nachfrage eines Professors werden neben dem Fachnamen/Bezeichnung die jeweils tätigen Professoren und Quellen nachgetragen. Im ersten Schritt wurden alle Dozenten zu Ihrem Fach ausgewiesen. Demnächst folgend sind alle weiteren Quellen aus denen Informationen zusammengetragen wurden um diese Vorlesungsunterlagen zu erstellen. Wir bitten um etwas Geduld, bis dieser Prozess abgeschlossen ist. diff --git a/Telematik 1.md b/Telematik 1.md new file mode 100644 index 0000000..8522e71 --- /dev/null +++ b/Telematik 1.md @@ -0,0 +1,3566 @@ +--- +title: Telematik 1 +date: Sommersemester 2020 +author: Felix Husslein, Robert Jeutter +--- + +- [Kapitel 1: Kurze Übersicht](#kapitel-1-kurze-übersicht) + - [Unterschiede zwischen Telefon und Internet](#unterschiede-zwischen-telefon-und-internet) + - [Verbindungsarten:](#verbindungsarten) + - [Phyische Verbindungen (Arten)](#phyische-verbindungen-arten) + - [Größere Netzwerke](#größere-netzwerke) + - [Multiplexing](#multiplexing) +- [Kapitel 2: Architektur](#kapitel-2-architektur) + - [Verbindungsorientiert vs. Verbindungslos](#verbindungsorientiert-vs-verbindungslos) + - [Protokolle](#protokolle) + - [Protokollspezikiationen:](#protokollspezikiationen) + - [Layering: Vor- und Nachteile](#layering-vor--und-nachteile) + - [ISO/OSI Referenzmodell](#isoosi-referenzmodell) + - [Kritik am ISO/OSI Modell](#kritik-am-isoosi-modell) + - [Architekturvoraussetzungen für das Internet](#architekturvoraussetzungen-für-das-internet) + - [Grundlagen der Internetarchitektur](#grundlagen-der-internetarchitektur) + - [TCP/IP Referenzmodell](#tcpip-referenzmodell) + - [Kritik am TCP/IP Modell](#kritik-am-tcpip-modell) + - [ISO/OSI vs TCP/IP](#isoosi-vs-tcpip) + - [Standardisierung](#standardisierung) + - [ISO Standardisierverfahren](#iso-standardisierverfahren) + - [Zusammenfassung Kapitel 2](#zusammenfassung-kapitel-2) +- [Kapitel 3: Physikalisches Layer](#kapitel-3-physikalisches-layer) + - [Synchronisation](#synchronisation) + - [Vereinfachtes Konzept:](#vereinfachtes-konzept) + - [Breitband- vs. Basisbandübertragung](#breitband--vs-basisbandübertragung) + - [Breitbandübertragung](#breitbandübertragung) + - [Digitales vs. Analoges Signal](#digitales-vs-analoges-signal) + - [Zusammenfassung Kapitel 3](#zusammenfassung-kapitel-3) +- [Kapitel 4: Data Link Layer](#kapitel-4-data-link-layer) + - [Services des Link Layers](#services-des-link-layers) + - [Einfache Linklayerfunktionen (Übersicht)](#einfache-linklayerfunktionen-übersicht) + - [Framing](#framing) + - [Fehlerkontrolle](#fehlerkontrolle) + - [Verbindungsaufbau](#verbindungsaufbau) + - [Flusskontrolle](#flusskontrolle) + - [Framing](#framing-1) + - [Framing durch Zählen der Charakter](#framing-durch-zählen-der-charakter) + - [Framing durch Flagbitmuster/Bitstuffing](#framing-durch-flagbitmusterbitstuffing) + - [Framing durch Codeverletzungen](#framing-durch-codeverletzungen) + - [Fehlerkontrolle - Redundanz](#fehlerkontrolle---redundanz) + - [Parität](#parität) + - [Checksummen](#checksummen) + - [Hammingdistanz](#hammingdistanz) + - [Frame Mengen - Code Books, Code](#frame-mengen---code-books-code) + - [Cyclic Redundancy Check - CRC](#cyclic-redundancy-check---crc) + - [Rückwärtsfehlerkontrolle](#rückwärtsfehlerkontrolle) + - [Send and Wait](#send-and-wait) + - [Alternating Bit Protokoll](#alternating-bit-protokoll) + - [ARQ - Sliding Windows](#arq---sliding-windows) + - [Übertragungsfehler und Empfangsfenstergröße](#übertragungsfehler-und-empfangsfenstergröße) + - [Go-Back-N](#go-back-n) + - [Selective Reject / Selective Repeat](#selective-reject--selective-repeat) + - [Duplexoperation und Piggybacking](#duplexoperation-und-piggybacking) + - [Leistungsverhalten:](#leistungsverhalten) + - [Folgerung Kapitel 4](#folgerung-kapitel-4) +- [Kapitel 5: Medium Access Control (MAC)](#kapitel-5-medium-access-control-mac) + - [Einführung: Multiple Access Link und Protokolle](#einführung-multiple-access-link-und-protokolle) + - [Multiple Access Protokoll](#multiple-access-protokoll) + - [Broadcastkanal mit Rate R b/s](#broadcastkanal-mit-rate-r-bs) + - [Statisches Multiplexing](#statisches-multiplexing) + - [Berstender Verkehr (Burst)](#berstender-verkehr-burst) + - [Statisches multiplexing berstenden Verkehrs - Verzögerung](#statisches-multiplexing-berstenden-verkehrs---verzögerung) + - [Dynamische Kanalzuweisung](#dynamische-kanalzuweisung) + - [Annahmen für die dynmaische Kanalzuweisung](#annahmen-für-die-dynmaische-kanalzuweisung) + - [Zahlen von Merit](#zahlen-von-merit) + - [Durchsatz und angebotene Last](#durchsatz-und-angebotene-last) + - [Grundlegende Optionen für MAC](#grundlegende-optionen-für-mac) + - [Kollisionsbehaftete Protokolle](#kollisionsbehaftete-protokolle) + - [Carrier Sensing](#carrier-sensing) + - [CSMA und die Ausbreitungsverzögerung](#csma-und-die-ausbreitungsverzögerung) + - [Collision Detetion - CSMA/CD](#collision-detetion---csmacd) + - [Wahl einer zufälligen Wartezeit](#wahl-einer-zufälligen-wartezeit) + - [Adaption von k an die Last](#adaption-von-k-an-die-last) + - [Binary exponential Backoff](#binary-exponential-backoff) + - [Wettbewerbsfreie Protokolle](#wettbewerbsfreie-protokolle) + - [Polling und Tokenweitergabe](#polling-und-tokenweitergabe) + - [Bit-Map-Protokoll](#bit-map-protokoll) + - [Limited Contention Protokolle](#limited-contention-protokolle) + - [Fallstudie Ethernet](#fallstudie-ethernet) + - [Topologien](#topologien) + - [Unzuverlässiger, verbindungsloser Dienst](#unzuverlässiger-verbindungsloser-dienst) + - [Physisches Layer](#physisches-layer) + - [Ethernet verwendet CSMA/CD](#ethernet-verwendet-csmacd) + - [Ethernet - CSMA-CD Algorithmus](#ethernet---csma-cd-algorithmus) + - [Effizienz](#effizienz) + - [Hubs](#hubs) + - [Switch](#switch) + - [Geschwindigkeiten der Ethernetversionen](#geschwindigkeiten-der-ethernetversionen) + - [Zusammenfassung Kapitel 5](#zusammenfassung-kapitel-5) +- [Kapitel 6 Internetworking](#kapitel-6-internetworking) + - [LAN Verbindungen](#lan-verbindungen) + - [Gründe für mehrere LANs](#gründe-für-mehrere-lans) + - [Möglichkeiten des Überwindens der Begrenzungen](#möglichkeiten-des-überwindens-der-begrenzungen) + - [Physical Layer Verbindungen](#physical-layer-verbindungen) + - [Repeater](#repeater) + - [Hub](#hub) + - [Data Link Layer](#data-link-layer) + - [Switch](#switch-1) + - [Pfaderkennung - Selbstlernen](#pfaderkennung---selbstlernen) + - [Weiterleiten](#weiterleiten) + - [Bridges](#bridges) + - [Rückwärtslernen in Bridges - Bootstrapping](#rückwärtslernen-in-bridges---bootstrapping) + - [Lösung 1: Einschränken des Flutens](#lösung-1-einschränken-des-flutens) + - [Lösung 2: Spanning Trees](#lösung-2-spanning-trees) + - [Higher-Layer Verbindungen](#higher-layer-verbindungen) + - [Router](#router) + - [Gateways](#gateways) + - [Weitere Probleme mit LAN/LAN Verbindungen](#weitere-probleme-mit-lanlan-verbindungen) + - [Zusammenfassung Kapitel 6](#zusammenfassung-kapitel-6) +- [Kapitel 7: Netzwerklayer](#kapitel-7-netzwerklayer) + - [Bauen großer Netzwerke](#bauen-großer-netzwerke) + - [Netzwerklayerfunktionen](#netzwerklayerfunktionen) + - [Weiterleitung](#weiterleitung) + - [Durchsuchen der Routingtabelle](#durchsuchen-der-routingtabelle) + - [Zusammenspiel zwischen Routing und Weiterleitung](#zusammenspiel-zwischen-routing-und-weiterleitung) + - [Verbindungsaufbau](#verbindungsaufbau-1) + - [Netzwerkservicemodell](#netzwerkservicemodell) + - [Virtuelle Schaltkreisbasierte vs. Datagrammorientierte Netzwerke](#virtuelle-schaltkreisbasierte-vs-datagrammorientierte-netzwerke) + - [Verbindungslose und Verbindungsbasierende Dienste auf dem Netzwerklayer](#verbindungslose-und-verbindungsbasierende-dienste-auf-dem-netzwerklayer) + - [Virtuelle Schaltkreise](#virtuelle-schaltkreise) + - [Implementierung virtueller Schaltkreise](#implementierung-virtueller-schaltkreise) + - [Weiterleitungstabellen](#weiterleitungstabellen) + - [VC Signalprotokolle](#vc-signalprotokolle) + - [Datagrammnetzwerke](#datagrammnetzwerke) + - [Longest Prefix Matching](#longest-prefix-matching) + - [Datagramm vs. VC-Netzwerk](#datagramm-vs-vc-netzwerk) + - [Wie ist ein Router eigentlich aufgebaut?](#wie-ist-ein-router-eigentlich-aufgebaut) + - [Eingangsportfunktionen](#eingangsportfunktionen) + - [Switching Fabric](#switching-fabric) + - [Ausgangsports](#ausgangsports) + - [Ausgangsportwarteschlangen](#ausgangsportwarteschlangen) + - [Eingangsportwarteschlangen](#eingangsportwarteschlangen) + - [IP - Datagrammformat und Paketverarbeitung](#ip---datagrammformat-und-paketverarbeitung) + - [IP Paketformat](#ip-paketformat) + - [IP Fragmentierung und Reassemblierung](#ip-fragmentierung-und-reassemblierung) + - [IP Adressierung](#ip-adressierung) + - [Scheitern von einfachen Adressierungsmethoden](#scheitern-von-einfachen-adressierungsmethoden) + - [Adressierung und hierarchisches Routing](#adressierung-und-hierarchisches-routing) + - [Nähe](#nähe) + - [internetnamen und Adressen](#internetnamen-und-adressen) + - [Klassen von IP-Adressen](#klassen-von-ip-adressen) + - [IP-Adressierung](#ip-adressierung-1) + - [Subnets](#subnets) + - [IP Adressen](#ip-adressen) + - [CIDR: Classless Inter Domain Routing](#cidr-classless-inter-domain-routing) + - [Wie bekommt man eigentlich eine IP-Adresse?](#wie-bekommt-man-eigentlich-eine-ip-adresse) + - [Wie kommt das Netzwerk eigentlich an seinen Subnetpart von IP-Adressen?](#wie-kommt-das-netzwerk-eigentlich-an-seinen-subnetpart-von-ip-adressen) + - [IP Adressierung: Allokation von Adressen](#ip-adressierung-allokation-von-adressen) + - [NAT - Network Address Translation](#nat---network-address-translation) + - [Schließen der letzten Lücke: ARP](#schließen-der-letzten-lücke-arp) + - [ARP Protokoll im gleichen LAN](#arp-protokoll-im-gleichen-lan) + - [Routing in ein anderes LAN](#routing-in-ein-anderes-lan) + - [ICMP und IPv6](#icmp-und-ipv6) + - [ICMP: Internet Control Message Protocol](#icmp-internet-control-message-protocol) + - [Traceroute und ICMP](#traceroute-und-icmp) + - [IPv6](#ipv6) + - [IPv6 Header](#ipv6-header) + - [Weitere Veränderungen zu IPv4](#weitere-veränderungen-zu-ipv4) + - [Übergang von IPv4 zu IPv6](#übergang-von-ipv4-zu-ipv6) + - [Routing Algorithmen](#routing-algorithmen) + - [Überblick über Routingalgorithmen](#überblick-über-routingalgorithmen) + - [Fluten](#fluten) + - [Mögliche Anwendungsfelder fürs Fluten](#mögliche-anwendungsfelder-fürs-fluten) + - [Zufallsrouting](#zufallsrouting) + - [Adaptive Routingalgorithmen](#adaptive-routingalgorithmen) + - [Zentralisiertes adaptives Routing](#zentralisiertes-adaptives-routing) + - [Isoliertes adaptives Routing](#isoliertes-adaptives-routing) + - [Rückwärtslernen](#rückwärtslernen) + - [Verteiltes adaptives Routing](#verteiltes-adaptives-routing) + - [Klassifikation von Algorithmen für dezentralisiertes adaptives Routing](#klassifikation-von-algorithmen-für-dezentralisiertes-adaptives-routing) + - [Distanzvektorrouting Algorithmen](#distanzvektorrouting-algorithmen) + - [Distanzvektorrouting - Übersicht](#distanzvektorrouting---übersicht) + - [Distanzvektoralgorithmus - Quelltext](#distanzvektoralgorithmus---quelltext) + - [Distanzvektor: Reaktion auf Veränderung der Linkkosten](#distanzvektor-reaktion-auf-veränderung-der-linkkosten) + - [Poisoned Reverse](#poisoned-reverse) + - [Link State Routing](#link-state-routing) + - [Dijkstrasalgorithmus zur Berechnung kürzester Pfade](#dijkstrasalgorithmus-zur-berechnung-kürzester-pfade) + - [Weiterführende Diskussion zu Dijkstras Algorithmus](#weiterführende-diskussion-zu-dijkstras-algorithmus) + - [Link State Routing mit Dijkstras Algorithmus](#link-state-routing-mit-dijkstras-algorithmus) + - [Vergleich zwischen Link-State und Distanzvektoralgorithmen](#vergleich-zwischen-link-state-und-distanzvektoralgorithmen) + - [Hierarchisches Routing](#hierarchisches-routing) + - [Autonome Systeme](#autonome-systeme) + - [Routing im Internet](#routing-im-internet) + - [Verschiedenes Intra-AS und Inter-AS Routing, aber warum?](#verschiedenes-intra-as-und-inter-as-routing-aber-warum) + - [Verbundene autonome Systeme](#verbundene-autonome-systeme) + - [Inter-AS Aufgaben](#inter-as-aufgaben) + - [Beispiel: Setzen der Weiterleitungstabelle in Router 1d](#beispiel-setzen-der-weiterleitungstabelle-in-router-1d) + - [Beispiel: Wählen aus mehreren ASen](#beispiel-wählen-aus-mehreren-asen) + - [Routing im Internet](#routing-im-internet-1) + - [Intra-AS Routing (IGP)](#intra-as-routing-igp) + - [RIP - Routing Information Protokoll](#rip---routing-information-protokoll) + - [RIP - Advertisements](#rip---advertisements) + - [RIP - Linkausfall und Linkrecovery](#rip---linkausfall-und-linkrecovery) + - [RIP - Tabellenverarbeitung](#rip---tabellenverarbeitung) + - [OSPF - Open Shortest Path First](#ospf---open-shortest-path-first) + - [Weiterführende Funktionen](#weiterführende-funktionen) + - [Hierarchisches OSPF](#hierarchisches-ospf) + - [BGP - Border Gateway Protokoll](#bgp---border-gateway-protokoll) + - [BGP - Grundlagen](#bgp---grundlagen) + - [Verteilung von Erreichbarkeitsinformationen](#verteilung-von-erreichbarkeitsinformationen) + - [Pfadattribute und BGP Routen](#pfadattribute-und-bgp-routen) + - [BGP Routenwahl](#bgp-routenwahl) + - [BGP Nachrichten](#bgp-nachrichten) + - [Zusammenfassung Kapitel 7](#zusammenfassung-kapitel-7) +- [Kapitel 8: Transport Layer](#kapitel-8-transport-layer) + - [Transportlayerdienste und Protokolle](#transportlayerdienste-und-protokolle) + - [Transport vs. Netzwerklayer](#transport-vs-netzwerklayer) + - [Transportlayerprotokolle im Internet](#transportlayerprotokolle-im-internet) + - [Adressierung und Multiplexing](#adressierung-und-multiplexing) + - [Multiplexing und Demultiplexing](#multiplexing-und-demultiplexing) + - [Wie funktioniert Demultiplexing?](#wie-funktioniert-demultiplexing) + - [Verbindungsloses Demultiplexing](#verbindungsloses-demultiplexing) + - [Verbindungsorierntiertes Demultiplexing](#verbindungsorierntiertes-demultiplexing) + - [Multithreaded-Webserver](#multithreaded-webserver) + - [Verbindungskontrolle](#verbindungskontrolle) + - [Aufbau der Transportverbindung](#aufbau-der-transportverbindung) + - [Datentransferdienst](#datentransferdienst) + - [Verbindungsabbau](#verbindungsabbau) + - [Probleme während des Verbindungsaufbaus](#probleme-während-des-verbindungsaufbaus) + - [Drei Wege Handshake](#drei-wege-handshake) + - [Verbindungsablehnung](#verbindungsablehnung) + - [Verbindungsabbbau](#verbindungsabbbau) + - [Verbindungsabbau in der Realität](#verbindungsabbau-in-der-realität) + - [Flusskontrolle](#flusskontrolle-1) + - [Motivation: Kontrolle von Überlastsituationen](#motivation-kontrolle-von-überlastsituationen) + - [Flaschenhälse auf der Empfängerseite](#flaschenhälse-auf-der-empfängerseite) + - [Flusskontrolle](#flusskontrolle-2) + - [Flusskontrolle - Pufferallokation](#flusskontrolle---pufferallokation) + - [Flusskontrolle durch Continue und Stop](#flusskontrolle-durch-continue-und-stop) + - [Implizite Flusskontrolle](#implizite-flusskontrolle) + - [Kreditbasierte Flusskontrolle](#kreditbasierte-flusskontrolle) + - [Flusskontrolle - Permits und Acknowledgements](#flusskontrolle---permits-und-acknowledgements) + - [Staukontrolle](#staukontrolle) + - [Warum benötigt man Staukontrolle?](#warum-benötigt-man-staukontrolle) + - [Gründe für Stau](#gründe-für-stau) + - [Zusammenfassung](#zusammenfassung) + - [Adaptiere die Senderate an die Netzwerkkapazität](#adaptiere-die-senderate-an-die-netzwerkkapazität) + - [Wünschenswerte Eigenschaften von Staukontrolle](#wünschenswerte-eigenschaften-von-staukontrolle) + - [Designoptionen für Staukontrollmechanismen](#designoptionen-für-staukontrollmechanismen) + - [Mögliche Aktionen](#mögliche-aktionen) + - [Mögliche Aktionen - Taxonomie](#mögliche-aktionen---taxonomie) + - [Routeraktionen - Verwerfen von Paketen](#routeraktionen---verwerfen-von-paketen) + - [Verwerfen von Paketen - Implizites Feedback](#verwerfen-von-paketen---implizites-feedback) + - [Vermeiden von vollen Warteschlangen - Proaktive Aktionen](#vermeiden-von-vollen-warteschlangen---proaktive-aktionen) + - [Choke Pakete](#choke-pakete) + - [Warnungsbits](#warnungsbits) + - [Random Early Detection](#random-early-detection) + - [Was passiert aber, wenn Feedback empfangen wurde?](#was-passiert-aber-wenn-feedback-empfangen-wurde) + - [Transportprotokolle im Internet](#transportprotokolle-im-internet) + - [UDP - User Datagram Protocol](#udp---user-datagram-protocol) + - [UDP Checksummen](#udp-checksummen) + - [TCP - Transmission Control Protocol](#tcp---transmission-control-protocol) + - [TCP - Sequenznummern und ACKs](#tcp---sequenznummern-und-acks) + - [TCP Round Trip Time und Timeouts](#tcp-round-trip-time-und-timeouts) + - [TCP Verbindungsaufbau](#tcp-verbindungsaufbau) + - [Verbindungsidentifikation bei TCP](#verbindungsidentifikation-bei-tcp) + - [TCP Verbindungsmanagement](#tcp-verbindungsmanagement) + - [TCP Verbindung in drei Phasen](#tcp-verbindung-in-drei-phasen) + - [Zuverlässiger Datentransfer in TCP](#zuverlässiger-datentransfer-in-tcp) + - [TCP Senderevents](#tcp-senderevents) + - [TCP Sender (vereinfacht)](#tcp-sender-vereinfacht) + - [TCP ACK Generierung](#tcp-ack-generierung) + - [Schnelle Neuübertragung](#schnelle-neuübertragung) + - [Algorithmus](#algorithmus) + - [TCP Fluss- und Staukontrolle](#tcp-fluss--und-staukontrolle) + - [Sende- und Empfangspuffer bei TCP](#sende--und-empfangspuffer-bei-tcp) + - [TCP Flusskontrolle: Angebotenes Fenster](#tcp-flusskontrolle-angebotenes-fenster) + - [Nagles Algorithmus - Selbsttaktung und Fenster](#nagles-algorithmus---selbsttaktung-und-fenster) + - [Staukontrolle bei TCP](#staukontrolle-bei-tcp) + - [TCP ACK/Selbsttaktung](#tcp-ackselbsttaktung) + - [Gute und schlechte Nachrichten](#gute-und-schlechte-nachrichten) + - [Verkleinern des Staufensters](#verkleinern-des-staufensters) + - [Vergrößern des Staufensters](#vergrößern-des-staufensters) + - [Additives Erhöhen](#additives-erhöhen) + - [AIMD - Sägezahnmuster der angebotenen TCP Last](#aimd---sägezahnmuster-der-angebotenen-tcp-last) + - [Schnelle initialisierung - Slow Start (historischer Name)](#schnelle-initialisierung---slow-start-historischer-name) + - [Verlassen des Slowstarts](#verlassen-des-slowstarts) + - [Problematik der Paketbursts](#problematik-der-paketbursts) + - [Lösung: Auch hier Slow Start verwenden](#lösung-auch-hier-slow-start-verwenden) + - [Zusammenfassung TCP Staukontrolle](#zusammenfassung-tcp-staukontrolle) + - [TCP Performance](#tcp-performance) + - [TCP Durchsatz](#tcp-durchsatz) + - [TCP Fairness](#tcp-fairness) + - [Fairness](#fairness) + - [Fairness und UDP](#fairness-und-udp) + - [Fariness und parallele TCP-Verbindungen](#fariness-und-parallele-tcp-verbindungen) + - [Verzögerungsmodellierung](#verzögerungsmodellierung) + - [Festes Staufenster](#festes-staufenster) + - [TCP Verzögerungsmodellierung: Slow Start](#tcp-verzögerungsmodellierung-slow-start) + - [Fallstudie HTTP Modellierung](#fallstudie-http-modellierung) + - [HTTP Antwortzeiten](#http-antwortzeiten) + - [Zusammenfassung Kapitel 8](#zusammenfassung-kapitel-8) +- [Kapitel 9: Internet Application Layer](#kapitel-9-internet-application-layer) + - [Erstellen einer Netzwerkanwendung](#erstellen-einer-netzwerkanwendung) + - [Prinzipien von Netzwerkanwendungen: Architekturen](#prinzipien-von-netzwerkanwendungen-architekturen) + - [Client-Server Architektur](#client-server-architektur) + - [Peer-to-Peer Architketur](#peer-to-peer-architketur) + - [Hybride Client-Server und P2P](#hybride-client-server-und-p2p) + - [Prozesskommunikation](#prozesskommunikation) + - [Sockets](#sockets) + - [Adressierung von Prozessen](#adressierung-von-prozessen) + - [Durch das Anwendungsprotokoll festgelegte Eigenschaften](#durch-das-anwendungsprotokoll-festgelegte-eigenschaften) + - [Welche Transportdienste werden von den Anwendungen benötigt?](#welche-transportdienste-werden-von-den-anwendungen-benötigt) + - [Internettransportprotokolldienste](#internettransportprotokolldienste) + - [Web & HTTP](#web--http) + - [HTTP Übersicht](#http-übersicht) + - [HTTP Verbindungen](#http-verbindungen) + - [Antwortzeitmodellierung](#antwortzeitmodellierung) + - [Persistentes HTTP](#persistentes-http) + - [HTTP Anfragenachrichten](#http-anfragenachrichten) + - [Hochladen von Einfaben](#hochladen-von-einfaben) + - [Methodentypen](#methodentypen) + - [HTTP Statuscodes](#http-statuscodes) + - [HTTP Webcaching und Cookies](#http-webcaching-und-cookies) + - [Nutzer-Server-Zustand: Cookies](#nutzer-server-zustand-cookies) + - [Webcaches (Proxyserver)](#webcaches-proxyserver) + - [Weitere Informationen über Webcaches](#weitere-informationen-über-webcaches) + - [Bedingtes GET](#bedingtes-get) + - [Webserverarchitekturen](#webserverarchitekturen) + - [Grundlegende Webserveraufgaben](#grundlegende-webserveraufgaben) + - [Webserverarchitekturen](#webserverarchitekturen-1) + - [1. Prozessmodell](#1-prozessmodell) + - [2. Threadmodell](#2-threadmodell) + - [3. In-Kernel Modell](#3-in-kernel-modell) + - [4. Eventbasiertes Modell](#4-eventbasiertes-modell) + - [Performancevergleich](#performancevergleich) + - [Webservercluster](#webservercluster) + - [FTP: Das Dateitransferprotokoll](#ftp-das-dateitransferprotokoll) + - [Separate Kontroll- & Datenverbindung](#separate-kontroll---datenverbindung) + - [FTP Kommandos und Antworten](#ftp-kommandos-und-antworten) + - [Electronic Mail: E-Mail](#electronic-mail-e-mail) + - [SMTP](#smtp) + - [SMTP Vergleich mit HTTP](#smtp-vergleich-mit-http) + - [Mailnachrichtenformat](#mailnachrichtenformat) + - [Nachrichtenformat: Multimediaerweiterungen](#nachrichtenformat-multimediaerweiterungen) + - [Mailzugriffsprotokolle](#mailzugriffsprotokolle) + - [POP3](#pop3) + - [POP3 und IMAP](#pop3-und-imap) + - [DNS - Domain Name System](#dns---domain-name-system) + - [Verteilte hierarchische Datenbank](#verteilte-hierarchische-datenbank) + - [DNS: Root Name Server](#dns-root-name-server) + - [TLD, Authorative und lokale DNS Server](#tld-authorative-und-lokale-dns-server) + - [Iterative Anfragen](#iterative-anfragen) + - [Rekursive Anfragen](#rekursive-anfragen) + - [DNS Caching und Updaten von Records](#dns-caching-und-updaten-von-records) + - [DNS Records](#dns-records) + - [DNS Protokoll, Nachrichten](#dns-protokoll-nachrichten) + - [Einfügen von Records ins DNS](#einfügen-von-records-ins-dns) + - [P2P Filesharing](#p2p-filesharing) + - [Probleme mit einem zentralisierten Verzeichnis](#probleme-mit-einem-zentralisierten-verzeichnis) + - [Anfragefluten: Gnutella](#anfragefluten-gnutella) + - [Gnutella Protokoll](#gnutella-protokoll) + - [Gnutella Peerjoining](#gnutella-peerjoining) + - [Socketprogrammierung mit TCP](#socketprogrammierung-mit-tcp) + - [Socketprogrammierung unter Verwendung von TCP](#socketprogrammierung-unter-verwendung-von-tcp) + - [Stream Jargon](#stream-jargon) + - [Socketprogrammierung mit UDP](#socketprogrammierung-mit-udp) + - [Bauen eines einfachen Webservers](#bauen-eines-einfachen-webservers) + - [Zusammenfassung Kapitel 9](#zusammenfassung-kapitel-9) +- [Kapitel 10: Netzwerk Sicherheit](#kapitel-10-netzwerk-sicherheit) + - [Einführung - Bedrohungen, Sicherheitsziele, Schutzmaßnahmen](#einführung---bedrohungen-sicherheitsziele-schutzmaßnahmen) + - [Was ist eine Bedrohung in einem Kommunikationsnetzwerk?](#was-ist-eine-bedrohung-in-einem-kommunikationsnetzwerk) + - [Sicherheitsziele (Security Objectives) in Abnhängigkeit von der Anwendungsumgebung](#sicherheitsziele-security-objectives-in-abnhängigkeit-von-der-anwendungsumgebung) + - [Sicherheitsziele technisch definiert](#sicherheitsziele-technisch-definiert) + - [Bedrohungen technisch definiert](#bedrohungen-technisch-definiert) + - [Sicherheitsanalyse von gelayerten Protokollarchitekturen](#sicherheitsanalyse-von-gelayerten-protokollarchitekturen) + - [Angriff auf dem Nachrichtenlevel](#angriff-auf-dem-nachrichtenlevel) + - [Sicherheitsmechanismen gegen Bedrohungen](#sicherheitsmechanismen-gegen-bedrohungen) + - [Grundlagen der Sicherheitstechnologie](#grundlagen-der-sicherheitstechnologie) + - [Terminologie](#terminologie) + - [Sicherheitsdienste - Übersicht](#sicherheitsdienste---übersicht) + - [Kryptologie - Definition und Terminologie](#kryptologie---definition-und-terminologie) + - [Kryptographische Algorithmen](#kryptographische-algorithmen) + - [Wichtige Eigenschaften von Verschlüsselungsalgorithmen](#wichtige-eigenschaften-von-verschlüsselungsalgorithmen) + - [Symmetrische Verschlüsselung](#symmetrische-verschlüsselung) + - [Asymmetrische Kryptographie](#asymmetrische-kryptographie) + - [Erkennung verschlüsselter Nachrichten](#erkennung-verschlüsselter-nachrichten) + - [Kryptographisches Protokoll](#kryptographisches-protokoll) + - [Einführung in die Sicherheitsdienste von Kommunikationsnetzwerken](#einführung-in-die-sicherheitsdienste-von-kommunikationsnetzwerken) + - [Sicherheit in Netzwerken: Was sollen wir wo tun?](#sicherheit-in-netzwerken-was-sollen-wir-wo-tun) + - [Pragmatisches Modelll für sicheres und vernetztes Rechnen](#pragmatisches-modelll-für-sicheres-und-vernetztes-rechnen) + - [Beziehungen zwischen Layern und Anforderungsleveln](#beziehungen-zwischen-layern-und-anforderungsleveln) + - [Die IP Sicherheitsarchitektur IPSec](#die-ip-sicherheitsarchitektur-ipsec) + - [Sicherheitsprobleme des Internetprotokolls](#sicherheitsprobleme-des-internetprotokolls) + - [Sicherheitsziele von IPSec](#sicherheitsziele-von-ipsec) + - [IPSec: Sicherheitsassoziation](#ipsec-sicherheitsassoziation) + - [IPSec Protokollmodi](#ipsec-protokollmodi) + - [IPSec: Verschachtelung von Sicherheitsassoziationen](#ipsec-verschachtelung-von-sicherheitsassoziationen) + - [IPSec Authentication Header (AH)](#ipsec-authentication-header-ah) + - [IPSec Encapsulating Security Protocol (ESP)](#ipsec-encapsulating-security-protocol-esp) + - [IPSec: Etablierung von Sicherheitassoziationen](#ipsec-etablierung-von-sicherheitassoziationen) + - [Internetfirewalls](#internetfirewalls) + - [Terminologie](#terminologie-1) + - [Firewallarchitekturen](#firewallarchitekturen) + - [Einfache Paketfilterarchitektur](#einfache-paketfilterarchitektur) + - [Die Screened Host Architektur](#die-screened-host-architektur) + - [Die Screened Subnet Architektur](#die-screened-subnet-architektur) + - [Firewalls: Paketfiltrierung](#firewalls-paketfiltrierung) + +--- +# Kapitel 1: Kurze Übersicht + +## Unterschiede zwischen Telefon und Internet +- Telefon: Kontinuierliche Übertragung der Daten in beide Richtungen in nahezu Echtzeit +- Internet: Daten werden übertragen, Latenzen sind verschmerzbar + +## Verbindungsarten: +Jede Verbindung benötigt eine Stelle welche von Bits in Signale wandelt und umgekehrt +> Signale sind die physische Repräsentation von Daten in der Form einer charakteristischen Variation in Zeit oder Ausbreitung… + +Wichtige Eigenschaften auf niedrigem Niveau: +- Delay d: Zeit vom Versenden bis zum Empfangen +- Speed v: Wie schnell reist das Signal im Übertragungsmedium (Kupfer/Glasfaser bei 2/3c, WLAN bei c) + +> delay = distance / v + +## Phyische Verbindungen (Arten) +- Simplex: Nur ein Teilnehmer kann immer senden +- Half Duplex: Beide Seiten senden abwechselnd Daten über den selben Kanal + - TDD (Time Division Duplex): Nutzer senden in einem festgelegten Zeitrahmen und kommen sich somit nicht in die Quere +- Full Duplex: Beide Nutzer können gleichzeitig senden + - FDD (Frequenzy Division Duplex): Die Nutzer senden gleichzeitig auf unterschiedlichen Frequenzen. Somit ist ein Kabel für eine Verbindung in beide Richtungen ausreichend. + - TDD (Time Division Duplex): Ist möglich, wenn einer sendet und der andere das zu Sendende kurz zwischenspeichert und später den Inhalt des Caches und das Aktuelle gleichzeitig sendet (Funktioniert nur, wenn das Medium doppelt so viel Kapazität wie die Datenrate des Senders hat) + +## Größere Netzwerke +Einfaches untereinander Verbinden wird unübersichtlich, deshalb Einführung eines neuen Strukturelementes: +* Option 1: Circuit Switching + * einfach + * einmal aufgesetzt verbleiben die Ressourcen beim Nutzer + * Circuit muss hergestellt werden, bevor kommuniziert werden kann +* Option 2: Packet Switching + * Aufteilen von Daten in kleinere Pakete die nach und nach gesendet werden + * Problem: Informationen zu Sender/Empfänger und Start/Endzeitpunkt eines Pakets müssen mit übermittelt werden + * Switches übernehmen zusätzliche Aufgaben: + * Zwischenspeichern in Puffern + * Herausfinden des Ziels + * Weiterleiten + * Wird deshalb 'Store and Forward' Netzwerk genannt + +## Multiplexing +Ähnlich, das Switch-Element hat aber nur eine ausgehende Leitung +1. TDM (Time Division Multiplexing): Übertrage ein Paket nach dem Anderen (Zeitliche Unterteilung) +2. FDM (Frequency Division Multiplexing): Gebrauch verschiedener Frequenzen um gleichzeitig Mehreres übertragen zu können. + +Alternativen: CDM (Code DM), SPM (Space DM) + +Sinn der Sache: Simuliert jedem Gerät seine eigene Datenleitung zu haben, ohne mehrere Leitungen bereitstellen zu müssen. + +Ein Mux benötigt immer einen Demux, sodass das Paket den Weg korrekt verfolgen kann. + +> Broadcast Medium: +>- Nur ein Sender zu jeder Zeit +>- Zugriffskontrolle (MUX o. Absprache) + +Optionen für die Auswahl des nächsten Hops bei großen Netzwerken: +1. Fluten: Sende das Paket an alle Nachbarn +2. Hot Potato Routing: Sende an einen zufälligen Nachbarn +3. Routingtabellen: In jedem Switch mit einem Eintrag pro Ziel. Enthält Info über kürzeste Wege + * Kriterien: Schleifenfreiheit, gute Einschätzungen + * Konstruktion: Anfangs leer, wie soll ein Knoten etwas erfahren? + * Passiv: Beobachtung des Traffics + * Aktiv: Austausch von Informationen zwischen Routern + * Problem: Ab gewisser Größe keine Speichermöglichkeit für jedes Ziel mehr + * Lösung: Divide and Conquer: Aufteilen des Netzwerks in Ebenen + +Fehlerquellen: +* Umwandlung von Bits in Signale +* Zugriff nicht möglich +* Paketverlust +* Fehlerhafte Routingtabellen +* Falsche Anordnung der Pakete +* Empfangsrate des Empfängers niedriger als die Senderate des Senders + +Umgang mit Fehlern: +* Fehlerkontrolle := Zwischen Nachbarn oder Endpunkten +* Überlastungskontrolle + * Schutz gegen Pufferüberläufe, Regulierung der ins Netz geschickten Pakete (Staukontrolle) + * Schutz von Endsystemen gegen zu viele ankommende Pakete (Flusskontrolle) +* Wo und Wie ist die wichtige Frage: + * Im Endsystem oder im Netzwerk + * Großer Unterschied zwischen Telefon und Internet + +--- +# Kapitel 2: Architektur +Netzwerke werden irgendwann zu groß, um sie als eine Ebene zu betrachten, deshalb: Aufspaltung in verschiedene Layer. +* Jedes Layer besitzt eigene Regeln und Prozeduren +* Jeder Dienst besitzt Schnittstellen zu höheren Ebenen +* Dienste können über ihren SAP (Service Access Point) erreicht werden und sind sozusagen ein Versprechen, was mit den Daten die am SAP ankommen passiert. + +Services: Layer bieten ihren Nutzern über ihre Interfaces Dienste an. + +Konvention für die Layer: Fortlaufende Nummerrierung, je höher desto abstrakter + +Serviceprimitive: Menge an Operationen welche auf dem Interface eines Dienstes möglich sind + +* Main Groups + * Viele verschiedene Serviceprimitive sind denkbar, normalerweise werden vier verwendet: + * Request (Req) := Anfrage an ein Layer einen Service auzuführen + * Indication (Ind) := Ein Layer zeigt seinem Nutzer, dass etwas passiert ist (asynchrone Benachrichtigung) + * Response (Res) := Ein Nutzer von höherem Layer beantwortet eine Indication + * Confirmation (Conf) := Der ursprüngliche Dienstaufrufer wird über die Beendigung des Servicerequests informiert + * Nicht alle Typen müssen immer zur Verfügung stehen +* Dateneinheiten + * Dateneinheiten sind wohl begrenzte Nachrichten + * Nur vollständige Nachrichten werden gesendet + * Nur vollständige Nachrichten werden empfangen + * Dateneinheit ist das einzelne Byte, eine Folge von Bytes oder ein Bytestream + * Nicht in Nachrichten strukturiert + * Sender sendet eine Folge, wovon der Empfänger jede Teilsequenz verwenden kann +* Korrektheitsanforderungen + * Completeness: Alle gesendeten Nachrichten werden irgendwann zugestellt + * Correctness: Alle Daten die ankommen, sind auch genau die, die losgeschickt wurden (unverändert, ohne Bitfehler) + * Reihenfolgegetreu: Nachrichten und Bytesequenzen kommen in der korrekten Reihenfolge an + * Verlässlich: Sicher, Verfügbar,… + * Bestätigt: Erhalt von Daten wird dem Sender bestätigt + +Nicht alle Anforderungen müssen immer erfüllt sein + +## Verbindungsorientiert vs. Verbindungslos +* Telefonie vs. Post + * Service mit Einrichtungsphase -> Verbindungsorientierter Dienst + * Drei Phasen: Verbinden, Datenaustausch, Trennen + * Aufruf eines Serviceprimitivs kann zu zu jeder Zeit stattfinden -> Verbindungsloser Dienst + * Die Unterscheidung ist unabhängig von der Wahl von Circuit vs. Paketswitching +* Verbindungsorientierte Dienste müssen Primitive Bereitstellen um Verbindungen handhaben zu können: + * CONNECT - Einrichtung der Verbindung + * LISTEN - Warten auf Verbindungsanfragen + * INCOMING_CONN - Anzeige eingehender Connectionrequests + * ACCEPT - Annahme einer Verbindung + * DISCONNECT - Terminierung einer Verbindung + +Typische Servicebeispiele: +* Datagrammdienst: + * Dateneinheit -> Nachrichten + * Korrekt, aber nicht in Reihenfolge + * Verbindungslos + * unsicher/ nicht zuverlässig, nicht bestätigt +* Zuverlässiger Bytestream: + * Dateneinheit -> Bytestrom + * Korrekt, vollständig, reihenfolgegetreu, bestätigt + * Manchmal sicher/zuverlässig + * Verbindungsorientiert + +## Protokolle +Was macht ein Protokoll aus? … spezielle Nachrichten werden versand, auf welche hin spezielle Taten unternommen werden +> Protokolle bestimmen das Format, die Reihenfolge von Nachrichten, welche über Netzwerkeinrichtungen versandt und empfangen werde, sowie Aktionen welche bei Übertragung und Erhalt von Nachrichten ausgeführt werden. + +* Protokolle sind Regelsätze, welche beschreiben wie zwei oder mehr entfernte Teile (peers oder protocol entities) eines Layers kooperieren, um den Dienst des gegebenen Layers zu implementieren. +* Ein Protokoll ist die Implementierung eines Services + +### Protokollspezikiationen: +* Das formale Verhalten eines Protokolls muss präzise spezifiziert werden +* Hierfür geeignet: FSMs (Finite State Machines) + +Protokolle und FSMs +* FSMs implementieren die tatsächlichen Verhaltensregeln eines Protokolls +* Müssen mit entfernten Peers kommunizieren: + * müssen hierfür den Service des darunterliegenden Layers verwenden + * Mittels Serviceprimitiven, welche auch ankommende Daten an das Protokoll beretstellen können + * Anzeigen von niedrigeren Layern in Events für die Protokollengine des höheren Levels + +Wenn niedere Services verwendet werden, so werden den Nachrichten administrative Infos hinzugefügt, entweder als Header oder als Trailer +> Strict Layering:\ +> Jedes Layer verwendet nur den Service des darunter liegenden Layers + +Protokollmechanismen: +* Adressing +* Fragmentation +* Re-Sequencing +* Error-Control +* Flow-Control +* Congestation-Control +* Ressource-Allocation +* Multiplexing +* Compression +* Privacy, Authentication + +Wie sollten Layer strukturiert werden? +* Modularisation vereinfacht die Wartung +* Layerstruktur und Protokolle definieren die Kommunikationsarchitektur + +### Layering: Vor- und Nachteile +| Vorteile | Nachteile | +| -- | -- | +| Layer nötig um Komplexität zu verwalten und zu beherrschen | Layer können Funktionen redundant haben | +| Änderung der Implementierung eines Layerdienstes ist transparent | Verschiedene Layer können selbe Information benötigen | +| Typische Funktion: Ideales Netzwerk | Layer n benöitigt eventuell Einblick in Layern n+x | + +Es existieren zwei Referenzmodelle: +* ISO/OSI +* TCP/IP + +## ISO/OSI Referenzmodell +* Designprinzipien: + * Ein Layer per Ebene + * Jedes Layer mit wohldefinierter Funktion + * Layergrenzen mit mglst. wenig Informationsfluss + * Genug Layer zur Unterscheidung, wenig genug um Verwaltbarkeit zu schaffen + +Insgesamt 7 Layer werden unterschieden. +* Physisches Layer (PH) + * Bietet eine bittransparente Schnittstelle zum physischen Medium + * Spezifiziert mechanische, elektrische, funktionale und prozedurale Mittel um die **physische Verbindung zwischen zwei offenen Systemen zu unterstützen.** + * Physische Verbindung impliziert nicht die verbindungsorientierte Operation + * Verschiedene Übertragungsmedien können genutzt werden, jeweils verschiedene Protokolle sind von Nöten + * In-sequence Zustellung der Bits ist sichergestellt + * Fehlererkennung ist manchmal inkludiert +* Link Layer (L) + * Unterstützt Übertragung von service data units (SDU) größer als „word“ unter Systemen, welche über einen einzigen physischen Pfad verbunden sind. + * Essentielle Funktion ist block synchronization + * Teilweise wird Fehlererkennung oder Fehlerkontrolle zur Verfügung gestellt. + * Im Fall von Halb-duplex oder multipoint links muss der Zugriff auf das Medium **kontrolliert werden und Peersysteme müssen addressiert werden.** +* Network Layer (N) + * Erschafft einen logischen Pfad zwischen offenen Systemen, welche verbunden sind mit individuellen, möglicherweise verschiedenen Subnetworks + * Dieser logische Pfad kann durch mehrere, möglicherweise verschiedene dazwischenliegende Subnetworks gehen + * Diese Netzwerkebene unterstützt Routing, also müssen sich N-Service Benutzer nicht **um den Pfad kümmern** + * Der N-Service ist uniform, unabhängig von der Variation an Subnetwork Technologien, Topologien, QoS und der Organisation + * Netzwerk Addresse = Endsystem Addresse +* Transport Layer (T) + * Vervollständigt den Übertragungsteil des OSI Stacks. Unterstützt die Übertragung mit **gefordertem QoS, auf wirtschaftliche Weise zwischen (T)-nutzern (normalerweise Prozessse in einem Endsystem), unabhängig von der Netzwerkstruktur** + * Verschiedene Klassen von Protokollen mit verschiedenen Funktionalitäten sind **festgelegt (connectionoriented / connectionless; reliable / unreliable)** +* Session Layer (S) + * Unterstützt die Synchronisation des Dialogs und die Verwaltung des Datenaustausches (möglicherweise über mehrere transport layer connections aufspannend) + * Quarantine Data delivery - Eine ganze Gruppe von übertragenen S-SDUs wird zugestellt auf explizite Anfrage des Senders + * Interaktionsverwaltung erlaubt ausdrücklich festzulegen, welcher S-User das Recht bekommt zu übertragen + * Zurücksetzen der Verbindung auf vordefinierte Synchronisationspunkte +* Presentation Layer (P) + * Unterstützt die Übersetzung von Daten und Datenstrukturen in einzigartige Repräsentation + * Ausschließlich die Syntax wird modifiziert um die Semantik beizubehalten + * Auswahl von einer der allgemein anerkannten Transfersyntax + * Die lokale Syntax von jedem Endsystem wird in oder von der ausgewählten Transfer Syntax übersetzt +* Application Layer (A) + * Unterstützt den direkten Endnutzer durch die Bereitstellung einer Vielzahl an application services + * Dies kann sein: + * Genereller Typ (z.B. Entfernte prozedurale Anrufe, Transaktionsdurchführung,...) + * Spezifischer Typ (z.B. Virtuelles Terminal, Dateiübertragungszugriff und Verwaltung, Arbeitswechsel,...) + * Ein typisches Beispiel: virtuelles Terminal (Funktionen des reellen Terminals werden in **virtuelle Funktionen gemappt**) + +#### Kritik am ISO/OSI Modell +* Das Modell als solches mit der Unterteilung in Layer ist heutzutage sehr einflussreich +* Im praktischen Gebrauch aber eher irrelevant +* ISO konnte sich nicht durchsetzen +* Im Internetprotokoll (IP-Modell) wurden die obersten drei OSI-Layer in ein Applicationlayer zusammengefasst + +#### Architekturvoraussetzungen für das Internet +* Generalität := Unterstütze alle möglichen Sets von Applikationen +* Heterogenität := Verbinde alle Arten von Netzwerktechnologien +* Robustheit := Wichtiger als Effizienz +* Erweiterbarkeit := Wichtiger als Effizienz +* Skalierbarkeit := Spätere Entdeckung + +#### Grundlagen der Internetarchitektur +* Dumme Netzwerke, smarte Endgeräte +* Dumme Netzwerke brauchen nur einen geringsten gemeinsamen Dienst + * Datagrammdienst: kein Verbindungsstatus in den Routern + * Best effort: Gleichbehandlung + * Verlieren, verdoppeln und vertauschen +* Intelligente Hosts + * Behalten den Zustand + * "Schicksalsteilung" - Wenn ein Host zusammenbricht und den Kommunikationszustand verliert, so teilen alle Applikationen, welche kommunizieren dieses Schicksal + + +### TCP/IP Referenzmodell +* Basierend auf dem ARPANET +* Definiert nur zwei Layer + * Internetlayer: Packetswitching, Adressierung, Routing und Forwarding. Insbesondere für hierarchische Netze + * Transportlayer + * zuverlässiger Bytestrom: TCP (Transport Control Protokoll) + * unzuverlässiges Datagramm: UDP (User Datagramm Protokoll) +* Niedere und höhere Layer nicht wirklich definiert + * Host zu Host Kommunikation als gegeben angesehen + * Anwendungen geschätzt +* Jedes Layer nimmt Daten vom darüberliegenden Layer, fügt eine Headereinheit hinzu und erstellt eine neue Dateneinheit und schickt diese an das Layer darunter +* TCP/IP - Reihe von Protokollen: viele anwendungsspezifische Protokolle über IP + +#### Kritik am TCP/IP Modell +* keine klare Unterteilung zwischen Service, Protokoll und Interface + * Gleichstellung von TCP mit zuverlässigem Bytestrom eigentlich nicht zulässig + * Insbesondere unter IP +* Stark spezialisierter Stack, erlaubt keine Generalisierung +* Große Lücke unterhalb von IP +* Viele Einzelfalllösungen + +### ISO/OSI vs TCP/IP +* ISO/OSI: Sehr nützliches Modell, keine existierenden Protokolle +* TCP/IP: Nicht existentes Modell, sehr nützliche Protokolle +* Deshalb: ISO/OSI Modell aber TCP/IP Stack + +## Standardisierung +* Zum Bau großer Netzwerke werden Standards benötigt +* Traditionell aus dem Telekommunikationshintergrund + * Eingelaufen, weltweit aber langsam +* Internet + * Hauptsächlich um die IETF herum + * Zählungsorientiert, Fokus auf funktionierenden Implementationen + * Hoffnung auf schnelle Einführungszeiten + * Herstellergremien + +### ISO Standardisierverfahren +Standardisierungsprozess: +* DP: Draft Proposal +* DIS: Draft International Standard +* IS: International Standard + +## Zusammenfassung Kapitel 2 +* Komplexitätsbeherrschung nur mit Teilung in Subsysteme mit klar definierten Rollen -> Layering +* Jedes Layer bietet einen bestimmten Service an + * Services werden mächtiger, je höher man in der Hierarchie aufsteigt +* Um einen Service anzubieten, muss ein Layer über entfernte Geräte verteilt sein +* Entfernte Teile eines Layers verwenden ein Protokoll um Zusammenzuarbeiten + * Ein Protokoll ist eine horizontale, ein Service eine vertikale Beziehung +* Zwei wichtige Referenzmodelle existieren, welche beschreiben, wie man Funktionalitten in Layer gruppieren kann, welcher Service wo bereitgestellt wird, und wie man Protokolle strukturiert. + +--- +# Kapitel 3: Physikalisches Layer +## Synchronisation +Wann sollte man das Signal eigentlich sampeln? +* Wie weiß der Empfänger, wann das Signal auf einen Wert gemappt werden soll? + * Konvention: In der Mitte jedes Symbols, nur wann ist das nun genau? + * Länge ist typischerweise bekannt über die Konvention über die Symbolrate +* Der Empfänger muss mit dem Sender auf Bitlevel synchronisiert sein + * Link-Layer zuständig für Framesynchronisation + +### Vereinfachtes Konzept: +* Nimm an, dass Sender und Empfänger irgendwann synchron sind und beide eine Uhr haben, welche bei jedem Symbolschritt tickt +* Problem: Uhrendrift ist ein großes Problem - die Synchronisation wird verloren gehen +* Lösung: + 1. Stelle ein explizites Uhrensignal auf einem parallelen Kanal bereit + 2. Synchronisiere nur an kritischen Punkten (Uhrendrift ist nicht so schnell) + 3. Extrahiere Uhreninformation aus dem Signal selbst + +Idee: Mit NRZL (Non-Return to Zero Level) müsste sich die Länge der Bits herausfinden lassen + +Problem: Lange 1 oder 0 Folgen bieten keine Anhaltspunkte für die Bitgrenzen, somit hinfällig + +Idee: Manchesterkodierung, stelle dem Sender bei jedem Bit Informationen bereit, dass dies eine Stelle ist, bei der ein Bit startet, stoppt, seine Mitte erreicht hat + +Stellt eine ausreichende Anzahl an Signalwechseln sicher + +Problem: Benötigen die doppelte Bandbreite, da die Baudrate = 2*Bitrate ist. + +> Baudrate:\ +> Die Baudrate beschreibt die Anzahl der Symbole welche innerhalb einer Zeiteinheit übertragen werden + +## Breitband- vs. Basisbandübertragung +* Bisherige Übertragungsschemen: Basisbandübertragung + * Schieben die digitalen Symbolsequenzen direkt auf den Draht + * Verschiedene Level von Spannung/Stromstärke und co wird verwendet +* Probleme: Beschränkte Bandbreite verändert das Signal, Dämpfung und Verzerrung + +### Breitbandübertragung +* Lösen vom breiten Spektrum für DC-Übertragung +* Verwende Sinuswelle als Träger, hat meist eine, allerdings auch nur eine, hohe Frequenz +* Reine Sinuswellen haben keine Information, deshalb Beeinflussung durch + * Amplitude a + * Frequenz f + * Phase φ + +Unterschiedliche Varianten der Signalmodulation möglich: +1. Amplitudenmodulation\ + Die Amplitude lässt sich beispielsweise als das zu sendende Signal s(t) geben. Spezialfälle: + * s(t) analog - Amplitudenmodulation + * s(t) digital - Amplitudenkeying + * s(t) 0 oder 1 - An/Aus Keying +2. Frequenzmodulation +3. Phasenmodulation + * Phasenmodulation mit hohen verschiedenen Werten pro Symbol + * Der Empfänger kann gut zwischen Phasenwechseln unterscheiden + * Verwende Phasenverschiebungen von 0, π/2, π, 3π/2 um je zwei Bits je Symbol zu kodieren + * Besser noch in π/4 Schritten, somit Uhrenextraktion ermöglicht und Datenrate = 2* Symbolrate + * Wird QPSK genannt + * Verschiedene Modulationsarten können gut miteinander kombiniert werden + * Beispiel: 16-QAM (Quadrature Amplitude Modulation) + * Verwendet 16 Kombinationen von Phasenwechseln und Amplitude für jedes Symbol, somit Pro Symbol 2⁴ Bits codiert und übertragen + +## Digitales vs. Analoges Signal +* Digitale Übertragung: Endliches Set von verschiedenen Signalen +* Analoge Übertragung: Unendliches Set von verschiedenen Signalen +* Beispiel: Signal korresponidert zur Stromstärke auf der Leitung + * Digital: Endlich viele erlaubte Stromstärken, zb. 1A, 2A, 3A, 4A + * Analog: Jede Stromstärke ist erlaubt +* Vorteil von digitaler Übertragung: Hohe Chance, dass der Empfänger, das gesendete Signal sehr gt rekonstruieren kann + +Beispiele für Übertragungsmedien +* Geführte Übertragungsmedien + * Kupferdrähte - Twisted Pair + * Kupferdrähte - Koaxialkabel + * Fibre Optics (Glasfaser) +* Drahtlose Übertragung + * Radio + * Mikrowellen + * Infrarot + * Lichtwellen + +## Zusammenfassung Kapitel 3 +* Das physikalische Layer ist zuständig für die Umwandlung einer logischen Sequenz an Bits in ein physisches Signal, welches sich durch den Raum ausbreiten kann +* Viele verschiedene Formen von physischen Signalen sind möglich +* Signale sind limitiert durch ihre Ausbreitung ineinem physikalischen Medium (begrenzte Bandbreite, …) und Rauschen. +* Bits können kombiniert werden in vielfach besetzte Symbole für die Übertragung + * Erhöht die Differenz zwischen Baud- und Bitrate + * Basisbandübertragung ist fehlerbehaftet, teilweise verbesserbar durch die Modulation eines Signals auf einen Träger (Breitbandübertragung) + +--- +# Kapitel 4: Data Link Layer +## Services des Link Layers +* Der Link Layer sitzt oberhalb des physischen Layers + * Kann also einen Bitstromübertragungsdienst verwenden + * Service kann allerdings inkorrekte Bits haben +* Erwartungen des höheren Netzwerklayers + * Entweder Paketservice oder Bitstromdienst + * Möchte von Fehlern nichts wissen und sich darum auch nicht kümmern + +Optionen für Linklayer-Services +* Zuverlässig (Ja/Nein) + * Zugestelltes Paket mit gleichem Inhalt wie das losgeschickte + * Zustellung aller Pakete + * Reihenfolgentreue +* Fehlerkontrolle verfügbar? + * Vorwärts oder Rückwärtsorientiert +* Verbindungsorientiert? + * Soll gemeinsamer Kontext etabliert werden +* Paket oder Bitstromabstraktion + * Typischerweise in Computernetzwerken: Pakete + * Gibt es eine maximale Paketlänge? + +## Einfache Linklayerfunktionen (Übersicht) +### Framing +* Wie erstellt man aus dem Bitstrom des physischen Layers klar abgegrenzte Frames und wie erkennt man diese? + * Für Fehlerkontrolle benötigt + * Frames und Pakete sind das selbe, ist nur eine Namenskonvention für das Link Layer +* Zusätzlich: Fragmentation und Wiederzusammensetzung, falls Pakete des Netzwerklayers größer denen des Link Layers sein sollten + +### Fehlerkontrolle +* Typischerweise eher im Netzwerklayer +* Fehlererkennung - gibt es fehlerhafte Bits? +* Fehlerkorrektur - Werden erkannte Fehler repariert? + * Vorwärts - Investiere Arbeit bevor der Fehler passiert + * Rückwärts - Investiere Arbeit nachdem der Fehler passiert ist, unternimm Reparaturversuche + +### Verbindungsaufbau +* Verbindungen in vielerlei Hinsicht nützlich + * Anwendungskontext + * Fehlerkontrolle +* Frage: Wie baut man Verbindungen auf und wieder ab? + * Insbesondere oberhalb von Frames, mittels virtueller Verbindungen, da es keine geswitchte Ende-zu-Ende Verbindung gibt + +### Flusskontrolle +* Schneller Sender, langsamer Empfänger -> Puffer des Empfängers werden schneller gefüllt, als er diese leeren kann -> Verlorener Übertragungsaufwand +* Deshalb Adaptierung der Anzahl an Frames pro Link Layer Sendungen pro Zeit an den Empfänger + +## Framing +* Wie kann man einen Bitstrom in eine Sequenz von Frames umwandeln? + +### Framing durch Zählen der Charakter +* Idee: Veröffentlichen der Anzahl an Bits in einem Frame an den Empfänger + * Hinzufügen der Infos in den Frameheader +* Problem: Fehlerhafte Zählerinformation zerstört wiederum die gesamte Framesynchronisation + +### Framing durch Flagbitmuster/Bitstuffing +* Verwende ein Bitmuster welches Start/Ende markiert +* Verwende Bitstuffing, wann immer 5*1 hintereinander, so füge eine 0 daran an, außer beim Flagmuster +* Der Empfänger wiederum, wirft dann alle 0en nach 5*1 weg + +### Framing durch Codeverletzungen +* Angenommen, die Codierungsregeln des physischen Layers lassen noch Spielraum + * nicht alle Möglichkeiten an Kombinationen sind genutzt + * Bei Manchester z.B. nur low/high und high/low +* Falls diese Regeln verletzt werden, können zusätzliche Daten übertragen werden, z.B. Beginn und Ende eines Frames +* Bei Manchester dann high/high oder low/low +* Zerstört zwar das Selbstclocking Feature aber bei kurzen Übertragungen verschmerzbar + +## Fehlerkontrolle - Redundanz +* Zwei grundlegende Aspekte: + * Erkennen + * Korrigieren +* Beides ist unabhängig voneinander möglich + * Erkennen ohne Korrigieren: Tu einfach so als wäre das Paket nie angekommen + * Korrigiere aber erkenne nicht: Versuche so viel wie möglich zu korrigieren, aber versuche keine neuen zu entdecken und kümmere dich auch nicht darum + * Beispiel: Videoanruf oder Musikstreaming, dort sind kleinere Bitfehler voll verschmerzbar + > EDC = Error Detection and Correction Bits\ + > D = Data protected by error checking +* Fehlerdetektion ist nie 100% möglich: Fehler können übersehen werden … +* Irgendeine Form von Fehlerkontrolle erfordert Redundanz in den Frames +* Ohne Redundanz: + * Frame der Länge m kann 2^m Frames darstellen + * alle davon sind legal + * Unmöglich hier Veränderungen zu erkennen +* Kernidee: Deklariere einige Nachrichten als illegal + * Benötigen dennoch 2^m legale Frames, deshalb Frames mit n > m Gesamtlänge + * Die extra Bits werden in Headern oder Trailern mit versand und erlauben es dem Empfänger illegale Frames zu erkennen +* Wie hilft das bei der Bitfehlererkennung? + * Sender sendet nur legale Frames, die vom Medium korrumpiert werden + * Hoffnung: Ein legaler Frame wird nie ein anderer legaler Frame, sondern ein illegaler, notwendig hierfür: nur eine gewisse Anzahl an Bitflips darf auftreten + +### Parität +* Erzeugung eines redundanten Bit: Parität + * ungerade Parität: füge ein Bit hinzu, sodass die Gesamtzahl an 1en ungerade ist + * gerade Parität: füge ein Bit hinzu, sodass die Gesamtzahl der 1en gerade ist +* Angenommen der Empfänger erwartet immer gerade Parität, so kann er Fehler erkennen, sobald es eine ungerade Parität gibt + +### Checksummen +* Zur Berechnung von Checksummen behandelt der Sender die Daten als Sequenz von binären Integers +* Gruppieren in zweier Kombis und aufaddieren von deren Werten um die Checksumme zu erhalten +* Positiv: Einfach zu berechnen +* Negativ: Erkennen nicht alle häufigen Fehler + +### Hammingdistanz +Hammingdistanz = Anzahl an Stellen an denen sich zwei Frames x und y in binärer Darstellung unterscheiden lösbar mittels (x XOR y). + +Generalisierung +* Um Bitfehler zu erkennen, ist eine Hammingdistanz von d+1 in der Menge der legalen Frames nötig + * So, dass man unmöglich mit nur d Bitflips einen legalen Frame in einen anderen Schreiben kann +* Um Bitfehler korrigieren zu können ist eine Hammingdistanz von 2d+1 in der Menge der legalen Frames benötigt + * So sind alle Frames die bis zu d Bits vom nächsten legalen Frame entfernt sind, noch mehr als d Bits zum anderen legalen Frame entfernt sind + +### Frame Mengen - Code Books, Code +* Terminologie + * Codebook = Menge von legalen Frames + * Rate R von Code $S: R = log|S|/n$ (Effizienz) + * Distanz d von Code $S: d = d(S)/n$ (Fehlererkennungs/korrekturmöglichkeiten) +* Kriterien für guten Code: hohe Distant und große Rate +* Konstruktion guter Codes schwer, Möglichkeit mehrerer Paritätsbits wappnet gegen Bündelfehler + +### Cyclic Redundancy Check - CRC +* Effizient, hohe Erkennungswahrscheinlichkeit mit wenig Redundanzbits +* Funktion beruht auf polynomieller Arithmetik + * Bitstrings als Repräsentanten von Polynomen + * Koeffizienten 0 und 1 möglich, interpretiert als modulo 2 +* Idee: Fasse die Stränge von Bits als Repräsentation der Koeffizienten des Polynoms auf + * Bitstring mit (n+1) Bits = Polynom von Grad n +* Verwende Polynome um CR Bits zu berechnen + * Definiere eine Generatorpolynom G(x) des Grades g + * Sowohl Sender als auch Empfänger bekannt + * Verwenden g Redundanzbits + * Gegeben Nachricht M(x) + * Sender berechnet Rest r(x) der Division $x^g*M(x)/G(x)$ + * Überträge $T(x) = x^g M(x)-r(x)$ + * T(x) ist restfrei Teilbar durch G(x) + * Empfänger erhält m(x) + * Berechnet den Rest der Division von m(x) durch G(x) + +CRC Übertragung und Empfang +* Keine Fehler T(x) kommt korrekt an +* Bitfehler: T(x) ist verändert, dh. Koeffizienten wurden verändert + * Es kommt also T(x) + E(x) an +* Auf Empfängerseite: + * Empfange m(x) und berechne m(x) / G(x) + * Fehlerfrei: m(x) = T(x) + * Bitfehler: m(x) / G(x) = (T(x)+E(x))/G(x) = T(x)/G(x) + E(x)/G(x) +* Die Wahl von G(x) bestimmt die CRC Eigenschaften +* In der Anwendung werden sämtliche Fehler nach dem CRC-Check ignoriert + * Fehler können dennoch auftretem, insbesondere sind Fehler meist berstend + +### Rückwärtsfehlerkontrolle +Behandlung erkannter Fehler auf zwei Arten und Weisen +- Vorwärts: Sender sendet redundante Infos so, dass der Empfänger selbst ausbessern kann +- Rückwärts: Sender sendet redundante Infos so, dass der Empfänger fehlerhafte Pakete wahrscheinlich erkennt und Pakete in dem Fall nochmal verschickt werden können + +Rückwärtskorrekturverfahrensprotokolle sind unter dem Namen Automatic Repeat Request (ARQ) bekannt: +* Send and Wait +* Go-Back-N +* Selective Reject + +#### Send and Wait +* Sender schickt ein Paket, stellt sich einen Timer, wartet auf eine Quittung, und wenn keine ankommt, dann überträgt er es erneut +* Beschädigte Pakete werden vom Empfänger einfach verworfen +* Problem: Falls das ACK Paket verloren geht/ beschädigt wird, so kann dies der Sender nicht erkennen: + * Schickt einfach neu, und der Empfänger hat plötzlich zwei Kopien des selben Pakets +* Lösung + * Einführen von Sequenznummern, um zwischen verlorenen Paketen und Quittungen, sowie neuen und schon empfangenen Paketen zu unterscheiden + * Konvention: Sende Sequenznummer des zuletzt korrekt empfangenen Pakets in der Quittung + +##### Alternating Bit Protokoll +* Einführung der Sequenznummern 0 und 1 in den Nachrichten und ACKs +* Bedenke: ACKs nun mit doppelter Funktion + * Bestätigen dem Sender, die Ankunft des Pakets + * Erlauben es dem Sender eine weitere Nachricht zu senden + +##### ARQ - Sliding Windows +> Effizienz\ +> Definiert als die Rate der Zeit, in welcher der Sender neue Informationen sendet (für den fehlerfreien Kanal)\ +> Effizienz = $\frac{T_{packet} }{ T_{packet} + d + T_{ack} + d}$ + +* Die Effizienz des einfachen Alternatingbitprotokolls ist gering, wenn die Verzögerung im Vergleich zur Datenrate hoch ist. + +Verbesserung der Effizienz +* Ineffizienz von Alternatingbitprotokollen in Situationen mit großem Bandwith/Delay Produkt hängt mit der Wartezeit und dadurch ungenutztem Speicherplatz zusammen +* Dauerhaftes Senden führt zu höherer Effizienz, deshalb Pipelining von Paketen und Einführen eines größeren Sequenznummernraums + +Sliding Windows +* Führe neuen Sequenznummernraum mit 2^n Sequenznummern ein, wobei nie alle gleichzeitig verwendet werden dürfen +* Verwende Sliding Windows sowohl beim Sender als auch beim Empfänger, um diese Nummern zu behandeln + * Sendefenster = Menge an zum Versand freigegebenen Sequenznummern + * Empfangsfenster = Menge an Sequenznummern welche zur gegebenen Zeit akzeptiert werden + +###### Übertragungsfehler und Empfangsfenstergröße +* Annahme: Linklayer sollte alle Frames korrekt und in Reihenfolge zustellen, der Sender verwendet Pipelining +* Beim Verlieren von Paketen bei einer Empfangsfentergröße 1 werden alle folgenden Pakete verworfen + +#### Go-Back-N +* Bei Empfangsfenstergröße 1 können alle auf einen verlorenen Frame gesendeten Frames nicht vom Empfänger verarbeitet werden + * Sind out of Sequence und können nicht bestätigt werden +* -> Sender wird einen Timeout erfahren + * Da alle Frames in der Zwischenzeit aber weitergesendet wurden, müssen diese erneut übertragen werden +* Go Back N ist leider ziemlich verschwenderisch mit den Ressourcen, minimiert aber den Overhead beim Empfänger + +##### Selective Reject / Selective Repeat +* Empfänger kann nun einige Pakete puffern +* Der Empfänger sendet im Fehlerfall negative Acknowledgements +* Der Sender wiederholt die Übertragung von fehlenden Frames + +##### Duplexoperation und Piggybacking +* Bisher Simplexoperation am oberen Serviceinterface, dh. Empfänger sendet ausschließlich ACKs zurück +* Wenn das obere Dienstinterface Full-Duplex unterstützt, dann wechsle Datenframes und ACK-Frames für eine gegebene Richtung ab + * Stecke die ACK-Info für Richtung A ! B in die Datenframes für B ! A (Piggybacking) + +#### Leistungsverhalten: +* Fehlerfreies Send and Wait: + * S = 1/(1+2a) wobei a = T-prop / T-frame +* Fehlerbehaftetes Send and Wait: + * S = (1-P)/(1+2a) +* Fehlerfreies Sliding Window: + * Sei W die Anzahl an Frames, welche der Sender senden kann, bevor er auf Quittungen warten muss + * Normalisierter Durchsatz: S = {1, falls W >= 2a+1, W/(2a+1) sonst} +* Selective Reject: + * S = {1-P, falls W >= 2a+1, (W(1-P))/(2a+1) sonst} +* Go-Back-N: + * S = {(1-P)/(1+2aP), falls W >= 2a+1, (W(1-P))/((2a+1)(1-P+WP)) sonst} + +## Folgerung Kapitel 4 +* Die meisten Probleme im Linklayer entstehen durch Fehler + * Fehler in der Synchronisation erfordern nichttriviale Framingfunktionen + * Fehler in der Übertragung erfordern Mechanismen diese zu Korrigieren und zu Verstecken, oder sie zu erkennen und zu reparieren +* Flusskontrolle ist oft eng in die Fehlerkontrolle integriert + * Ist allerdings eine separate, auch getrennt implementierbare Funktion +* Wahl des Fehlerkontrollschemas beeinflusst die Performance +* Verbindungsaufbau und -abbau muss noch behandelt werden + +--- +# Kapitel 5: Medium Access Control (MAC) +## Einführung: Multiple Access Link und Protokolle +* Point to Point +* Broadcast (geteiltes Medium) +* Einzelner geteilter Broadcastkanal +* zeitgleiche Übertragung von zwei oder mehr Knoten: Interferenz + +### Multiple Access Protokoll +* Verteilter Algorithmus, der bestimmt, wie Knoten auf ein geteiltes Medium zugreifen +* Oftmals kein out-of-Band Kanal für die Koordination + +### Broadcastkanal mit Rate R b/s +* Will nur einer Senden so kann er dies mit R, wollen M Instanzen senden, so sollen sie dies in R/M können. +* Völllig dezentralisiert und so einfach wie möglich + +### Statisches Multiplexing +* Eine einzelne Ressource kann statisch gemultiplext werden indem: + * Man feste Sendezeiten einräumt + * Mehrere Frequenzbänder verwendet + +### Berstender Verkehr (Burst) +* großes Problem, da + * die Ressource groß genug sein muss um mit der Datenrate sofort zurecht zu kommen + * auf den durchschnittlichen Verbrauch ausgelegt sein muss und aber Puffer benötigt + +### Statisches multiplexing berstenden Verkehrs - Verzögerung +* Basisfall: Kein Multiplexing, einzige Trafficquelle mit durchschnittlicher Rate P und Kapazität C + * Verzögerung ist T +* Multiplexing: Unterteile Ressource in N Quellen mit gesamter totalen Rate, statisch gemultiplext + * Verzögerung T-FDM = N \* T + * Unabhängig von FDM, TDM +* -> Multiplexing erhöht das Delay um das N-fache + +### Dynamische Kanalzuweisung +* Statisches Multiplexing nicht geeignet für berstenden Verkehr +* Alternative: Weise der Quelle welche Senden will den Kanal/Link zu + +#### Annahmen für die dynmaische Kanalzuweisung +* Stationsmodell: + * N unabhängige Stationen + * Mögliches Lastmodell: Wahrscheinlichkeit des Generierens eines Pakets im Intervall t ist x*T, mit x konstant +* Einkanalannahme: + * Nur ein Kanal für alle Stationen und für alle Nachrichten +* Kollisionsannahme: + * Nur je ein Frame zeitgleich fehlerfrei übertragbar +* Zeitmodell: + * Kontinuierlich: Übertragungen können jederzeit stattfinden + * Geslottet: Zeit ist in Slots eingeteilt, Übertragung kann nur an Slotgrenzen beginnen +* Carrier Sensing: + * Stationen können (oder auch nicht) erkennen, ob der Kanal frei oder in Benutzung ist + * Falls Kanal als belegt angesehen, so wird nichts übertragen + +##### Zahlen von Merit +* Wie ist die Effizienz eines dynamischen Kanalzuweisungssystems zu bewerten? + * Bei hoher Last sollen möglichst viele Pakete durchkommen + * Bei niedriger Last soll die Verzögerung so gering als mögich sein + * Fairness - Wird jede Station gleich behandelt? + +###### Durchsatz und angebotene Last +* Last G: falls > 1 so Überladung +* Ideal: S gleicht angebotener Last solange G < 1, S = 1 falls G <= 1 (nicht sehr realistisch) + +### Grundlegende Optionen für MAC +* Kollisionsfreie Protokolle +* Limited Contention Protokolle (beschränkt Kollisionsbehaftet) +* Kollisionsprotokolle + +#### Kollisionsbehaftete Protokolle +* ALOHA: + * Jeder sendet einfach sobald er etwas zu senden hat, keine Benachrichtigung über den Erfolg einer Übertragung möglich + * Paketübertragung bei ALOHA ist nur dann erfolgreich, wenn es keine weitere Übertragung in zwei Paketzeiten gibt -> mittlerer Erreichbarer Durchsatz < 20% +* Slotted ALOHA: + * Verwende nun Zeitslots (werden als irgendwie verfügbar angesehen) + * Dadurch Verdoppelung des Durchsatzes auf ca 36% + * Problem nach wie vor, der Durchsatz bricht zusammen, sobald sich die Last erhöht + +### Carrier Sensing +* Höre bevor du redest, und sende nichts, wenn das Medium gerade belegt ist +* 1-Persistent CSMA + * Falls belegt, so warte bis frei und sende dann -> Probleme entstehen, wenn mehrere nach der jetzigen Nachricht senden wollen +* Non-Persistent CSMA + * Wenn Kanal frei so übertrage, wenn Kanal belegt, so warte eine zufällige Zeit vor dem nächsten Freiheitstest + * Performance abhängig von der Zufallsverteilung, besser bei hoher Last, bei geringer Last nur unnützes Warten +* P-Persistent CSMA + * Kombiniert bisherige Ideen + geslottete Zeit + * Warte ständig auf freiwerden des Kanals, + * übertrage dann aber nicht sofort, sondern werfe eine Münze mit WK p, und sende mit WK p oder Warte mit 1-p auf nächsten Zeitslot und prüfe wieder + +#### CSMA und die Ausbreitungsverzögerung +* Problem jedes CSMAs: Ausbreitungsverzögerung +* Zwei Stationen seien bereit zum Senden zur Zeit t und t+e + * Zum Zeitpunkt t ist der Kanal frei, und Stationen durch Verzögerung d > e getrennt + * -> Station 2 kann bereits begonnene Übertragung von Station 1 nicht erkennen und sendet -> Kollision + +#### Collision Detetion - CSMA/CD +* Bei Kollision zweier Pakete geht viel Zeit durch die Beendigung der Übertragung verloren +* Abhängig vom physischen Layer können Kollisionen erkann werden + * Notwendig: Sender muss während des Sendens in den Kanal hören und dies mit seinem gesendeten vergleichen , falls dies nicht identisch ist, so deklariere es als Kollision +* Sollte eine Kollision aufgetreten sein, so warte eine zufällige Zeit + +#### Wahl einer zufälligen Wartezeit +* Einfach: Wähle einen aus k Slots +* Aber wie beschränkt man k nach oben? + * Kleines k: kurze Verzögerung, mehr Kollisionen + * Großes k: große Verzögerung, weniger Kollisionen + * -> Adaptiere k an die Verkehrslast + +#### Adaption von k an die Last +* Verwende Kollisionen als Indikator für ein zu kleines Wettbewerbsfenster +* Frage: Wie erhöht man k und wie verringert man es wieder? + +#### Binary exponential Backoff +* Erhöhe nach Kollisionen: + * Verdopplung von k bis zu einer gewissen Größe +* Verringern von k: + * Kompliziert: Wenn genug Frames nicht kollidiert sind, so reduziere k + * Einfach: Starte jedesmal wieder bei k = 1 + +### Wettbewerbsfreie Protokolle +* Kollsionen bereiten Probleme -> Medium ohne Wettbewerb nutzen +* Beispiel: Statisches TDMA (Time Division Multiple Access) +* Ansätze um die Nachteile von TDMA zu kompensieren: + * Zuweisung der Zeitslots nur an sendebereite Knoten + * Zentraler Master vergibt Rederechte + * Tokenring + * Stationen übermitteln Sendewunsch + +### Polling und Tokenweitergabe +Polling: +* Masterknoten läd Slaveknoten zum Übertragen in Reihenfolge ein +* Probleme: Polling Overhead, Latenz, Single Point of Failure + +Tokenweitergabe: +* Kontrolltoken wird von einem zum anderen Knoten übertragen +* Probleme: Token Overhead, Latenz, Tokenverlust + +### Bit-Map-Protokoll +* Stationen melden Sendewunsch während eines Reservierungsslots an + +Eigenschaften: +* Verhalten bei geringer Last: + * Wenn kaum ein Paket versendet werden soll, so wiederholt das Medium die Contentionslots - > Wartezeit +* Verhalten bei großer Last: + * Hoher und stabiler Durchsatz mit vernachlässigbarem Overhead +* Bit-Map ist ein Carrier Sense Protokoll + +### Limited Contention Protokolle +* Wünschenswert: Protokoll mit + * geringer Verzögerung bei wenig Last + * hohem Durchsatz bei viel Last +* Idee 1: + * Anpassen der Stationsanzahl per Contentionslot + * Contentionslots sind gut für den Durchsatz, bei geringer Last können wir es uns aber nicht leisten, auf die Antworten zu warten -> Stationen müssen sich dynamisch einen Slot teilen +* Idee 2: Adaptives Baumprotokoll + * Verwende verschiedene Auflösungslevel für die Wettbewerbsslots + * Im höchsten Level teilen sich alle einen Slot + * Wenn nur ein Node einer Gruppe senden will, so darf er das + * Wenn es mehr als einer ist, so kommt es zur Kollision im Contentionslot -> verdopplte die Slots und halbiere die Stationsanzahl pro Slot + * Rekursion! + +## Fallstudie Ethernet +### Topologien +* Bustoplogie := Alle Geräte sind an einem Kabel angebunden und sind in einer Kollisionsdomäne +* Sterntopologie := einfachere automatische Verwaltung und Wartung bei fehlerhaften Adaptern + +#### Unzuverlässiger, verbindungsloser Dienst +* Verbindungslos: + * Kein Handshake +* Unzuverlässig: + * Keine ACKs oder NACKs + * Datagrammstream kann Lücken haben, welche gefüllt werden müssen, falls benötigt + +#### Physisches Layer +* Typischerweise Manchestercodierung + +#### Ethernet verwendet CSMA/CD +* Keine Slots +* Carrier Sense: Niemand überträgt, wenn er merkt, dass ein anderer Adapter gerade sendet +* Collision Detection: Übertragender Adapter bricht ab, wenn er Kollisionen bemerkt +* Random Access: Warten einer zufälligen Zeit vor erneuter Übertragung + +##### Ethernet - CSMA-CD Algorithmus +1. Adapter erhält Datagramm von der Netzwerkschicht und erstellt Frame +2. Falls Kanal frei, so sendet der Adapter den Frame, falls dem nicht so ist, warte bis Kanal frei +3. Wenn erfolgreich übertragen, dann ist der Adapter mit dem Frame fertig +4. Falls eine andere Übertragung zeitgleich stattgefunden hat, so stoppe und sende ein Störsignal +5. Nach dem Abbrechen geht es in den Exponential Backoff: Nach n-ter Kollision wähle ein K aus {0,1,2,…,2^(m-1)} mit m = min{10,n}: Adapter wartet nun K * 512 Bitzeiten und kehrt zu 2 zurück + +* Jam Signal: Stellt mit 48 Bits sicher, dass alle anderen die Kollision mitbekommen haben +* Bitzeit: 0.1 µs bei 10 Mbps Ethernet +* Exponentiall Backoff: + * wähle zuerst K aus {0,1}, dann ab der zweiten Kollision aus {0,1,2,3} und nach 10 Versuchen aus {0,1,2,3,…,1023} + +#### Effizienz +efficiency = $\frac{1}{ (1+5 * (t_{prop}/t_{trans}))}$ + +#### Hubs +* essentielle physical-layer-repeater +* Eingehende Bits werden an alle Ausgänge mit selber Rate und ohne Puffern verteilt +* Kein CSMA-CD am Hub, Aufgabe der Adapter\ +-> Hub stellt nur elektronische Verbindung her -> eine Kollisionsdomäne + +#### Switch +* nicht nur eine einfache elektrische Verbindung für sternförmige Topologie +* Wie tauscht man Pakete zwischen Kollisionsdomänen aus? + * Switches enthalten Puffer, welche direkt ankommende Pakete zwischenspeichern, bevor sie diese weiterleiten + +#### Geschwindigkeiten der Ethernetversionen +1. Switched Ethernet - mehrere Stationen über ein Kabel +2. Fast Ethernet - wie Switched nur mit 10ns Bitzeit +3. Gigabit Ethernet - jedes Kabel hat genau zwei Maschinen angehängt + * Mit Switch: + * Keine geteilten Kollisionsdomönen, benötigen kein CSMA-CD + * Fullduplexoperation auf jedem Link + * Mit Hub: + * Kollisionen, Halbduples, CSMA-CD + * Maximale Kabellänge 25 Meter + +## Zusammenfassung Kapitel 5 +* MAC Protokolle sehr wichtig, wenn man sich ein Medium mit vielen Anderen teilen will +* Hauptkategorien: Collision, Collision Free und limited contention +* Maßzahlen zur Beurteilung: Durchsatz, Verzögerung und Fairness +* Wichtige Fallstudie: Ethernet - Lehre: Halte es einfach! + +--- +# Kapitel 6 Internetworking +## LAN Verbindungen +* Klassisches Ethernet - Ein Kabel eine Kollisionsdomäne +* Funktioniert für einige Geräte, kollabiert ab gewisser Größe, CSMA-CD kann ebenfalls nicht mehr mithalten + +### Gründe für mehrere LANs +* Beschränkte Anzahl an Nutzern in einem einzelnen Netz +* Geographische Verteilung - würde zu ungeheuren Round Trip Zeiten führen +* Zuverlässigkeit - Defekte Sender würden ständig zwischenfunken +* Sicherheit - Promiscous Operation - Begrenzung möglichen Schadens + +### Möglichkeiten des Überwindens der Begrenzungen +* Application Layer <-> Application Gateway +* Transport Layer <-> Transport Gateway +* Network Layer <-> Router +* Data Link Layer <-> Bridge, Switch +* Physical Layer <-> Repeater, Hub + +## Physical Layer Verbindungen +### Repeater +* Physical Layer Gerät, verbindet zwei Kabel und verstärkt die ankommenden Signale und leitet dieses weiter +* Versteht den Inhalt der Pakete nicht und interessiert sich nicht dafür + +### Hub +* Physical Layer Gerät, verbindet mehrere Kabel elektrisch +* Alle verbundenen Kabel formen eine Kollisionsdomäne +* Versteht den Inhalt der Pakete nicht und interessiert sich nicht dafür + +-> Lösungen nicht zufriedenstellend: Lösen die wirklich interessanten Probleme nicht + +## Data Link Layer +### Switch +* Verbindet mehrere Terminals, ohne eine Kollisionsdomäne zu erzeugen +* Speichert Link-Layer-Frames und leitet diese weiter +* Wenn ein Paket auf ein Segment geleitet werden muss, wird CSMA-CD zum Zugriff verwendet +* Inspiziert Adressen ankommender Pakete und leitet diese weiter (benötigt Puffer und Wissen, wo welches Terminal steht) + +Weiterleitung: Wie weiß man, wo was hingeleitet werden muss? -> Routingproblem + +#### Pfaderkennung - Selbstlernen +* Jeder Switch hat eine Switchtabelle +* Eintrag: (MAC-Adresse, Interface, Zeitstempel) +* Beim Empfang eines Frames lernt der Switch den Ort des Senders kennen (Rückwärtslernen) + +#### Weiterleiten +* Falls Ziel bekannt so prüfe, ob + * es in das selbe Segment gehört aus dem es kommt -> verwerfen + * sonst leite es passend weiter +* andernfalls flute das Netzwerk damit + +### Bridges +* Switches sind beschränkt, da sie nur einfache Terminals verbinden +* Jedes mit einer Bridge verbundene Netzwerk ist eine eigene Kollisionsdomäne, und auch verschiedene LAN-Typen können miteinander verbunden werden + +#### Rückwärtslernen in Bridges - Bootstrapping +* Algorithmus + * Flute, falls nicht bekannt wohin gesendet werden muss, oder + * verwerfe, wenn bekannt, dass es nicht nötig ist, oder + * leite spezifisch weiter, wenn das Ziel bekannt ist + +Probleme: Durch Fluten können Paketloops entstehen +##### Lösung 1: Einschränken des Flutens +* Verhindern des unendlichen loopens indem gespeichert wird, was schon weitergeleitet wurde +* Dies benötigt Zustände und Einzigartigkeit und Pakete müssen unterscheidbar sein +* Großer Overhead + * Zustände sind problematisch, da das Durchsuchen Zeit kostet + +##### Lösung 2: Spanning Trees +* Wandle das Netzwerk ein einen zyklenfreien Graph und berechne darauf den Spannbaum + > Definition Spannbaum:\ + > Gegeben sei ein Graph G=(V,E), ein Spannbaum T = (V,E-T) ist ein Subgrap von V, wobei E-T ein Teil von E ist, welcher ein Spannbaum, der verbunden und azyklisch ist. + +### Higher-Layer Verbindungen +#### Router +* Bisher haben alle Geräte Adressen entweder ignoriert, oder arbeiteten mit MAC-Layer Adressen +* Für Verbindungen außerhalb eines LANs sind solche Adressen nicht ausreichend + * Hauptproblem: flache Adressstruktur, nicht skalierbar +* Benötigen ausgefeiltere Adressstruktur + +#### Gateways +* Wenn selbst Router nicht ausreichend, dann sind Higher-Layer-Verbindungen notwendig + * Arbeit auf dem Transportlevel und oberhalb, zum Beispiel für Transcodierung + +### Weitere Probleme mit LAN/LAN Verbindungen +* LAN meist lokal eingesetzt, aber logische Distanz sollte auch berücksichtigt werden +* Idee: Platziere in das physische LAN ein virtuelles LAN (VLAN) +* Konfigurationstabellen bezüglich VLAN Zugehörigkeit benötigt + +## Zusammenfassung Kapitel 6 +* einzelne LANs sind nicht ausreihend um Kommunikationswege für größere Installationen bereitzustellen +* Verbindung einzelner LANs nötig + * Physisches Layer - Repeater und Hub + * Data-Link-Layer - Bridges und Switches + * Netzwerklayer - Routing + * Higher-Layer - Gateways +* Probleme: + * redundante Bridges ermöglichen Trafficfluten, benötigen Spannbaumalgorithmen + * Einfache Adressen nicht skalierbar -> benötigen Router + +--- +# Kapitel 7: Netzwerklayer +## Bauen großer Netzwerke +* Internetworkingmechanismen helfen Paketen an ihr Ziel zu gelangen + * Hubs: Broadcast + * Switch: Sende an direkt verbundenes Netzwerk + * Bridges: Fluten (verursacht Probleme) +* Fluten ist keine gute Idee für große Netzwerke -> Spannbäume sind aber schonmal gut + +## Netzwerklayerfunktionen +* Weiterleiten: Bewege Pakete vom Routereingang auf den entsprechenden Ausgang +* Routing: Berechnen der Route, die die Pakete von Quelle bis zum Ziel gegangen sind + +### Weiterleitung +* Wie bekomme ich Pakete von einem Netzwerk ins Andere? -> Verwende Switches/Bridges/Router +* Tatsächliche Routingtabellen enthalten IP-Adressen, Flags, Netzmasken, etc. + +### Durchsuchen der Routingtabelle +* Suche nach übereinstimmender Hostadresse (Flag H gesetzt) +* Suche dann nach passender Netzwerkadresse +* Drittens, Suche nach einem Defaulteintrag + * Führe netstat -rn auf der Maschine aus und finde die Einträge der Routingtabelle + * Erlaubt es uns einen einzelnen Eintra für eine Liste an Einträgen zu haben, welche alle den selben next-hop Wert haben +* Frage: Wie kommt man nun auf die in der Routingtabelle gespeicherten Informationen? + +## Zusammenspiel zwischen Routing und Weiterleitung +### Verbindungsaufbau +* Dritte wichtige Komponente in manchen Netzwerkarchitekturen + * ATM, Frame Relay, X.25 +* Bevor Datagramme fließen, werden zwei Hosts und Router eine virtuelle Verbindung aufbauen +* Netzwerk und Transportlayer Verbindungsdienste: + * Netzwerk: Zwischen zwei Hosts + * Transport: Zwischen zwei Prozessen +* Im Internet gibt es keinen Verbindungsaufbau auf dem Netzwerklayer + +### Netzwerkservicemodell +Frage: Welches Servicemodell für die Übertragung von Datagrammen vom Sender an den Empfänger verwenden? +* Dienste für individuelle Datagramme: + * Garantierte Zustellung mit weniger als 40msec Verzögerung +* Dienste für einen Datagrammstrom: + * Zustellung in Sendereihenfolge + * Garantierte Mindestbandbreite + * Begrenzungen bei den Abständen von Paketen + +### Virtuelle Schaltkreisbasierte vs. Datagrammorientierte Netzwerke +### Verbindungslose und Verbindungsbasierende Dienste auf dem Netzwerklayer +* Datagrammnetzwerke = verbindungsloser Netzwerklayerdienst +* VC Netzwerke = verbindungsbasierter Netzwerklayerdienst + +### Virtuelle Schaltkreise +* Rufaufbau bevor überhaupt etwas übertragen werden kann + Rufabbau danach +* Jedes Paket überträgt einen VC-Identifier +* Jeder Router auf dem Weg behält einen Zustand für jede Verbindung vor und es können Link und Routerressourcen an einzelne Verbindungen zugeteilt werden + +### Implementierung virtueller Schaltkreise +* Besteht aus einem Pfad von der Quelle zum Ziel, sowie +* VC-Nummern, für jeden Link auf dem Pfad +* und Einträgen in Weiterleitungstabellen in Routern auf dem Weg +* Pakete welche zum VC gehören tragen eine VC-Nummer +* VC-Nummern müssen auf jedem Link geändert werden (neue kommen von Weiterleitungstabellen) + +### Weiterleitungstabellen +* Aufbau: Incoming Interface, Incoming VC, Outgoing Interface, Outgoing VC + +### VC Signalprotokolle +* Verwendet zum Aufbau und zur Terminierung von VCs, heutzutage nicht mehr verwendet + +### Datagrammnetzwerke +* Kein Verbindungsaufbau auf dem Netzwerklayer +* Router halten keine Zustände für Ende-zu-Ende Verbindungen +* Pakete werden anhand ihrer Zielhostadresse weitergeleitet (-> verschiedene Pfade für selbes Ziel) + +### Longest Prefix Matching +* Wähle diejenige Adresse aus der Tabelle, welche die größte Anzahl führender Adressbits mit der gegebenen gemein hat + +### Datagramm vs. VC-Netzwerk +* Internet + * Datenaustausch zwischen Computern + * "intelligente" Endsysteme, können z.B. Fehlerkontrolle und Fehlerkorrektur implementieren + * Viele verschiedene Linktypen, d.h einheitlicher Dienst nahezu ausgeschlossen +* ATM + * Geht aus der Telefonie hervor + * Konzept menschlicher Kommunikation: + * Striktes Timing, Zuverlässigeit benötigt + * "Dumme" Endsysteme, d.h. Komplexität liegt innerhalb des Netzwerkes + +## Wie ist ein Router eigentlich aufgebaut? +* Zwei Hauptfunktionalitäten: + * Ausführen von Routingalgorithmen und Protokollen + * Weiterleiten von Datagrammen von eingehenden auf ausgehende Links + +### Eingangsportfunktionen +Dezentralisiertes Switching: +* Gegebenes Datagrammziel, finde passenden Ausgangsport durch Benutzung von Weiterleitungstabellen +* Queuing, falls Pakete schnelller ankommen als man sie weiterleiten kann + +### Switching Fabric +1. Switching mittels Speicher + * Herkömmliche Rechner mit Switching unter direkter CPU-Kontrolle + * Kopieren der Pakete in den Systemspeicher + * Geschwindigekeit limitiert durch die Speicherbandbreite +2. Switching mittels BUS + * Übertragung von Datagrammen intern über einen Bus + * Switchinggeschwindikeit limitiert durch die Busbandbreite + * typ. 1Gbps Bus, ausreichend für Heim und Businessrouter +3. Switching mittels Verbindungsnetzwerk (Crossbar) + * Überwinden der Bandbreitenbeschränkungen von Busen + * Design: Fragmentierung von Datagrammen in Zellen fester Größe, wobei nun die Zellen durch das Fabric geswitcht werden + * Bis zu 1.28 Tbps Switchinggeschwindigkeit + +### Ausgangsports +* Pufferung nötig, sobald Pakete vom Fabric schneller ankommen, als die Ausgangsrate ist +* Schedulingdisziplin wählt aus den zu übertragenden Datagrammen + +### Ausgangsportwarteschlangen +* Probleme: Verzögerung und Verluste durch Pufferüberläufe möglich + +### Eingangsportwarteschlangen +* Fabric langsamer als Kombination von Eingangsports -> Schlangenbildung +* Head-of-the-Line (HOL) blocking: Datagramme am Anfang der Warteschlange hindert andere in der Warteschlange daran weiter zu kommen +* Probleme: Warteschlangenverzögerung und Verluste durch Pufferüberläufe + +## IP - Datagrammformat und Paketverarbeitung +### IP Paketformat +* Version: Versionsnummer des eingesetzten IP +* IHL: IP Header Length in 32 Bit Worten +* Typ des Dienstes: Infos zur Priorisierung +* Totale Länge: Die gesamtlänge in Bytes inklusive Header +* Identifier: Wenn Fragmentierung auftritt, bekommt jedes zugehörige Paket den selben Identifier +* Flags: + * DF: don't fragment + * MF: more fragments, alle außer das letzte Paket haben dies gesetzt +* Fragment Offset: Position des Fragments im ursprünglichen Paket +* TTL: Zähler für die Hopanzahl, wird an jedem Router dekrementiert, sobald gleich 0 -> verwerfen +* Protokoll: Spezifiziert verwendetes Protokoll +* Headerchecksum: Erlaubt Verifizierung der Inhalte im IP Header +* Quell und Zieladressen: identifizieren der Quelle und des Ziels +* Optionen: bis 40 Byte, zur Erweiterung verwendet + +### IP Fragmentierung und Reassemblierung +* Netzwerklinks haben eine MTU (größter Linklevelframe) -> verschiedene Linktypen, verschiedene MTUs +* Große IP Datagramme werden innerhalb des Netzes unterteilt + * Aus einem Datagramm werden mehrere, die erst beim Zielsystem wieder zusammengesetzt werden + * IP Header Identifizieren und Ordnen die neuen Pakete + +### IP Adressierung +#### Scheitern von einfachen Adressierungsmethoden +* Bei MAC/LLC: Jedes Gerät mit globaler einzigartiger Adresse -> Probleme: Jede Bridge mit extra Eintrag für jedes Gerät -> massiver Speicher- und CPU-Overhead + +#### Adressierung und hierarchisches Routing +* Benötigen eine Adressstruktur welche hierarchische Routingstrukturen respektiert und ausdrückt + +#### Nähe +* Achtung: + * Proximity: Beschreibt physische Nähe + * Closeness: Beschreibt strukturelle und logische Nähe mit kurzer Distanz + +#### internetnamen und Adressen +#### Klassen von IP-Adressen +* Class A: sehr große Organisationen, bis 16 Millionen Hosts +* Class B: große Organisationen, bis 65 Tausend Hosts +* Class C: kleine Organisationen, bis 255 Hosts +* Class D: Multicast, keine Netzwerk/Host Hierarchie +* Class E: reserviert +* Loopback: 127.xxx.xxx.xxx ist zum Testen reserviert, hierauf versendete Pakete werden als eingehende behandelt +* Broadcast: alles 1en +* Adresshierarchie: + * Jede Adresse mit Hostteil und Netzwerkteil + * Class A,B,C unterstützen nur zwei Level der Hierarchie + * Aber weitere Strukturierung des Hostteils in Subnetze möglich + +### IP-Adressierung +* IP Adresse: 32 Bit Identifier für Hosts oder Routinginterfaces +* Interface: Verbindung zwischen Host und dem physischen Link + * IP Adressen werden an das jeweilige Interface vergeben + +#### Subnets +* IP Adresse: + * Subnetteil + * Hostteil +* Was ist ein Subnet? + * Geräteinterfaces mit selbem Subnetteil in der IP Adresse können untereinander ohne Router kommunizieren +* Um die Subnetze herauszufinden entferne jedes Interface von dessen Host oder Router. Somit erschaffte Inseln sind isolierte Netze, also Subnetze + +#### IP Adressen +* Classfull-Adressierung: + * Ineffiziente Nutzung von Adressräumen + * Bsp: Class B Netz allokiert Adressen für 65k Hosts, selbst wenn nur 2k Adressen benötigt +* CIDR - Classless Inter Domain Routing: + * Netzwerkportion von Adressen beliebiger Länge + * Adressformat a.b.c.d/x, wobei x die Anzahl an Bits in der Netzwerkportion der Adresse darstellt + +#### CIDR: Classless Inter Domain Routing +* Überwinden der Klassengrenzen durch Supernetting +* ISPs können nun Class C Blocks zu einem großen Block zusammenfassen +* "Longest match routing" auf maskierten Adressen +* Beispiel: Alle in Europa vergebenen Adressen teilen sich einen gemeinsamen Prefix -> Nur ein Eintrag für alle Verbindungen nach Europa in den meisten amerikanischen Routern + +#### Wie bekommt man eigentlich eine IP-Adresse? +* Hart eincodiert in einer Konfigdatei +* DHCP: Dynamic Host Configuration Protocol: beziehe die Adresse dynamisch von einem Server + +#### Wie kommt das Netzwerk eigentlich an seinen Subnetpart von IP-Adressen? +* Der Provider stellt eine allokierte Portion des Addressraums des ISPs bereit + +### IP Adressierung: Allokation von Adressen +Woher bekommt ein ISP einen Adressblock?\ +-> ICANN: Internet Corporation for Assigned Names and Numbers +* Allokiert Adressen +* Verwaltet DNS +* Weist Domainnamen zu und löst Konflikte + +#### NAT - Network Address Translation +* Motivation: Knappheit an IP-Adressen +* Idee: + * Lokale Netzwerke haben nur eine der Außenwelt bekannte IP-Adresse, somit hat nicht jedes Gerät eine vom ISP bereitgestellte Adresse +* Vorteile: + * Möglichkeit intern Adressen zu vergeben ohne die Außenwelt informieren zu müssen + * Wechsel des ISPs möglich, ohne intern Adressen zu verändern + * Geräte im Netzwerk nicht von außen ansprechbar (Sicherheitsfaktor) +* 16 Bit Portnummernfeld -> 60 000 simultane Verbindung mit nur einer einzigen LAN-Side Adresse +* NAT ist allerdings kontrovers diskutiert: + * Router sollten nur bis Layer 3 verarbeiten + * Verletzt das Ende-zu-Ende Prinzip + * Adressmangel sollte durch IPv6 gelöst werden + +#### Schließen der letzten Lücke: ARP +* Was passiert, wenn ein Paket bei seinem Zielnetzwerk ankommt? + * Wie wandelt man eine IP-Adresse in eine MAC-Adresse, welche dem zugehörigen Gerät gehört? +* Einfachste Lösung: Schreie! + * Broadcast auf das LAN, mit der Frage, welcher Node IP X.X.X.X hat + * -> Antwort des Nodes mit der MAC-Adresse -> Zustellung möglich +* ARP - Adress Resolution Protocol + +##### ARP Protokoll im gleichen LAN +* A möchte B ein Datagramm senden, aber Bs MAC ist nicht in As ARP Tabelle +* A broadcastet ein ARP-Anfrage-Paket, welches Bs IP-Adresse enthält + * Ziel-MAC = FF-FF-FF-FF-FF-FF + * Alle Maschinen im LAN erhalten die Anfrage +* B erhält das ARP-Paket, und antwortet A mit seiner MAC +* A speichert das IP to MAC Adresspaar in seiner ARP Tabelle bis die Information veraltet ist +* ARP ist eine Plug-and-Play Technologie (Nodes erstellen ihre Tabellen selbstständig) + +##### Routing in ein anderes LAN +* A erstellt Datagramm mit Quelle A und Ziel B +* A verwendet ARP um Rs MAC-Adresse für die IP hier 111.111.111.110 zu erhalten +* A erstellt Link-Layer-Frame mit Rs Macadresse als Ziel, Inhalt: A zu B Datagramm +* As Adapter sendet den Frame, Rs Adapter erhält diesen +* R entfernt das IP-Datagramm vom Ethernetframe und sendet es ans Ziel B +* R verwendet ARP um Bs Adresse zu erhalten +* R erstellt einen Frame, welcher das A zu B Datagramm enthält, und sendet diesen zu B + +## ICMP und IPv6 +### ICMP: Internet Control Message Protocol +* Verwendet von Hosts und Routern um auf Netzwerkebene Informationen auszutauschen + * Fehlermeldungen oder Echo-Anfragen +* In Netzwerkebenen oberhalb von IP werden ICMP Nachrichten als IP Datagramme versendet +* ICMP Nachrichten: Typ, Code + erste 8 Bytes des den Fehler auslösenden IP-Datagramms + +#### Traceroute und ICMP +* Quelle sendet Serie von UDP Nachrichten ans Ziel, jeweils immer mit TTL+1 +* Wenn das n-te Datagramm am n-ten Router ankommt, so verwirft er dieses, sendet aber eine ICMP Nachricht (Typ 11, Code 0) an die Quelle, welche Namen und IP des Routers enthält +* Zurück an der Quelle wird die RoundTripTime errechnet, traceroute macht dies drei mal +* Stoppkriterien: + * UDP Segment erreicht das Ziel + * Ziel gibt ein "host unreachable" zurück (Typ 3, Code 3) + +## IPv6 +* Motivation: + * 32 Bit Adressraum bald ausgeschöpft + * Headerformat hilft bei schneller Verarbeitung und Weiterleitung + * Header nun als Hillfmittel für QoS +* IPv6 Datagrammformat + * Header mit 40 Byte Größe (also 20 Byte mehr als bei IPv4) + * Fragmentierung ist nicht mehr erlaubt + +### IPv6 Header +* Priority: Signalisiert die Priotität der Datagramme im Fluss +* Flow Label: Identifiziert Datagramme im selben Fluss +* Next Header: Identifiziert das Layer der höheren Schicht für Daten + +### Weitere Veränderungen zu IPv4 +* Checksummen -> komplett entfernt +* Optionen -> Erlaubt, aber außerhalb des Headers +* ICMPv6 -> Zusätzliche Nachrichtentypen + Multicastgruppenmanagementfunktionen + +### Übergang von IPv4 zu IPv6 +* Nicht alle Router können gleichzeitig aktualisiert werden -> Frage: Wie kann das Netzwerk mit einer Mischung aus beiden Versionen zurechtkommen? +* Lösung: Tunneln: + * IPv6 wird als Nutzlast in IPv4 Datagrammen mitgeschickt + * Rückschläge -> Zusätzlicher IPv4 Header + * Verarbeitungsoverhead an den Tunnelendpunkten + * Keine Priorisierung möglich + +## Routing Algorithmen +### Überblick über Routingalgorithmen +* Ein Router führt einen Routingalgorithmus aus, um zu entscheiden, an welchem Ausgang ein eingehendes Paket weiter übertragen werden sollte. + * Verbindungsorientiert: nur beim Verbindungsaufbau + * Verbindungslos: entweder für jedes Paket oder periodisch ausgeführt +* Oftmals unter Verwendung von Metriken + * Zuweisung eines Kostenfaktors an jeden Link, bspw. Anzahl an Hops, Kosten in € eines Links,… +* Zwei grundlegende Typen existieren: + * Nichtadaptive Routingalgorithmen: Nehmen keine Rücksicht auf aktuellen Netzwerkzustand (z.B. Fluten) + * Adaptive Routingalgorithmen: Berücksichtigen aktuellen Netzwerkzustand (z.B. Distanzvekotrrouting, Link State Routing) + +### Fluten +* Strategie: jedes eingehende Paket wird auf jede ausgehende Linie geschickt, außer auf die Herkunftslinie +* Reduzierung der Nummer an Duplikaten: + * Hopzähler im Paketheader, sodass das Paket nach gewisser Anzahl an Hops verworfen wird + * Füge im ersten Router Sequenznummern in jedes Paket ein, welches vom Host empfangen wird. Jeder Router beinhaltet eine Tabelle, welche Sequenznummern er vom first-hop Router bekommen hat, daraufhin verwirft er alle Pakete, welche er bereits gesehen hat. + +#### Mögliche Anwendungsfelder fürs Fluten +* Militärische Anwendungen: + * Ziel soll immer erreicht werden können +* Updaten von verteilten Datenbanken +* Netzwerke mit häufigen Topologiewechseln + +### Zufallsrouting +* Jedes ankommende Paket wird auf einen zufälligen Ausgang geschickt, außer auf den Quellausgang -> es bahnt sich seinen Weg sozusagen durch den Router + +### Adaptive Routingalgorithmen +* Probleme nichtadaptiver Algorithmen: + * Keine Anpassungsmöglichkeit auf stark schwankendes Verkehrsaufkommen + * Kein ausreichend guter Umgang mit berstendem Verkehr +* Drei Grundtypen + * Zentralisiertes adaptives Routing + * Isoliertes adaptives Routing - benötigt keinen Informationsaustausch zwischen Routern + * Verteiltes adaptives Routing - Router tauschen periodisch Infos aus und aktualisieren Weiterleitungstabellen + +#### Zentralisiertes adaptives Routing +* Strategie: + * Anpassen an die vorherrschende Verkehrslast + * Ein Routingkontrollcenter muss ins Netzwerk eingebaut sein, welches periodisch den Linkstatus der Router erhält und kürzeste Routen berechnet und diese an die Router sendet +* Probleme: + * Ausfall des Controllers sorgt für nichtadaptives Routing + * Skaliert nicht + +#### Isoliertes adaptives Routing +* Idee: + * Routingentscheidungen werden nur anhand der Informationen des lokalen Routers getroffen, wie bei Hotpotato oder Rückwärtslernen +* Hot Potato Routing + * Wenn ein Paket ankommt, so leite es auf schnellste Art und Weise an den Ausgang mit der kleinsten Ausgangswarteschlange, ganz egal wohin dieser Ausgang dann führt + +##### Rückwärtslernen +* Idee: + * Paketheader enthalten wichtige Infos, wie Quelle, Ziel, Hopzähler -> Netzwerkknoten lernen etwas über die Netzwerktopologie während sie Pakete behandeln +* Algorithmus: + * Routing ursprünglich zufällig + * Pakete mit Hopzähler 1 stammt von direkt verbundenem Knoten, usw… + * Bei Ankunft eines Pakets vergleicht der IMP die Hopzahl für eine gegebene Quelladresse und aktualisiert diese falls nötig + * Wichtig: Periodisches Vergessen der Routen ist wichtig, um sich weiterhin anpassen zu können + +#### Verteiltes adaptives Routing +* Ziel: Finde einen guten Pfad durch das Netzwerk, welcher einen von der Quelle zum Ziel führt +* Graphabstraktion für Routingalgorithmen + * Graphknoten sind Router + * Graphkanten sind physische Links + * Linkkosten: Verzögerung, € Kosten oder das Staulevel + * Pfadkosten: Summe der Linkkosten auf einem Weg + +#### Klassifikation von Algorithmen für dezentralisiertes adaptives Routing +Globale vs. dezentralisierte Information? +* Dezentralisiert + * Router kennen physisch verbundene Nachbarn und Linkkosten zu diesen + * Iterativer Prozess zum Berechnen und Austausch von Informationen mit Nachbarn + * Distanzvektoralgorithmen: + * RIP - Routing Information Protocol + * BGP - Border Gateway Protocol +* Global + * Alle Router haben vollständige Topologie- und Linkkosteninformationen +* Link State Algorithmen + * Dijkstra + * OSPF - Open Shortes Paths First + +Statisch oder dynamisch? +* Statisch + * Router wechseln langsam über die Zeit hinweg +* Dynamisch + * Router wechseln häufiger + * Periodisches Updaten als Antwort auf Linkkostenwechsel + + +### Distanzvektorrouting Algorithmen +* Iterativ + * Läuft bis keine Knoten mehr Informationen austauschen + * Selbstterminierend -> kein Stoppsignal +* Asynchron + * Knoten müssen Informationen nicht getaktet austauschen +* Verteilt + * Jeder Knoten kommuniziert nur mit seinem direkten Nachbarn +* Distanztabellendatenstruktur + * Jeder Knoten hat seine eigene + * Spalte für jedes mögliche Ziel + * Zeile für jeden direkt angeschlossenen Nachbarknoten + * Beispiel: in Knoten X, für Ziel Y über Nachbar Z: + +> D^X(Y,Z) = Distanz von X nach Y mit Z als nächsten Hop + +#### Distanzvektorrouting - Übersicht +* Iterativ, asynchron: + * Jede lokale Änderung wird verursacht durch: + * lokale Änderung der Linkkosten + * Nachricht vom Nachbarn also dessen Änderung des kleinsten Knotenpfads +* Verteilt: + * Jeder Knoten benachrichtigt die Nachbarn nur dann wenn sich dessen Pfad mit den kleinsten Kosten geändert hat + +#### Distanzvektoralgorithmus - Quelltext +``` +//Initialisierung: +//für alle adjazenten Knoten v: +D^X(*,v) = infinity +D^X(v,v) = c(X,v) +//für alle Ziele y +sende min-w D^X(y,w) an jeden Nachbarn +loop +wait (bis eine Veränderung der Linkkosten auffallen oder man benachrichtigt wird) +if(c(V,X) verändert) + // verändere die Kosten zu allen Zielen durch den Nachbarn v durch d + // d kann auch negativ sein + für alle Ziele y: D^X(y,V) = D^X(y,V)+d +else if(Empfang eines Updates von V w.r.t Ziel Y) + // der kürzeste Pfad von Y zu einem Y hat sich verändert + // V hat einen neuen Wert für sein min-w D^V(Y,w) + // rufe diesen neuen Wert newval ab + für dieses einzelne Ziel y: D^X(y,V) = c(X,V)+newval +if (neues min-w D^X(Y,w) für irgendein Ziel Y, so senden wir den neuen Wert an alle Nachbarn) +forever +``` + +#### Distanzvektor: Reaktion auf Veränderung der Linkkosten +* Der Knoten erkennt die Veränderung von lokalen Linkkosten +* Die Distanztabelle wird geupdated +* Wenn Kosten im kleinsten Kostenpfad verändert werden, so werden die Nachbarn benachrichtigt +* Gute Nachrichten verbreiten sich schnell, schlechte Nachrichten verbreiten sich nur langsam + +#### Poisoned Reverse +* Wenn Z durch Y routet um zu X zu gelangen: + * Z sagt Y, dass seine eigene Distanz zu X unendlich ist (somit routet Y nicht über X nach Z) + * Löst dies das gesamte Problems des Zählens bis in die Unendlichkeit? + +### Link State Routing +* Linkstaterouting verwendet typischerweise Dijkstras Algorithmus + * Netzwerktopologie und Linkkosten sind allen Knoten bekannt: + * erzielt durch den Link-State-Broadcast + * Alle Knoten mit selber Information +* Ziel: Berechnung des kleinsten Kostenpfades von einem Knoten S zu allen andern Knoten V: + * Kann verwendet werden um eine Routingtabelle für dieses s zu erstellen + +#### Dijkstrasalgorithmus zur Berechnung kürzester Pfade +* Grundlegende Idee: + * Menge N mit Quellknoten S, füge nach und nach die zu dem Zeitpunkt bekannten mit kürzesten Pfaden erreichbaren Knoten ein + * Initial werden alle Pfade zu anderen Knoten als S auf unendlich gesetzt + * In jedem Schritt: + * Wähle Knoten V, welcher nicht in N ist, und von S aus nur mit Pfaden über bereits entdeckte Knoten erreicht werden kann + * Füge V in N ein + * Aktualisiere die geschätzten Kosten für alle direkten Nachbarn w von v, falls ein Pfad über v billiger wäre als die bisherige Schätzung + * Wenn eine Schätzung für einen Knoten w angepasst wird, so speichere auch den Vorgängerknoten V, welcher zu dieser Schätzung führt +* Somit speichert der Algorithmus für jeden Knoten v: + * Einen Schätzwert für den kürzesten Pfad + * Den Vorgängerknoten p(v) vom bis dahin als kürzesten Pfad angenommenen Pfad von s zu v + * Eine Listen von Knoten N für welche die kürzesten Pfade definitiv bekannt sind +* Aktualisierungsverfahren für die Schätzwerte + * Angenommen der Knoten v ist neu in die Liste hinzugefügt worden und wir aktualisieren den Schätzwert für den Knoten w: + * d(v) ist der Schätzwert für den kürzesten Pfad von v, d(w) ist der Schätzwert für w + * c(v,w) sind die Kosten der Kante von v zu w + +```cpp +if( d(v) + c(v,w) < d(w)){ + d(w) = d(v) + c(v,w); + p(w) = v; +} +``` + +* Intuition hinter dieser Prozedur + * Nimm an, dass d(w) und d(v) endlich sind + * Es existiert also ein Pfad (s,v1,v2,…,v) von s zu v mit gewicht d(v) + * Folglich existiert ein Pfad (s,v1,v2,…,v,w) von s zu w mit dem Gewicht d(v) + c(v,w) + * Also gibt es einen weiteren Pfad mit Gewicht d(w) + * somit kann der kürzeste Pfad zu w nicht mehr Gewicht haben, also entweder d(w) oder d(v)+c(v,w). + +#### Weiterführende Diskussion zu Dijkstras Algorithmus +* Algorithmenkomplexität für |V| Knoten: + * Jedes mal Überprüfung aller Knoten die nicht in N sind + * Benötigt O(V²) Vergleiche, dies ist optimal in dicht besiedelten Graphen + * Für dünnbesiedelte Graphen gibt es schnellere Varianten +* Variable Linkkosten -> Oszillation möglich + +#### Link State Routing mit Dijkstras Algorithmus +* Jeder Router misst diie Kosten zwischen sich selbst und benachbarten Routern +* Der Router baut ein Paket, welches all diese Daten enthält +* Verteilung dieser Pakete durch Fluten mit Sequenznummern und einem Altersfeld, sodass bereits gesehene Pakete oder veraltete verworfen werden können +* Sobald ein Router alle Linkstatepakete erhalten hat, kann er die gesamte Topologie rekonstruieren und einen kürzesten Pfad zwischen sich und allen anderen Knoten berechnen + +#### Vergleich zwischen Link-State und Distanzvektoralgorithmen +* Nachrichtenkomplexität: + * LS: mit N Knoten und E Links werden O(n-e) Nachrichten versandt + * DV: Austausch nur zwischen Nachbarn +* Konvergenzgeschwindigkeit + * LS: O(n²) Algorithmus benötigt O(N-E) Nachrichten (teils mit Oszillation) + * DV: Konvergenzzeit variiert + * Routingschleifen, Count to Infinity Problem, Oszillation +* Robustheit: (im Falle eines Routerausfalls) + * LS: + * Ein Knoten kann falsche Linkkosten ausgeben + * Jeder Knoten berechnet nur seine eigene Tabelle + * DV: + * DV Knoten kann falsche Gewichte ausgeben + * Jede Tabelle wird nun noch von anderen Routern verwendet -> Fehler breiten sich über das ganze Netzwerk aus + +### Hierarchisches Routing +Warum benötigen wir hierarchisches Routing? +* Skalierbarkeit -> 50+ Millionen Ziele in Routingtabellen ist sinnlos +* Autonomität -> Internet = Netz von Netzen, aber ein Admin möchte eventuell ja den Traffic im eigenen Netzwerk kontrollieren + +#### Autonome Systeme +* Aggregation von Routern in Regionen -> Autonome Systeme AS +* Router im selben AS verwenden das selbe Routingprotokoll + * Intra-AS Routingprotokoll + +> Gateway Router:\ +> * Spezielle Router innerhalb des AS, führen das Intra-AS Routingprotokoll mit allen anderen Routern im AS aus +> * Zusätzlich verantwortlich für das Routing an exteren Ziele -> Inter-AS Routingprotokolle mit anderen Gatewayroutern + +#### Routing im Internet +* Das globale Internet besteht aus miteinander verbundenen AS + * Stub AS: kleine Unternehmen (ein Link zum Internet) + * Multihomed AS: große Unternehmen (mehrere Links, ohne Transitverkehr) + * Transit AS: Netzbetreiber +* Zwei Level Routing: + * Intra-AS: Administrator verantwortlich für die Auswahl + * RIP: Distanzvektor + * OSPF: Link State + * IGRP: Distanzvektor + * Inter-AS: Einheitlicher Standard + * BGP: Pfadvektor + +#### Verschiedenes Intra-AS und Inter-AS Routing, aber warum? +* Policy: + * Inter AS: Admin möchte Kontrolle über sein Netz haben + * Intra AS: ein einziger Admin, also keine Policyentscheidungen nötig +* Skalierbarkeit: + * Hierarchisches Routing spart Tabellenplatz und sorgt für weniger Updateverkehr +* Performance: + * Inter-AS: Policy wichtiger als Performance + * Intra-AS: Performance als oberstes Gut + +#### Verbundene autonome Systeme +* Forwardingtabelle sowohl durch intra- als auch inter-AS Routingalgorithmen konfiguriert + * Intra-AS setzt Einträge für interne Ziele + * Inter-As und Intra-AS setzt Einträge für externe Ziele + +#### Inter-AS Aufgaben +* Problem + * AS1 erhält Datagramm für ein Ziel außerhalb von AS1, Weiterleitung durch Gateway Router, aber welchen? +* AS1 muss lernen welche Ziele über AS2 und AS3 erreichbar sind und diese Info an alle Router in AS1 weitergeben +* -> Job des Inter-AS Routing + +##### Beispiel: Setzen der Weiterleitungstabelle in Router 1d +* Angenommen AS1 lernt vom Inter-AS Protokoll, dass das Subnetz x durch AS3 (Gateway 1c) erreichbar ist, aber nicht von AS2 +* Verteilung der Info an alle internen Router +* Router 1d bestimmt über die Intra-AS Routinginformation, dass sein Interface l auf dem Pfad mit den geringsten Kosten zu 1c ist +* Der Router setzt nun einen Eintrag in die Weiterleitungstabelle (x,l) + +##### Beispiel: Wählen aus mehreren ASen +* Angenommen AS1, lernt durch das inter-AS Protokoll, dass es Subnetz x über AS2 und AS3 erreichen kann +* Um die Weiterleitungstabelle zu Konfigurieren muss Router 1d herausfinden, zu welchem Gateway es die Pakete für Subnetz x weiterleiten sollte -> Ebenfalls Job des Inter-AS Protokolls +* Hot-Potato-Routing: Sende das Paket an den nächsten von zwei Routern, werde das Paket also so schnell wie möglich wieder los + +### Routing im Internet +#### Intra-AS Routing (IGP) +* Typische Routingprotokolle: RIP, OSPF, IGRP + +#### RIP - Routing Information Protokoll +* Distanzvektoralgorithmus mit #Hops als Metrik + +#### RIP - Advertisements +* Distanzvektoren: + * Austausch zwischen Nachbarn alle 30s via Responsenachrichten + * Auch Advertisements genannt +* Jedes Advertisement + * Liste an bis zu 25 Zielnetzwerken im AS + +#### RIP - Linkausfall und Linkrecovery +Falls nach 180s kein Advertisement empfangen wurde, so deklariere den Nachbarn als tot +* Routen werden invalid -> Nachbarn werden informiert und verbreiten die Informationen +* Verwenden poisoned reverse um ping-pong-loops zu verhindern (undendliche Distanz = 16 Hops) + +#### RIP - Tabellenverarbeitung +* RIP Routingtabellen werden durch einen Prozess (route-d) auf Anwendungsebene gemanagt +* Advertisements werden periodisch in UDP Paketen verschickt + +### OSPF - Open Shortest Path First +* Open = Öffentlich verfügbar +* Beruht auf dem Link-State-Algorithmus + * LS Paketfluten + * Topologiekarte an jedem Knoten verfügbar + * Routenberechnung mit Dijkstra +* OSPF Advertisements annocieren nun keine Wege sondern Linkzustände mit je einem Eintrag pro Nachbarknoten + * Fluten der Advertisements, welche direkt in IP Pakete eingebettet sind, in das gesamte Netzwerk + +#### Weiterführende Funktionen +* Sicherheit: alle Nachrichten authentifiziert +* Mehrere Pfade mit gleichen Kosten erlaubt +* Für jeden Link gibt es mehrere Kostenmetriken für verschiedene Types of Service (TOS) +* Integrierter Support für Uni und Multicast + > Unicast: Ein Sender, ein Empfänger + > + > Multicast: Ein Sender, eine Gruppe von Empfänger + > + > Broadcast: Ein Sender, alle Teilnehmer eines Netzes + +#### Hierarchisches OSPF +* Zwei Level Hierarchie: local Area, backbone + * Link State Advertisements nur im eigenen Gebiet + * Jeder Knoten mit detaillierter Gebietstopologie, kennt aber nur die Richtung zu Netzwerken in anderen Gebieten +* Area Border Router: Fassen Distanzen zu Netzen im eigenen Gebiet zusammen, senden Adverisements an andere Area-Border-Router +* Backbone Router: führen OSPF uneingeschränkt auf Backbones aus +* Boundary Router: verbinden zu anderen ASs + +#### BGP - Border Gateway Protokoll +* De facto Standard +* BGP stellt jedem autonomen System die Möglichkeit bereit: + * Subnetzerreichbarkeitsinfos vom Nachbar AS zu erhalten + * Erreichbarkeitsinformationen im gesaten AS zu verteilen + * Gute Routen zu Subnetzen herauszufinden + * Erlaubt es Subnetzen deren Existenz zu verkünden + +#### BGP - Grundlagen +* Routerpaare tauschen Routinginformationen über semipermanente TCP Verbindungen aus: BGP Sitzungen (sind keine physischen Links) +* Wenn AS2 einen Prefix an AS1 verkündet, so ist dies ein Versprechen, alle an diesen Prefix adressierten Datagramme dorthin weiterzuleiten + +#### Verteilung von Erreichbarkeitsinformationen +* Dank eBGP Sitzung zwischen 3a und 1c sendet AS3 eine Prefixerreichbarkeitsinformation an AS1 +* 1c kann dann iBGP verwenden um diese neue Prefixerreichbarkeitsinformation an alle Router in AS1 verschicken +* 1b kann diese neue Erreichbarkeitsinformation an AS2 über die 1b zu 2a eBGP Sitzung weiter verteilen +* Wenn ein Router etwas über einen eneuen Prefix lernt, so erstellt er einen Eintrag für diesen Prefix in seiner eigenen Weiterleitungstabelle + +#### Pfadattribute und BGP Routen +* Wenn ein Prefix verkündet wird, so enthält diese Verkündigung BGP Attribute: + * Prefix + Attribute = Route +* Zwei wichtige Attribute + * AS-Pfad: Erhält die AS,durch die welche die Verkündigung für den Prefix hindurchgegangen ist + * NEXT-HOP: Indiziert den spezifischen internen AS Router, welcher sozusagen spezifiuiert, in welches AS man als nächsten Hop gehen sollte +* Wenn der Gatewayrouter eine Routenankündigung erhält, so verwendet er eine import policy zum Annehmen oder Ablehnen der Route + +#### BGP Routenwahl +* Falls mehr als eine Route zum Prefix führt muss eine gewählt werden, bspw. durch Policyentscheidungen, kürzeste AS Pfade oder Hot-Potato-Routing, … + +#### BGP Nachrichten +* BGP Nachrichten werden in TCP Nachrichten übertragen + * OPEN: Öffnet TCP Verbindung zum Peer und authentifiziert den Sender + * UPDATE: Kündigt neuen Pfad an oder verwirft den Alten + * KEEPALIVE: Hält die Verbindung am Leben wenn keine Update-Nachrichten verschickt werden müssen, ebenfalls das ACK für die OPEN Anfrage + * NOTIFICATION: Zeigt Fehler in vorheriger Nachricht an; wird auch zum Terminieren der Verbindung verwendet + +## Zusammenfassung Kapitel 7 +* Routing in großen Netzwerken benötigt nicht nur adäquate Routingalgorithmen für generelle Graphen, sondern auch eine angemessene, hierarchische Struktur für Netzwerke +* Die Netzwerkstruktur muss sich in der Adressierungsstruktur zeigen, da flache Adressen in einem vermeidbaren Overhead resultieren würden +* Verschiedene Metriken und Ziele müssen erreicht werden, insbesondere im Interdomainrouting, bei welchem Optimalität nur ein einzelner Aspekt ist + +--- +# Kapitel 8: Transport Layer +## Transportlayerdienste und Protokolle +* Stellen logische Kommunikation zwischen Anwendungsprozessen von verschiedenen Hosts bereit + * Sendeseite: Segmentiert Anwendungsnachrichten und leitet diese Segmente an die Netzwerkschicht + * Empfangsseite: Reassembliert Segmente in Nachrichten und leitet diese an die Anwendungsschicht weiter +* Als Transportprotokolle werden im Internet hauptsächlich TCP und UDP verwendet + +## Transport vs. Netzwerklayer +* Netzwerklayer: logische Kommunikation zwischen zwei Hosts +* Transportlayer: logische Kommunikation zwischen zwei Prozessen + +## Transportlayerprotokolle im Internet +* Zuverlässige, in Order Zustellung: TCP + * Stau- & Flusskontrolle + * Verbindungsaufbau +* Unzuverlässige, ungeordente Zustellung: UDP + * Einfache Erweiterung des best Effort IP Ansatzes +* Nicht vorhanden sind: Verzögerungs- und Bandbreitengarantien + +## Adressierung und Multiplexing +* Stelle mehrere SAPs bereit um mehrere Anwendungen zu Multiplexen +* Bspw: Portnummern + * Dynamisch alloziert, aber teils vordefiniert für bekannte Dienste, Webserver Port 80, Port 25 für Mail + +## Multiplexing und Demultiplexing +* Multiplexing auf Sendeseite: + * Sammeln von Daten an mehreren Sockets, verpacken der Daten mit Header zum Demultiplexing +* Demultiplexing auf Empfangsseite: + * Zustellen empfangener Segmente an den korrekten Socket + +### Wie funktioniert Demultiplexing? +* Hosts verwenden IP-Adressen und Portnummern um Segmente an korrekte Sockets zuzustellen + +### Verbindungsloses Demultiplexing +* Erstelle Sockets mit Portnummern + * DatagramSocket mySocket1 = new DatagramSocket(9111); + * DatagramSocket mySocket1 = new DatagramSocket(9222); +* UDP Sockets werden übber Zweiertupel aus Ziel IP und Ziel Port identifiziert + +### Verbindungsorierntiertes Demultiplexing +* TCP Sockets werden durch ein Vierertupel aus Quell-IP, Quellport, ZielIP und Zielport identifiziert +* Der Emfpänger verwendet alle vier Werte um das Segment an den passenden Socket weiterzuleiten +* Pro Server gleichzeitig mehrere Sockets, eindeutig bestimmt durch das 4er Tupel +* Webserver haben verschiedene Sockets für jeden verbundenen Client + * Nichtpersistentes HTML hat verschiedene Sockets für jede Anfrage + +### Multithreaded-Webserver +* Behandelt jede Anfrage als einen neuen Thread, anstelle eines neuen Prozesses, dh. ein Prozess handelt mehrere simultane Verbindungen -> höhere Crashwahrscheinlichkeit + +### Verbindungskontrolle +* Bei verbindungsorientierten Diensten gibt es drei Phasen der Verbindung: + * Connect + * Data + * Disconnect +* Für jede Phase gibt es spezielle Dienstprimitive, wobei wir je nach Layer noch einen layerspezifischen Prefix an die Primitive hinzufügen + * Transportlayer: T-Connect, T-Data, T-Disconnect + +#### Aufbau der Transportverbindung +* bestätigendes Serviceprimitiv: T-Connect +* Primitive: + * T-Connect.Request(Zieladr., Quelladr) + * T-Connect.Indication(Zieladr., Quelladr.) + * T-Connect.Response(Antwortadresse) + * T-Connect.Confirmation(Antwortadresse) + +#### Datentransferdienst +* Datentransferdienst: T-Data (bestätigungslos) +* Primitive: + * T-Data.req(userdata) + * T-Data.ind(userdata) + +#### Verbindungsabbau +* bestätigungsloser Abbaudienst: T-Disconnect +* Verwendung: + * Abrupter Abbau einer Verbindung (möglw. Verlust von TSDUs) + * Ablehnen einer Verbindungsanfrage +* Primitive: + * T-Disconnect.req(userdata) + * T-Disconnect.ind(reason, userdata) +* Parameter: + * Grund des Abbaus: z.B. unbekannt, Veranlasst durch anderen Nutzer, Fehlen von Ressourcen, Auftreten von Fehler, Unerreichbarkeit + +#### Probleme während des Verbindungsaufbaus +* Verlust der CR (Connection Request) oder CC (Connection Confirm) TPDU +* Duplikate von TPDUs + +##### Drei Wege Handshake +* Problematisch ist vor allem der Verlust der CC TPDU +* Lösung: Drei Wege Handshake während des Verbindungsaufbaus + * Verbindung wird Aufgabaut, sobald beide Verbindungsaufbau TPDUs bestätigt wurden + * Benötigt zusätzliches ACK (Acknowledgement) oder DT (Data) +* Neues Problem: Schützt noch nicht vor verspäteten Duplikaten + * Problem: Wenn sowohl die Verbindungsanfrage CR, als auch die Verbindungsbestätigung CC dupliziert und verspätet sind, so hat der Empfänger wieder keine Möglichkeit herauszufinden ob dies eine neue oder alte Kopie ist +* Lösung: Der Sender muss eine Frage beantworten, welche der Empfänger fragt + * Packe hierzu eine Sequenznummer in die CR, ACK, CC, DATA TPDUs + * Muss durch die Gegenseite kopiert werden, und erlaubt den Verbindungsaufbau nur dann, wenn die korrekte Nummer bereit gestellt wird. Verwende Sequenznummern deshalb möglichst nicht schnell hintereinander erneut +* Neue Lösung funktioniert für Duplikate der CR und der CR + ACK + +##### Verbindungsablehnung +* Ablehnung einer eingehenden CR mit einer DR oder Error TPDU + * Gründe: + * Ablehnung durch Transportdienstbenutzer + * Nichterfüllbarkeit der Dienstanforderungen + +##### Verbindungsabbbau +* Normaler Abbau + * Kann den Verlust von nicht bestätigten Daten nach sich ziehen, TCP verhindert dies, indem alle gesendeten PDUs vor Beenden der Verbindung bestätigt werden müssen + * Varianten: + * implizit: Abbau der Netzwerklayerverbindung + * explizit: Verbindungsfreigabe mit Disconnect-TPDUs +* Sobald ein Verbindungskontext aufgebaut ist, sollte es einfach sein, eine Verbindung wieder abzubauen + * Ziel: Abbau der Verbindung erst dann, wenn beide Teilnehmer zugestimmt haben, nichts mehr sagen zu wollen und alles erhalten zu haben -> Praktisch ist dies unmöglich: Denn woher weiß man, dass der Andere weiß, dass man weiß, dass der Andere weiß …, dass alles volständig übertragen wurde? -> Problem der zwei Armeen + +##### Verbindungsabbau in der Realität +* Problem der zwei Armeen ist dem des Verbindungsbbaus äquivalent +* Wenn eine Verbindung abgebaut wird, kann man aber größere Risiken in Kauf nehmen +* Typischerweise gelößt mit 3-Wege-Handshake: Sende DR, setze einen Timer, warte auf den DR des Teilnehmers und bestätige diesen +* Auch die drei Problemfälle von verlorenem ACK, Verlorene zweite DR + erneute Übertragung der ersten DR sowie verlorene zweite DR + verlorenes ACK werden gelöst. + +--- +### Flusskontrolle +#### Motivation: Kontrolle von Überlastsituationen +Typischweise sind ein Sender, Empfänger und das Netzwerk dazwischen in der Kommunikation involviert, um Überlastsituationen zu verhindern, muss die Menge an Daten den vorhandenen Kapazitäten der Systeme angepasst werden + +#### Flaschenhälse auf der Empfängerseite +* Annahme: Das Netzwerk selbst ist kein Flaschenhals, es kann alle Pakete ausliefern +* Gründe für Flaschenhälse auf der Empfangsseite: verschiedene Performancecharakteristika oder mehrere Sender auf einen Empfänger +* Konsequenzen: Empfänger ist überfordert mit ankommenden Paketen, Puffer laufen über und Daten gehen verloren + +#### Flusskontrolle +* Aufgabe: Schutz des Empfängers vor zu vielen ankommenden Paketen von der Sendeseite +* Bereitgestellt auf der: + * Linklayerebene: um Überlastung von "forwarding Segmenten" zu verhindern + * Höhere Layer: um Überlastung von Verbindungen zu verhindern +* Flusskontrolle auf dem Transportlayer ist komplizierter + * Viele Verbindungen, benötigt dynamische Allokation von Pufferspeicher + * Transportlayer PDUs mit schwankender Größe + * Puffermöglichkeiten des Netzes fügen weitere Komplexität hinzu + +#### Flusskontrolle - Pufferallokation +* Flusskontrolle abhängig von der Puffermöglichkeit +* Um ausstehdene Pakete zu unterstützen müssen diese entweder sofort und in korrekter Reihenfolge beim Empfänger ankommen, oder es muss genügend Puffer vorhanden sein +* Wie erreicht man Puffersicherheit? + * Empfänger verlangsamt den Sender + * Anforderung von Pufferspeicher durch den Sender + * Mitteilung des Empfängers an den Sender, dass nur noch so viel Puffer verfügbar ist (bei Sliding Window einfach das Sendefenster anpassen) + +#### Flusskontrolle durch Continue und Stop +* Einfachste Lösung: Sende Stopnachrichten wenn der Empfänger nicht schritthalten kann und Continue, sobald wieder Ressourcen vorhanden sind +* Beispiel: XON/XOFF: funktioniert aber nur bei Fullduplexverbindungen + +#### Implizite Flusskontrolle +* Idee: Halte ACKs oder NACKs zurück, um den Sender zu verlangsamen, somit werden Fehlerkontrollmechanismen nun zur Flusskontrolle missbraucht werden +* Nachteil: Senderseitig keine Unterscheidung mehr möglich, ob Pakete verloren gingen, oder er verlangsamt werden soll, was in unnötigen Wiederholungsübertragungen resultiert + +#### Kreditbasierte Flusskontrolle +* Der Empfänger gewährt dem Sender expliziten Kredit, sodass dieser meherere Pakete senden kann +* Ist der Kredit aufgebraucht, so muss der Sender warten, bis er wieder neuen zugeteilt bekommt +* Hierbei benötigen wir Fehlerkontrolle um auf verlorene Kreditnachrichten resultieren zu können +* Alternativ: absoluter Kredit oder Kreditfenster + +#### Flusskontrolle - Permits und Acknowledgements +* Permits = Empfänger hat Pufferspeicher, sende also weiter +* Acknowledgements = Empfänger hat Anzahl X an Paketen empfangen +* Kombinierbar mit dynamisch wachsendem Pufferplatz beim Emfänger (Beispiel TCP) + +--- +### Staukontrolle +#### Warum benötigt man Staukontrolle? +Jedes Netzwerk kann nur eine gewisse Anzahl an Traffic pro Zeit transportieren, wenn nun mehr Traffic von den Quellen ausgeht, als das Netzwerk als nominelle Kapazität hat, so kommt es zu Staukollapsen und verlorenen Paketen + +#### Gründe für Stau +1. Zwei Sender, zwei Empfänger, ein Router mit unendlich viel Pufferspeicher, keine erneuten Übertragungen + * Große Verzögerung bei Stau +2. Ein Router mit endlich viel Pufferspeicher, Sender überträgt Pakete nur erneut, wenn sie tatsächlich verloren gehen + * Immer λ-in = λ-out (goodput) + * Kosten des Staus: + * Mehrarbeit wegen der erneuten Übertragung für einen goodput + * Unbenötigte erneute Übertragungen +3. Vier Sender, Multihoppfade, Timeout/Erneute Übertragungen + * Wenn ein Paket verworfen wird oder verloren geht, so war jede Übertragungskapazität für dieses Paket verloren und verschwendet. + +#### Zusammenfassung +* Staukontrolle ist essentiell, um Schneeballeffekte zu vermeiden + * Sobald ein Netzwerk einmal überladen ist, wird es Pakete verlieren + * Nach Erkennung von Paketverlusten durch ein zuverlässiges Transportprotokoll, werden Pakete erneut übertragen, was die Last abermals erhöht + * -> Teufelskreislauf + +#### Adaptiere die Senderate an die Netzwerkkapazität +* Die Senderate jeder Quelle muss an die aktuelle Kapazität des Netzwerks angepasst werden +* Staukontrolle ist ein globales Problem, da dies abhängig von allen Routern, Weiterleitungsdisziplinen, Lastinjektionenund so weiter ist. +* Flusskontrolle wiederum ist ein lokales Problem + * Die Quelle darf das Ziel nicht überlasten, also sind nur Ziel und Quelle involviert + +#### Wünschenswerte Eigenschaften von Staukontrolle +* Sollte dazu führen, dass möglichst viele Pakete mit kurzer Verzögerung zugestellt werden +* Alle Teilnehmer sollten einen gerechten Anteil der verfügbaren Kapzität erhalten, aber wie bewertet man Fairness und was sollte alles beachtet werden? + +#### Designoptionen für Staukontrollmechanismen +* Open Loop: Designe das System von Beginn an so, dass es korrekt funktioniert und man keine Korrekturen zur Laufzeit vornehmen muss +* Closed Loop: Verwende Feedback, um zu erlauben, dass sich der Sender an die Situation anpasst +* Explizited Feedback: Die Stelle, an welcher der Stau auftritt informiert den Sender +* Implizites Feedback: der Sender extrahiert aus dem Netzwerkverhalten Informationen darüber, wie er sich verhalten sollte + +#### Mögliche Aktionen +* Erhöhen der Kapzität -> teuer, kurzfristig nicht umsetzbar +* Reservierungen und Zugriffskontrolle - erlaube also keinen zusätzlichen Verkehr wenn das Netzwerk stark ausgelastet ist -> nur für schaltkreisbasierende Netzwerke verfügbar +* Reduzierung der Last in kleiner Granularität -> Bringe einzelne Quellen dazu ihre Last zu reduzieren, sodass nichts terminiert werden muss (benötigt Feedback vom Netz: closed loop) + +#### Mögliche Aktionen - Taxonomie +* Router vs. Hostzentriert + * Wo werden die Informationen erhoben, Entscheidungen getroffen und Aktionen veranlasst? +* Fenster vs. Ratenbasiert + * Wie wird die erlaubte, ins Netz zu gebende Last definiert, durch + * die Rate, also X Bytes die Sekunde, oder + * durch ein Staufenster, als Menge von Sequenznummern von Bytes, welche versendet werden müssen, bevor weitere Permits benötigt werden + +#### Routeraktionen - Verwerfen von Paketen +* Pufferplatz eines Routers ist voll und ein neues Paket kommt an, welches verwirft man, das neu ankommende oder eines aus der Warteschlange? + * Für Medieninhalte sind neue wichtiger als alte Pakete + +#### Verwerfen von Paketen - Implizites Feedback +* Das sendende Protokoll kann Verluste erkennen, in kabelgebundenen Netzwerken ist annehmbar, dass Paketverluste nur durch Stau entstehen -> Verlust von Paketen als klarer Hinweis auf Stau +* Bei Open Loop Systemen sollte es nie vorkommen, dass ein Paket an einer vollen Warteschlange ankommt + +#### Vermeiden von vollen Warteschlangen - Proaktive Aktionen +* Wenn ein in einem Netzwerk Pakete an einer vollen Warteschlange ankommen, so steht es bereits relativ schlecht um das Netz -> Eingreifen bereits vor dieser Situation +* Reagiere sobald die Queue einen gewissen Staufaktor erreicht hat -> Der Router ist dann in einem Warnzustand + +#### Choke Pakete +* Sobald ein Stau der Router einen Stau erkannt hat -> Sende Chokepakete +* Chokepakete sagen dem Ziel, dass es seine Senderate verringern soll +* Problem hierbei: Wie sinnvoll ist es, in ein sowieso schon volles Netzwerk noch weitere Pakete zu injezieren? Und wie lange dauert es eigentlich bis die Quelle vom Stau erfährt (BW\*Delay)? + +#### Warnungsbits +Sobald ein Router feststellt, dass er von Stau betroffen ist, setzt er ein Warnbit in allen Paketen die er verschickt -> Da das Ziel das Warnungsbit in sein ACK Paket aufnimmt, erfährt die Quelle vom Stau und kann ihre Sendeleistung minimieren + +#### Random Early Detection +* nutze verworfene Pakete als implizites Feedback, bereits bevor die Warteschlange voll ist, wirf also vorzeitig Pakete weg um Feedback zu geben +* Mit steigender Staubelastung am Router kann die Entwurfswahrscheinlichkeit erhöht werden + +#### Was passiert aber, wenn Feedback empfangen wurde? +* Ratenbasierte Protokolle: + * Reduzieren der Rate ist einfach, aber wann erhöht man wieder? +* Fensterbasierte Protokolle: Schrumpfe das Staufenster + * Um welchen Faktor? Wie lässt man das Fenster überhaupt wachsen? + +--- +### Transportprotokolle im Internet +#### UDP - User Datagram Protocol +* Kein Schnickschnack, minimalistisches Internettransportprotokoll +* Best Effort Dienst -> UDP Segmente können verloren gehen, nicht reihenfolgegetreu zugestelllt werden +* Verbindungslos -> Kein Handshaking und unabhängige Behandlung der Pakete +* UDP wird oftmals für das Streamen von Multimediainhalten verwendet -> Tolerant gegenüber Verlusten und Ratenempfindlich (weiterhin für DNS und SNMP) +* Verlässliche Dienste unter UDP mit Zuverlässigkeit auf dem Applikationslayer + +##### UDP Checksummen +* Ziel: erkenne im Übertragenen Segment +* Senderseite: + * Behandle Segmentinhalte als Sequenz von 16-Bit Integern + * Checksumme: Addition der Segmentinhalte (1-Komplement) + * Platziere den Checksummenwert in das Checksummenfeld +* Empfängerseite: + * Berechne Checksumme des empfangengen Segments + * Prüfe ob der berechnete Wert gleich dem im Cheksummenfeld ist + * Falls nein -> Fehler erkannt + * Falls ja -> kein Fehler erkannt, dass keiner passiert ist, ist aber dadurch nicht gesagt + +#### TCP - Transmission Control Protocol +* Punkt-zu-Punkt: Ein Sender, ein Empfänger +* Zuverlässiger, reihenfolgegetreuer Bytestrom -> keine Nachrichtengrenzen +* Pipelined: Staukontrolle und Flusskontrolle bestimmen die Fenstergröße +* Sende und Empfangspuffer +* Vollduplex Daten: Bidirektionaler Datenfluss +* Verbindungsorientiert: Handshaking initialisiert den Sender- und Empfängerzustand bevor Daten ausgetauscht werden +* Fluss und Staukontrolle: Kein Überfordernd des Empfängers oder des Netzwerkes + +##### TCP - Sequenznummern und ACKs +* Sequenznummern: Bytestromnummer des ersten Bytes aus den Daten des Segments +* ACKs: Sequenznummer des nächsten von der anderen Seite erwarteten Bytes +* Die Frage wie man Pakete, welche nicht in Reihenfolge angekommen sind, behandeln soll, überlässt TCP dem Implementierer + +##### TCP Round Trip Time und Timeouts +* Zuverlässsiger Datenverkehr benötigt eine Behandlung von Timeouts +* Frage: Wie setzt man einen TCP Timeoutwert? + * Länger als die schwankende RTT, nicht zu kurz -> Unnötige Neuübertragungen, nicht zu lange -> langsame Reaktion auf Segmentverlust +* Frage: Wie kann man die RTT abschätzen? + * SampleRTT: gemessene Zeit von der Übertragung eines Segments bis zum Erhalt der ACK Nachricht + * Besser: Mittelung über mehrere SampleRTTs + > EstimatedRTT = (1-a) · EstimatedRTT + a · SampleRTT +* Exponentiell gewichteter Durchschnitt, typisch für a: 0,125 +* Setzen des Timeouts auf EstimatedRTT + Sicherheitsbereich +* Erste Einschätzung, wie groß die Abweichung des SampleRTT zum EstimatedRTT ist: + * DevRTT = (1-ß) · DevRTT + ß · |SampleRTT - EstimatedRTT| + * mit ß = 0,25 +* Setzen das Timeoutintervall auf: EstimatedRTT + 4 · DevRTT + +##### TCP Verbindungsaufbau +* TCP Verbindungen können aktiv oder passiv hergestellt werden: + * Active: Anfragen einer TCP Verbindung mit speziellem, über IP und Portnummer, spezifizierten Transportdienstnutzer + * Passiv: eine Anwendung informiert TCP, dass sie bereit ist eine eingehende Verbindung zu akzeptieren. + * Es kann ein Socket spezifiziert werden, auf welchem die Verbindung erwartet wird, oder + * jede Verbindung wird angenommen (unspecified passive open) + * Egal wie die Verbindung zustandekommt, wird allerdings ein neuer Socket erstellt + +##### Verbindungsidentifikation bei TCP +* TCP Verbindungen laufen zwischen Initiator und Responder, bzw. den Anwendungsprozessen welche auf den Systemen laufen +* Eine TCP Verbindung wird über ein Vierertupel identifiziert + >(Quellport, Quell IP, Zielport, Ziel IP) + +##### TCP Verbindungsmanagement +* Drei Wege Handshake + * Client sendet ein TCP SYN (SYN = 1, ACK = 0) an den Server -> spezifiziert initiale, nie benutzte Sequenznummer + * Server erhält das SYN Paket und antwortet mit einem SYNACK (SYN = 1, ACK = 1) -> Server alloziert Puffer und spezifikation der initialen Sequenznummer des Servers + * Der Client erhält das SYNACK und antwortet hierauf mit einem ACK (SYN = 0, ACK = 1), hier können nun erstmals Daten enthalten sein +* Terminieren einer Verbindung + * Client sendet ein TCP FIN + * Server empfängt das FIN, antwortet mit einem ACK und sendet ebenfalls ein FIN + * Client erhält ein FIN Segment, antwortet darauf mit ACK und geht in timed Wait Zustand, antwortet auf alle FINs mit ACKs + * Server erhält ein ACK, die Verbindung ist geschlossen + +##### TCP Verbindung in drei Phasen +1. Verbindungsaufbau + * 3-Wege Handshake + * Aushandlung der Fenstergröße und der Sequenznummern +2. Datentransfer + * Piggybacking von Acknowledgements +3. Verbindungsabbau + * bestätigt + * verhindert den Verlust von bereits gesendeten Daten + +##### Zuverlässiger Datentransfer in TCP +* TCP erschafft einen zuverlässigen Datendienst oberhalb des unzuverlässigen IP Dienstes +* Eigenschaften: + * Pipelining von Paketen + * Kumulative ACKs + * Verwendung eines einzigen Neuübertragungstimers + * Auslösung von Neuübertragungen durch: + * Timeoutevents + * Duplizierte ACKs + +##### TCP Senderevents +* Daten von der Anwendung empfangen: + * Erstelle Segment mit einer Sequenznummer # + * Sequenznummer = Bytestromnummer des ersten Datenbytes im Segment + * Starte den Timer, falls bisher nicht geschehen +* Timeout: + * Übertrage das, den Timeout auslösende Paket erneut und starte den Timer von vorne +* Empfang eines ACKs + * Falls es zuvor unbestätigte Segmente gab, so aktualisiere was als bestätigt bekannt ist und starte den Timer erneut, sollte es noch ausstehende Segmente geben + +##### TCP Sender (vereinfacht) +* SendBase-1: letztes kumulativ bestätigte Byte (SendBase ist das nächste erwartete Byte) +* Beispiel: + * SendBase = 72, y = 73, der Empfänger will also 73+; y > SendBase, so, dass die neuen Daten bestätigt werden + +```cpp +NextSeqSum = InitialSeqSum +SendBase = InitialSeqSum +loop(forever){ + switch(event) + event: data received from application above, create TCP Segment with sequence number NextSeqSum + if(timer not running){ + start timer + } + pass Segment to IP + NextSeqSum = NextSeqSum + length(data) + + event: timer timout + retransmit not yet acked segment with smallest sequence number + start timer + + event: ACK received, with ACK field value of y + if(y > sendBase){ + SendBase = y + if(there are currently not-yet-acknowledged segments){ + start timer + } + } +} +``` + +##### TCP ACK Generierung +* Ereignis beim Empfänger: + * Ankunft eines Segments in Reihenfolge mit erwarteter Sequenznummer. Alle Daten bis zu dieser Sequenznummer sind bereits bestätigt + * Verspätetes ACK, warte bis zu 500ms auf das nächste Paket. Falls kein Segment eintrifft, so sende die Bestätigung + * Ankunft eines Pakets in richtiger Reihenfolge mit erwarteter Sequenznummer, für ein anderes Paket steht das ACK allerdings noch aus + * Sende sofort eine einzelne kumulierte Bestätigung für beide Pakete + * Ankunft eines out-of-order Seqments mit einer höheren als erwarteten Sequenznummer. Also erkennung einer Lücke + * Sende sofort eine duplizierte Bestätigung, welche die Sequenznummer des nächsten erwarteten Bytes anzeigt + * Ankunft eines Segments, welches eine Lücke teilweise oder vollständig füllt + * Sende sofort eine Bestätigung, unter der Bedingung, dass das Segment am niedrigeren Ende der Lücke startet + +##### Schnelle Neuübertragung +* Die Timeoutperiode ist oft relativ lang -> große Verzögerung, bis ein verlorenes Paket erneut gesendet wird +* Erkenne verlorene Segmente über die ACK Duplikate + * Sender senden oftmals viele Pakete hintereinander, wenn Segmente verloren gehen, so wird es voraussichtlich viele ACKduplikate geben +* Wenn der Sender 3 ACKs für die selben Daten erhält, so nimmt er an, dass das Segment nach den besätigten Daten verloren ging -> Schnelle Neuübertragung noch bevor der Timer ausläuft + +##### Algorithmus +```cpp +event: ACK recevied, with ACK Field value of y +if(y > SendBase){ + SendBase = y; + if(there are currently not-yet-acked segments){ + start timer + } +} +else { + increment count of duplicate ACKs received for y + if(count of duplicate y ACKs = 3){ + resend segment with sequence number y + } +} +``` + +### TCP Fluss- und Staukontrolle +#### Sende- und Empfangspuffer bei TCP +* Sender: Puffer um Fehlerkontrolle bereit zu stellen +* Empfänger: Zwischenspeichern von noch nicht abgerufenen, oder nicht reihenfolgegetreu angekommenen Paketen + * Bemerkung: Alte TCP Versionen verwendeten GoBackN und verwarfen diese Pakete + +#### TCP Flusskontrolle: Angebotenes Fenster +* Der Empfänger kann seine Empfangpufferkapazitäten verkünden + * Verwendeter Pufferspeicher = (NextByteExpected-1)-LastByteRead + * Maximal verfügbarer Puffer = MaxRcvdBuffer + * Angebotener Pufferplatz = MaxRcvdBuffer - ((NextByteExpected-1)-LastByteRead) +* Erinnerung: Das angebotene Fenster beschränkt die Menge an Daten welche der Sender in das Netzwerk schickt (Sender stellt sicher, dass LastByteSend-LastByteAcked <= Advertised Window ist) + +#### Nagles Algorithmus - Selbsttaktung und Fenster +* TCP Selbsttaktung: Ankunft eines ACKs ist ein Zeichen dafür, dass neue Daten auf das Netzwerk geschickt werden können +* Es wäre allerdings sinnlos, für kleine Größen, wie ein Byte, direkt nach dem ACK weiterzusenden (silly window syndrome) +* Nagles Algorithmus beschreibt wie viele Daten TCP Senden darf + * Wenn eine Anwendung zu versendende Daten produziert + * falls sowohl angebotene Daten und das angebotene Fenster >= MSS -> Sende ein volles Segment + * andernfalls + * falls unbestätigte Daten auf dem Weg sind, so puffere neue Daten bis das MSS voll ist, + * andernfalls schicke die Daten sofort + +#### Staukontrolle bei TCP +* Implizites Feedback durch verworfene Pakete + * Annahme: Stau als Hauptgrund für verworfene Pakete +* Fensterbasierte Staukontrolle + * TCP führt Buch über die Anzahl an Bytes die es noch in das Netzwerk injezieren darf, diese Fenstergröße kann wachsen oder schrumpfen + * Der Sender beschränkt die Übertragung zusätzlich: + * LastByteSend-LastByteAcked <= CongWin + +##### TCP ACK/Selbsttaktung +Durch die ACKs kann der Sender darüber Aufschluss erhalten, wann die Pakete das Netzwerk verlassen -> Folglich dienen ACKs nicht nur als Bestätigung, sondern auch als Erlaubnis wieder die selbe Anzahl an Daten in das Netzwerk zu senden + +##### Gute und schlechte Nachrichten +* Gute Nachricht: Ankunft eines ACKs + * Dh. wir haben das Netzwerk bisher nicht überlastet, versuchen folglich das Staufenster noch ein bisschen zu vergrößern +* Schlechte Nachrichten: Kein ACK, ein Timeout tritt auf + * Das Paket wurde verworfen, das Netzwerk ist überlastet, versuchen also das Staufenster zu verkleinern + +##### Verkleinern des Staufensters +* Überlastete Fenster sind äußerst unpraktisch, greifen deshalb drastisch ein, und halbieren das Staufenster, sobald ein Timeout eintritt +* Falls ein Paket durch Übertragungsfehler und nicht durch Überlastung verloren geht, so wird dies durch TCP missinterpretiert und es reagiert über + * Tritt in Kabelnetzwerken selten auf, führt aber zu Problemen bei Drahtlosnetzwerken + +##### Vergrößern des Staufensters +Der Sender kann sich hier nicht sicher sein, ob tatsächlich noch Kapzitäten vorhanden sind, deshalb versuche, wenn alle Pakete, der in der letzten RTT gesendeten Pakete, angekommen sind, ein Paket mehr zu senden + +##### Additives Erhöhen +* Wartet nicht auf eine volle RTT um zusätzliche Last hinzuzufügen, sondern verwendet dazu bereits einzelne ACKs +```cpp +Increment = MSS · (MSS / Congestion Window) +Congestion Window += Increment + +Mit MSS als maximale Segmentgröße +``` + +##### AIMD - Sägezahnmuster der angebotenen TCP Last +* TCP verwendet AIMD, also additive increase, multiplicative decrease Taktik +* Es wird also kontinuierich auf zusätzliche Bandbreite geprüft und durch die Erhöhung der Bandbreitengrenze wird das Netzwerk regelmäßig die multiplikative Verringerung ausführen -> Sägezahnmuster + +##### Schnelle initialisierung - Slow Start (historischer Name) +* Problem: Es dauert ewig, bis wir mit einem neuen Netzwerk überhaupt mittels additive increase an die Bandbreitengrenze kommen +* Idee Vergrößerung des Staufensters mittels Verdopplung nach jeder RTT oder Hinzufügen eines Pakets je ACK + +##### Verlassen des Slowstarts +Sobald die Bandbreitengrenze erreicht ist, werden Paketverluste und Timeouts auftreten, TCP wechselt ab diesem Zeitpunkt wieder in den normalen Modus + +##### Problematik der Paketbursts +* Ein Sender sendet sein volles Fenster, alle Pakete kommen an, ACKs gehen verloren und es kommt zu Timeouts die das Staufenster halbieren +* Ein Paket wird erneut übertragen, und es kommt ein kumulatives ACK für alle Pakete an, der Sender allerdings sendet nun in seinem halbierten Sendefenster nochmals die selben Daten -> ACK Taktung fehlt + +###### Lösung: Auch hier Slow Start verwenden +* Verhindern solcher Paketbursts durch lineare Erhöhung des Staufensters + * Setzen das Staufenster auf 1 und starten Slow Start +* Weiterhin haben wir nun grundlegende Informationen über die Netzwerkkapazität + * Müssen auf den ersten Paketverlust warten, hier ist das halbierte Fenster eine gute Annahme + * Wir können nun den Verlust von Paketen verhindern, wenn wir das vorherige Staufenster als Stauschwellenwert ansehen + +#### Zusammenfassung TCP Staukontrolle +* Wenn das Sendefenster < Schwellenwert, dann ist der Sender in der Slow Start Phase und das Fenster wächst exponentiell +* Wenn das Staufenster > Schwellenwert, dann ist der Sender in der Stauvermeidungsphase und das Fenster wächst linear +* Wenn ein dreifach dupliziertes ACK auftritt, so wird der Schwellenwert auf Staufenster/2 und das Staufenster auf den Schwellenwert gesetzt +* Wenn ein Timeout auftritt, so wird der Schwellenwert auf Staufenster/2 und das Staufenster auf 1 MSS gesetzt +* Erweiterungen: Fast Retransmit, fast recovery + * Ergreifen korrigierende Aktionen ohne auf ein Timeout warten zu müssen + * Nötig für Netze mit großen Bandbreitenverzögerungen +* Verschiedene TCP Versionen: TCP Tahoe, TCP Reno, TCP Vegas +* Größte Quelle für Komplikationen: Die Dummheit des Netzwerks + +#### TCP Performance +##### TCP Durchsatz +Der Durchschnittliche Durchsatz von TCP ist 0,75 · W/RTT + +##### TCP Fairness +* Fairnessziel: Wenn K TCP Sitzugen des selben Flaschenhalses mit Bandbreite R durchschreiten müssen, so sollten alle eine durchschnittliche von R/K haben. +* TCP ist fair, da: + * Eine additive Erhöhung eine Steigung von 1 ergibt, sobald sich der Durchsatz erhöht + * Multiplikative Verringerung den Durchsatz proportional verringert + +#### Fairness +###### Fairness und UDP +UDP wird für Multimediaanwendungen verwendet, da sie durch die Staukontrolle nicht gedrosselt werden wollen, wir senden also mit konstanter Rate und kümmern uns nicht um Verluste + +###### Fariness und parallele TCP-Verbindungen +* Programme können mehrere TCP-Verbindungen zu einem Host aufbauen +* Beispiel: Linkrate R unterstützt 9 Verbindungen + * Eine neue Anwendung fragt nach einer TCP Verbindung und erhält Rate R/10 + * Eine neue Anwendung fragt nach neun TCP Verbindungen und erhält Rate R/2 + +###### Verzögerungsmodellierung +* Wie lange dauert es, bis ein Objekt nach der Anfrage bei einem Webserver empfangen wird? + * Ohne Stau nur abhängig vom Verbindungsaufbau, der Datenübertragungsverzögerung und Slow Start +* Bemerkungen: + * Link L zwischen Client und Server mit Rate R, S = MSS, O = Objektgröße in Bits, keine Neuübertragungen + * Fenstergröße: + * Zuerst feste Größe, W Segmente + * Dann dynamische Fenster und Slowstart + +###### Festes Staufenster +1. WS/R > RTT + S/R: ACK für das erste Segment im Fenster kommt an, bevor einganzes Fenster an Daten verschickt wurde, erlaubt kontinuierliches Dauersenden + ``` + delay = 2RTT + O/R + ``` +2. WS/R < RTT + S/R: Warte auf das ACK nachdem ein Sendefenster an Daten geschickt wurde + ``` + delay = 2RTT + O/R + (K-1)[S/R + RTT - WS/R] + ``` + +###### TCP Verzögerungsmodellierung: Slow Start +* Die Verzögerung für ein Objekt ist die folgende: + ``` + Latenz = 2RTT + O/R + P[RTT+S/R]-((2^p)-1) · (S/R) + ``` +* Wobei P die Anzahl an Zeiten ist, in denen TCP beim Server in Bereitschaft ist: + ``` + P = min{Q, K-1} + ``` +* wobei Q die Anzahl an Zeiten ist, in denen der Server in Bereitschaft ist, unter der Bedingung, dass die Objekte von unendlicher Größe wären +* und K die Anzahl an Fenstern ist, welche das Objekt belegt +* Mit den Verzögerungskomponenten: + * 2RTT für Verbindungsaufbau und Anfrage + * O/R um das Objekt zu Übertragen + * Zeit die der Server durch Slowstart ruht + +### Fallstudie HTTP Modellierung +* Eine Webseite besteht aus folgenden Teilen + * 1 Basis HTML Seite von O Bits + * M Bildern zu je O Bits +* Nichtpersistentes HTTP (eine Verbindung pro Objekt) + * M+1 TCP Verbindungen in einer Reihe + * Antwortzeit: + * (M+1) · O/R + (M+1) · 2RTT + Idlezeiten +* Persistentes HTTP (eine Verbindung für alle Objekte) + * 2RTT für die Anfrage und den Empfang der Basis HTML Datei + * 1 RTT zum Anfordern der Bilder und deren Erhalt + * Antwortzeit + * (M+1) · O/R + 3RTT + Idlezeiten +* Nichtpersistentes HTML mit X parallelen Verbindungen + * 1 TCP Verbindung für die Basisdatei + * M/X parallele Verbindungen für die Bilder + * Antwortzeit + * (M+1) · O/R + (M/X +1) · 2RTT + Idlezeiten + +#### HTTP Antwortzeiten +* Für kleine Bandbreiten wird die Verbindungs- und Antwortzeit durch die Übertragungszeit dominiert + * Persistente Verbindungen zeigen nur geringfügige Verbesserungen gegenüber parallelen Verbindungen +* Bei größeren RTTs wird die Antwortzeit vom TCP - Aufbau und Slowstartverzögerungen dominiert + * Persistente Verbindungen sind nun deutlich im Vorteil, insbesondere in Netzen mit großem Bandwithdelayprodukt + +## Zusammenfassung Kapitel 8 +* Prinzipien hinter Transportlayerdiensten + * Adressierung, Mulitplexing, Demultiplexing + * Verbindungskontrolle + * Flusskontrolle + * Staukontrolle +* Instantiierung und Implementierung im Internet + * UDP + * TCP +* Drei wichtige Protokollfunktionen sind bei TCP direkt in einem Sliding Window Protokoll implementiert: + * Fehlerkontrolle: Durch Sequenznummern, ACKs und Neuübertragungen + * Flusskontrolle: Durch Inspizieren von ACKs und Permits + * Staukontrolle: Durch das Verlangsamen des Senders, wenn Pakete oder ACKs verloren gehen + +# Kapitel 9: Internet Application Layer +## Erstellen einer Netzwerkanwendung +* Schreibe Programme, die: + * auf verschiedenen Endsystemen laufen + * über ein Netzwerk kommunizieren +* Keine Software wird explizit für das Kernnetzwerk geschrieben + * Kernnetzgeräte arbeiten nicht auf der Anwendungsschicht + * Dieses Design erlaubt extrem schnelle Anwendungsentwicklung + +## Prinzipien von Netzwerkanwendungen: Architekturen +* Client-Server +* Peer-to-Peer +* Hybride aus Client-Server und Peer-to-Peer + +### Client-Server Architektur +* Server + * ständig eingeschaltet und mit permanenter IP-Adresse + * Serverfarmen zur Skalierung +* Clients + * Kommunizieren zeitweise mit dem Server + * Können dynamische IP-Adressen haben + * Kommunizieren nie direkt miteinander + +### Peer-to-Peer Architketur +* Ohne ständig eingeschalteten Server +* Beliebige Endsysteme kommunizieren direkt miteinander, sind dabei zeitweise verbunden und haben wechselnde IP Adressen + +### Hybride Client-Server und P2P +* Ursprüngliches Napster-Filesharing + * Filetransfer über P2P, mit zentralisierter Dateisuche +* Instant Messaging + * Chatten zwischen den Anwendern verwendet P2P + * Anwesenheitserkennung und Lokalisierung ist zentralisiert + +## Prozesskommunikation +* Prozesse: Programm welches auf einem Host ausgeführt wird + * Zwei Prozesse welche auf einem Host laufen, verwenden Interprozesskommunikation um zu kommunizieren + * Prozesse auf unterschiedlichen Hosts verwenden Nachrichtenaustausch + * Clientprozess: Initiiert die Verbindung + * Serverprozess: Wartet darauf kontaktiert zu werden + * Bemerkung: Anwendungen, welche die P2P Architektur verwenden, haben Client und Server Prozesse + +### Sockets +* Prozesse Senden und Empfangen Nachrichten an oder von ihrem Socket +* Application Programming Interface + * Wahl des Transportprotokolls + * Möglichkeit einige Parameter zu definieren + +### Adressierung von Prozessen +* Prozesse die Nachrichten empfangen sollen, müssen einen Bezeichner haben +* Jeder Host hat eine einzigartige 32-Bit IP-Adresse sowie eine Portnummer, beides zusammen ist durch den Bezeichner dann beschrieben + +## Durch das Anwendungsprotokoll festgelegte Eigenschaften +* Arten von ausgetauschten Nachrichten +* Syntax der Nachrichtenarten und Semantik der einzelnen Felder +* Regeln darüber, wann Prozesse, wie welche Nachrichten senden und darauf reagieren +* Offene vs. proprietäre Protokolle + * Public-Domain Protokolle + * offen für jeden Zugänglich, erlauben Interoperabilität + * Beispiel: HTTP, FTP, SMTP + * Proprietäre Protokolle + * Definiert durch einen Vertreiber, meist keine öffentlichen Spezifikationen + * Beispiel: KaZaA, Skype + +### Welche Transportdienste werden von den Anwendungen benötigt? +* Datenverlust + * Audio verkraftet einiges an Verlust + * Datenaustausch oder Telnet benötigen einen 100% zuverlässigen Datenaustausch +* Zeitliches Verhalten + * Internettelefonie oder Games brauchen kurze Latenzen +* Bandbreite + * Multimediaanwendungen benötigen teils eine minimale Bandbreite um funktionieren zu können + * Elastische Anwendungen hingegen, kommen mit so viel Bandbreite zurecht, wie sie eben zugesprochen bekommen + +## Internettransportprotokolldienste +* TCP + * Verbindungsorientiert -> Verbindungsaufbau zwischen Client und Server benötigt + * zuverlässiger Transport + * Flusskontrolle -> Der Sender überlastet den Empfänger nicht + * Staukontrolle -> Verlangsame den Sender, wenn das Netzwerk nahe der Belastungsgrenze ist + * Nicht vorhanden -> Timing, Garantien über die Bandbreite +* UDP + * Unzuverlässiger Datentransfer + * Nicht bereitgestellt + * Verbindungsaufbau + * Zuverlässigkeit + * Fluss- und Staukontrolle + * Timing oder Bandbreitengarantien + +## Web & HTTP +* Eine Website beseht aus Objekten +* Objekte können ein Bild, eine HTML Datei, ein Java Applet sein +* Eine Webseite besteht aus einer grundlegenden HTML Datei, welche verschiedene Referenzen auf Objekte enthält +* Jedes Objekt ist durch eine URL adressierbar + +### HTTP Übersicht +HTTP - Hyper Text Transfer Protocol +* Das Anwendungsnachrichtenprotokoll des Webs +* Client-Server Modell +* Wichtige Entwicklungsstufen: + * HTTP 1.0 (schließt die Verbindung nach jeder Anfrage) + * HTTP 1.1 (hält die Verbindung auch weiterhin Aufrecht) +* HTTP verwendet TCP + * Clients bauen eine TCP Verbindung zum Server an Port 80 auf + * Server akzeptieren diese Anfragen und HTTP Nachrichten werden zwischen dem Browser und dem Webserver ausgetauscht + * Die TCP Verbindung wird geschlossen +* HTTP selbst ist zustandslos, d.h. der Server hält keine Informationen über frühere Besuche auf der Website + +### HTTP Verbindungen +* Nichtpersistentes HTTP: + * höchstens ein Objekt wird über die TCP Verbindung verschickt + * HTTP/1.0 ist nichtpersistent +* Persistentes HTTP + * Mehrere Objekte können über eine TCP Verbindung zwischen Client und Server ausgetauscht werden + * HTTP/1.1 verwendet standardmäßig Persistenz + +### Antwortzeitmodellierung +> RTT\ +> Benötigte Zeit um ein kleines Paket so zu senden, dass es vom Client zum Server und zurück geschickt wird. + +* Antwortzeit + * eine RTT um die TCP Verbindung aufzubauen + * eine RTT für die HTTP Anfrage und die ersten paar Bytes der Antwort +* Totalzeit + * 2 RTT + Dateiübertragungszeit + +### Persistentes HTTP +* Probleme nicht persistenten HTTPs + * Benötigt 2RTT pro Objekt + * Allokierung von Hostressourcen für jede TCP Verbindung + * Browser können immerhin oftmals mehrere TCP Verbindungen aufbauen, um referenzierte Objekte zu Empfangen +* Persistentes HTTP + * Der Server lässt die Verbindung auch nach der Antwort noch am Leben + * Nachfolgende HTTP Nachrichten werden also über den selben, bereits allokierten Kanal gesendet +* Persistenz ohne Pipeling + * Der Client stellt nur dann eine Anfrage, wenn die vorherige Antwort empfangen wurde + * Eine RTT für jedes referenzierte Objekt +* Persistenz mit Pipelining + * Standard in HTTP/1.1 + * Der Client sendet eine Anfrage, sobald er ein referenziertes Objekt entdeckt + * Nur eine RTT für alle referenzierten Objekte + +### HTTP Anfragenachrichten +Insgesamt nur zwei Arten von Nachrichten: request und response + +![screenshot013.png](/core/preview?fileId=295415&x=1024&y=1024&a=true#mimetype=image%2Fpng&hasPreview=true&fileId=295415) + +### Hochladen von Einfaben +* POST Methode + * Webseiten beinhalten oft Formulareingaben, die Eingabe wird dann im Entity Body an den Server geschickt +* URL Methode + * Verwendet die GET Methode + * Die Eingaben werden im URL Feld der Requestline hochgeladen + +### Methodentypen +* HTTP 1.0 + * GET + * POST + * HEAD (Anweisung, das angefragte Element in der Antwort außen vor zu lassen) +* HTTP 1.1 + * GET, POST, HEAD + * PUT (Läd die Datei im Entity Body an den in der URL spezifizierten Pfad) + * DELETE (Löscht die in der URL spezifizierte Datei) + +### HTTP Statuscodes +* 200 OK - Anfrage okay, das angefragte Objekt folgt +* 301 Moved Permanently - das angefragte Objekt wurde verschoben, der neue Pfad folgt +* 400 Bad Request - Anfrage wurde nicht verstanden +* 404 Not Found - angefrodertes Objekt konnte auf dem Server nicht gefunden werden +* 505 HTTP Version not supported + +### HTTP Webcaching und Cookies +#### Nutzer-Server-Zustand: Cookies +* Vier Komponenten + * Cookieheaderzeile in der Antwort + * Cookieheaderzeile in der Anfrage + * Die Cookiedatei wird auf dem Rechner des Hosts gespeichert und vom Browser verwaltet + * Speichern der Cookieinformationen in einer Backenddatenbank der Webseite +* Welchen Nutzen haben Cookies? + * Autorisierung + * Warenkörbe und Empfehlungen + * Nutzersitungszustand + +> Cookies erlauben es den Webseite viel über einen Nutzer herauszufinden, +man gibt beispielsweise unfreiwillig Namen und Emailadressen weiter, +welche zum Beispiel für Werbeagenturen gefundenes Fressen sind. + +#### Webcaches (Proxyserver) +Ziel: Bedienen der Clientanfrage ohne den urpsrünglichen Webserver dabei zu involvieren +* Der Nutzer stellt den Browser so ein, dass dieser über einen Cache auf das Netz zugreift +* Alle Anfragen des Browsers gehen zuerst an den Cache, hat er das angefragte Material, so wird er dieses an den Client schicken, oder andernfalls beim Webserver besorgen und dem Client dann weiterleiten + +##### Weitere Informationen über Webcaches +* Der Cache agiert sowohl als Client als auch als Server +* Gründe für Webcaches + * Reduzieren von Antwortzeiten für Clientanfragen + * Reduzieren von Verkehr auf dem Zugangslink des ISPs + * Ein Internet voller Caches erlaubt es armen Anbietern effektiv Inhalte zu übertragen + +##### Bedingtes GET +* Ziel: Sende das Objekt nicht, wenn eine aktuelle Version des Objekts bereits im Cache liegt +* Cache: Spezifiziere das letzte Änderungsdatum der Datei im Cache in der HTTP Anfrage +* Server: Die Antwort beinhaltet das Objekt nur dann, wenn die Kopie im Cache veraltet ist + +### Webserverarchitekturen +#### Grundlegende Webserveraufgaben +* Zum Empfang von Anfragen bereitmachen +* Annehmen von Verbindungen und Anfragen +* Lesen und Verarbeiten von Anfragen +* Antworten auf Anfragen +* Bereitmachen und Annehmen von Anfragen + +#### Webserverarchitekturen +* Prozessmodell +* Threadmodell +* In-Kernel Modell +* Eventbasiertes Modell + +##### 1. Prozessmodell +* Einem Prozess werden alle benötigten Schritte zugewiesen, welche benötigt werden, um eine Anfrage zu bearbeiten +* Wenn die Bearbeitung abgeschlossen ist, so ist der Prozess wieder in der Lage neue Verbindungen zu akzeptieren +* Typischerweise werden mehrere Prozesse benötigt +* Ein Prozess blockiert, beispielsweise read(), dann entscheidet das OS, welcher Prozess als nächstes ausgeführt werden darf +* Die Parallelität wird durch die Anzahl an Prozessen limitiert +* Beispiel: Apache auf UNIX +* Vorteile + * Synchronisation dem Prozessmodell inhärent + * Absicherung zwischen Prozessen +* Nachteile + * Langsam + * Schwere Ausführbarkeit von Operationen, welche auf globalen Informationen beruhen + +##### 2. Threadmodell +Verwende Threads anstelle von Prozessen +* Motivation: + * Threaderstellung und Threadlöschung ist billiger + * Austausch von Daten zwischen Threads ist einfacher als bei Prozessen, aber Synchronisation wird nun für geteilte Daten benötigt +* Beispiele: + * JAWS, IIS, Apache unter Windows +* Vorteile: + * Schneller als Prozesse + * Teilen standardmäßig aktiv +* Nachteile: + * Benötigt OS Unterstützung + * Kann per Prozess Limitierungen überlasten + * Beschränkte Kontrolle über Schedulingentscheidungen + +##### 3. In-Kernel Modell +* Eine Möglichkeit: ganzer Server im Kernel +* Meist: nur statische Dateien werden vom Kernel bedient, andere Anfragen gehen an den regulären User-Space-Server +* Dedizierter Kernelthread für HTTP Anfragen +* Vorteile: + * Vermeidet das Kopieren von und in den Userspace + * Sehr schnell, solange es eng in den Kernel integriert ist +* Nachteile: + * Bugs können das OS, also die ganze Maschine crashen + * Schwer zu debuggen und zu Erweitern + * Inhärent OS-spezifisch +* Beispiele: + * khttpd + * TUX + * AFPA (Advanced Fast Path Architecture) + +##### 4. Eventbasiertes Modell +Verwenden eines einzelnen Webserverprozesses um mehrere Anfragen zu behandeln +* Beispiele: Zeus, Flash, Boa, Mathopd, ScatterWeb EWS +* Ein einzelnes HTTP Servermodell mit einer Liste an HTTP Verbindungen: list[index]; +* myHttpConnection[index].status = {response, begin, end, dynamic} +* myHttpConnection[index].PosInPage = readpointer; +* Vorteile + * Sehr schnell, kein Kontextwechsel + * Inhärentes Teilen ohne Locks + * Komplette Kontrolle über die Schedulingentscheidungen + * Kein komplexer OS-Support benötigt +* Nachteile + * Per-Prozess Begrenzungen + * Nicht jedes OS mit voll asynchroner E/A, so können beim Lesen immernoch Blockierungen entstehen + * Flash verwendet immerhin Hilfsprozesse um dies zu verhindern + +#### Performancevergleich +###### Webservercluster +* Zwei Wege um die Kapazität zu erhöhen: + * eine größere Maschine + * Cluster an billigen Standardmaschinen, beispielsweise PCs +* Zur Zeit dominiert v.a. die zweite Variante aufgrund: + * der Skalierbarkeit + * der Hochverfügbarkeit + * der Kosten +* Es stellt sich eine wichtige Designfrage: Anfragenverteilung + * Traditionell: Round Robin + * Effizienter: Inhaltsbasiert + +#### FTP: Das Dateitransferprotokoll +* Übertrage Daten von und zum Server +* Client Server Modell +* Standard FTP Port: 21 + +##### Separate Kontroll- & Datenverbindung +* Der FTP Client kontaktiert den Server auf Port 21 und verwendet dazu das TCP Protokoll +* Der Client wird über eine Kontrollverbindung autorisiert +* Der Client kann nun auf dem entfernten Verzeichnis arbeiten, idem er Kommandos über die Kontrollleitung sendet +* Wenn ein Server ein Kommando zum Dateitransfer erhält, so öffnet er eine TCP Datenverbindung zum Client +* Nachdem eine Datei übertragen wurde, schließt der Server die Verbindung, im Falle von einer weiteren zu übertragenden Datei, eröffnet der Server eine zweite TCP Datenverbindung +* -> Out of Band Kontrolle +* FTP Server behalten den Zustand, also derzeitiges Verhältnis und frühere Authentifizierung + +##### FTP Kommandos und Antworten +* Beispielkommandos: + * gesendet als ASCII Text über die Kontrollleitung + * USER username + * PASS password + * LIST gibt den Inhalt des aktuellen Verzeichnis aus + * RETR filename holt die Datei + * STOR filename speichert die Datei auf dem entfernten Host +* Beispielrückgabecodes: + * Statuscode und Phrase (wie bei HTTP) + * 331 Username OK. password required + * 125 data connection already open: transfer starting + * 425 can't open data connection + * 452 Error writing File + +#### Electronic Mail: E-Mail +* Bestehend aus drei Hauptkomponenten + * Useragent + * Mailserver + * Einfaches Mailübertragungsprotokoll: SMTP +* Useragent + * Erlaubt das Schreiben, Lesen und Bearbeiten von Nachrichten + * Ein- und ausgehende Nachrichten werden auf einem Server gespeichert +* Mailserver + * Die Mailbox beinhaltet eingehende Nachrichten, die Nachrichtenschlange die ausgehenden Nachrichten + +##### SMTP +* Verwendet TCP um Nachrichten zuverlässig vom Client zum Server zu übertragen, verwendet Port 25 +* Direkte Übertragung: vom Sender zum Empfänger +* Dreiphasige Übertragung + * Handshaking + * Übertragung der Nachrichten + * Terminieren der Verbindung +* Kommando/Antwort Interaktion + * Kommandos: ASCII Text + * Antwort: Statuscode und Phrase +* Nachrichten müssen in 7 Bit ASCII kodiert sein +* SMTP verwendet persistente Verbindungen +* SMTP Server verwenden CRLF um das Ende einer Nachricht zu erkennen + * Führt zu Problemen, wenn man versucht ohne Bitstuffing einen einzelnen . zu versenden + +###### SMTP Vergleich mit HTTP + +* Beide verwenden ASCII Statuscodesund Kommando/Antwort Interaktion +* HTTP: + * PULL: Der Initiator fragt den Antwortenden nach den Inhalten welche er haben möchte + * Jedes Objekt in eigener Antwortnachricht +* SMTP: + * PUSH: Der Initiator sendet dies, welches er kommunizieren will an den Antwortenden + * Mehrere Objekte werden in einer mehrteiligen Nachricht gesendet + +##### Mailnachrichtenformat +* SMTP als Protokoll, um Nachrichten auszutauschen +* RFC 822 als Standard für das Textnachrichtenformat +* Headerzeilen, beispielsweise: + * To: + * From: + * Subject: +* Body: + * Die Nachricht, bestehend nur aus ASCII Zeichen + +###### Nachrichtenformat: Multimediaerweiterungen +* MIME: Multimedia Mail Extensions +* Zusätzliche Zeilen im Nachrichtenheader deklarieren den MIME Inhaltstyp + +##### Mailzugriffsprotokolle +* SMTP: Zustellen/Speichern auf dem Empfangsserver +* Mailzugriffsprotokoll: Anfordern vom Server + * POP: Post Office Protocol + * Autorisierung und Download + * IMAP: Internet Mail Access Protocol + * Mehr Features aber komplexer + * Manipulation der serverseitig gespeicherten Nachrichten + * HTTP: Yahoo Mail, Hotmail, etc. + +##### POP3 +* Autorisierungsphase + * Clientkommandos: + * user: Nutzernamen deklarieren + * pass: Passwort übermitteln + * Serverantworten + * +OK + * -ERR +* Transaktionsphase + * Client + * list: Listet die Nachrichtennummern auf + * retr: Ruft die Nachrichten durch ihre Nummern ab + * dele: Löscht die Nachricht + * quit: Logout + +##### POP3 und IMAP +* POP3 + * Das Beispiel nutzt den Download und Delete Modus + * Bob kann die Emails also nicht nochmals lesen, wenn er den Client wechselt + * Download und Keep: + * Ermöglicht es Kopien von Nachrichten auf mehreren Clients zu haben + * POP3 ist zustandlos über mehrere Sitzungen +* IMAP + * Behält alle Nachrichten am Server + * Erlaubt es Nachrichten geräteübergreifend in Ordnern zu organisieren + * IMAP hält den Nutzerzustand über Sitzungsgrenzen hinweg + +### DNS - Domain Name System +* Für Menschen gibt es viele verschiedene Bezeichner, für Internethosts und Router gibt es IP Adressen und Namen, doch wie kann man einen Namen auf eine IP-Adresse mappen? +* DNS + * verteilte Datenbank implementiert in der Hierarchie von vielen verschiedenen Nameservern + * Anwendungsschichtprotokoll für Hosts, Router und Nameserver zum Kommunizieren zur Namensauflösung +* DNS Dienste + * Hostname auf IP Adressen Übersetzung + * Host Aliasing + * Mailserver + * Lastverteilung mittels replizierter Webserver - Eine Menge von IP-Adressen für einen cannonical Namen +* Warum zentralisiert man DNS nicht? + * Single Point of Failure + * Verkehrsaufkommen, Instandhaltung und Wartung + * Eine zentrale Autorität über die weltweite Namensauflösung? + +-> Skaliert einfach viel zu schlecht + +#### Verteilte hierarchische Datenbank +* Client möchte die IP für www.amazon.com + * Rootserver wird nach dem .com Server gefragt + * .com DNS Server wird nach dem amazon.com DNSServer gefragt + * Der Client fragt den amazon.com DNS Server nach der IP für www.amazon.com + +#### DNS: Root Name Server +* Kontaktiert von einem lokalen Nameserver, welcher den Namen nicht auflösen kann +* Root Name Server + * Kontaktiert den autorativen Nameserver, falls das Namensmapping unbekannt ist, erhält das Mapping und leitet dies an den lokalen Nameserver zurück + +#### TLD, Authorative und lokale DNS Server +* TLD (Top Level Domain) Server + * Verantwortlich für .com, .org, .net, .edu und die Landesdomains +* Authorative DNS Server + * DNS Server einer Organisation, stellen den authorativen Hostnamen für das IP Mapping der Organisationsserver + * Verwaltung durch Organisation oder Dienstanbieter +* Lokale DNS Server + * Gehören nicht strikt zur Hierarchie + * Jeder ISP hat einen eigenen + * Wenn ein Host eine DNS Anfrage stellt, so wird die Frage zuerst zum lokalen DNS Server gesendet (fungiert also als ein Proxy) + +##### Iterative Anfragen +Der kontaktierte Server antwortet mit dem Namen des zu kontaktierenden Servers: "Ich kenne seinen Namen nicht, aber frage diesen Server und er wird dir helfen können" + +##### Rekursive Anfragen +* Legt dem kontaktierten Server die Namensauflösung auf +* Aufgrund der hohen Last nicht durch TLD oder Rootserver unterstützt + +#### DNS Caching und Updaten von Records +* Sobald ein Server ein Mapping kennenlernt, cacht er diese für eine bestimmte Zeit + * TLD Server sind typischerweise in lokalen Nameservern gecacht, sodass nicht jedes mal der Rootserver besucht werden muss +* Update-/Benachrichtigungsmechanismen + * Verwendet von DHCP Servern um DNS Einträge in den Servern aktuell zu halten + * Alternativ auch DDNS über HTTPS um DNS Einträge für Hosts mit oft wechselnden IP Adressen zu aktualisieren + +#### DNS Records +* DNS: Verteilte Datenbank, welche die Ressource Records (RR) speichert + > RR Format: (name, value, type, ttl) +* Typ A +* name = Hostname +* value = IP Adresse +* Typ NS + * name = die Domain + * value = IP des authorativen Nameservers für diese Domain +* Typ MX + * value ist der Name des Mailservers, welcher mit dem name assoziert ist +* Typ CNAME + * name ist der Aliasname für irgendeinen cannonical Namen + * www.ibm.com ist tatsächlich servereast.backup2.ibm.com + * value ist der cannonical Name + +#### DNS Protokoll, Nachrichten +* DNS Protokoll: Frage und Antwortnachrichten mit selbem Nachrichtenformat +* Nachrichtenheader + * Identfizierung - 16 Bit Nummer für die Frage, identisch für die Antwort + * Flags + * Frage oder Antwort + * Rekursion erwünscht + * Rekursion verfügbar + * Antwort ist authorativ + +##### Einfügen von Records ins DNS +* Registrieren den Namen bei einem Registrar + * Müssen dem Registrar die Namen und IP Adressen von unserem authorativen Nameserver bereitstellen + * Der Registrar fügt zwei RRs in den .com TLD Server: + * (networkutopia.com, dns1.networkutopia.com, NS) + * (dns1.networkutopia.com, 212.212.212.1, A) + * Setzen dann einen Typ A Record für www.networkutopia.comund einen Typ MX Record für networkutopia.com in den authorativen Server + +### P2P Filesharing +* Ausführung eines Filesharingclients auf dem eigenen Rechner, erhalten für jede Verbindung eine neue IP Adresse, suchen nach einer Datei, welche Alice von Bob kopieren will. Währenddessen können andere Leute schon bei Alice Dateien per HTTP kopieren +* Ein Peer ist sowohl ein Webclient als auch ein transienter Webserver +* Alle Peers sind Server -> Hoch Skalierbar + +#### Probleme mit einem zentralisierten Verzeichnis +* Ein Single Point of Failure +* Performanceflaschenhals +* Copyrightverletzungen +> Dateiübertragung ist dezentralisiert, die Lokalisierung findet allerdings zentral statt. + +#### Anfragefluten: Gnutella +* Grundlegende Eigenschaften + * komplett verteilt, also kein zentraler Server + * Viele Gnutella Clients implementieren das Public Domain Protocol +* Overlaynetzwerk: Graph + * Kante zwischen Peer X und Y, falls eine TCP Verbindung zwischen ihnen existiert + * Alle aktiven Kanten und Knoten formen das Overlaynetzwerk + * Eine Kante ist **kein** physischer Link + +##### Gnutella Protokoll +* Fragenachricht wird über existierende TCP Verbindungen geschickt +* Peers leiten die Anfragenachricht weiter, Anfragentreffer werden dann rückwärts über den Pfad geschickt + +##### Gnutella Peerjoining +* Ein neu hinzukommender Peer X muss andere Peers im Gnutellanetzwerk finden: verwende hierzu eine Liste an Peerkandidaten +* X versucht sequentiell Verbindungen mit Peers aufzubauen, bis X die Verbindung mit Y aufbaut +* X sendet eine Pingnachricht an Y, Y leitet diese weiter +* Alle Peers die dadurch eine Pingnachricht erhalten, senden eine Pongnachricht zurück +* X erhält nun viele Pongnachrichten. Hierauf kann X nun viele neue Verbindungen eingehen + +### Socketprogrammierung mit TCP +Ziel: Lernen wie man Client/Server Anwendungen programmieren kann, welche Sockets zur kommunikation verwenden. +* Eingeführt in BSD 4.1 UNIX +* Sockets werden explizit erstellt, benutzt und durch Anwendungen freigegeben +* Client/Server Paradigmen +* Zwei Artenvon Transportdiensten über die Socket API: + * Unzuverlässige Datagramme + * Zuverlässig & Bytestromorientiert +> Socket\ +> Ein lokal auf dem Host laufendes, von einer Anwendung erstelltes, OS-kontrolliertes Interface, durch welches ein Anwendungsprozess sowohl Nachrichten vom und zu anderen Anwendungsprozessen Senden, als auch Empfangen kann. + +#### Socketprogrammierung unter Verwendung von TCP +* Socket: Tür zwischen Anwendungsprozess und dem Ende zu Ende Transportprotokoll +* TCP Dienst: zuverlässsige Übertragung von Bytes von einem Prozess zu einem anderen Prozess +* Der Client muss den Server kontaktieren + * Der Serverprozess muss zuerst ausgeführt werden und einen Socket erstellt haben, welcher auf den Clientkontakt wartet +* Der Client kontaktiert den Server durch: + * Erstellen eines lokalen TCP Sockets + * Spezifizieren der IP-Adresse und der Portnummer des Serverprozess + * Wenn der Client den Socket erstellt, dann baut das Client TCP eine Verbindung zum Server-TCP auf, das Server TCP erstellt daraufhin auch einen neuen Socket, sodass nun kommuniziert werden kann. + * Dies erlaubt es dem Server mit mehreren Clients zu sprechen + * Die Quellportnummern unterscheiden die Clients + > Sichtweise der Anwendung\ + > TCP stellt eine zuverlässige und reihenfolgegetreue Übertragung von Bytes zwischen Client und Server sicher + +#### Stream Jargon +* Ein Stream ist eine Sequenz aus Zeichen, welche in oder aus einem Prozess fließen +* Ein Eingangsstream ist an eine Eingabequelle gebunden, beispielsweise eine Tastatur oder einen Socket +* Ein Ausgangsstream ist an eine Ausgabequelle gebunden, wie einen Monitor oder einen Socket + +### Socketprogrammierung mit UDP +Bei UDP: Keine Verbindung zwischen Client und Server +* Kein Handshaking +* Der Sender fügt die IP-Adresse und den Zielport des Ziels explizit an jedes Paket +* Der Server muss die IP-Adresse und den Port des Senders aus dem erhaltenen Paket extrahieren +* Bei UDP können Daten nicht reihenfolgegetreu ankommen, oder verloren gehen +> Sichtweise der Anwendung\ +> UDP stellt eine unzuverlässige Übertragung von Gruppen an Bytes zwischen Client und Server bereit + +### Bauen eines einfachen Webservers +* Behandelt eine HTTP Anfrage, akzeptiert diese und parst den Header +* Zieht die angeforderte Datei vom Serverdateisystem +* Erstellt eine HTTP Antwortnachricht: Headerzeilen + Datei +* Sendet die Antwort an den Client + +## Zusammenfassung Kapitel 9 +* Anwendungsarchitekturen + * Client/Server + * Peer2Peer + * Hybride +* Anforderungen an Anwendungsdienste + * Zuverlässigkeit, Bandbreite, Verzögerung +* Internettransportdienstmodelle + * Verbindungsorientiert, verlässlich: TCP + * Unzuverlässig, mit Datagrammen: UDP +* Spezifische Protokolle + * HTTP + * FTP + * SMTP, POP, IMAP + * DNS +* Socketprogrammierung +* **Das wichtigste: Anwendungsprotokolle** + * Typischerweise Anfrage/Antwort Nachrichtenaustausch + * Clients fragen Info oder Dienst an + * Server antworten mit Daten und Statuscode + * Nachrichtenformate + * Header: Felder welche Info über die Daten geben + * Daten: Informationen, welche kommuniziert werden + * Kontroll vs. Datennachrichten + * In-Band vs. Out-of-Band + * Zentralisiert vs. Dezentralisiert + * Zuverlässiger vs. unzuverlässiger Nachrichtenaustausch + * Komplexität am Rande des Netzwerks + +--- +# Kapitel 10: Netzwerk Sicherheit +## Einführung - Bedrohungen, Sicherheitsziele, Schutzmaßnahmen +### Was ist eine Bedrohung in einem Kommunikationsnetzwerk? +* Abstrakte Definition + * Eine Bedrohung in einem Kommunikationsnetzwerk ist jedes mögliche Ereignis oder eine Sequenz von Aktionen, welche zu einer Verletzung einer oder mehrerer Sicherheitsziele führen + * Die Realisierung einer Bedrohung wird Attacke genannt +* Beispiele: + * Hacker brechen in Computer ein, Emails werden verändert, Finanzdaten werden verändert, ein Hacker legt eine Webseite lahm +* Was sind Sicherheitsziele: + * Sicherheitsziele können definiert werden: + * Abhängig vom Anwendungsumfeld, oder einem generelleren, technischeren Weg + +#### Sicherheitsziele (Security Objectives) in Abnhängigkeit von der Anwendungsumgebung +* Banking + * Schutz gegen Betrüger oder versehentliche Veränderung an Transaktionen + * Eindeutiges und fälschungssicheres Identifizieren der Kunden + * Sichern der PINs gegen zufälllige Entdeckung und der Privatspäre der Kunden +* Elektronisches Handeln + * Schützen der Privatsphäre der Kunden und des Unternehmens + * Bereitstellen von rechtlich bindenden Signaturen für Transaktionen +* und viele weitere im Bereich der Regierung, öffentlicher Telekommunikationsanbieter, Geschäfte und privater Haushalte +* Ziel ist es in jedem Fall sich gegen Angriffe von Außen zu schützen + +#### Sicherheitsziele technisch definiert +* Vertraulichkeit: + * Verschickte oder gespeicherte Daten sollen nur einem bestimmten Nutzerkreis zugänglich sein + * Vertraulichkeit von Instanzen wird auch als Anonymität bezeichnet +* Datenintegrität + * Es sollte möglich sein, jede Veränderung von Daten zu erkennen, dies benötigt unter anderem, die Möglichkeit den Ersteller von Daten identifizieren zu können +* Verantwortlichkeit + * Es sollte möglich sein, eine Instanz zu identifizieren, welche für irgendein Kommunikationsereignis zuständig ist +* Verfügbarkeit + * Dienste sollten verfügbar sein und auch funktionieren +* Kontrollierter Zugriff + * Nur autorisierte Instanzen solle in der Lage sein auf bestimmte Dienste oder Daten zuzugreifen + +#### Bedrohungen technisch definiert +* Maskerade (Spoofing) + * Eine Instanz behauptet jemand Anderes zu sein +* Abhören (Sniffing) + * Jemand versucht Daten zu lesen, welche er nicht lesen darf und soll +* Autorisierungsverletzungen + * Eine Instanz verwendet Ressourcen die sie nicht verwenden darf +* Verlust oder Veränderung von übertragener Information + * Veränderung oder Zerstörung von Daten +* Fälschung von Daten + * Eine Instanz erzeugt Daten im Namen einer Anderen +* Abstreiten von Kommunikationsereignissen (Repudiation) + * Eine Instanz streitet seine Beteiligung an einem Kommunikationsereignis ab +* Sabotage + * Jede Art von Aktion welche darauf abzielt, die Verfügbarkeit oder korrekte Funktion von Diensten zu reduzieren + +#### Sicherheitsanalyse von gelayerten Protokollarchitekturen +* Dimension 1: Auf welchem Interface findet der Angriff statt? +* Dimension 2: Auf welchem Layer findet der Angriff statt? + +##### Angriff auf dem Nachrichtenlevel +* Passive Übergriffe: + * Spähen +* Aktive Angriffe: + * Verzögerung von PDUs + * Wiederholung von PDUs + * Löschen von PDUs + * Veränderung von PDUs + * Einfügen von PDUs +* Ein erfolgreicher Angriff benötigt: + * Seiteneffektsfreiheit auf andere Kommunikationen + * Steineneffektsfreiheit auf andere PDUs in der selben Datenübertragung +* Eine Sicherheitsanalyse einer Protokollarchitektur muss diese Angriffe bezüglich der Layer der Architektur analysieren + +##### Sicherheitsmechanismen gegen Bedrohungen +* Physische Sicherheit: + * Abschließen der Betriebsräume, Zutrittskontrolle + * Tamper Proofing von sensitivem Equipment + * Schutz vor Überwachung der Umgebung +* Personelle Sicherheit + * Sensitivität bei Mitarbeitern erzeugen + * Überprüfung der Angestellten + * Sicherheitstraining +* Administrative Sicherheit + * Kontrollieren neuer Software + * Prozeduren um Sicherheitsverstöße zu erkennen + * Ansehen und Reagieren auf Audittrails +* Ausstrahlungssicherheit + * Steuerung von Frequenzen und anderer elektromagnetischer Ausstrahlungen +* Mediensicherheit + * Kontrollieren der Erstellung, Reproduktion und Zerstörung von Informationen + * Scannen von Medien auf Schadsoftware +* Lifecyclekontrollen + * Vertrauenswürdiges Systemdesign der Implementierung, Evaluation und Unterstüzung + * Dokumentierung + * Einhalten von Programmierstandards +* Computersicherheit + * Schutz der Informationen, während diese auf Rechnern gespeichert oder verarbeitet werden + * Schutz der Rechner selbst +* Kommunikationssicherheit + * Schutz der Informationen beim Transport von einem zum anderen System + * Schutz der Kommunikationsinfrastruktur an sich + +## Grundlagen der Sicherheitstechnologie +### Terminologie +* Sicherheitsdienst: + * Abstrakter Dienst, welcher versucht, eine bestimmte Sicherheitseigenschaft zu gewährleisten + * Kann mittels kryptographischer Algorithmen oder auf konventionelle Weise realisiert werden +* Kryptographischer Algorithmus + * Eine mathematische Transformation von Eingangsdaten (Daten, Schlüsseln) zu Ausgangsdaten +* Kryptographisches Protokoll + * Eine Serie an Schritten und Nachrichtenaustauschen zwischen mehreren Instanzen, um ein spezifisches Sicherheitsziel zu erfüllen + +### Sicherheitsdienste - Übersicht +* Authentisierung + * Grundlegender Sicherheitsdienst, welcher sicherstellt, dass eine Instanz tatsächlich die Identität hat, welche sie vorgibt zu haben +* Integrität + * Kleiner Bruder der Authentisierung, da er sicherstellt, dass Daten, welche von einer gewissen Einheit erstellt worden sind, nicht ohne Erkennung verändert werden können +* Vertraulichkeit + * Stellt sicher, dass die geschützen Daten geheim bleiben +* Zugriffskontrolle + * Kontrolliert, dass jede Identität nur auf die Informationen und Dienste zugreift, zu welchen sie auch zugriffsberechtigt ist +* Nicht Ablehnung + * Schütz davor, dass andere Einheiten nach einer Kommunikation behaupten können, nie daran teilgenommen zu haben + +### Kryptologie - Definition und Terminologie +* Kryptologie: + * Wissenschaft, die sich mit Kommunikation in sicherer und geheimer Art befasst + * Kryptologie besteht aus + * Kryptographie (graphein = schreiben): Die Lehre der Prinzipien und Techniken, durch welche Informationen in Ciphertext verpackt und später durch legitimierte Nutzer, wieder durch einen geheimen Schlüssel entschlüsselt werden können + * Kryptoanalyse (analyein = etwas lösen): Die Wissenschaft und Kunst Informationen von Ciphern wiederherzustellen und dies ohne das Wissen über den Schlüssel zu schaffen +* Cipher: + * Methode eine Nachricht so zu transformieren, dass die Bedeutung nicht mehr erkannt werden kann + * Cipher sind nur eine Klasse kryptographischer Algorithmen + * Die Transformation hat typischerweise eine Nachricht und einen geheimen Schlüssel als Eingabe + +#### Kryptographische Algorithmen +* Für die Netzwerksicherheit sind vor allem das Verschlüsseln und Signieren von Daten von Bedeutung: + * Verschlüsseln von Daten: Transformiert Plaintext in Ciphertext um die Inhalte zu verschleiern + * Signieren von Daten: Berechnet einen Checkwert oder eine digitale Signatur zu einem gegebenen Plaintext oder Ciphertext, sodass dieser durch alle oder einige Instanzen mit Zugriff verifiziert werden kann +* Prinzipielle Kategorien von Kryptographiealgorithmen + * Symmetrische Kryptographie verwendet einen Schlüssel für Ver- und Entschlüsselung oder Signieren und Überprüfen + * Assymmetrische Kryptographie verwendet zwei Schlüssel für Ver- und Entschlüsselung + * Kryptographische Hashfunktionen verwenden keinen Schlüssel (ist kein separater Input, wird in die Daten gemischt oder angehängt) + +#### Wichtige Eigenschaften von Verschlüsselungsalgorithmen +* Fehlerausbreitung: Charakterisiert die Effekte von Bitfehlern während der Übertragung von Ciphertext zum rekonstruierten Klartext +* Synchronisation: Charakterisiert die Effekte von verlorenen Ciphertexten auf den rekonstruierten Klartext + +##### Symmetrische Verschlüsselung +* Der selbe Schlüssel wird zur Ver- und Entschlüsselung eingesetzt +* Beispiele: DES, 3DES, AES, IDEA, RC4,… + +##### Asymmetrische Kryptographie +* Idee: + * Verwende zwei verschiedene Schlüssel +K und -K für Ver- und Entschlüsselung + * Gegeben ein zufälliger Ciphertext c = E(+K,m) und +K, so sollte es unmöglich sein, m = D(-K,c) zu berechnen + * Der Schlüssel -K ist nur A selbst bekannt und wird As privater Schlüssel genannt + * Der Schlüssel +K ist As öffentlicher Schlüssel, den jeder kennen darf +* Anwendungen: + * Verschlüsselung + * Wenn B eine Nachricht mit As öffentlichem Schlüssel +K verschlüsselt, so kann sich B sicher sein, dass nur A diese Nachricht mit dem Schlüssel -K entschlüsseln kann + * Signieren + * Wenn A eine Nachricht mit seinem privaten Key -K verschlüsselt, so kann jeder diese Signatur mit As öffentlichem Schlüssel +K entschlüsseln +* Praktische Überlegungen + * Asymmetrische Verschlüsselungsverfahren sind um Größenordnungen langsamer als symmetrische Verschlüsselung, deshalb verwendet man die asymmetrische Verschlüsselung eher in Verbindung mit symmetrischer, nämlich indem man die Datenmengen symmetrisch verschlüsselt, und nur den Schlüssel auf asymmetrische Art verschlüsselt + +##### Erkennung verschlüsselter Nachrichten +* Motivation + * Fehlererkennungscodes erlauben es uns zu erkennen, ob Nachrichten während der Übertragung durch Bitflips o.ä. verändert wurden (Parität, CRC, …) + * -> Wunsch nach ähnlichem Wert, welcher besagt, ob eine Nachricht mutwillig verändert wurde +* Realisierung von MCVs: + * Kryptographische Hashfunktionen + * Entweder kombiniert mit asymmetrischer Kryptographie um einen signierten modification detection code (MDC) zu erhalten, oder Inklusion eines geteilten, geheimen, mit der Nachricht gemischten Schlüssel in der Nachricht + * Message Authentication Codes + * Häufige message authentication codes (MAC) werden aus einem symmetrischen Blockcipher konstruiert + +##### Kryptographisches Protokoll +* Definition: Ein kryptographisches Protokoll wird definiert als eine Serie von Schritten und Nachrichtenaustauschen zwischen mehreren Einheiten um ein spezielles Sicherheitsziel zu erreichen +* Anwendungen kryptographischer Protokolle + * Schlüsselaustausch + * Authentisierung + * Integrität: Erlaubt dem Empfänger zu verifizieren, von wem eine Nachricht kam und ob sie verändert wurde + * Einheitenauthentisierung: Erlaubt es Kommunikationspartnern die Identität ihrer Peers zu verifizieren + +## Einführung in die Sicherheitsdienste von Kommunikationsnetzwerken +### Sicherheit in Netzwerken: Was sollen wir wo tun? +* Dimension 1: Welcher Sicherheitsdienst auf welchem Knoten? +* Dimension 2: Welcher Sicherheitsdienst auf welcher Netzwerkebene? + +### Pragmatisches Modelll für sicheres und vernetztes Rechnen +* Anwendung: + * Ein Stück Software muss eine gewisse Aufgabe ausführen, beispielsweise Email, Webdienste, Speichern von Daten, … +* Endsystem: + * Irgendein Gerät, von PC bis Server oder Mainframe + * Endsysteme haben aus Sicherheitsgründen typischerweise eine Richtlinienautorität +* Subnetzwerk: + * Sammlung von Kommunikationsstellen unter der Kontrolle einer administrativen Organisation + * Aus Sicherheitsgründen haben Subnetz typischerweise eine Richtlinienautorität +* Inter-Netzwerk: + * Sammlung von untereinander verbundener Subnetzwerken + * Grundsätzlich haben in einem Inter-Netzwerk verbundene Subnetze eigene, also verschiedene Richtlinienautoritäten +* Vier Ebenen mit jeweils unterschiedichen Anforderungen an Sicherheitsprotokollelemente + * Anwendungsebene: Sicherheitsptrotokollelemente sind anwendungsabhängig + * Endsystemebene: Bereitstellung von Schutz auf einer Endsystem zu Endsystembasis + * Subnetzwerkebene: Bereitstellung von Schutz über ein Subnetzwerk oder Inter-Netzwerk welches als weniger sicher als andere Stellen des Netzwerks gilt + * Linkebene: Bereitstellung von Schutz in einem Subnetzwerk, beispielsweise über einen Link, welcher weniger vertrauenswürdig als andere Stellen des Subnetzwerks gilt + +### Beziehungen zwischen Layern und Anforderungsleveln +* Die Beziehungen zwischen Protokolllayern und den Protokollelementssicherheitsanforderungen lassen sich nicht 1zu1 abbilden: + * Sicherheitsmechanismen welche sowohl Anforderungen an Endsystemen oder Subnetzwerkebenen erfüllen, können entweder in der Transport, und/oder in der Netzwerkschicht realisiert werden + * Link-Level-Anforderungen können erfüllt werden, indem man Sicherheitsmechanismen entweder im Linklayer, und/oder auf der physischen Ebene integriert + +### Die IP Sicherheitsarchitektur IPSec +#### Sicherheitsprobleme des Internetprotokolls +* Wenn eine Instanz ein IP Paket erhält, so hat es keinen Nachweis über: + * Die Herkunft der Daten und deren Integrität + * Also, dass das Paket tatsächlich von der Einheit gesendet wurde, welche in der Quelladresse des Pakets referenziert wird + * dass das Paket noch den ursprünglichen Inhalt enthält + * dass die Empfangseinheit tatsächlich die Einheit ist, an welche der Sender das Paket schicken wollte + * Vertraulichkeit + * Dass die ursprünglichen Daten nicht von einem Dritten inspiziert und gelesen wurden, während das Paket auf dem Weg vom Sender zum Empfänger war + +#### Sicherheitsziele von IPSec +* Datenherkunftsauthentisierung/ Verbindungslose Datenintegrität: + * Es soll unmöglich sein, ein IP Datagramm mit einer maskierten Quell- oder Zieladresse zu versenden, ohne, dass dies der Emfpänger erkennen kann. + * Es soll unmöglich sein, ein IP Paket während der Übertragung so zu verändern, dass es dem Empfänger nicht auffallen kann + * Wiederholungsschutz: Es soll nicht möglich sein, ein gespeichertes Paket zu späterem Zeitpunkt zu versenden, ohne, dass dies der Empfänger mitbekommt +* Vertrauenswürdigkeit: + * Es soll nicht möglich sein, den Inhalt der IP Datagramme auszuspähen + * Es soll weiterhin eine begrenzte Traffic Flow Confidentiality geben +* Sicherheitsrichtlinie + * Sender, Empfänger und zwischenliegende Knoten sollen erkennen können, ob ein Paket ihrer Sicherheitsrichtlinie entspricht und dieses gegebenenfalls verwerfen + +#### IPSec: Sicherheitsassoziation +* Eine Sicherheitsassoziation (SA) it eine "Simplexverbindung" welche Sicherheitsdienste für den von ihr beförderten Verkehr anbietet + * Sicherheitsdienste werden einer SA durch die Verwendung von entweder AH (Authentication Header) oder ESP (Encapsulating Security Payload) bereitgestellt + * Für bidirektionale Kommunikation werden zwei SA benötigt + * Eine SA ist eindeutig bestimmt durch ein Tripel, welches aus eine Sicherheitsparamterindex (SPI), einer Ziel-IP-Adresse und einem Sicherheitsprotokollbezeichner (AH/ESP) besteht + * Eine SA kann zwischen folgenden Peers aufgebaut werden + * Host <-> Host + * Host <-> Gateway + * Gateway <-> Host + * Gateway <-> Gateway + * Es gibt zwei konzeptionelle Datenbanken, die mit SAs assoziiert werden + * Die Sicherheitsrichtliniendatenbank (SPD), spezifiziert welche Sicherheitsdienste wie für IP Pakete bereitgestellt werden + * Die Sicherheitsassoziationsdatenbank (SADB) + +#### IPSec Protokollmodi +* Eine SA ist immer von einem der folgenden Typen: + * Der Transportmodus kann nur zwischen Endpunkten der Kommunikation verwendet werden + * Host <-> Host + * Host <-> Gateway (falls Gateway hier Kommunikationsendpunkt) + * Der Tunnelmodus kann mit beliebigen Peers verwendet werden +* Unterschiede zwischen den Modi: + * Der Transportmodus fügt nur einen sicherheitsspezifischen Header hinzu (+ potentiellen Trailer) + * Der Tunnelmodus kapselt IP Pakete +* Die Kapselung von IP-Paketen ermöglicht es den Gateways , Daten im Auftrag von anderen Instanzen zu schützen + +#### IPSec: Verschachtelung von Sicherheitsassoziationen +Beispiel: Host A und Gateway RB führen Datenherkunftsauthentisierung aus und die Gateways RA und RB führen Subnetz-to-Subnetz Vertraulichkeit aus + +##### IPSec Authentication Header (AH) +* Im Tunnelmodus stellt der Payload nochmals ein ganzes IP Paket dar +* Wichtig: AH funktioniert nur in NAT freien Umgebungen + +##### IPSec Encapsulating Security Protocol (ESP) +* Dem ESP Header folgt direkt ein IP Header oder ein AH-Header +* Das next-header Feld vom vorhergehenden Header indiziert 50 für ESP + +#### IPSec: Etablierung von Sicherheitassoziationen +* Bevor ein Paket von IPSec geschützt wird, muss eine SA zwischen den beiden "kryptographischen Endpunkten", welche den Schutz bereitstellen, aufgebaut werden +* SA Etablierung kann auf folgende Arten geschehen + * Manuell, durch proprietäre Methoden des Systemmanagements (nur in Ausnahmefällen) + * Dynamisch, durch ein standardisiertes Authentisierungs- und Schlüsselmanagementprotokoll +* IPSec definiert eine standardisierte Methode für die Etablierung von SAs + * Internet Security Association and Key Management Protocol (ISAKMP) + * Definiert Protokollformate und Prozeduren für die Sicherheitsaushandlung + * Internet Key Exchange (IKE) + * Definiert IPSecs Standardauthentisierungs- und Schlüsselaustauschprotokoll + +## Internetfirewalls +* Eine Netzwerkfirewall kann gut mit einer mittelalterlichen Zugbrücke verglichen werden: + * Sie beschränkt, welche Menschen die Burg betreten, da es nur den einen kontrollierten Eingang gibt + * Sie hält Angreifer davon ab, zu den weiteren Schutzmaßnahmen vorzudringen + * Sie beschränkt, welche Leute die Burg am streng überwachten Übergang verlassen +* Typischerweise wird eine Firewall an einem Punkt installiert, dan dem ein geschützes Subnetz an ein weniger vertrauenswürdiges Netzwerk angeschlossen wird +* Grundsätzlich realisieren Firewalls also Zugriffskontrolle auf dem Subnetzlevel + +### Terminologie +* Firewall: + * Eine oder eine Menge an Komponenten, welche den Zugriff zwischen einem geschützten Netzwerk und dem Internet oder zwischen einer Menge an Netzwerken beschränkt +* Paketfiltern/Screening: + * Die Aktion, welche ein Gerät ausführt, um selektiv den Fluss an Daten in und aus einem Netzwerk zu kontrollieren + * Paketfiltern ist eine wichtige Technik um Zugriffskontrolle auf dem Subnetzwerklevel für paketorientierte Netzwerke zu implementieren +* Bastion Host: + * Ein Computer, welcher besonders gesichert werden muss, da er anfälliger für Angriffe ist, als andere Computer im Subnetz + * Ein Bastion Host in einer Firewall ist typischerweise der Hauptansprechpartner für Nutzerprozesse von Hosts innerhalb des Netzwerks zu Prozessen von externen Hosts +* Dual Homed Host + * Ein Computer mit > 2 Netzwerkinterfaces +* Proxy: + * Ein Programm, welches sich im Auftrag interner Clients mit externen Servern beschäftigt + * Proxies leiten genehmigte Clientanfragen an die Server, und die Antworten auch wieder an den Client weiter + * Wenn ein Proxy die Kommandos eines Anwendungsprotokollls versteht und interpretiert, dann ist es ein Application Level Proxy, andernfalls, falls er die PDUs nur zwischen Cient und Server weiterreicht, so ist es ein Circuit Level Proxy +* Network Address Translation (NAT): + * Eine Prozedur, durch welche ein Router die Daten in Paketen ändert um die Netzwerkadressen zu modifizieren + * Dies erlaubt es die interne Netzwerkstruktur zu verschleiern +* Perimeternetzwerk + * Ein Subnetz, welches zwischen einem externen und einem internen Netzwerk hinzugefügt wird, um eine weitere Sicherheitseben bereitzustellen + * Ein Synonym hierfür ist DMZ (De Militarized Zone) + +### Firewallarchitekturen +#### Einfache Paketfilterarchitektur +* Einfachste Architektur bestehend aus einem paketfilternden Router +* Realisierbar durch PC mit zwei Netzwerkinterfaces oder einem dedizierten Router + +#### Die Screened Host Architektur +* Der Paketfilter erlaubt zuverlässigen Verkehr zwischen dem screended Host und dem Internet und blockiert jeglichen Verkehr zwischen anderen internen Hosts und dem Internet +* Der screened Host stellt Proxydienste bereit + * Ungeachtet des teilweisen Schutz durch den Paketfilter, fungiert der screened Host als ein Bastion Host + +#### Die Screened Subnet Architektur +* Ein Perimeternetzwerk wird zwischen zwei Paketfiltern installiert +* Der innere Paketfilter dient zum zusätzlichen Schutz im Falle, dass der Bastion Host je kompromittiert wird (so kann ein übernommener Bastion Host keinen internen Verkehr mithören) +* Dieses Perimeternetzwerk ist ebenfalls ein guter Ort, um einen öffentlich erreichbaren Server zu hosten + +#### Firewalls: Paketfiltrierung +* Was kann man mit Paketfiltern alles erreichen? + * Theoretisch alles, da alle Informationen, welche in einer Kommunikation ausgetauscht werden als Pakete transportiert werden + * Praktisch allerdings, dient folgendes als Orientierungshilfe + * Operationen, welche detaillierte Kenntnisse über Protokolle höherer Schichten erfordern, oder die verlängerte Nachverfolgung von vergangenen Ereignissen benötigen, sind in Proxysystemen einfacher zu realisieren + * Operationen, die zwar einfach sind, aber sehr schnell ausgeführt werden müssen, sind in Paketfiltersystemen einfacher zu handhaben +* Grundlegendes Paketfiltern erlaubt es den Datentransfer anhand folgender Kriterien zu kontrollieren: + * Quell IP + * Ziel IP + * Transportprotokoll + * Quell- und Zielanwendungsport + * Potentielle, spezifische Kontrollflags + * Das Netzwerkinterface, auf welchem das Paket ankam \ No newline at end of file