docs: add obsidian hwr docs

Komplexitätstheorie/zusammenfassungen/Grundlagen.md

@@ -0,0 +1,397 @@
+# Komplexitätstheorie – Grundlagen, Entscheidbarkeit & Probleme
+
+**Basierend auf:** KO1 & KO2 (Prof. Dr. Björn Grohmann, HWR Berlin)
+
+-----
+
+## 1. Die Turing-Maschine
+
+### Was ist eine Turing-Maschine?
+
+Eine Turing-Maschine (TM) ist ein abstraktes Berechnungsmodell – im Grunde der einfachste denkbare „Computer”. Sie besteht aus drei Teilen:
+
+- **Ein unendlich langes Band**, unterteilt in Zellen. Jede Zelle enthält genau ein Symbol.
+- **Ein Lese-/Schreibkopf**, der sich auf dem Band nach links oder rechts bewegen kann, Symbole lesen und schreiben kann.
+- **Eine endliche Steuerung**, die anhand des aktuellen Zustands und des gelesenen Symbols entscheidet, was als nächstes passiert.
+
+### Formale Definition
+
+Eine TM ist ein 7-Tupel $(Q, \Sigma, \Gamma, \delta, q_0, q_{\text{accept}}, q_{\text{reject}})$:
+
+|Bestandteil        |Bedeutung                                                                     |
+|-------------------|------------------------------------------------------------------------------|
+|$Q$                |Endliche Zustandsmenge                                                        |
+|$\Sigma$           |Eingabealphabet (ohne Blanksymbol $\sqcup$)                                   |
+|$\Gamma$           |Bandalphabet ($\sqcup \in \Gamma$, $\Sigma \subseteq \Gamma$)                 |
+|$\delta$           |Übergangsfunktion: $Q \times \Gamma \rightarrow Q \times \Gamma \times {L, R}$|
+|$q_0$              |Startzustand                                                                  |
+|$q_{\text{accept}}$|Akzeptierzustand – die Maschine sagt „Ja”                                     |
+|$q_{\text{reject}}$|Ablehnungszustand – die Maschine sagt „Nein”                                  |
+
+Die Übergangsfunktion $\delta$ ist das Herzstück: Sie sagt „Wenn du im Zustand $q$ bist und Symbol $a$ liest, dann schreibe Symbol $b$, wechsle in Zustand $q’$ und bewege den Kopf nach links oder rechts.”
+
+### Konfiguration
+
+Eine Konfiguration ist eine Momentaufnahme der TM zu einem bestimmten Zeitpunkt. Sie umfasst den aktuellen Zustand, den Bandinhalt und die Kopfposition.
+
+Beispiel: $1011q_701111$ bedeutet, dass auf dem Band „101101111” steht, die Maschine im Zustand $q_7$ ist und der Kopf auf dem Zeichen direkt rechts von $q_7$ steht (also auf der „0”).
+
+### Was bedeutet „halten”?
+
+Eine Turing-Maschine **hält**, wenn sie irgendwann in den Akzeptier- oder Ablehnungszustand gelangt und damit ihre Berechnung beendet. Wenn sie das nie tut, läuft sie endlos weiter – sie „hält nicht”. Das ist so, als würde ein Programm in einer Endlosschleife stecken und nie ein Ergebnis liefern.
+
+-----
+
+## 2. Varianten von Turing-Maschinen
+
+### Mehrband-TM (Multitape TM)
+
+Eine TM mit $k$ separaten Bändern und $k$ unabhängigen Köpfen. Die Übergangsfunktion hat die Form:
+
+$$\delta: Q \times \Gamma^k \rightarrow Q \times \Gamma^k \times {L, R, S}^k$$
+
+Jede Mehrband-TM kann durch eine Einband-TM simuliert werden (alle Bänder werden hintereinander auf ein Band geschrieben, getrennt durch #-Symbole). Die Simulation kostet quadratischen Zeitoverhead: $O(T(n)^2)$.
+
+### Nichtdeterministische TM (NTM)
+
+Die Übergangsfunktion liefert statt eines einzigen Nachfolgezustands eine **Menge** von möglichen Übergängen:
+
+$$\delta: Q \times \Gamma \rightarrow \mathcal{P}(Q \times \Gamma \times {L, R})$$
+
+Man kann sich das so vorstellen: An jedem Schritt „verzweigt” sich die Berechnung in mehrere parallele Pfade. Die NTM akzeptiert, wenn **mindestens ein** Pfad akzeptiert. Sie lehnt ab, wenn **alle** Pfade ablehnen.
+
+Jede NTM kann durch eine deterministische TM simuliert werden, allerdings mit exponentiellem Zeitverlust: Eine $t(n)$-Zeit-NTM wird zu einer $2^{O(t(n))}$-Zeit-DTM.
+
+### Universelle Turing-Maschine (UTM)
+
+Eine UTM $\mathcal{U}$ kann jede andere TM simulieren. Sie bekommt als Eingabe die Beschreibung einer TM $M$ (kodiert als Bitfolge, die sogenannte **Gödelnummer**) und eine Eingabe $x$ und berechnet dann $M(x)$.
+
+Die UTM ist im Grunde der theoretische Vorläufer des modernen Computers: Ein Gerät, das beliebige Programme ausführen kann.
+
+-----
+
+## 3. Äquivalente Berechnungsmodelle
+
+Mehrere andere Berechnungsmodelle sind **genauso mächtig** wie die Turing-Maschine. Das stützt die Church-Turing-These.
+
+|Modell             |Kernidee                                                                               |
+|-------------------|---------------------------------------------------------------------------------------|
+|**WHILE-Programme**|Schleifen mit Inkrement/Dekrement auf Variablen                                        |
+|**GOTO-Programme** |Nummerierte Anweisungen mit Sprungbefehlen                                             |
+|**Lambda-Kalkül**  |Funktionsdefinition und -anwendung (Grundlage funktionaler Programmierung)             |
+|**Rule 110**       |Eindimensionaler Zellularautomat – selbst dieses einfache System ist Turing-vollständig|
+
+### Church-Turing-These
+
+> „Jede effektiv berechenbare Funktion kann durch eine Turing-Maschine berechnet werden.”
+
+Das ist keine bewiesene Aussage, sondern eine These. Sie besagt: Es gibt kein Berechnungsmodell, das mehr berechnen kann als eine TM. Bisher wurde kein Gegenbeispiel gefunden.
+
+-----
+
+## 4. Entscheidbarkeit
+
+### Turing-erkennbar (semi-entscheidbar)
+
+Eine Sprache $L$ ist **Turing-erkennbar**, wenn es eine TM gibt, die so arbeitet:
+
+- Eingabe $w \in L$: Die TM akzeptiert (hält und sagt „Ja”).
+- Eingabe $w \notin L$: Die TM lehnt ab **oder läuft endlos weiter**.
+
+Das Problem: Man weiß nie, ob die Maschine noch rechnet oder ob sie in einer Endlosschleife steckt.
+
+### Turing-entscheidbar (entscheidbar)
+
+Eine Sprache $L$ ist **Turing-entscheidbar**, wenn es eine TM gibt, die so arbeitet:
+
+- Eingabe $w \in L$: Die TM akzeptiert.
+- Eingabe $w \notin L$: Die TM lehnt ab.
+- **Die TM hält immer** – sie liefert auf jeder Eingabe eine definitive Antwort.
+
+### Der Zusammenhang
+
+Eine Sprache ist entscheidbar **genau dann, wenn** sie sowohl Turing-erkennbar als auch co-Turing-erkennbar ist. Die Idee: Man lässt zwei Maschinen parallel laufen – eine für $L$, eine für das Komplement $\overline{L}$. Eine von beiden wird irgendwann akzeptieren, und dann hat man die Antwort.
+
+### Hierarchie der Berechenbarkeit
+
+```
+Entscheidbar  ⊂  Semi-entscheidbar  ⊂  Alle Sprachen
+(TM hält immer)  (TM hält für w ∈ L)   (manche sind gar nicht berechenbar)
+```
+
+-----
+
+## 5. Unentscheidbare Probleme
+
+### Das Halteproblem ($HALT_{\text{TM}}$)
+
+$$HALT_{\text{TM}} = {\langle M, w \rangle \mid M \text{ ist eine TM und } M \text{ hält auf Eingabe } w}$$
+
+**Frage:** Kann man im Voraus entscheiden, ob ein beliebiges Programm auf einer beliebigen Eingabe irgendwann anhält oder ewig weiterläuft?
+
+**Antwort:** Nein – das Halteproblem ist unentscheidbar.
+
+### Die Akzeptanzsprache ($A_{\text{TM}}$)
+
+$$A_{\text{TM}} = {\langle M, w \rangle \mid M \text{ ist eine TM und } M \text{ akzeptiert } w}$$
+
+$A_{\text{TM}}$ ist semi-entscheidbar (man kann $M$ auf $w$ simulieren), aber **nicht entscheidbar**.
+
+### Beweis durch Diagonalisierung
+
+Der Beweis nutzt dieselbe Idee wie Cantors Diagonalisierung:
+
+1. **Annahme:** Es gibt einen Entscheider $H$, der für jede TM $M$ und jede Eingabe $w$ korrekt entscheidet, ob $M$ die Eingabe $w$ akzeptiert.
+2. **Konstruktion:** Baue eine „teuflische” Maschine $D$, die bei Eingabe $\langle M \rangle$ den Entscheider $H$ auf $\langle M, \langle M \rangle \rangle$ aufruft – also fragt „akzeptiert $M$ sich selbst?” – und dann **das Gegenteil tut**.
+3. **Widerspruch:** Was passiert bei $D(\langle D \rangle)$?
+- Falls $H$ sagt „$D$ akzeptiert sich selbst” → $D$ lehnt ab. Aber dann akzeptiert $D$ sich selbst nicht – Widerspruch zu dem, was $H$ gesagt hat.
+- Falls $H$ sagt „$D$ akzeptiert sich selbst nicht” → $D$ akzeptiert. Aber dann akzeptiert $D$ sich selbst doch – wieder Widerspruch.
+1. **Schlussfolgerung:** $H$ kann nicht existieren.
+
+Man kann sich das auch als Tabelle vorstellen: Zeilen sind TMs, Spalten sind Eingaben, Einträge sind 0 (lehnt ab) oder 1 (akzeptiert). $D$ nimmt die Diagonale und invertiert sie – und kann daher in keiner Zeile der Tabelle vorkommen, obwohl $D$ selbst eine TM ist.
+
+### Postsches Korrespondenzproblem (PCP)
+
+**Gegeben:** Wortpaare $(x_1, y_1), \ldots, (x_k, y_k)$, dargestellt als Dominosteine mit Ober- und Unterseite.
+
+**Gefragt:** Kann man eine Folge von Dominosteinen (mit Wiederholung) so aneinanderlegen, dass die obere und die untere Zeichenkette identisch sind?
+
+Das PCP ist unentscheidbar, aber semi-entscheidbar (man kann systematisch alle Kombinationen durchprobieren).
+
+### Hilberts 10. Problem
+
+**Frage (1900):** Gibt es ein Verfahren, das für jede Polynomgleichung mit ganzzahligen Koeffizienten entscheidet, ob sie eine ganzzahlige Lösung hat?
+
+**Antwort (Matijassewitsch, 1970):** Nein – unentscheidbar.
+
+### Weitere unentscheidbare Probleme
+
+|Problem                            |Frage                                          |Semi-entscheidbar?            |
+|-----------------------------------|-----------------------------------------------|------------------------------|
+|$E_{\text{TM}}$: Leerheitsproblem  |Ist $L(M) = \emptyset$?                        |Nein (co-Turing-erkennbar)    |
+|$EQ_{\text{TM}}$: Äquivalenzproblem|Gilt $L(M_1) = L(M_2)$?                        |Nein                          |
+|$REGULAR_{\text{TM}}$              |Ist $L(M)$ regulär?                            |Nein                          |
+|$MIN_{\text{TM}}$                  |Ist $M$ eine minimale TM?                      |Nicht einmal semi-entscheidbar|
+|Erfüllbarkeit (Prädikatenlogik)    |Ist ein prädikatenlogischer Ausdruck erfüllbar?|Ja, aber unentscheidbar       |
+|Gültigkeit (Prädikatenlogik)       |Ist ein Ausdruck allgemeingültig?              |Ja, aber unentscheidbar       |
+
+-----
+
+## 6. Zeitkomplexität
+
+### Laufzeit
+
+Die Laufzeit (Running Time) einer deterministischen TM $M$ ist die Funktion $f(n)$, die angibt, wie viele Schritte $M$ **im schlimmsten Fall** auf einer Eingabe der Länge $n$ benötigt.
+
+Bei einer nichtdeterministischen TM zählt man die maximale Schrittzahl über **alle Berechnungspfade** (auch die nicht-akzeptierenden).
+
+### Zeitkonstruierbarkeit
+
+Eine Funktion $t(n)$ heißt zeitkonstruierbar, wenn man den Wert $t(n)$ selbst in $O(t(n))$ Schritten berechnen kann. Beispiele: $n$, $n \log n$, $n^2$, $2^n$.
+
+### Simulationskosten
+
+|Transformation                                       |Zeitoverhead                |
+|-----------------------------------------------------|----------------------------|
+|Alphabetreduktion (auf ${0,1,\sqcup,\triangleright}$)|$O(\log                     |
+|$k$ Bänder → 1 Band                                  |$O(k \cdot T(n)^2)$         |
+|NTM → DTM                                            |$2^{O(T(n))}$ (exponentiell)|
+|Bidirektional → Unidirektional                       |$O(T(n))$                   |
+
+-----
+
+## 7. Komplexitätsklassen
+
+### Die wichtigsten Klassen im Überblick
+
+|Klasse     |Definition                      |Intuition                           |Beispiele                                   |
+|-----------|--------------------------------|------------------------------------|--------------------------------------------|
+|**P**      |$\bigcup_k \text{TIME}(n^k)$    |Effizient lösbar                    |Sortieren, kürzeste Wege, Primzahltest (AKS)|
+|**NP**     |$\bigcup_k \text{NTIME}(n^k)$   |Lösung effizient überprüfbar        |SAT, Hamiltonkreis, TSP, Knapsack           |
+|**co-NP**  |Komplemente der NP-Sprachen     |„Nein”-Antwort effizient überprüfbar|UNSAT, Tautologie                           |
+|**PSPACE** |$\bigcup_k \text{SPACE}(n^k)$   |Polynomieller Speicher reicht       |TQBF                                        |
+|**EXPTIME**|$\bigcup_k \text{TIME}(2^{n^k})$|Exponentielle Zeit                  |Generalisiertes Schach                      |
+
+### Die Inklusionskette
+
+$$P \subseteq NP \subseteq PSPACE = NPSPACE \subseteq EXPTIME$$
+
+Die Gleichheit $PSPACE = NPSPACE$ folgt aus Savitch’s Theorem.
+
+### P vs. NP – Die zentrale offene Frage
+
+**P** = Probleme, die ein Computer effizient **lösen** kann.
+**NP** = Probleme, deren Lösung ein Computer effizient **überprüfen** kann.
+
+Die Frage „Ist P = NP?” fragt im Kern: Ist jedes Problem, dessen Lösung leicht zu überprüfen ist, auch leicht zu finden? Die meisten Informatiker vermuten Nein. Das Problem ist eines der sieben Millennium-Probleme (Preisgeld: 1 Million Dollar).
+
+### Speicherkomplexität
+
+$$\text{SPACE}(f(n)) = {L \mid L \text{ wird von einer det. TM in } O(f(n)) \text{ Speicher entschieden}}$$
+
+$$\text{NSPACE}(f(n)) = {L \mid L \text{ wird von einer nichtdet. TM in } O(f(n)) \text{ Speicher entschieden}}$$
+
+### Savitch’s Theorem
+
+$$\text{NSPACE}(f(n)) \subseteq \text{SPACE}(f^2(n))$$
+
+Nichtdeterministischer Speicher lässt sich deterministisch mit nur quadratischem Mehraufwand simulieren. Die Kernidee ist die CANYIELD-Prozedur: Um zu prüfen, ob Konfiguration $c_2$ von $c_1$ in $t$ Schritten erreichbar ist, probiert man alle möglichen Zwischenkonfigurationen $c_m$ und prüft rekursiv, ob $c_1 \to c_m$ in $t/2$ Schritten und $c_m \to c_2$ in $t/2$ Schritten möglich ist. Die Rekursionstiefe ist $O(\log t)$, jede Ebene braucht $O(f(n))$ Speicher, also insgesamt $O(f(n)^2)$.
+
+-----
+
+## 8. NP-Vollständigkeit
+
+### Polynomialzeit-Reduktion
+
+Eine Sprache $A$ ist polynomialzeit-reduzierbar auf $B$ (geschrieben $A \leq_P B$), wenn es eine in Polynomialzeit berechenbare Funktion $f$ gibt mit:
+
+$$w \in A \iff f(w) \in B$$
+
+Intuition: Wenn man $B$ lösen kann, kann man auch $A$ lösen – man wandelt einfach jede $A$-Instanz mittels $f$ in eine $B$-Instanz um. $B$ ist also **mindestens so schwer** wie $A$.
+
+### Definition: NP-vollständig
+
+Eine Sprache $B$ ist NP-vollständig, wenn:
+
+1. $B \in NP$ (die Lösung ist effizient überprüfbar), **und**
+2. $A \leq_P B$ für **jedes** $A \in NP$ (jedes NP-Problem lässt sich auf $B$ reduzieren).
+
+Erfüllt $B$ nur Bedingung 2, heißt $B$ **NP-hard** (NP-schwer). NP-harte Probleme müssen nicht selbst in NP liegen.
+
+$$\text{NP-vollständig} = NP \cap \text{NP-hard}$$
+
+### Cook-Levin-Theorem (1971/1973)
+
+**SAT ist NP-vollständig.** Das war der erste Beweis, dass überhaupt ein NP-vollständiges Problem existiert. Daraus folgt: Könnte man SAT in Polynomialzeit lösen, wäre $P = NP$.
+
+### PSPACE-Vollständigkeit
+
+Eine Sprache $B$ ist PSPACE-vollständig, wenn $B \in PSPACE$ und jedes $A \in PSPACE$ polynomiell auf $B$ reduzierbar ist.
+
+**TQBF** (True Quantified Boolean Formula) ist PSPACE-vollständig. TQBF fragt, ob eine voll quantifizierte Boolesche Formel (mit $\forall$ und $\exists$) wahr ist. TQBF verallgemeinert SAT: Während SAT nur fragt „Gibt es eine erfüllende Belegung?” ($\exists$), erlaubt TQBF auch Allquantoren ($\forall$), was das Problem härter macht.
+
+-----
+
+## 9. Die wichtigsten NP-vollständigen Probleme
+
+### SAT (Erfüllbarkeitsproblem)
+
+**Eingabe:** Eine Boolesche Formel $\phi$ (z.B. $(x \lor \bar{y}) \land (\bar{x} \lor z)$).
+**Frage:** Gibt es eine Belegung der Variablen mit wahr/falsch, sodass die Formel wahr wird?
+**Zertifikat:** Die erfüllende Belegung selbst – man setzt die Werte ein und prüft.
+
+### Hamiltonkreis
+
+**Eingabe:** Ein ungerichteter Graph.
+**Frage:** Gibt es einen Rundweg, der **jeden Knoten genau einmal** besucht und zum Startknoten zurückkehrt?
+**Zertifikat:** Der Rundweg selbst – man prüft, ob er jeden Knoten genau einmal enthält.
+
+Die NP-Vollständigkeit wird durch Reduktion von SAT bewiesen, wobei eine Formel in einen Graphen mit speziellen Gadgets übersetzt wird (Variablenpfade, XOR-Gadgets, OR-Gadgets, Kreuzungs-Gadgets).
+
+### Traveling Salesman Problem (TSP)
+
+**Eingabe:** Städte mit Entfernungen und ein Budget $k$.
+**Frage:** Gibt es eine Rundreise durch alle Städte mit Gesamtlänge $\leq k$?
+**Zertifikat:** Die Rundreise selbst.
+
+### Knapsack (Rucksackproblem)
+
+**Eingabe:** Gegenstände mit Gewichten und Werten, ein Rucksack mit Kapazität $W$ und ein Zielwert $V$.
+**Frage:** Kann man Gegenstände so auswählen, dass das Gesamtgewicht $\leq W$ ist und der Gesamtwert $\geq V$?
+**Zertifikat:** Die Auswahl der Gegenstände.
+
+### Minesweeper
+
+**Eingabe:** Ein teilweise aufgedecktes Minesweeper-Feld.
+**Frage:** Gibt es eine konsistente Minenbelegung für die verdeckten Felder?
+
+Die NP-Vollständigkeit wird gezeigt, indem man logische Schaltkreise (Drähte, NOT-Gates, AND-Gates) innerhalb eines Minesweeper-Spielfelds simuliert. Damit lässt sich jede SAT-Instanz als Minesweeper-Konfiguration kodieren.
+
+### Karp’s Liste (1972)
+
+Richard Karp bewies 1972, dass 21 Probleme NP-vollständig sind, alle durch Reduktionen ausgehend von SAT. Dazu gehören unter anderem Clique, Node Cover, Chromatic Number, Set Covering, Exact Cover, 3D-Matching, Partition und Max Cut.
+
+-----
+
+## 10. NP-Härte von Videospielen
+
+Viele Videospiele sind NP-hard. Dafür gibt es allgemeine Metatheorems:
+
+### Metatheorem 1: Location Traversal + Single-Use Paths
+
+Wenn ein Spiel bestimmte Punkte vorschreibt, die besucht werden müssen, und Wege nur einmal benutzbar sind, ist es NP-hard (Reduktion vom Hamiltonkreisproblem).
+
+### Metatheorem 2: Tokens, Toll Roads, Location Traversal
+
+Ein Spiel ist NP-hard, wenn es sammelbare Tokens, kostenpflichtige Wege und zu besuchende Orte hat. Beispiel: In Pac-Man sind Power Pills die Tokens und Geisterkorridore die Toll Roads.
+
+### Metatheorem 3: Keys, Doors, One-Way Paths
+
+Wie Metatheorem 2, aber mit Schlüsseln statt Tokens und Türen statt Toll Roads.
+
+### Metatheorem 4: Doors + Pressure Plates
+
+Türen und Druckplatten (die Türen öffnen/schließen) machen ein Spiel NP-hard, selbst wenn keine zwei Druckplatten dieselbe Tür steuern.
+
+### Metatheorem 5: Doors + k-Buttons
+
+Buttons, bei denen der Spieler entscheiden kann, ob er sie drückt, und die $k$ Türen gleichzeitig beeinflussen, machen ein Spiel NP-hard für $k \geq 2$.
+
+-----
+
+## 11. Zusammenfassung: Was ist wo?
+
+### Entscheidbarkeit
+
+|Problem                                   |Entscheidbar?|Semi-entscheidbar?        |
+|------------------------------------------|-------------|--------------------------|
+|$A_{\text{TM}}$ (akzeptiert M w?)         |Nein         |Ja                        |
+|$HALT_{\text{TM}}$ (hält M auf w?)        |Nein         |Ja                        |
+|PCP                                       |Nein         |Ja                        |
+|Hilberts 10. Problem                      |Nein         |Ja                        |
+|$E_{\text{TM}}$ (ist $L(M)$ leer?)        |Nein         |Nein (co-Turing-erkennbar)|
+|$EQ_{\text{TM}}$ (sind $L(M_1) = L(M_2)$?)|Nein         |Nein                      |
+|$MIN_{\text{TM}}$ (ist M minimal?)        |Nein         |Nein                      |
+
+### Komplexität
+
+|Problem                 |Klasse            |
+|------------------------|------------------|
+|Sortieren, kürzeste Wege|P                 |
+|Primzahltest (AKS)      |P                 |
+|SAT                     |NP-vollständig    |
+|Hamiltonkreis           |NP-vollständig    |
+|TSP                     |NP-vollständig    |
+|Knapsack                |NP-vollständig    |
+|Minesweeper             |NP-vollständig    |
+|TQBF                    |PSPACE-vollständig|
+|Generalisiertes Schach  |EXPTIME           |
+
+### Beziehungen zwischen den Klassen
+
+```
+Entscheidbar:    P ⊆ NP ⊆ PSPACE = NPSPACE ⊆ EXPTIME
+
+Unentscheidbar:  Halteproblem, A_TM, PCP, Hilberts 10. Problem, ...
+```
+
+-----
+
+## 12. Glossar
+
+| Begriff                      | Bedeutung                                                    |
+| ---------------------------- | ------------------------------------------------------------ |
+| **Turing-Maschine**          | Abstraktes Berechnungsmodell mit Band, Kopf und Steuerung    |
+| **Konfiguration**            | Momentaufnahme: Zustand + Band + Kopfposition                |
+| **Gödelnummer**              | Binäre Kodierung einer TM                                    |
+| **Church-Turing-These**      | Alles Berechenbare ist Turing-berechenbar                    |
+| **Turing-erkennbar**         | TM akzeptiert $w \in L$, kann auf $w \notin L$ endlos laufen |
+| **Turing-entscheidbar**      | TM hält immer und gibt korrekte Antwort                      |
+| **Diagonalisierung**         | Beweistechnik: Widerspruch durch Selbstreferenz + Negation   |
+| **Zeitkomplexität**          | Maximale Schrittzahl einer TM bei Eingabelänge $n$           |
+| **Speicherkomplexität**      | Maximale Zahl besuchter Bandzellen bei Eingabelänge $n$      |
+| **Verifier**                 | Algorithmus der $(w, c)$ prüft – $c$ ist das Zertifikat      |
+| **Polynomialzeit-Reduktion** | $A \leq_P B$: Umwandlung von $A$ in $B$ in Polynomialzeit    |
+| **NP-vollständig**           | In NP + jedes NP-Problem reduzierbar darauf                  |
+| **NP-hard**                  | Jedes NP-Problem reduzierbar darauf (muss nicht in NP sein)  |
+| **PSPACE-vollständig**       | In PSPACE + jedes PSPACE-Problem reduzierbar darauf          |

Komplexitätstheorie/zusammenfassungen/ko1 - themenliste.md

@@ -0,0 +1,73 @@
+# Komplexitätstheorie – Vorlesung 1: Themenliste
+**Prof. Dr. Björn Grohmann | HWR Berlin | 18.02.2026**
+
+---
+## 1. Turing-Maschinen
+
+- Historischer Hintergrund (Alan Turing, Princeton)
+- Formale Definition als 7-Tupel (Q, Σ, Γ, δ, q₀, q_accept, q_reject)
+- Konfigurationen einer Turing-Maschine
+- Beispiel: Sprache B = {w#w | w ∈ {0,1}*} – Zustandsdiagramm
+- **Church-Turing-These**: Jede effektiv berechenbare Funktion ist Turing-berechenbar
+
+## 2. Varianten von Turing-Maschinen
+
+- **Multitape Turing Machine** – Äquivalenz zur Single-Tape TM
+- **Universelle Turing-Maschine** – Gödelnummer, Simulation mit O(CT log T) Schritten
+- **Nichtdeterministische Turing-Maschine (NTM)** – Übergangsfunktion δ: Q × Γ → P(Q × Γ × {L,R})
+- Äquivalenz NTM ↔ DTM mit exponentiellem Zeitverlust (2^O(t(n)))
+
+## 3. Laufzeit & Zeitkomplexität
+
+- Running Time / Time Complexity einer deterministischen TM
+- Running Time einer nichtdeterministischen TM (maximale Tiefe aller Zweige)
+- **Time Constructibility** – Definition und Bedeutung
+- Overhead-Resultate: Alphabetreduktion (4 log|Γ| · T(n)), Tape-Reduktion (5kT(n)²), Bidirektionale TM (4T(n))
+
+## 4. Entscheidbarkeit
+
+- **Turing-erkennbar** (rekursiv aufzählbar / semi-entscheidbar)
+- **Turing-entscheidbar** (rekursiv / entscheidbar)
+- Satz: Eine Sprache ist entscheidbar ⟺ sie ist Turing-erkennbar und co-Turing-erkennbar
+
+## 5. Das Halteproblem
+
+- Sprache A_TM = {⟨M, w⟩ | M ist TM und M akzeptiert w} – semi-entscheidbar, aber unentscheidbar
+- HALT_TM = {⟨M, w⟩ | M ist TM und M hält auf w} – unentscheidbar
+- Beweis per Diagonalisierung (Widerspruchsargument)
+
+## 6. Weitere unentscheidbare Probleme
+
+- **Postsches Korrespondenzproblem (PCP)** – semi-entscheidbar
+- **Hilberts 10. Problem** – Diophantische Gleichungen
+- **Erfüllbarkeitsproblem** und **Gültigkeitsproblem** der Prädikatenlogik (semi-entscheidbar)
+- **Unerfüllbarkeitsproblem** der Prädikatenlogik
+- E_TM (leere Sprache), EQ_TM (Sprachäquivalenz), REGULAR_TM (reguläre Sprache)
+- MIN_TM (minimale TM) – nicht einmal semi-entscheidbar
+
+## 7. Die Klasse P
+
+- Definition: P = ⋃_k TIME(n^k) – in Polynomialzeit entscheidbare Sprachen
+- Beispielmengen: ℕ, 2ℕ, Primzahlen ℙ, Summen/Produkte von Primzahlen
+
+## 8. Die Klasse NP
+
+- Verifier-basierte Definition: polynomieller Verifier, polynomiell verifizierbar
+- NP = Klasse der Sprachen mit polynomiellen Verifizierern
+- Äquivalente Definition: NP = ⋃_k NTIME(n^k)
+- P: schnell _entscheidbar_ vs. NP: schnell _verifizierbar_
+- Beispielmengen: Summen/Produkte von Primzahlen, Primzahlen (n ≠ p·q), SAT, UNSAT
+
+## 9. P vs. NP
+
+- Offene Frage: P ⊂ NP oder P = NP?
+- Millennium-Problem (Clay Mathematics Institute, 1 Mio. Dollar Preisgeld)
+
+## 10. NP-Vollständigkeit & Reduktionen
+
+- **Polynomialzeit-berechenbare Funktion**
+- **Polynomialzeit-Reduktion** (A ≤_P B)
+- Definition NP-vollständig: (1) B ∈ NP, (2) jedes A ∈ NP ist polynomiell auf B reduzierbar
+- **NP-hard**: nur Bedingung (2)
+- Venn-Diagramm: P ⊆ NP ⊆ NP-hard, NP-complete = NP ∩ NP-hard
+- **Cook-Levin Theorem**: SAT ist NP-vollständig (SAT ∈ P ⟺ P = NP)

Komplexitätstheorie/zusammenfassungen/ko1 - zusammenfassung.md

@@ -0,0 +1,403 @@
+# Komplexitätstheorie – Vorlesung 1: Zusammenfassung
+**Prof. Dr. Björn Grohmann | HWR Berlin | 18.02.2026**
+
+---
+## 1. Turing-Maschinen
+
+### Historischer Hintergrund
+
+Alan Turing (geboren 23. Juni 1912 in London, gestorben 8. Juni 1954) studierte Mathematik in Cambridge (B.A. 1934) und promovierte an der Princeton University (Ph.D. 1938) mit der Dissertation „Systems of Logic Based on Ordinals". Er entwickelte das Konzept der Turing-Maschine als abstraktes Berechnungsmodell, das bis heute die Grundlage der theoretischen Informatik bildet.
+
+### Formale Definition
+
+Eine **Turing-Maschine** ist ein 7-Tupel $(Q, \Sigma, \Gamma, \delta, q_0, q_{\text{accept}}, q_{\text{reject}})$, wobei $Q$, $\Sigma$ und $\Gamma$ endliche Mengen sind:
+
+1. $Q$ ist die **Zustandsmenge** (set of states).
+2. $\Sigma$ ist das **Eingabealphabet**, das das Blanksymbol $\sqcup$ nicht enthält.
+3. $\Gamma$ ist das **Bandalphabet**, wobei $\sqcup \in \Gamma$ und $\Sigma \subseteq \Gamma$.
+4. $\delta: Q \times \Gamma \rightarrow Q \times \Gamma \times \{L, R\}$ ist die **Übergangsfunktion** (transition function).
+5. $q_0 \in Q$ ist der **Startzustand** (start state).
+6. $q_{\text{accept}} \in Q$ ist der **Akzeptierzustand** (accept state).
+7. $q_{\text{reject}} \in Q$ ist der **Ablehnungszustand** (reject state), wobei $q_{\text{reject}} \neq q_{\text{accept}}$.
+
+Die Turing-Maschine besteht aus einer endlichen Steuerung (control) und einem **unendlich langen Band**, auf dem Symbole gelesen und geschrieben werden.
+
+### Konfiguration
+
+Eine **Konfiguration** beschreibt den vollständigen Zustand einer TM zu einem Zeitpunkt: Sie umfasst den aktuellen Zustand, den Bandinhalt und die Position des Lese-/Schreibkopfes. Beispiel: Die Konfiguration $1011q_701111$ bedeutet, dass sich die Maschine im Zustand $q_7$ befindet und der Kopf auf dem Zeichen unmittelbar rechts von $q_7$ steht.
+
+### Beispiel: Sprache $B = \{w\#w \mid w \in \{0,1\}^*\}$
+
+Diese Sprache besteht aus allen Wörtern, die aus zwei identischen Hälften bestehen, getrennt durch ein #-Zeichen. Die TM arbeitet wie folgt:
+
+- Das erste Zeichen der linken Hälfte wird gelesen, durch $x$ ersetzt und gemerkt (Zustand $q_1$).
+- Der Kopf wandert nach rechts über das #-Zeichen zum entsprechenden Zeichen der rechten Hälfte.
+- Stimmt das Zeichen überein, wird es ebenfalls durch $x$ ersetzt; der Kopf wandert zurück zum nächsten unmarkierten Zeichen links.
+- Dieser Prozess wiederholt sich, bis alle Zeichen abgeglichen sind.
+- Wenn am Ende nur $x$-Symbole und ein # auf dem Band stehen und ein Blank erreicht wird → **accept**.
+- Bei jedem Mismatch → **reject**.
+
+Das Zustandsdiagramm umfasst die Zustände $q_1$ bis $q_8$ sowie $q_{\text{accept}}$ (und implizite reject-Pfade, die im Diagramm der Vorlesung weggelassen wurden).
+
+### Church-Turing-These
+
+> „Jede effektiv berechenbare Funktion kann durch eine Turing-Maschine berechnet werden."
+
+Dies ist keine mathematisch beweisbare Aussage, sondern eine **These** (Hypothese). Sie wird gestützt durch die Tatsache, dass alle bekannten Berechnungsmodelle (WHILE-Programme, GOTO-Programme, Lambda-Kalkül, Rule 110 Zellularautomaten etc.) äquivalent zur Turing-Maschine sind.
+
+---
+
+## 2. Äquivalente Berechnungsmodelle
+
+### WHILE-Programme
+
+WHILE-Programme sind ein einfaches Berechnungsmodell mit folgender Syntax:
+
+- $P \rightarrow X := X + C$ (Inkrement)
+- $\mid\quad X := X - C$ (Dekrement, wobei das Ergebnis nicht negativ wird)
+- $\mid\quad P;\; P$ (Sequenz)
+- $\mid\quad \text{WHILE } X \neq 0 \text{ DO } P \text{ END}$ (Schleife)
+
+WHILE-Programme sind **Turing-vollständig**, d.h. sie können genau die gleichen Funktionen berechnen wie eine Turing-Maschine.
+
+### GOTO-Programme
+
+GOTO-Programme bestehen aus nummerierten Anweisungen $M_1: A_1;\; M_2: A_2;\; \ldots;\; M_k: A_k$ mit den Operationen:
+
+- $x_i := x_j + n$ (Addition einer Konstante)
+- $x_i := x_j - n$ (Subtraktion einer Konstante)
+- $\text{GOTO } M_i$ (unbedingter Sprung)
+- $\text{IF } x_i = n \text{ GOTO } M_j$ (bedingter Sprung)
+- $\text{HALT}$ (Programmende)
+
+Auch GOTO-Programme sind äquivalent zu Turing-Maschinen.
+
+### Rule 110 (Zellularautomat)
+
+Rule 110 ist ein eindimensionaler Zellularautomat, dessen Übergangsregel durch die Binärdarstellung der Zahl 110 (01101110) definiert wird. Jede Zelle wird basierend auf ihrem eigenen Zustand und den Zuständen ihrer beiden Nachbarn aktualisiert. Es wurde bewiesen, dass Rule 110 **Turing-vollständig** ist – ein einfacher Zellularautomat kann also universelle Berechnungen durchführen.
+
+---
+
+## 3. Varianten von Turing-Maschinen
+
+### Multitape Turing Machine (Mehrband-TM)
+
+Die Übergangsfunktion einer $k$-Band-TM hat die Form:
+
+$$\delta: Q \times \Gamma^k \rightarrow Q \times \Gamma^k \times \{L, R, S\}^k$$
+
+Die Maschine verfügt über $k$ separate Bänder mit eigenen Köpfen (Input-Tape mit Read-Only-Head, Work-Tape und Output-Tape mit Read/Write-Heads).
+
+**Theorem:** Jede Multitape-TM hat eine äquivalente Single-Tape-TM. Die Simulation erfolgt, indem alle Bänder auf einem einzigen Band kodiert werden (getrennt durch #-Symbole), wobei die Kopfpositionen durch markierte Symbole (z.B. Punkte über den Zeichen) dargestellt werden.
+
+### Universelle Turing-Maschine (UTM)
+
+Es existiert eine TM $\mathcal{U}$, die für jede Eingabe $x, \alpha \in \{0,1\}^*$ das Ergebnis $\mathcal{U}(x, \alpha) = M_\alpha(x)$ berechnet, wobei $M_\alpha$ die durch die **Gödelnummer** $\alpha$ kodierte Turing-Maschine ist.
+
+Die UTM nutzt mehrere Arbeitsbänder: ein Input-Tape, Work-Tapes (Simulation des Arbeitsbandes von $M$, Beschreibung von $M$, aktueller Zustand von $M$) und ein Output-Tape.
+
+**Simulationsoverhead:** Wenn $M_\alpha$ in $T$ Schritten hält, so hält $\mathcal{U}(x, \alpha)$ in $O(CT \log T)$ Schritten, wobei $C$ eine Konstante ist, die nur von der Alphabetgröße, Bandanzahl und Zustandsanzahl von $M_\alpha$ abhängt.
+
+### Nichtdeterministische Turing-Maschine (NTM)
+
+Die Übergangsfunktion einer NTM hat die Form:
+
+$$\delta: Q \times \Gamma \rightarrow \mathcal{P}(Q \times \Gamma \times \{L, R\})$$
+
+Statt eines einzigen Nachfolgezustands gibt es eine **Menge** möglicher Übergänge. Die NTM kann als Maschine mit drei Bändern simuliert werden: Input-Tape, Simulation-Tape und Address-Tape (das die nichtdeterministischen Entscheidungen kodiert).
+
+**Theorem:** Jede NTM hat eine äquivalente DTM. Jede $t(n)$-Zeit-NTM (mit $t(n) \geq n$) kann durch eine deterministische TM in Zeit $2^{O(t(n))}$ simuliert werden — also mit **exponentiellem Zeitverlust**.
+
+**Akzeptanzkriterium:** Eine NTM akzeptiert eine Eingabe, wenn **mindestens ein** Berechnungspfad akzeptiert. Sie lehnt ab, wenn **alle** Pfade ablehnen.
+
+---
+
+## 4. Laufzeit und Zeitkomplexität
+
+### Running Time (deterministisch)
+
+Sei $M$ eine deterministische TM, die auf allen Eingaben hält. Die **Laufzeit** (running time / time complexity) von $M$ ist die Funktion $f: \mathbb{N} \rightarrow \mathbb{N}$, wobei $f(n)$ die **maximale Anzahl von Schritten** ist, die $M$ auf einer Eingabe der Länge $n$ benötigt. Man sagt: „$M$ läuft in Zeit $f(n)$" oder „$M$ ist eine $f(n)$-Zeit-Turing-Maschine."
+
+### Running Time (nichtdeterministisch)
+
+Sei $N$ eine nichtdeterministische TM, die ein Entscheider ist. Die **Laufzeit** von $N$ ist die Funktion $f: \mathbb{N} \rightarrow \mathbb{N}$, wobei $f(n)$ die **maximale Anzahl von Schritten** ist, die $N$ auf **irgendeinem Zweig** ihrer Berechnung bei einer Eingabe der Länge $n$ benötigt.
+
+### Time Constructibility
+
+Eine Funktion $t: \mathbb{N} \rightarrow \mathbb{N}$ mit $t(n) \geq O(n \log n)$ heißt **zeitkonstruierbar** (time constructible), wenn die Funktion, die den String $1^n$ auf die Binärdarstellung von $t(n)$ abbildet, in Zeit $O(t(n))$ berechenbar ist.
+
+Es gibt auch eine alternative Definition, bei der lediglich $t(n) \geq n$ gefordert wird.
+
+Typische zeitkonstruierbare Funktionen sind z.B. $n$, $n \log n$, $n^2$, $2^n$.
+
+### Overhead-Resultate (Simulationskosten)
+
+| Transformation | Zeitoverhead |
+|---|---|
+| **Alphabetreduktion** (beliebiges Alphabet → $\{0,1,\sqcup,\triangleright\}$) | $4 \log |\Gamma| \cdot T(n)$ |
+| **Tape-Reduktion** ($k$ Bänder → 1 Band) | $5k \cdot T(n)^2$ |
+| **Bidirektionale TM → Unidirektionale TM** | $4 \cdot T(n)$ |
+
+### Zeitkomplexitätsklasse TIME
+
+Sei $t: \mathbb{N} \rightarrow \mathbb{R}^+$ eine Funktion. Die **Zeitkomplexitätsklasse** $\text{TIME}(t(n))$ ist die Menge aller Sprachen, die von einer $O(t(n))$-Zeit-Turing-Maschine entschieden werden können.
+
+---
+
+## 5. Entscheidbarkeit
+
+### Turing-erkennbar (rekursiv aufzählbar / semi-entscheidbar)
+
+Eine Sprache heißt **Turing-erkennbar** (Turing-recognizable), wenn es eine TM gibt, die sie erkennt. Das bedeutet:
+
+- Für $w \in L$: Die TM akzeptiert.
+- Für $w \notin L$: Die TM lehnt ab **oder hält nicht** (läuft unendlich lange).
+
+### Turing-entscheidbar (rekursiv / entscheidbar)
+
+Eine Sprache heißt **Turing-entscheidbar** (Turing-decidable), wenn es eine TM gibt, die sie entscheidet. Das bedeutet:
+
+- Für $w \in L$: Die TM akzeptiert.
+- Für $w \notin L$: Die TM lehnt ab.
+- Die TM **hält immer** (auf jeder Eingabe).
+
+### Zusammenhang
+
+**Theorem:** Eine Sprache ist entscheidbar **genau dann, wenn** sie sowohl Turing-erkennbar als auch co-Turing-erkennbar ist.
+
+Beweisskizze: Man lässt die TM $M_1$ (für $L$) und $M_2$ (für $\overline{L}$) parallel auf der Eingabe $w$ laufen. Wenn $M_1$ akzeptiert → accept; wenn $M_2$ akzeptiert → reject. Da eine der beiden Maschinen für jede Eingabe irgendwann akzeptiert, hält das Verfahren immer.
+
+---
+
+## 6. Das Halteproblem
+
+### $A_{\text{TM}}$ – Die Akzeptanzsprache
+
+$$A_{\text{TM}} = \{\langle M, w \rangle \mid M \text{ ist eine TM und } M \text{ akzeptiert } w\}$$
+
+$A_{\text{TM}}$ ist **semi-entscheidbar** (Turing-erkennbar): Man simuliert $M$ auf $w$. Wenn $M$ akzeptiert → accept; wenn $M$ ablehnt → reject. Problem: Wenn $M$ nicht hält, hält auch der Simulator nicht.
+
+**Theorem:** $A_{\text{TM}}$ ist **unentscheidbar**.
+
+### $HALT_{\text{TM}}$ – Das Halteproblem
+
+$$HALT_{\text{TM}} = \{\langle M, w \rangle \mid M \text{ ist eine TM und } M \text{ hält auf Eingabe } w\}$$
+
+**Theorem:** $HALT_{\text{TM}}$ ist **unentscheidbar**.
+
+### Beweis per Diagonalisierung
+
+Der Beweis der Unentscheidbarkeit von $A_{\text{TM}}$ verwendet ein **Diagonalisierungsargument** (Widerspruchsbeweis):
+
+1. Angenommen, es gibt einen Entscheider $H$ für $A_{\text{TM}}$.
+2. Konstruiere daraus eine Maschine $D$, die bei Eingabe $\langle M \rangle$ die Maschine $H$ auf $\langle M, \langle M \rangle \rangle$ simuliert und das Ergebnis **invertiert**.
+3. Was passiert bei $D(\langle D \rangle)$?
+   - Falls $D$ akzeptiert → $H$ sagt "$D$ akzeptiert $\langle D \rangle$" → $D$ sollte ablehnen. **Widerspruch!**
+   - Falls $D$ ablehnt → $H$ sagt "$D$ akzeptiert $\langle D \rangle$ nicht" → $D$ sollte akzeptieren. **Widerspruch!**
+4. Also kann $H$ nicht existieren.
+
+Das Diagonalisierungsargument funktioniert über eine Matrix: Die Zeilen sind Turing-Maschinen $T_1, T_2, T_3, \ldots$, die Spalten sind Eingaben $i_1, i_2, i_3, \ldots$, und die Einträge (0 oder 1) zeigen, ob $T_i$ die Eingabe $i_j$ akzeptiert. Die Maschine $D$ invertiert die Diagonale — und erzeugt so den Widerspruch, da $D$ als Zeile in der Matrix selbst vorkommen müsste.
+
+---
+
+## 7. Weitere unentscheidbare Probleme
+
+### Postsches Korrespondenzproblem (PCP)
+
+**Gegeben:** Eine endliche Folge von Wortpaaren $(x_1, y_1), \ldots, (x_k, y_k)$ mit $x_i, y_i \in \{0,1\}^+$ (dargestellt als Dominos mit oberer und unterer Hälfte).
+
+**Gefragt:** Gibt es eine endliche Folge von Indizes $i_1, \ldots, i_n \in \{1, \ldots, k\}$, sodass $x_{i_1} \ldots x_{i_n} = y_{i_1} \ldots y_{i_n}$? (Können Kopien der Dominos so aneinandergelegt werden, dass oben und unten das gleiche Wort steht?)
+
+Das PCP ist **unentscheidbar**, aber immerhin **semi-entscheidbar** (man kann systematisch alle Kombinationen durchprobieren).
+
+Benannt nach **Emil Leon Post** (1897–1957).
+
+### Hilberts 10. Problem
+
+David Hilbert formulierte 1900 die Frage: Gibt es ein Verfahren, mit dem man für eine beliebige diophantische Gleichung (Polynomgleichung mit ganzzahligen Koeffizienten) entscheiden kann, ob sie eine ganzzahlige Lösung hat?
+
+**Antwort (1970, Matijassewitsch):** Nein — dieses Problem ist **unentscheidbar**.
+
+### Probleme der Prädikatenlogik
+
+| Problem | Frage | Status |
+|---|---|---|
+| **Erfüllbarkeitsproblem** | Ist ein prädikatenlogischer Ausdruck $A$ über Signatur $S$ erfüllbar? | semi-entscheidbar, unentscheidbar |
+| **Gültigkeitsproblem** | Ist $A$ allgemeingültig? | semi-entscheidbar, unentscheidbar |
+| **Unerfüllbarkeitsproblem** | Ist $A$ unerfüllbar? | semi-entscheidbar, unentscheidbar |
+
+Das Erfüllbarkeitsproblem und das Gültigkeitsproblem sind jeweils **semi-entscheidbar**. Das Unerfüllbarkeitsproblem ist ebenfalls semi-entscheidbar (da es das Komplement des Gültigkeitsproblems ist).
+
+### Weitere unentscheidbare Sprachen über TMs
+
+| Sprache | Definition | Semi-entscheidbar? |
+|---|---|---|
+| $E_{\text{TM}}$ | $\{\langle M \rangle \mid M \text{ ist TM und } L(M) = \emptyset\}$ | Nein (co-Turing-erkennbar) |
+| $EQ_{\text{TM}}$ | $\{\langle M_1, M_2 \rangle \mid L(M_1) = L(M_2)\}$ | Nein |
+| $REGULAR_{\text{TM}}$ | $\{\langle M \rangle \mid L(M) \text{ ist regulär}\}$ | Nein |
+| $MIN_{\text{TM}}$ | $\{\langle M \rangle \mid M \text{ ist eine minimale TM}\}$ | **Nicht einmal semi-entscheidbar** |
+
+$MIN_{\text{TM}}$ enthält die Beschreibungen aller TMs, für die es keine kürzere äquivalente TM gibt.
+
+---
+
+## 8. Die Klasse P
+
+### Definition
+
+$$\text{P} = \bigcup_k \text{TIME}(n^k)$$
+
+**P** ist die Klasse aller Sprachen, die in **polynomieller Zeit** auf einer **deterministischen** Single-Tape-Turing-Maschine entscheidbar sind.
+
+### Beispiele: Welche Mengen liegen in P?
+
+| Menge | In P? | Begründung |
+|---|---|---|
+| $\mathbb{N} = \{1, 2, 3, \ldots\}$ | Ja | Trivial entscheidbar (jede natürliche Zahl akzeptieren) |
+| $2\mathbb{N} = \{2, 4, 6, \ldots\}$ | Ja | Letztes Bit prüfen (gerade Zahl) |
+| $\mathbb{P}$ (Primzahlen) | Ja | AKS-Algorithmus (2002) läuft in Polynomialzeit |
+| $\{p + q \mid p, q \in \mathbb{P}\}$ (Summen von Primzahlen) | Ja | Alle Zerlegungen $p + q = n$ durchprobieren, jeweils Primzahltest |
+| $\{p \cdot q \mid p, q \in \mathbb{P}\}$ (Produkte von Primzahlen) | Ja | Faktorisierung in Polynomialzeit prüfbar (Probedivision genügt, da nur Zerlegung in zwei Primfaktoren gefragt) |
+
+---
+
+## 9. Die Klasse NP
+
+### Verifier-basierte Definition
+
+Ein **Verifier** für eine Sprache $A$ ist ein Algorithmus $V$, sodass:
+
+$$A = \{w \mid V \text{ akzeptiert } \langle w, c \rangle \text{ für ein Zertifikat } c\}$$
+
+Ein **polynomieller Verifier** läuft in polynomieller Zeit **bezogen auf die Länge von $w$** (nicht von $c$).
+
+Eine Sprache $A$ ist **polynomiell verifizierbar**, wenn sie einen polynomiellen Verifier hat.
+
+### Definition von NP
+
+$$\text{NP} = \text{die Klasse aller Sprachen mit polynomiellen Verifizierern}$$
+
+**Äquivalente Definition über NTMs:**
+
+**Theorem:** Eine Sprache ist in NP genau dann, wenn sie von einer **nichtdeterministischen polynomialzeit-TM** entschieden wird.
+
+$$\text{NP} = \bigcup_k \text{NTIME}(n^k)$$
+
+### Kernunterschied P vs. NP
+
+- **P** = Klasse der Sprachen, deren Mitgliedschaft schnell **entschieden** werden kann.
+- **NP** = Klasse der Sprachen, deren Mitgliedschaft schnell **verifiziert** werden kann (gegeben ein passendes Zertifikat).
+
+### Beispiele: Welche Mengen liegen in NP?
+
+| Menge | In NP? | Begründung |
+|---|---|---|
+| $\{p + q \mid p, q \in \mathbb{P}\}$ | Ja | Zertifikat: die beiden Primzahlen $p, q$; Verifikation: Summe prüfen + Primzahltests |
+| $\{p \cdot q \mid p, q \in \mathbb{P}\}$ | Ja | Zertifikat: die beiden Primfaktoren; Verifikation: Produkt prüfen + Primzahltests |
+| $\{n \in \mathbb{N} \mid n \neq p \cdot q, \; p,q \in \mathbb{P}\}$ (Primzahlen) | Ja | Zertifikat: $n$ selbst (bzw. AKS-Test); da $\mathbb{P} \in \text{P} \subseteq \text{NP}$ |
+| $\text{SAT}$ (erfüllbare Boolesche Formeln) | Ja | Zertifikat: eine erfüllende Belegung; Verifikation: Formel auswerten |
+| $\text{UNSAT}$ (unerfüllbare Boolesche Formeln) | Unklar | Kein offensichtliches kurzes Zertifikat; vermutlich nicht in NP (liegt in co-NP) |
+
+---
+
+## 10. P vs. NP
+
+### Die offene Frage
+
+Es ist unbekannt, ob $\text{P} = \text{NP}$ oder $\text{P} \subsetneq \text{NP}$ gilt.
+
+- Falls $\text{P} = \text{NP}$: Jedes Problem, dessen Lösung effizient überprüfbar ist, wäre auch effizient lösbar.
+- Falls $\text{P} \neq \text{NP}$: Es gibt Probleme, die effizient überprüfbar, aber nicht effizient lösbar sind.
+
+Die meisten Informatiker vermuten $\text{P} \neq \text{NP}$.
+
+### Millennium-Problem
+
+Das P-vs-NP-Problem ist eines der sieben **Millennium-Probleme** des Clay Mathematics Institute, ausgelobt im Jahr 2000, mit einem Preisgeld von **1 Million US-Dollar** für eine Lösung. Von den sieben Problemen wurde bisher nur die **Poincaré-Vermutung** gelöst (Perelman, 2003).
+
+---
+
+## 11. NP-Vollständigkeit und Reduktionen
+
+### Polynomialzeit-berechenbare Funktion
+
+Eine Funktion $f: \Sigma^* \rightarrow \Sigma^*$ heißt **polynomialzeit-berechenbar** (polynomial time computable function), wenn eine polynomialzeit-TM $M$ existiert, die bei Eingabe $w$ mit $f(w)$ auf dem Band hält.
+
+### Polynomialzeit-Reduktion
+
+Eine Sprache $A$ ist **polynomialzeit-reduzierbar** auf Sprache $B$ (geschrieben $A \leq_P B$), wenn eine polynomialzeit-berechenbare Funktion $f: \Sigma^* \rightarrow \Sigma^*$ existiert, sodass für alle $w$ gilt:
+
+$$w \in A \iff f(w) \in B$$
+
+Die Funktion $f$ heißt **Polynomialzeit-Reduktion** von $A$ auf $B$.
+
+Intuition: Wenn $A \leq_P B$, dann ist $B$ **mindestens so schwer** wie $A$. Wenn ich $B$ lösen kann, kann ich auch $A$ lösen (indem ich erst $f$ anwende und dann den Algorithmus für $B$ benutze).
+
+### NP-Vollständigkeit (NP-completeness)
+
+Eine Sprache $B$ ist **NP-vollständig**, wenn zwei Bedingungen erfüllt sind:
+
+1. $B \in \text{NP}$ (das Problem liegt in NP), **und**
+2. Jede Sprache $A \in \text{NP}$ ist polynomialzeit-reduzierbar auf $B$ (d.h. $A \leq_P B$ für alle $A \in \text{NP}$).
+
+### NP-hard (NP-schwer)
+
+Wenn $B$ nur die **zweite Bedingung** erfüllt (jedes Problem aus NP ist auf $B$ reduzierbar), aber $B$ nicht notwendigerweise selbst in NP liegt, heißt $B$ **NP-hard**.
+
+### Beziehung im Venn-Diagramm
+
+- $\text{P} \subseteq \text{NP} \subseteq \text{NP-hard}$ (als Inklusionskette)
+- $\text{NP-complete} = \text{NP} \cap \text{NP-hard}$ (die Schnittmenge)
+
+Wenn man ein NP-hardes Problem effizient lösen könnte, könnte man damit **jedes** Problem in NP effizient lösen.
+
+### Cook-Levin-Theorem
+
+**Theorem (Cook 1971, Levin 1973):** $\text{SAT}$ ist **NP-vollständig**.
+
+$$\text{SAT} = \{\langle \phi \rangle \mid \phi \text{ ist eine erfüllbare Boolesche Formel}\}$$
+
+**Konsequenz:** $\text{SAT} \in \text{P} \iff \text{P} = \text{NP}$.
+
+Das Cook-Levin-Theorem war das erste Resultat, das die Existenz NP-vollständiger Probleme nachwies. Es zeigt: SAT ist das „universelle" Problem in NP — wenn man SAT in Polynomialzeit lösen könnte, wären alle NP-Probleme in Polynomialzeit lösbar.
+
+---
+
+## 12. Die Landschaft der Komplexitätsklassen (Überblick)
+
+Die Vorlesung zeigte das „Landscape of Computational Complexity" (University at Buffalo, 2008), das die Hierarchie der Komplexitätsklassen visualisiert:
+
+- **REG** ⊂ **L** ⊂ **NL** ⊂ **P** ⊂ **NP** ⊂ **PSPACE** ⊂ **EXP** ⊂ **NEXP** ⊂ **EXPSPACE**
+- Auf der anderen Seite die **Arithmetische Hierarchie**: REC ⊂ RE, co-RE, und darüber TOT und höhere Stufen
+- **Complexity Zoo**: Eine Sammlung von über 545 Komplexitätsklassen (gepflegt von Scott Aaronson u.a.)
+
+Wichtige offene Fragen umfassen unter anderem: P ≠ NP, L ≠ NL, NP ≠ co-NP, P ≠ PSPACE, und viele weitere Separierungen.
+
+---
+
+## Glossar der wichtigsten Begriffe
+
+| Begriff | Definition |
+|---|---|
+| **Turing-Maschine (TM)** | Abstraktes Berechnungsmodell mit unendlichem Band, endlicher Steuerung und Lese-/Schreibkopf |
+| **Konfiguration** | Momentaufnahme einer TM: Zustand + Bandinhalt + Kopfposition |
+| **Church-Turing-These** | Jede effektiv berechenbare Funktion ist Turing-berechenbar |
+| **Multitape TM** | TM mit mehreren Bändern; äquivalent zur Single-Tape TM |
+| **Universelle TM** | TM, die jede andere TM simulieren kann (über deren Gödelnummer) |
+| **Gödelnummer** | Binäre Kodierung einer Turing-Maschine |
+| **NTM** | Nichtdeterministische TM; Übergangsfunktion liefert Menge von Möglichkeiten |
+| **Zeitkomplexität** | Maximale Schrittzahl einer TM auf Eingaben der Länge $n$ |
+| **Time constructible** | Funktion $t(n)$, deren Wert in $O(t(n))$ Schritten berechnet werden kann |
+| **Turing-erkennbar** | TM akzeptiert alle $w \in L$, kann aber auf $w \notin L$ endlos laufen |
+| **Turing-entscheidbar** | TM akzeptiert alle $w \in L$ und lehnt alle $w \notin L$ ab (hält immer) |
+| **Halteproblem** | Frage, ob eine TM auf einer Eingabe hält; unentscheidbar |
+| **Diagonalisierung** | Beweistechnik: Konstruktion eines Widerspruchs durch Selbstreferenz |
+| **PCP** | Postsches Korrespondenzproblem; unentscheidbar, aber semi-entscheidbar |
+| **P** | Klasse der in Polynomialzeit deterministisch entscheidbaren Sprachen |
+| **NP** | Klasse der in Polynomialzeit verifizierbaren Sprachen |
+| **Verifier** | Algorithmus, der bei Eingabe $(w, c)$ die Mitgliedschaft von $w$ in $L$ prüft |
+| **Polynomialzeit-Reduktion** | Transformation $A \leq_P B$: $w \in A \iff f(w) \in B$ mit $f$ in Polynomialzeit |
+| **NP-vollständig** | In NP + jedes NP-Problem ist darauf reduzierbar |
+| **NP-hard** | Jedes NP-Problem ist darauf reduzierbar (muss nicht selbst in NP sein) |
+| **SAT** | Erfüllbarkeitsproblem für Boolesche Formeln; erstes nachgewiesenes NP-vollständiges Problem |
+| **Cook-Levin-Theorem** | SAT ist NP-vollständig; SAT ∈ P ⟺ P = NP |

Komplexitätstheorie/zusammenfassungen/ko2 - zusammenfassung.md

@@ -0,0 +1,227 @@
+# KO2 – NP-Vollständigkeit, Space Complexity & PSPACE
+**Vorlesung:** Prof. Dr. Björn Grohmann, HWR Berlin  
+**Datum:** 25.02.2026  
+**Folien:** 72–106
+
+---
+## 1. Hamiltonian Circuit Problem
+
+Das **Hamiltonian Circuit Problem** fragt für einen ungerichteten Graphen, ob ein Rundweg (Hamiltonkreis) existiert, der **jeden Knoten genau einmal** besucht und zum Ausgangspunkt zurückkehrt.
+
+Das Problem ist **NP-vollständig**, und zwar bereits dann, wenn der Graph **planar** (d.h. in der Ebene darstellbar ohne Kantenkreuzungen) und **3-regulär** (jeder Knoten hat genau 3 Nachbarn) ist.
+
+### Reduktion von SAT auf Hamiltonian Circuit
+
+Die NP-Vollständigkeit wird durch eine Konstruktion gezeigt, die eine aussagenlogische Formel in einen Graphen übersetzt. Der konstruierte Graph besitzt genau dann einen Hamiltonkreis, wenn die zugehörige Formel erfüllbar ist.
+
+**Beispielformel:**  
+$$F = (x \lor y \lor z) \land (\bar{x} \lor \bar{y} \lor w) \land (y \lor \bar{z} \lor \bar{w})$$
+
+**Konstruktionselemente:**
+
+- **Variablenpfade:** Der linke Weg steht für „wahr", der rechte Weg für „falsch". Ein XOR-Gadget stellt sicher, dass genau einer der beiden Wege zum Pfad gehört.
+- **Klausel-Gadgets (OR):** Mindestens eines der drei Literale muss „wahr" sein.
+- **Kreuzungs-Gadgets:** Sorgen dafür, dass sich Kanten des Graphen nicht kreuzen (Planarität).
+
+---
+## 2. Graph-Gadgets im Detail
+
+### Tutte Fragment
+
+Ein spezielles planares Graphfragment mit drei Anschlüssen. Es hat die Eigenschaft, dass ein Hamiltonpfad durch das Fragment stets durch **genau einen** der drei Anschlüsse ein- und austritt. Es wird als Symbol mit einem Pfeil in einem Kreis dargestellt. Es gibt genau **6 mögliche Wege** durch das Fragment.
+
+### Exclusive-OR (XOR) Gadget
+
+Wird aus zwei Tutte-Fragmenten konstruiert. Verbindet zwei Pfade (v→v' und u→u') so, dass ein Hamiltonpfad **genau einen** der beiden Wege nutzen kann, nicht beide. Die zwei möglichen Wege entsprechen den zwei Wahrheitswerten einer Variable.
+
+### Kreuzungs-Gadget (Crossing)
+
+Ermöglicht es, zwei sich kreuzende Kanten planar darzustellen. Wird aus mehreren XOR-Gadgets zusammengesetzt. Hat vier Anschlüsse und erlaubt vier mögliche Wegkombinationen, die den beiden unabhängigen Durchquerungsrichtungen entsprechen.
+
+### OR-Gadget
+
+Verbindet zwei Pfade (v→v' und u→u') so, dass **mindestens einer** der beiden Wege durchlaufen werden muss. Es gibt insgesamt 5 mögliche Wege (alle Kombinationen außer „keiner").
+
+### Triple-OR-Gadget
+
+Erweitert das OR-Gadget auf drei Eingänge (u→u', v→v', w→w'). Mindestens einer der drei Wege muss durchlaufen werden. Wird für 3-SAT-Klauseln mit drei Literalen benötigt.
+
+---
+## 3. MINESWEEPER ist NP-vollständig
+
+Die NP-Vollständigkeit von Minesweeper wird gezeigt, indem man logische Schaltkreise innerhalb eines Minesweeper-Spielfelds simuliert.
+
+### Grundidee
+
+In einem Minesweeper-Feld können Zellen entweder Minen enthalten oder nicht. Die Zahlen in aufgedeckten Zellen geben an, wie viele Minen sich in den benachbarten Zellen befinden. Man nutzt Variablen x und x' (Komplement), wobei x=Mine und x'=keine Mine (oder umgekehrt) einer Wahrheitsbelegung entspricht.
+
+### Bausteine der Reduktion
+
+- **Wire (Draht):** Ein horizontales Muster aus 5 Zeilen, in dem sich x und x' abwechseln. Die Randbedingungen (Zahlen 0 und 1) erzwingen, dass der Wahrheitswert konsistent entlang des Drahtes weitergeleitet wird.
+- **NOT-Gate:** Invertiert den Wahrheitswert eines Drahtes. Nutzt ein Muster mit Zahlen 2, 3 und Pflichtminen (*), sodass aus x am Eingang x' am Ausgang wird.
+- **Phase-Changer:** Besteht aus zwei NOT-Gates hintereinander. Verschiebt die Phase des Signals, ohne den Wahrheitswert zu ändern.
+- **Wire Crossing:** Ermöglicht es, zwei Drähte zu kreuzen, ohne dass ihre Signale interferieren. Wird mit drei XOR-Gates realisiert.
+- **XOR-Gate:** Kann aus AND- und NOT-Gates zusammengebaut werden (Standardkonstruktion: $A \oplus B = (A \land \lnot B) \lor (\lnot A \land B)$, äquivalent mittels NAND-Darstellung).
+- **AND-Gate:** Ein komplexes Muster (Figure 13), das zwei Eingangsdrähte U und V mit einem Ausgangsdraht T verbindet. Enthält feste Minen (*) und variable Zellen, deren Belegung durch die Zahlenbedingungen erzwungen wird.
+
+### Gesamtargumentation
+
+Da man mit Wires, NOT, AND (und daraus abgeleitet OR, XOR) beliebige Boolesche Schaltkreise bauen kann, lässt sich jede SAT-Instanz als Minesweeper-Konfiguration kodieren. Die Frage „Gibt es eine konsistente Minenbelegung?" entspricht der Frage „Ist die Formel erfüllbar?". Da SAT NP-vollständig ist, ist auch Minesweeper NP-vollständig.
+
+---
+
+## 4. „Gaming is Hard" – NP-Härte von Videospielen
+
+### Metatheorem 1: Location Traversal + Single-Use Paths
+
+Jedes Spiel, das **Location Traversal** (bestimmte Punkte müssen erreicht werden) und **Single-Use Paths** (Wege können nur einmal benutzt werden) aufweist, ist **NP-hard**.
+
+**Beweisskizze:** Man baut einen Level, der einen planaren, 3-regulären Graphen darstellt. Die Knoten sind die Punkte, die besucht werden müssen. Jede Kante ist ein Single-Use Path. Ein zusätzlicher Endpunkt wird mit dem Startknoten verbunden. Der Level ist genau dann lösbar, wenn ein Hamiltonkreis existiert.
+
+### Metatheorem 2: Tokens, Toll Roads, Location Traversal
+
+Ein Spiel ist **NP-hard**, wenn eine der folgenden Bedingungen gilt:
+
+- **(a)** Das Spiel hat **collectible tokens**, toll roads und location traversal.
+- **(b)** Das Spiel hat **cumulative tokens**, toll roads und location traversal. (Spieler startet mit n+1 tokens.)
+- **(c)** Das Spiel hat collectible cumulative tokens, **toll roads**, und der Avatar muss einen Ausgang erreichen. (2 tokens pro Punkt, jede Kante ist eine toll road, die Kante zwischen Start und Ende ist eine Sequenz von n toll roads.)
+
+**Beispiel:** Pac-Man – Power Pills sind tokens, Geisterkorridore sind toll roads.
+
+### Metatheorem 3: Keys, Doors, One-Way Paths
+
+Ein Spiel ist **NP-hard**, wenn es **doors** und **one-way paths** enthält und eine der folgenden Bedingungen gilt:
+
+- **(a)** Collectible keys und location traversal.
+- **(b)** Cumulative keys und location traversal.
+- **(c)** Collectible cumulative keys und der Avatar muss einen Ausgang erreichen.
+
+Funktioniert genau wie Metatheorem 2, wobei keys = tokens und doors = toll roads.
+
+### Metatheorem 4: Doors + Pressure Plates
+
+Wenn ein Spiel **doors** und **pressure plates** (Druckplatten, die Türen öffnen oder schließen) enthält und der Avatar einen Ausgang erreichen muss, dann ist das Spiel **NP-hard** – selbst wenn keine zwei Druckplatten dieselbe Tür steuern.
+
+**Konstruktion:** Wie bei MT 1, aber vor dem Ausgang befinden sich n Türen, die jeweils durch eine Druckplatte bei einem der Punkte geöffnet werden müssen. Single-Use Paths werden durch Druckplatten realisiert, die beim zweiten Durchgang den Weg versperren.
+
+### Metatheorem 5: Doors + k-Buttons
+
+Buttons sind wie Druckplatten, aber der Spieler kann **entscheiden**, ob er den Button drückt. Ein k-Button beeinflusst k Türen gleichzeitig.
+
+Wenn ein Spiel **doors** und **k-buttons** enthält und der Avatar einen Ausgang erreichen muss, dann ist das Spiel **NP-hard** für $k \geq 2$.
+
+---
+## 5. Übersicht NP-vollständiger Probleme
+
+Alle folgenden Probleme sind NP-vollständig und liegen damit in der Schnittmenge von NP und NP-hard:
+
+- **SAT** (Erfüllbarkeitsproblem aussagenlogischer Formeln)
+- **Hamiltonkreis**
+- **Traveling Salesman Problem (TSP)**
+- **Knapsack** (Rucksackproblem)
+- **MINESWEEPER**
+- und viele weitere (Karp's Liste mit 21 Problemen)
+
+### Karp's Liste (1972)
+
+Richard Karp bewies 1972, dass 21 Probleme NP-vollständig sind, ausgehend von SAT. Die Reduktionskette verläuft u.a.:
+
+SATISFIABILITY → CLIQUE → NODE COVER → {FEEDBACK NODE SET, FEEDBACK ARC SET, DIRECTED HAMILTON CIRCUIT → UNDIRECTED HAMILTON CIRCUIT}
+
+SATISFIABILITY → 0-1 INTEGER PROGRAMMING → SET PACKING → SET COVERING
+
+SATISFIABILITY WITH AT MOST 3 LITERALS PER CLAUSE → CHROMATIC NUMBER → {EXACT COVER → {3-DIMENSIONAL MATCHING, KNAPSACK → {SEQUENCING, PARTITION → MAX CUT}}, HITTING SET, STEINER TREE, CLIQUE COVER}
+
+---
+## 6. Space Complexity
+
+### Definition
+
+Die **Speicherkomplexität (Space Complexity)** einer deterministischen Turingmaschine M ist die Funktion $f: \mathbb{N} \to \mathbb{N}$, wobei $f(n)$ die **maximale Anzahl an Bandzellen** ist, die M auf irgendeiner Eingabe der Länge n besucht.
+
+Für eine **nichtdeterministische** Turingmaschine ist $f(n)$ die maximale Anzahl an Bandzellen, die M auf **irgendeinem Berechnungspfad** für eine Eingabe der Länge n besucht.
+
+**Anmerkung:** In der Literatur wird manchmal angenommen, dass die TM ein separates Eingabe- und Arbeitsband besitzt und nur die Zellen auf dem Arbeitsband gezählt werden.
+
+### Speicherkomplexitätsklassen
+
+$$\text{SPACE}(f(n)) = {L \mid L \text{ wird von einer det. TM in } O(f(n)) \text{ Speicher entschieden}}$$
+
+$$\text{NSPACE}(f(n)) = {L \mid L \text{ wird von einer nichtdet. TM in } O(f(n)) \text{ Speicher entschieden}}$$
+
+---
+## 7. Savitch's Theorem
+
+**Satz (Savitch):** Für jede Funktion $f: \mathbb{N} \to \mathbb{R}^+$ mit $f(n) \geq n$ gilt:
+
+$$\text{NSPACE}(f(n)) \subseteq \text{SPACE}(f^2(n))$$
+
+Der Satz gilt auch für $f(n) \geq \log(n)$.
+
+### Beweisskizze
+
+Gegeben eine nichtdeterministische TM N, die Sprache A mit Speicher $f(n)$ entscheidet, konstruieren wir eine deterministische TM M, die A in $O(f(n)^2)$ Speicher entscheidet:
+
+**Kernidee – CANYIELD-Prozedur:**  
+CANYIELD$(c_1, c_2, t)$ entscheidet, ob Konfiguration $c_2$ von Konfiguration $c_1$ in $t$ Schritten erreicht werden kann.
+
+- **Basisfall** ($t=1$): Prüfe direkt, ob $c_1 = c_2$ oder ob $c_1$ in einem Schritt zu $c_2$ führt.
+- **Rekursion** ($t > 1$): Für jede mögliche Zwischenkonfiguration $c_m$: Prüfe CANYIELD$(c_1, c_m, t/2)$ und CANYIELD$(c_m, c_2, t/2)$.
+
+**Speicheranalyse:**
+
+- Jede Rekursionsebene benötigt $O(f(n))$ Speicher (für die Zwischenkonfiguration).
+- Die Rekursionstiefe beträgt $O(\log t)$, wobei $t \leq 2^{d \cdot f(n)}$ für eine Konstante d.
+- Gesamtspeicher: $O(f(n)) \cdot O(\log t) = O(f(n)) \cdot O(f(n)) = O(f(n)^2)$.
+
+Da $f(n)$ zu Beginn nicht bekannt ist, testet M nacheinander $f(n) = 1, 2, 3, \ldots$
+
+---
+## 8. PSPACE
+
+### Definition
+
+**PSPACE** ist die Klasse aller Sprachen, die von einer deterministischen Turingmaschine in **polynomiellem Speicher** entschieden werden können:
+
+$$\text{PSPACE} = \bigcup_k \text{SPACE}(n^k)$$
+
+### Beziehung zwischen Zeit- und Speicherkomplexität
+
+$$P \subseteq NP \subseteq PSPACE = NPSPACE \subseteq EXPTIME = \bigcup_k \text{TIME}(2^{n^k})$$
+
+Die Gleichheit $\text{PSPACE} = \text{NPSPACE}$ folgt aus Savitch's Theorem (quadratischer Blow-up bei der Speicherkomplexität ist polynomiell).
+
+---
+## 9. PSPACE-Vollständigkeit
+
+### Definition
+
+Eine Sprache B ist **PSPACE-complete**, wenn:
+
+1. $B \in \text{PSPACE}$
+2. Jedes $A \in \text{PSPACE}$ ist in polynomieller Zeit auf B reduzierbar.
+
+Erfüllt B nur Bedingung 2, heißt B **PSPACE-hard**.
+
+### TQBF ist PSPACE-vollständig
+
+$$TQBF = {\langle \phi \rangle \mid \phi \text{ ist eine wahre, voll quantifizierte Boolesche Formel}}$$
+
+**Theorem:** TQBF ist PSPACE-complete.
+
+Eine voll quantifizierte Boolesche Formel hat die Form $\forall x_1 \exists x_2 \forall x_3 \ldots \phi(x_1, x_2, x_3, \ldots)$, wobei alle Variablen gebunden sind. TQBF fragt, ob eine solche Formel wahr ist.
+
+TQBF verallgemeinert SAT: Während SAT nur Existenzquantoren hat ($\exists x_1 \exists x_2 \ldots$: „Gibt es eine erfüllende Belegung?"), erlaubt TQBF auch Allquantoren. Diese Erweiterung macht das Problem härter – von NP-vollständig zu PSPACE-vollständig.
+
+---
+## Zusammenfassung der Komplexitätsklassen
+
+|Klasse|Beschreibung|Beispiel|
+|---|---|---|
+|**P**|Deterministisch in polynomieller Zeit lösbar|Sortieren, kürzeste Wege|
+|**NP**|Nichtdeterministisch in polynomieller Zeit lösbar (Lösung in Polynomialzeit verifizierbar)|SAT, Hamiltonkreis, TSP, Knapsack, Minesweeper|
+|**PSPACE**|Deterministisch in polynomiellem Speicher lösbar|TQBF|
+|**EXPTIME**|Deterministisch in exponentieller Zeit lösbar|Generalisiertes Schach|
+|**NP-hard**|Mindestens so schwer wie jedes Problem in NP|Alle NP-vollständigen Probleme + weitere|
+|**NP-vollständig**|In NP und NP-hard|SAT, Hamiltonkreis, TSP, Knapsack, Minesweeper|
+|**PSPACE-vollständig**|In PSPACE und PSPACE-hard|TQBF|

Komplexitätstheorie/zusammenfassungen/ko3 - zusammenfassung.md

@@ -0,0 +1,381 @@
+# Komplexitätstheorie – Zusammenfassung
+
+**Prof. Dr. Björn Grohmann – Hochschule für Wirtschaft und Recht Berlin**
+
+-----
+
+## 1. True Quantified Boolean Formulas (TQBF)
+
+### 1.1 Definition
+
+Eine **True Quantified Boolean Formula (TQBF)** ist eine vollständig quantifizierte Boolesche Formel, d.h. eine Boolesche Formel, in der **jede Variable** durch einen Existenz- ($\exists$) oder Allquantor ($\forall$) gebunden ist. Die Formel hat keinen freien Variablen und evaluiert daher zu einem festen Wahrheitswert (wahr oder falsch).
+
+**Beispiel:**
+
+$$\forall x , \exists y , (x \lor y) \land (\neg x \lor \neg y)$$
+
+Das Entscheidungsproblem TQBF fragt: *Ist eine gegebene vollständig quantifizierte Boolesche Formel wahr?*
+
+### 1.2 TQBF ist PSPACE-vollständig
+
+Die Vorlesung zeigt zwei zentrale Aussagen:
+
+**1) TQBF ist in PSPACE:**
+TQBF kann mit polynomiellem Speicher entschieden werden. Die Idee ist, die Formel rekursiv auszuwerten: Für jeden Quantor wird die entsprechende Variable nacheinander auf *wahr* und *falsch* gesetzt und rekursiv weitergerechnet. Da die Rekursionstiefe linear in der Anzahl der Variablen ist und jeder Rekursionslevel nur konstanten Zusatzspeicher benötigt, liegt der Gesamtverbrauch in $O(n)$ Speicher.
+
+**2) Jede Sprache in PSPACE ist auf TQBF reduzierbar (PSPACE-Härte):**
+Für ein Wort $w$ und eine Sprache $A \in \text{PSPACE}$ wird eine QBF konstruiert, die genau dann wahr ist, wenn $w \in A$.
+
+### 1.3 Die Reduktion im Detail
+
+#### Grundidee
+
+Man konstruiert eine Formel $\phi_{c_1, c_2, t}$, die genau dann wahr ist, wenn die Turing-Maschine von der Konfiguration $c_1$ zur Konfiguration $c_2$ in höchstens $t$ Schritten gelangen kann. Die gesuchte Formel ist dann $\phi_{c_{\text{start}}, c_{\text{accept}}, h}$ mit $h = 2^{O(n^k)}$.
+
+#### Naiver (erster) Ansatz
+
+$$\phi_{c_1, c_2, t} = \exists m_1 \left[\phi_{c_1, m_1, t/2} \land \phi_{m_1, c_2, t/2}\right]$$
+
+Hierbei wird eine Zwischenkonfiguration $m_1$ geraten (existenzquantifiziert), über die der Pfad von $c_1$ nach $c_2$ in zwei Hälften aufgeteilt wird. Das Problem: Durch die doppelte Rekursion **verdoppelt** sich die Formelgröße bei jedem Schritt. Da die Rekursionstiefe $O(n^k)$ beträgt, wird die Formel **exponentiell groß** – zu groß für einen polynomiellen Speicherverbrauch.
+
+#### Verbesserter Ansatz (Savitch-ähnlicher Trick)
+
+$$\phi_{c_1, c_2, t} = \exists m_1 ; \forall (c_3, c_4) \in {(c_1, m_1), (m_1, c_2)} ; \left[\phi_{c_3, c_4, t/2}\right]$$
+
+Der entscheidende Unterschied: Anstatt die Formel $\phi$ zweimal hinzuschreiben (einmal für $(c_1, m_1)$ und einmal für $(m_1, c_2)$), wird ein **Allquantor** verwendet, der über die **beiden möglichen Paare** $(c_3, c_4)$ iteriert. Damit wird die Formel nur **einmal** aufgeschrieben.
+
+**Technisches Detail:** Die Notation $\forall x \in {y, z} [\ldots]$ steht eigentlich für $\forall x \left[(x = y \lor x = z) \rightarrow \ldots\right]$. In der tatsächlichen Formel muss die Mengenzugehörigkeit durch eine **Äquivalenzrelation** in Boolescher Logik ausgedrückt werden.
+
+#### Größenanalyse
+
+- Jeder Rekursionslevel vergrößert die Formel um $O(n^k)$ (Kodierung der Konfigurationen).
+- Die Rekursionstiefe beträgt $O(n^k)$ (da $\log h = O(n^k)$).
+- Gesamtgröße der Formel: $O(n^{2k})$ – **polynomiell!**
+
+> **Ergänzung:** Dies ist die Kernidee des Beweises von Savitch’s Theorem angewandt auf die PSPACE-Vollständigkeit von TQBF. Der Allquantor erlaubt es, die exponentielle Aufblähung zu vermeiden, indem dieselbe Teilformel für beide Hälften wiederverwendet wird.
+
+-----
+
+## 2. „Gaming is Hard”, Part II – PSPACE-Härte von Spielen
+
+### 2.1 Metatheorem 4 (Pressure Plates)
+
+> **Metatheorem 4:** Wenn ein Spiel Türen und Druckplatten enthält und der Avatar einen Ausgang erreichen muss, dann gilt: Wenn jede Tür durch **zwei Druckplatten** gesteuert werden kann, ist das Spiel **PSPACE-hard**.
+
+### 2.2 Level-Aufbau als TQBF-Simulation
+
+Ein Level wird konstruiert, der eine TQBF direkt simuliert:
+
+- **Obere Reihe (Quantoren-Gadgets):** Abwechselnd $\exists x$, $\forall y$, $\exists z$, $\forall w$, …
+  - Der Spieler traversiert diese Gadgets vom Start zum Ende.
+  - **Existenzquantoren** ($\exists$): Der Spieler wählt einen Pfad (oben = true, unten = false). Die Wahl setzt Druckplatten, die Variablenwerte kodieren.
+  - **Allquantoren** ($\forall$): Der Spieler muss **beide** Pfade durchlaufen – d.h., das Spiel erzwingt, dass beide Belegungen getestet werden.
+- **Untere Reihe (Klausel-Gadgets):** Eine Reihe von Klauseln, die mit Türen realisiert werden.
+  - Jede Klausel prüft, ob die aktuelle Variablenbelegung die Klausel erfüllt.
+  - Die Türen sind durch Druckplatten gesteuert, die von den Quantor-Gadgets gesetzt werden.
+
+Die Gadgets für die einzelnen Komponenten nutzen Druckplatten zur Kodierung von Variablen an bestimmten Positionen. Die Variable $x$ an der Stelle $i$ wird durch die Position des Spielers und der dadurch aktivierten Druckplatten repräsentiert.
+
+### 2.3 Metatheorem 5 (k-Buttons)
+
+> **Metatheorem 5:** Wenn ein Spiel Türen und $k$-Buttons enthält und der Avatar einen Ausgang erreichen muss, dann gilt: Wenn $k \geq 3$, ist das Spiel **PSPACE-hard**.
+
+### 2.4 Simulation von Druckplatten durch 3-Buttons
+
+Die Vorlesung zeigt, wie eine Druckplatte mit Hilfe von **3-Buttons** simuliert werden kann. Das Gadget besteht aus vier Zuständen (Startkonfiguration und drei Folgezustände), die durch die Interaktion des Spielers mit den Buttons $a$, $b$, $c$, $d$ durchlaufen werden. Die Buttons steuern die Türen über $\pm x$, $\pm a$, $\pm b$, etc., wobei $+$ für „öffnen” und $-$ für „schließen” steht.
+
+> **Ergänzung:** Die Ergebnisse stammen aus dem Bereich der **computational complexity of games**. Die Arbeit von Viglietta (2014) und Aloupis et al. formalisiert, welche Spielmechaniken welche Komplexitätsklassen induzieren. Viele klassische Videospiele (z.B. generalisierte Versionen von Sokoban, Zelda, Pokemon) sind nachweislich PSPACE-hard.
+
+-----
+
+## 3. Hierarchy Theorems
+
+### 3.1 Time- und Space-Constructibility
+
+**Time-constructible:**
+Eine Funktion $t: \mathbb{N} \to \mathbb{N}$ mit $t(n) \geq O(n \log n)$ heißt **time-constructible**, wenn die Funktion, die den String $1^n$ auf die Binärdarstellung von $t(n)$ abbildet, in Zeit $O(t(n))$ berechenbar ist.
+
+**Space-constructible:**
+Eine Funktion $f: \mathbb{N} \to \mathbb{N}$ mit $f(n) \geq O(\log n)$ heißt **space-constructible**, wenn die Funktion, die den String $1^n$ auf die Binärdarstellung von $f(n)$ abbildet, in Platz $O(f(n))$ berechenbar ist.
+
+> **Ergänzung:** Die meisten „natürlichen” Funktionen wie $n$, $n^2$, $n \log n$, $2^n$ sind sowohl time- als auch space-constructible. Diese Bedingung ist nötig, damit die Maschine „weiß”, wie viel Ressourcen sie zur Verfügung hat, und einen Zähler korrekt setzen kann.
+
+### 3.2 Space Hierarchy Theorem
+
+> **Theorem (Space Hierarchy):** Für jede space-constructible Funktion $f: \mathbb{N} \to \mathbb{N}$ existiert eine Sprache $A$, die in $O(f(n))$ Speicher entscheidbar ist, aber **nicht** in $o(f(n))$ Speicher.
+
+#### Beweis (Skizze)
+
+Der Algorithmus $D$ entscheidet eine Sprache $A$ wie folgt:
+
+1. Sei $n$ die Länge der Eingabe $w$.
+2. Berechne $f(n)$ mittels Space-Constructibility und markiere genau so viel Band. Falls spätere Stufen mehr Platz benötigen, **reject**.
+3. Falls $w$ nicht die Form $\langle M \rangle 10^*$ hat (für eine TM $M$), **reject**.
+4. Simuliere $M$ auf $w$ und zähle die Schritte. Falls der Zähler $2^{f(n)}$ überschreitet, **reject**.
+5. Falls $M$ akzeptiert, **reject**. Falls $M$ ablehnt, **accept** (Diagonalisierung!).
+
+**Warum funktioniert das?** Angenommen, eine Maschine $M$ entscheidet $A$ mit $g(n)$ Speicher, wobei $g(n) \in o(f(n))$. Dann gibt es ein $n$, ab dem $D$ die Maschine $M$ korrekt simulieren kann (der Platz reicht aus). Aber $D$ tut dann das Gegenteil von $M$ – **Widerspruch**.
+
+#### Korollare
+
+- Für beliebige reelle Zahlen $0 \leq \epsilon_1 < \epsilon_2$: $\text{SPACE}(n^{\epsilon_1}) \subsetneq \text{SPACE}(n^{\epsilon_2})$.
+- $\text{PSPACE} \subsetneq \text{EXPSPACE} = \bigcup_k \text{SPACE}(2^{n^k})$.
+
+> **Ergänzung:** Das Space Hierarchy Theorem zeigt, dass mehr Speicher echt mehr Sprachen entscheidbar macht. Die Lücke ist dabei schärfer als beim Time Hierarchy Theorem, da kein logarithmischer Faktor benötigt wird. Dies liegt daran, dass die Simulation einer TM bezüglich des Platzes effizienter ist als bezüglich der Zeit.
+
+### 3.3 Time Hierarchy Theorem
+
+> **Theorem (Time Hierarchy):** Für jede time-constructible Funktion $t: \mathbb{N} \to \mathbb{N}$ existiert eine Sprache $A$, die in $O(t(n))$ Zeit entscheidbar ist, aber **nicht** in Zeit $o(t(n) / \log t(n))$.
+
+#### Beweis (Skizze)
+
+Der Algorithmus $D$ ist analog zum Space Hierarchy Theorem aufgebaut:
+
+1. Sei $n$ die Länge der Eingabe $w$.
+2. Berechne $t(n)$ mittels Time-Constructibility und speichere den Wert $\lfloor t(n) / \log t(n) \rfloor$ in einem Binärzähler. Dekrementiere diesen Zähler vor jedem Schritt der Stufen 3, 4 und 5. Falls der Zähler 0 erreicht, **reject**.
+3. Falls $w$ nicht die Form $\langle M \rangle 10^*$ hat, **reject**.
+4. Simuliere $M$ auf $w$.
+5. Falls $M$ akzeptiert, **reject**. Falls $M$ ablehnt, **accept**.
+
+**Warum der log-Faktor?** Das Counter-Update kostet pro Simulationsschritt jeweils $O(\log t(n))$, da der Binärzähler $\log t(n)$ Bits hat. Die Gesamtlaufzeit von $D$ beträgt also $\lfloor t(n) / \log t(n) \rfloor \cdot O(\log t(n)) = O(t(n))$.
+
+#### Korollare
+
+- Für beliebige reelle Zahlen $1 \leq \epsilon_1 < \epsilon_2$: $\text{TIME}(n^{\epsilon_1}) \subsetneq \text{TIME}(n^{\epsilon_2})$.
+- $\text{P} \subsetneq \text{EXPTIME}$.
+
+> **Ergänzung:** Die strenge Inklusion $\text{P} \subsetneq \text{EXPTIME}$ ist eines der wenigen **bewiesenen** Separationsresultate in der Komplexitätstheorie. Im Gegensatz dazu ist die Frage $\text{P} \stackrel{?}{=} \text{NP}$ nach wie vor offen.
+
+### 3.4 Warum ist Time-Constructibility notwendig?
+
+Die Voraussetzung der Time-Constructibility ist **essentiell**, wie das folgende Gap Theorem zeigt. Ohne diese Voraussetzung gibt es „pathologische” Funktionen, für die die Hierarchie zusammenbricht.
+
+-----
+
+## 4. Gap Theorem (Trakhtenbrot, Borodin)
+
+> **Theorem (Gap Theorem):** Es existiert eine berechenbare Funktion $f$, sodass $\text{TIME}(f(n)) = \text{TIME}(2^{f(n)})$.
+
+Das bedeutet: Es gibt eine Funktion $f$, bei der eine **exponentielle Erhöhung** der Zeitschranke **keine zusätzlichen Sprachen** entscheidbar macht!
+
+### Beweis (Skizze)
+
+Sei ${M_e}$ eine Aufzählung aller deterministischen TMs. Wir konstruieren $f$ schrittweise, sodass $f$ in jedem Schritt $e$ folgende Bedingung erfüllt:
+
+$$\forall x \left(|x| = n \land M_e(x) \downarrow \text{ in } t \text{ Schritten} \implies t \notin (f(n), 2^{f(n)}]\right)$$
+
+**Konstruktion von $f(n)$:**
+
+Betrachte die Sequenz $k_0 = 0$, $k_{l+1} = 2^{k_l}$. Für alle Berechnungen $M_e(x)$ mit $e \leq n$ (wobei $n = |x|$), die in $t_{e,x}$ Schritten halten, wähle das kleinste $k_l$, sodass **keines** der $t_{e,x}$ im Intervall $(k_l, 2^{k_l}]$ liegt. Setze $f(n) = k_l$.
+
+**Warum existiert ein solches $k_l$?** Da es nur endlich viele Paare $(e, x)$ mit $e \leq n$ und $|x| = n$ gibt, gibt es auch nur endlich viele Haltezeiten $t_{e,x}$. Die Intervalle $(k_l, 2^{k_l}]$ wachsen schnell genug, um immer eine „Lücke” (gap) zu finden.
+
+**Konsequenz:** Jede Sprache, die in $\text{TIME}(2^{f(n)})$ liegt, wird von einer TM entschieden, deren Haltezeit **unterhalb** von $f(n)$ liegt (nicht im Intervall dazwischen), also liegt sie automatisch auch in $\text{TIME}(f(n))$.
+
+> **Ergänzung:** Das Gap Theorem zeigt, dass die Hierarchie-Theoreme die Bedingung der Konstruierbarkeit **wirklich** benötigen. Die Funktion $f$ aus dem Gap Theorem ist typischerweise **nicht** time-constructible. Es handelt sich um ein fundamentales Resultat der abstrakten Komplexitätstheorie (Blum-Axiome).
+
+-----
+
+## 5. Speed-Up Theorem (Blum)
+
+> **Theorem (Speed-Up Theorem, M. Blum):** Es existiert eine berechenbare Menge $A$, sodass es für jeden Index $e$ (d.h. jede TM $M_e$) für $A$ einen anderen Index $i$ für $A$ gibt, sodass:
+> $$\forall^\infty x ; \left(\Phi_i(x) \leq \log \Phi_e(x)\right)$$
+
+Dabei ist $\Phi_e(x)$ die Anzahl der Berechnungsschritte von $M_e(x)$ (falls $M_e$ auf $x$ hält), und $\forall^\infty x$ bedeutet „für fast alle $x$” (alle bis auf endlich viele).
+
+**Bedeutung:** Egal welche TM $M_e$ die Sprache $A$ berechnet – es gibt immer eine **exponentiell schnellere** TM $M_i$, die dasselbe tut. Die Sprache $A$ hat also **keine optimale Berechnung**.
+
+### Beweis (Skizze)
+
+#### Hilfsfolge
+
+Definiere $g(x) = 2^x$, $g^{(1)}(x) = g(x)$, und $g^{(n+1)}(x) = g(g^{(n)}(x))$ (iterierte Exponentiation). Für $x > e + 1$ ist dann $h_e(x) = g^{(x-e)}(0)$ eine **abnehmende Familie** von Funktionen, d.h. $g(h_{e+1}(x)) = h_e(x)$.
+
+#### Diagonalisierung
+
+Für jedes $x$ wird $A(x)$ bestimmt, indem für alle $e \leq x$ geprüft wird:
+
+- Ist $e$ noch nicht markiert („cancelled”)?
+- Gilt $\Phi_e(x) < h_e(x)$?
+
+Für das **kleinste** solche $e$ definiere $A(x) = 1 - M_e(x)$ und markiere $e$. (Das ist der Diagonalisierungsschritt: $A$ tut das Gegenteil von $M_e$.)
+
+#### Konsequenzen
+
+Damit gilt für jedes $e$: Falls für unendlich viele $x$ gilt $\Phi_e(x) < h_e(x)$, folgt $M_e \neq A$. Anders geschrieben:
+
+$$\forall e \left(M_e = A \implies \forall^\infty x ; h_e(x) \leq \Phi_e(x)\right)$$
+
+#### Speed-Up-Eigenschaft
+
+Um $A(x)$ zu berechnen, lässt man für jedes $e \leq x$ die Maschine $M_e(x)$ für $h_e(x)$ Schritte laufen. Mit Hilfe der endlichen Menge $F_u = {(e, x, A(x)) : e < u \land e \text{ cancelled at stage } x}$ genügt es, dies nur für $u \leq e \leq x$ zu tun.
+
+Die Berechnung dauert $h_u(x) + \ldots + h_x(x)$ Schritte. Die Laufzeit für die ersten $x$ Stufen ist von oben beschränkt durch $x \cdot (h_u(x) + \ldots + h_x(x)) \leq h_{u-1}(x)$ (für fast alle $x$).
+
+Da $u$ beliebig groß gewählt werden kann, gilt:
+$$\forall e ; \exists i \left(M_i = A \land \forall^\infty x ; \Phi_i(x) \leq h_{e+1}(x)\right)$$
+
+Und damit insgesamt:
+$$\Phi_i(x) \leq h_{e+1}(x) \leq \log h_e(x) \leq \log \Phi_e(x)$$
+
+> **Ergänzung:** Das Speed-Up Theorem ist ein tiefliegendes Resultat, das zeigt, dass nicht jede berechenbare Sprache eine „schnellste” Berechnung besitzt. Es steht im Kontext der **Blum-Axiome** der abstrakten Komplexitätstheorie. Die Funktion $h_e$ wächst dabei so schnell (iterierte Exponentiation), dass der Logarithmus von $h_e$ immer noch zu $h_{e+1}$ wird – genau das ermöglicht den exponentiellen Speed-Up.
+
+-----
+
+## 6. Orakel-Turingmaschinen
+
+### Definition
+
+Ein **Orakel** für eine Sprache $A$ ist ein Gerät, das für jeden String $w$ in **einem einzigen Schritt** berichten kann, ob $w \in A$.
+
+Eine **Orakel-Turingmaschine** $M^A$ ist eine modifizierte TM mit einem speziellen **Orakelband**: Wann immer $M^A$ einen String auf dieses Band schreibt, erhält sie sofort die Antwort, ob der String in $A$ liegt.
+
+### Komplexitätsklassen mit Orakeln
+
+- $\text{P}^A$: Klasse der Sprachen, die von einer **polynomialzeit**-beschränkten Orakel-TM mit Orakel $A$ entschieden werden können.
+- $\text{NP}^A$: Analog für **nichtdeterministische** polynomialzeit-beschränkte Orakel-TMs.
+
+> **Ergänzung:** Orakel-TMs sind ein mächtiges Konzept, um die relative Stärke von Komplexitätsklassen zu untersuchen. Intuitiv simuliert das Orakel ein „Unterprogramm” mit beliebiger Mächtigkeit – die Anfrage kostet nur einen einzigen Schritt, unabhängig davon, wie schwer das Orakel-Problem eigentlich ist.
+
+-----
+
+## 7. Relativierung
+
+### Kernfrage
+
+Kann die Technik der **Relativierung** (Diagonalisierung über Orakel-TMs) dabei helfen, Komplexitätsklassen zu separieren?
+
+### Theorem (Baker, Gill, Solovay, 1975)
+
+> 1. Es existiert ein Orakel $A$, sodass $\text{P}^A \neq \text{NP}^A$.
+> 2. Es existiert ein Orakel $B$, sodass $\text{P}^B = \text{NP}^B$.
+
+### Beweis von Teil 2
+
+Wähle $B = \text{TQBF}$. Dann gilt:
+$$\text{NP}^{\text{TQBF}} \subseteq \text{NPSPACE} \subseteq \text{PSPACE} \subseteq \text{P}^{\text{TQBF}}$$
+
+Die letzte Inklusion gilt, weil TQBF PSPACE-vollständig ist – eine polynomialzeit Orakel-TM kann jedes PSPACE-Problem lösen, indem sie das Orakel befragt.
+
+### Beweis von Teil 1 (Diagonalisierung)
+
+Wir konstruieren ein Orakel $A$, sodass die Sprache
+$$L_A = {w \mid \exists x \in A \text{ mit } |x| = |w|}$$
+**nicht** in $\text{P}^A$ liegt (aber offensichtlich in $\text{NP}^A$, da man $x$ raten und das Orakel fragen kann).
+
+**Konstruktion von $A$ in Schritten:**
+
+Sei $M_1, M_2, M_3, \ldots$ die Aufzählung aller polynomialzeit Orakel-TMs.
+
+- **Schritt 1:** Wähle endlich viele beliebige Strings und füge sie zu $A$ hinzu.
+- **Schritt $i$:** Wähle $n$ so groß, dass $2^n > p_i(n)$ (Laufzeitschranke von $M_i$) und $n$ größer als alle bisherigen String-Längen in $A$.
+  - Simuliere $M_i$ auf Eingabe $1^n$.
+  - Falls $M_i$ das Orakel nach $y$ fragt und der Status von $y$ feststeht → antworte gemäß Status.
+  - Falls der Status nicht feststeht → antworte „Nein” und setze $y \notin A$.
+  - Falls $M_i$ **akzeptiert** → alle verbleibenden Strings der Länge $n$ erhalten den Status „nicht in $A$” (Diagonalisierung: $1^n \in L_A$, aber $M_i$ akzeptiert – Widerspruch zur korrekten Entscheidung).
+  - Falls $M_i$ **nicht akzeptiert** → wähle einen String der Länge $n$, nach dem $M_i$ das Orakel nicht gefragt hat, und füge ihn zu $A$ hinzu (das geht, weil $2^n > p_i(n)$, also hat $M_i$ weniger Strings abgefragt, als es gibt).
+
+### Konsequenz
+
+Da sowohl $\text{P}^A \neq \text{NP}^A$ als auch $\text{P}^B = \text{NP}^B$ möglich ist, kann **keine relativierende Beweistechnik** die P-vs-NP-Frage klären. Jeder Beweis, der für beliebige Orakel funktioniert, würde zu einem Widerspruch führen.
+
+> **Ergänzung:** Dies war ein bahnbrechendes Ergebnis von Baker, Gill und Solovay (1975), das zeigte, dass Diagonalisierung allein nicht ausreicht, um P ≠ NP zu beweisen. Spätere Arbeiten (Razborov, Rudich: „Natural Proofs”, 1997) zeigten weitere fundamentale Schranken für Beweistechniken.
+
+-----
+
+## 8. Polynomiale Hierarchie (PH)
+
+### 8.1 Definition über Quantoren
+
+Für eine Komplexitätsklasse $\mathcal{C}$ definieren wir:
+
+$$\exists \mathcal{C} = \left{x : \exists^{p(|x|)} y ; \langle x, y \rangle \in B \right}$$
+
+wobei $B \in \mathcal{C}$ und „$\exists^{p(|x|)} y$” bedeutet: es existiert ein String $y$ der Länge $\leq p(|x|)$.
+
+Analog für den Allquantor: $\forall \mathcal{C}$.
+
+**Beobachtungen:**
+
+- $\exists \text{P} = \text{NP}$ (die existenzielle Quantifizierung über P ergibt NP)
+- $\forall \text{P} = \text{co-NP}$ (die universelle Quantifizierung über P ergibt co-NP)
+
+### 8.2 Die Stufen der Hierarchie
+
+Die polynomiale Hierarchie wird induktiv definiert:
+
+|Stufe|$\Sigma^p$                                              |$\Pi^p$                           |$\Delta^p$                             |
+|-----|--------------------------------------------------------|----------------------------------|---------------------------------------|
+|0    |$\Sigma^p_0 = \text{P}$                                 |$\Pi^p_0 = \text{P}$              |                                       |
+|1    |$\Sigma^p_1 = \text{NP}$                                |$\Pi^p_1 = \text{co-NP}$          |$\Delta^p_1 = \text{P}$                |
+|2    |$\Sigma^p_2 = \exists \Pi^p_1 = \text{NP}(\text{co-NP})$|$\Pi^p_2 = \forall \Sigma^p_1$    |$\Delta^p_2 = \text{P}(\text{NP})$     |
+|$n+1$|$\Sigma^p_{n+1} = \exists \Pi^p_n$                      |$\Pi^p_{n+1} = \forall \Sigma^p_n$|$\Delta^p_{n+1} = \text{P}(\Sigma^p_n)$|
+
+Die **polynomiale Hierarchie** ist dann:
+$$\text{PH} = \bigcup_{n \geq 0} \Sigma^p_n$$
+
+### 8.3 Äquivalente Charakterisierung
+
+Eine Sprache $L$ ist in $\Sigma^p_i$ genau dann, wenn es eine polynomialzeit-TM $M$ und ein Polynom $q$ gibt, sodass:
+
+$$x \in L \iff \exists u_1 \in {0,1}^{q(|x|)} ; \forall u_2 \in {0,1}^{q(|x|)} ; \cdots ; Q_i u_i \in {0,1}^{q(|x|)} ; M(x, u_1, \ldots, u_i) = 1$$
+
+wobei die Quantoren **alternieren** ($\exists, \forall, \exists, \forall, \ldots$) und $Q_i = \forall$ falls $i$ gerade, $Q_i = \exists$ falls $i$ ungerade.
+
+Analog für $\Pi^p_i$ mit umgekehrter Quantorenreihenfolge ($\forall, \exists, \forall, \exists, \ldots$).
+
+### 8.4 Zusammenhang mit Orakel-Klassen
+
+> $\Sigma^p_{n+1} = \text{NP}(\Sigma^p_n)$
+
+**Beweis (Skizze):**
+
+- **Richtung $\Sigma^p_{n+1} \subseteq \text{NP}(\Sigma^p_n)$:** Per Definition ist jedes $S \in \Sigma^p_{n+1} = \exists \Pi^p_n$. Es gibt also ein $S’ \in \Pi^p_n$ mit $S = {x : \exists y \text{ mit } (x,y) \in S’}$. Da $\Pi^p_n \subseteq \text{NP}(\Sigma^p_n)$ (und auch $= \text{co-}\Sigma^p_{n+1}$), liegt $S$ in $\text{NP}(\Sigma^p_n)$.
+- **Richtung $\text{NP}(\Sigma^p_n) \subseteq \Sigma^p_{n+1}$:** Eine NP-Maschine mit Orakel $S’ \in \Sigma^p_n$ rät zunächst ein Zertifikat $y$ und stellt dann adaptive Orakel-Anfragen. Man kann die Orakel-Antworten **mitraten** und die Korrektheit der geratenen Antworten durch die Quantorenstruktur von $\Sigma^p_n$ verifizieren.
+
+### 8.5 Vollständige Probleme
+
+Für jede Stufe $i$ der Hierarchie ist $\Sigma_i\text{SAT}$ ein vollständiges Problem:
+
+$$\Sigma_i\text{SAT} = \exists u_1 ; \forall u_2 ; \exists \cdots ; Q_i u_i ; \varphi(u_1, u_2, \ldots, u_i) = 1$$
+
+### 8.6 Kollaps der Hierarchie
+
+- $\text{PH} \subseteq \text{PSPACE}$ (leicht einzusehen, da jede Stufe in PSPACE simulierbar ist).
+- Falls $\text{PH} = \text{PSPACE}$, so **kollabiert** PH (auf eine endliche Stufe).
+- Falls es ein **vollständiges Problem für PH** gibt, so kollabiert PH ebenfalls.
+
+> **Ergänzung:** Die Vermutung, dass PH **nicht** kollabiert, ist eines der zentralen offenen Probleme der Komplexitätstheorie. Ein Kollaps auf Stufe 0 würde $\text{P} = \text{NP}$ bedeuten, ein Kollaps auf Stufe 1 würde $\text{NP} = \text{co-NP}$ implizieren. Die meisten Forscher vermuten, dass die Hierarchie unendlich ist – aber ein Beweis fehlt.
+
+-----
+
+## Zusammenfassung der wichtigsten Beziehungen
+
+$$\text{P} \subseteq \text{NP} \subseteq \Sigma^p_2 \subseteq \cdots \subseteq \text{PH} \subseteq \text{PSPACE} \subseteq \text{EXPTIME} \subseteq \text{EXPSPACE}$$
+
+**Bekannte strikte Inklusionen:**
+
+- $\text{P} \subsetneq \text{EXPTIME}$ (Time Hierarchy Theorem)
+- $\text{PSPACE} \subsetneq \text{EXPSPACE}$ (Space Hierarchy Theorem)
+- $\text{NL} \subsetneq \text{PSPACE}$ (Space Hierarchy Theorem)
+
+**Offene Fragen:**
+
+- $\text{P} \stackrel{?}{=} \text{NP}$
+- $\text{NP} \stackrel{?}{=} \text{co-NP}$
+- $\text{P} \stackrel{?}{=} \text{PSPACE}$
+- Kollabiert PH?
+
+-----
+
+## Übersicht der Schlüsselresultate
+
+|Resultat                   |Aussage                                                   |Technik                                       |
+|---------------------------|----------------------------------------------------------|----------------------------------------------|
+|TQBF ist PSPACE-vollständig|Jedes PSPACE-Problem lässt sich als QBF kodieren          |Formelkonstruktion mit Allquantor-Trick       |
+|Space Hierarchy Theorem    |Mehr Platz → echt mehr Sprachen                           |Diagonalisierung                              |
+|Time Hierarchy Theorem     |Mehr Zeit → echt mehr Sprachen (mit log-Lücke)            |Diagonalisierung + Zähler                     |
+|Gap Theorem                |$\exists f$: $\text{TIME}(f(n)) = \text{TIME}(2^{f(n)})$  |Konstruktion von Lücken in Haltezeiten        |
+|Speed-Up Theorem           |$\exists A$: jede TM kann exponentiell beschleunigt werden|Diagonalisierung + abnehmende Funktionsfamilie|
+|Baker-Gill-Solovay         |Relativierung kann P vs NP nicht klären                   |Orakel-Konstruktion                           |
+|PH-Definition              |$\Sigma^p_{n+1} = \text{NP}(\Sigma^p_n)$                  |Quantoren-Alternierung                        |