hwr-notes/Komplexitätstheorie/zusammenfassungen/ko3 - zusammenfassung.md

# 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                        |