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