Computational Complexity 1 Einleitung

Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
1 Einleitung
Motivation
Computational Complexity
◮
Andreas Jakoby
◮
[email protected]
Sprechstunde: Dienstag 10:30-12:00
Sommer Semester 08
◮
Eine wesentliche Aufgabe der Informatik ist die Analyse von
Problemen mit der Zielsetzung eine effiziente algorithmische Lösung
für diese Probleme zu entwickeln.
Die erreichbare Effizienz einer algorithmischen Lösung hängt oft vom
Typ des Problems ab. Für manche Probleme können wir nicht
erwarten eine effiziente Lösung zu finden.
Abhängig von der erreichbaren Effizienz einer algorithmischen
Lösung, können wir Probleme verschiedenen Klassen – sogenannten
Komplexitätsklassen – zuordnen.
1
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
◮
zentrale Methoden zur Analyse von Problemen
wichtige Ressourcen
wichtige Komplexitätsklassen
◮
Beispiele für Probleme und deren Analyse
◮
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Scheinvergabe:
◮ Um einen Schein für diese Vorlesung zu erhalten, ist die erfolgreiche
Teilnahme an der abschließenden Prüfung erforderlich.
◮ Um zur Prüfung zugelassen zu werden, ist eine erfolgreiche
Teilnahme an den Übungen erforderlich. Die Kriterien für eine
erfolgreiche Übungsteilnahme sind:
Ziele der Vorlesung:
◮
2
alle bis auf maximal zwei Übungsblätter wurden erfolgreich
bearbeitet — ein Übungsblatt gilt als erfolgreich
bearbeitet, wenn auf diesem Blatt mindestens 50% der
Punkte erreicht wurden und diese Lösungen auch von dem
Studierenden vorgetragen werden können.
3
4
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
2 Die Turing-Maschine
2.1 Das Modell der Turing-Maschine
Definition 1 [Turing-Maschine (TM)] (Teil 2)
Zunächst wollen wir das Maschinenmodell der Turing-Maschine
einführen, die uns über wesentliche Teile dieser Vorlesung begleiten wird.
◮
Definition 1 [Turing-Maschine (TM)]
◮
Eine Speicherzelle ist ein Medium, das ein Symbol eines endlichen
Alphabets speichern kann.
◮
Ein Kopf ist eine Vorrichtung, die auf eine Speicherzelle zugreifen
kann. Je nach Spezifikation kann ein Kopf den Inhalt einer
Speicherzelle lesen oder/und verändern (neu beschreiben).
Eine unendliche Folge von Speicherzellen heißt ein einseitig
unendliches lineares Band.
◮
◮
Für die Eingabe und die Ausgabe besitzt eine TM (in der Regel) je
ein einseitig unendliches lineares Band, ein Eingabeband mit einem
Eingabekopf und ein Ausgabeband mit einem Ausgabekopf. Der
Eingabekopf ist eine reiner Lesekopf – er kann den Inhalt einer
Speicherzelle nicht verändern – und der Ausgabekopf ist eine reiner
Schreibkopf – er kann den Inhalt einer Speicherzelle nicht lesen.
Die Eingabe für eine TM befindet sich vor der Berechnung auf den
ersten n Speicherzellen des Eingabebands.
5
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
6
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Definition 1 [Turing-Maschine (TM)] (Teil 4)
◮
Definition 1 [Turing-Maschine (TM)] (Teil 3)
◮ Ein lineares Band nennen wir Zweiweg-Band, wenn sich der
dazugehörige Kopf sowohl nach rechts als auch nach links bewegen
kann, dass heißt, er kann sich von der i-ten Speicherzelle sowohl auf
die (i + 1)-te als auch auf die (i − 1)-te Speicherzelle bewegen.
◮
◮
Eine Turing-Maschine (TM) M beschreiben wir durch ein Tupel
M = (G , Σ, ΣE , ΣA , Q, q0 , Qf , ∆).
◮
◮
Kann sich der Kopf nur nach rechts bewegen, so nennen wir das
Band ein Einweg-Band.
Das Ausgabeband ist in der Regel ein Einweg-Band. Beim
Eingabeband unterscheiden wir zwischen einer TM mit Einweg- und
einer TM mit Zweiweg-Band.
◮
◮
◮
G bezeichnet den Speicher der Maschine.
Σ bezeichnet das (Arbeits-)Alphabet, ΣE das Eingabe- und ΣA das
Ausgabealphabet. Jedes dieser Alphabete beinhaltet das
Blanksymbol β.
Q bezeichnet die Menge der Zustände.
q0 ∈ Q bezeichnet den Startzustand und Qf ⊆ Q die Menge der
Endzuständen, in denen M hält.
∆ gibt die Übergangsrelation an.
Auf den Speicher und die Übergangsrelationen müssen wir näher
eingehen.
7
8
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Definition 1 [Turing-Maschine (TM)] (Teil 5)
◮
◮
Der Speicher ist eine Menge von Speicherzellen mit interner
Verbindungsstruktur, auf die M mit Hilfe von Köpfen zugreifen kann.
Die Köpfe können von M entlang der Verbindungen bewegt werden.
In dieser Vorlesung werden wir uns auf Speicher beschränken, die
aus k Zweiweg-Bändern mit jeweils einem Lese/Schreibkopf
bestehen. Wir nennen eine solche TM auch k-Band TM.
Definition 1 [Turing-Maschine (TM)] (Teil 6)
◮
◮
Die Übergangsrelation ∆ einer k-Band TM definieren wir als
Wir beschreiben die möglichen Bewegungen mit Hilfe von
R, RE , RA ⊆ {−1, 0, +1}, wobei wir mit −1 eine Bewegung nach
links und mit +1 eine Bewegung nach rechts darstellen. Eine 0
symbolisiert, dass der Kopf stehen bleibt.
Mit der Übergangsrelation ∆ assoziieren wir eine partielle
mehrdeutige Abbildung
∆ ⊆ Q × ΣE × Σk × Q × RE × Σk × R k × ΣA × RA ,
∆ : Q × ΣE × Σk → 2Q×RE ×Σ
wobei sich RE auf die möglichen Bewegungen des Eingabekopfes, RA
auf die möglichen Bewegungen des Ausgabekopfes und R k auf die
möglichen Bewegungen der k Köpfe im Speicher der TM bezieht.
k
×R k ×ΣA ×RA
.
9
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
10
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Definition 1 [Turing-Maschine (TM)] (Teil 7)
◮
TM
Eingabeband
β @1 # X 1 0 0 # X 1 0 1 # # 1 0 # v 1 # X 1 1 0 # # 1
Für q, q ′ ∈ Q, a ∈ ΣE , b1 , . . . , bk , c1 , . . . , ck ∈ Σ, d ∈ ΣA , u ∈ RE ,
v1 , . . . , vk ∈ R und w ∈ RA sei
(q ′ , u, c1 , . . . , ck , v1 , . . . , vk , d, w ) ∈ ∆(q, a, b1 , . . . , bk )
dann bedeutet dies, dass
◮
∆
◮
β @1 1 0 1 0 0 0 1 1 0 1 1 1 0 1 0 0 0 1 0 1 β β β β β β β
Ausgabeband
◮
◮
11
wenn M im Zustand q das Eingabesymbol a und die Symbole
b1 , . . . , bk mit den k Köpfen im Speicher liest,
sie in Zustand q ′ wechselt und den Eingabekopf in Richtung u
bewegt – er geht von Position pE auf Position pE + u.
Gleichzeitig schreiben jeweils der i-te Kopf im Speicher das Symbol
ci in die Speicherzelle, an der er sich unmittelbar vor diesem Schritt
befunden hat und bewegt diesen Kopf in die Richtung vi – er geht
von Position pi auf Position pi + vi .
Auf das Ausgabeband wir zudem d geschrieben und der Kopf in
Richtung w bewegt – er geht von Position pA auf Position pA + w .
12
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
◮
Ist die Übergangsrelation eindeutig, d.h. zu jedem q, a, b1 , . . . , bk
existiert maximal ein q ′ , u, c1 , . . . , ck , v1 , . . . , vk , d, w , so dass
(q, a, b1 , . . . , bk , q ′ , u, c1 , . . . , ck , v1 , . . . , vk , d, w ) ∈ ∆
∆ : Q × ΣE × Σ
◮
k
Eine partielle Konfiguration C beschreibt den Zustand, die
Beschriftung der Zellen des Speichers und der Kopfpositionen im
Speicher, dem Eingabe- und dem Ausgabeband. Für eine k-Band
TM deren Speicherzellen wir mit V bezeichnen gilt
C
ist, so nennen wir die TM deterministisch und verwenden das Kürzel
DTM. Wir schreiben dann auch
k
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Definition 2 [Konfiguration, Berechnung]
Definition 1 [Turing-Maschine (TM)] (Teil 8)
◮
Andreas Jakoby
Universität zu Lübeck
◮
k
→ Q × RE × Σ × R × ΣA × RA
◮
bzw. (q ′ , u, c1 , . . . , ck , v1 , . . . , vk , d, w ) = ∆(q, a, b1 , . . . , bk ).
Ist die Übergangsrelation nicht eindeutig, so nennen wir die TM
nichtdeterministisch und verwenden das Kürzel NTM.
∈ Q × Σ|V | × Nk+2
Spezifizieren wir zudem noch den Inhalt der Eingabe- und
Ausgabebandes, so erhalten wir die totale Konfiguration der TM.
C ′ heißt direkte Nachfolgekonfiguration der totalen Konfiguration C ,
kurz C ⊢ C ′ , falls sich C ′ aus C durch einmalige Anwendung der
Übergangsrelation ∆ erzeugen läßt. Einen solchen Übergang
bezeichnen wir auch als Rechenschritt oder einfacher als Schritt der
Maschine.
13
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
14
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Definition 2 [Konfiguration, Berechnung] (Teil 2)
◮ Gibt es eine Folge von Konfigurationen C1 , . . . , Cm , so dass
Zustand
q
q′
Eingabeband
a
a
Arbeitsband 1
b1
Arbeitsband 2
b2
Ausgabeband
?
(q ′ , −1, c1 , c2 , +1, −1, d, 0)
C ⊢ C1 ⊢ · · · ⊢ Cm ⊢ C ′
c1
◮
∈ ∆(q, a, b1 , b2 )
c2
gilt, so ist C ′ eine Nachfolgekonfiguration von C und wir schreiben
C ⊢∗ C ′ .
In der Anfangskonfiguration C0 = C0 (x)
◮
d
◮
◮
◮
15
steht die Eingabe x = x1 . . . xn in den ersten n Zellen des
Eingabebandes, alle anderen Speicherzellen (des Eingabebandes, der
Arbeitsbänder und des Ausgabebandes) tragen das Blanksymbol,
steht der Eingabe- und Ausgabekopf am Anfang des jeweiligen
Bandes,
stehen die Köpfe der Arbeitsbänder an ausgezeichneten
Anfangspositionen
und befindet sich die TM im Zustand q0 .
16
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Definition 2 [Konfiguration, Berechnung] (Teil 3)
◮
◮
Andreas Jakoby
Universität zu Lübeck
Definition 2 [Konfiguration, Berechnung] (Teil 4)
Eine Konfiguration, in der sich die TM in einem Endzustand befindet
nennen wir Endkonfiguration.
Eine Berechnung einer TM M auf einer Eingabe x ∈ Σ∗E ist eine
Folge C direkter Nachfolgekonfigurationen
◮
Die Menge der Speicherzellen, in denen M in C Informationen
speichert, besteht aus genau den Zellen, die in C von einem Kopf
betreten werden.
◮
Wird eine Zelle betreten, aber nie wieder verlassen, und zudem deren
Anfangsbeschriftung mit dem Blanksymbol nicht verändert, so
zählen wir diese Zelle nicht mit.
Für eine (endliche) haltende Berechnung CM (x) einer TM M auf
Eingabe x ∈ Σ∗E sei Res(CM (x)) das Resultat von CM (x) und für
eine DTMs M sei ϕM : Σ∗E → Σ∗A die von M berechnete
(partiell-rekursive) Funktion, mit

 Res(CM (x)) wenn die Berechnung CM (x)
von M auf x ∈ Σ∗E hält,
ϕM (x) :=

undefiniert sonst.
C = C0 (x) ⊢ C1 ⊢ · · · .
◮
◮
◮
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
◮
Ist die Folge endlich und die letzte Konfiguration eine
Endkonfiguration, so ist die Berechnung vollständig ausgeführt. Wir
sagen, M hält in C.
Die Beschriftung des Ausgabebands in der Endkonfiguration heißt
das Ergebnis der Berechnung C.
Beachte, dass das Ergebnis einer NTM nicht eindeutig sein muss.
Bei einer DTM die auf einer Eingabe hält, ist das Ergebnis jedoch
eindeutig und definiert.
17
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Definition 2 [Konfiguration, Berechnung] (Teil 5)
◮ Ist das Ergebnis einer TM für alle Eingaben auf 0 oder 1 beschränkt,
d.h. für alle haltenden Berechnungen C ist Res(C) ∈ {0, 1}, so
nennen wir die TM auch einen Akzeptor.
◮ Eine Berechnung C mit Res(C) = 1 nennen wir akzeptierende und
eine Berechnung C mit Res(C) = 0 verwerfende Berechnung.
◮
◮
18
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Definition 3 [Simulation]
◮ Eine Maschine M ′ simuliert eine Maschine M, falls M ′ dieselbe
Funktion wie M berechnet. Für Turing-Maschinen bedeutet dieses,
dass für alle x ∈ Σ∗E gilt
Bei Akzeptoren verzichten wir auf das Ausgabeband und unterteilen
die Menge der Endzustände in die Teilmenge Qa der akzeptierenden
und in die Teilmenge Qv der verwerfenden Zustände.
Wir nennen
ϕM ′ (x) = ϕM (x) .
L(M) := { x ∈ Σ∗E | es existiert CM (x) mit Res(CM (x)) = 1 }
die von M akzeptierte Sprache.
19
20
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
◮
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Beispiel TM für die Sprache {w #w |w ∈ {0, 1}∗ } mit Qf = {q3 } und
Definition 4 [Berechnungszeit einer TM]
◮
Andreas Jakoby
Universität zu Lübeck
◮
Wir nennen eine DTM M T -zeitbeschränkt, wenn auf jede Eingabe
x ∈ Σ∗E die DTM M auf C0 (x) nach maximal T (|x|) Schritten hält,
d.h. es existiert eine Konfigurationsfolge C1 , . . . , Cm mit m ≤ T (|x|),
so dass
C0 (x) ⊢ C1 ⊢ · · · ⊢ Cm
◮
◮
◮
◮
eine Berechnung von M ist und Cm eine Endkonfiguration von M
darstellt.
◮
Wir werden auf das Thema Komplexitätsmasse für TMs im Verlauf
der Vorlesung noch näher eingehen.
◮
◮
◮
∆(q0 , 0, β) = (q0 , +1, 0, +1, β, 0)
∆(q0 , 1, β) = (q0 , +1, 1, +1, β, 0)
∆(q0 , #, β) = (q1 , 0, β, −1, β, 0)
∆(q1 , #, 0) = (q1 , 0, 0, −1, β, 0)
∆(q1 , #, 1) = (q1 , 0, 1, −1, β, 0)
∆(q1 , #, β) = (q2 , +1, β, +1, β, 0)
∆(q2 , β, β) = (q3 , 0, β, 0, 1, 0)
∆(q2 , 0, 0) = ∆(q2 , 1, 1) = (q2 , +1, β, +1, β, 0)
∆(q2 , β, 0) = ∆(q2 , β, 1) = ∆(q2 , 0, β) = ∆(q2 , 0, 1)
= ∆(q2 , 1, β) = ∆(q2 , 1, 0) = (q3 , 0, β, 0, 0, 0)
21
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
22
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Beispiel (Teil 3)
Beispiel (Teil 2)
q0
Schritt 0: Zustand q0
Eingabe:
Speicher:
Ausgabe:
(a, β) → (+1, a, +1, β, 0) für alle a 6= #
(#, β) → (0, β, −1, β, 0)
q1
0
β
β
1
β
β
#
β
β
0
β
β
1
β
β
β
β
β
β
β
β
0
0
β
1
β
β
#
β
β
0
β
β
1
β
β
β
β
β
β
β
β
0
0
β
1
1
β
#
β
β
0
β
β
1
β
β
β
β
β
Schritt 1: Zustand q0
(#, a) → (0, a, −1, β, 0) für alle a 6= β
Eingabe:
Speicher:
Ausgabe:
(#, β) → (+1, β, +1, β, 0)
q2
β
β
β
(a, a) → (+1, β, +1, β, 0) für alle a 6= β
Schritt 2: Zustand q0
(a, b) → (0, β, 0, 0, 0) für alle a 6= b
(β, β) → (0, β, 0, 1, 0)
Eingabe:
Speicher:
Ausgabe:
q3
23
24
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Beispiel (Teil 4)
Beispiel (Teil 5)
Schritt 3: Zustand q1
Schritt 6: Zustand q2
Eingabe:
Speicher:
Ausgabe:
β
β
β
0
0
β
1
1
β
#
β
β
0
β
β
1
β
β
β
β
β
Eingabe:
Speicher:
Ausgabe:
β
β
β
0
0
β
1
1
β
#
β
β
0
β
β
1
β
β
Eingabe:
Speicher:
Ausgabe:
β
β
β
1
1
β
#
β
β
0
β
β
1
β
β
β
β
β
β
β
β
0
β
β
1
1
β
#
β
β
0
β
β
1
β
β
β
β
β
β
β
β
0
β
β
1
β
β
#
β
β
0
β
β
1
β
β
β
β
β
Schritt 8: Zustand q2
Schritt 5: Zustand q1
Eingabe:
Speicher:
Ausgabe:
0
0
β
Schritt 7: Zustand q2
Schritt 4: Zustand q1
Eingabe:
Speicher:
Ausgabe:
β
β
β
β
β
β
0
0
β
1
1
β
#
β
β
0
β
β
1
β
β
Eingabe:
Speicher:
Ausgabe:
β
β
β
25
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
26
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Definition 5 [Platzbedarf einer TM]
◮ Wir nennen eine DTM M S-platzbeschränkt, wenn auf jede Eingabe
x ∈ Σ∗E die DTM M maximal S(n) Speicherzellen im Speicher
besucht, d.h. auf der haltende Berechnung
Beispiel (Teil 9)
C0 (x) ⊢ C1 ⊢ · · · ⊢ Cm
Schritt 8: Zustand q3
Eingabe:
Speicher:
Ausgabe:
β
β
β
0
β
1
1
β
β
#
β
β
0
β
β
1
β
β
β
β
β
◮
von M speichert M in maximal S(n) Speicherzellen des Speichers
Informationen.
Wollen wir die Platzbeschränktheit einer TM näher untersuchen, so
ist es gewissermaßen unfair, wenn wir Eingabe und Ausgabe bei
dieser Schranke mit berücksichtigen müssen:
◮
◮
27
Wollen wir testen, ob die Anzahl der Einsen in einem binären String
gerade ist, so benötigen wir nur ein Bit aktiven Speicher. Die Länge
der Eingabe ist jedoch linear.
Wollen wir die Eingabe nur bitweise negieren so benötigen wir keinen
aktiven Speicher. Die Länge der Ausgabe ist jedoch linear in der
Eingabelänge.
28
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
2.2 Elementare Techniken
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Technik 2 [Ausgabe im Speicher]
◮
Technik 1 [Eingabe im Speicher]
◮
Andreas Jakoby
Universität zu Lübeck
Interessieren wir uns nicht für den Platzbedarf einer TM oder ist
diese so oder so nur S-platzbeschränkt für ein S ∈ Ω(n), so
verzichten wir oft auf das separate Eingabeband, und gehen davon
aus, dass die Eingabe auf dem ersten Band des Speichers zur
Verfügung gestellt wird. Wir können somit den Eingabestring im
Verlauf der Berechnung verändern. Die Startposition des Kopfes auf
diesem Band ist dann die erste Position der Eingabe.
Interessieren wir uns nicht für den Platzbedarf einer TM oder ist
diese so oder so nur S-platzbeschränkt für ein S ∈ Ω(h(n)), wobei
h(n) die maximale Länge einer Ausgabe auf Eingaben der Länge n
ist, so verzichten wir oft auf das separate Ausgabeband, und gehen
davon aus, dass die Ausgabe auf dem ersten (oder letzten) Band des
Speichers nach der Berechnung zur Verfügung gestellt wird. Wir
können somit den Ausgabestring im Verlauf der Berechnung
verändern. Die Ausgabe besteht dann aus dem String, den wir nach
der Berechnung auf diesem Band vorfinden.
29
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
◮
Für die Analyse von TMs ist es oft hilfreich, wenn die TM in einer
ausgezeichneten Konfiguration hält. Hierzu modifizieren wir die TM
wie folgt:
◮
◮
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Technik 4 [Speichern im endlichen Gedächtnis]
Technik 3 [Halten in einer ausgezeichneten Konfiguration]
◮
30
Eine TM kann eine beschränkte Menge an Information in ihrem
Zustand speichern.
Ist es zum Beispiel erforderlich, dass sie in ihrem Zustand bis zu fünf
Symbole aus dem Speicheralphabet Σ speichern
S kann, so ergänzen
wir die Zustandsmenge Q um die Zustände i∈[1..5] Q × Σi .
◮ In einem zweiten Beispiel wollen wir zeigen, wie eine TM in ihrem
Zustand ein Symbol speichern kann. Sei Q die ursprüngliche
Zustandsmenge der TM, dann ersetzen wir diese Menge durch
(Q ∪ {qS , qL }) × {0, 1, β}. Den Zustand (q, a) interpretieren wir wie
folgt: die TM befindet sich im Zustand q und speichert im endlichen
Gedächtnis das Symbol a. Sei ∆(q, b) = (q ′ , b ′ , r ) der Übergang der
ursprünglichen TM, dann erhalten wir die neue Übergangsrelation
über
8
′
′
< ((q , a), b , r ) falls q ∈ Q
′
ˆ
((q , b), b ′ , r ) falls q = qL (lese und speichere)
∆((q, a), b) =
:
((q ′ , β), a, r ) falls q = qS (schreibe und lösche).
◮
Im Verlauf der Berechnung markiert die TM alle Speicherzellen die
von ihr besucht werden. Hierfür kann es erforderlich sein, dass wir ein
zweites Blanksymbol einführen, welches wir während der Berechnung
beim Schreiben im Speicher anstelle des eigentlichen Blanksymbols
benutzen. Nach Abschluß der Berechnung kann die TM die
Beschriftung des Speichers löschen, d.h. mit Blanksymbolen
überschreiben.
Bei einem Akzeptor ersetzen wir alle akzeptierende Zustände durch
einen ausgewählten akzeptierenden Zustand, und alle verwerfende
Zustände durch einen ausgewählten verwerfenden Zustand. Bei einer
TM, die eine Ausgabe erzeugt ersetzen wir alle Endzustände durch
einen ausgewählten Endzustand.
31
32
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Technik 5 [Zusatzinformationen in Zuständen]
◮
◮
Eine TM kann eine beschränkte Menge an zusätzlichen Information
in ihrem Zustand speichern.
◮
Eine weitere Anwendung der Technik 5 ist die schnellen Berechnung
von Funktionen auf Eingaben konstanter Größe.
◮
Betrachten wir eine TM M, die eine (m + n)-parametrische Funktion
f (x1 , . . . , xm+n ) berechnet deren erste m Parameter xi = ci fest sind,
so können wir diese m Parameter analog zur Technik 4 im
Startzustand speichern, und die Eingabe für f um diese Parameter
verkürzen. Anstelle den Wert eines Parameters xi mit i ∈ [1..m] von
der Eingabe zu lesen, kann die neue TM den Wert ci aus ihrem
Zustandsgedächtnis lesen. Ansonsten simuliert die neue TM die alte
TM Schritt für Schritt. Wir erhalten dann eine TM zur Berechnung
einer Funktion
fc1 ,...,cm (xm+1 , . . . , xm+n ) = f (c1 , . . . , cm , xm+1 , . . . , xm+n ).
Mit Hilfe von zusätzlichen Zuständen kann eine Abbildung
g : Σs → Σr direkt in die Übergangsrelation codiert werden. In einem
Zustand qL liest die TM s Symbole y1 , . . . , ys aus dem Speicher und
geht dabei in die Zustände (qL , λ), . . . , (qL , y1 . . . ys ) über. Im
Zustand (qL , y1 . . . ys ) geht sie in den Zustand (qE , g (y1 . . . ys )) über.
Sie erhält somit in s Schritten das Ergebnis von g auf Eingabe
y1 , . . . , ys , unabhängig von der Komplexität der Funktion g . Beachte,
dass diese schnelle Berechnung der Funktion jedoch nur für Eingaben
konstanter Länge möglich ist.
33
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
34
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Technik 6 [Einteilung von Arbeitsbändern in Spuren]
◮
Vergrößern wir das Bandalphabet von Σ auf Σk für einen festen
Wert k ∈ N, so können wir k Symbole x1 , . . . , xk ∈ Σ des alten
Alphabets in einer Zelle in Form eines k-Tupels (x1 , . . . , xk )
speichern und somit auch in einem Schritt lesen, schreiben und
bearbeiten. Die jeweiligen i-ten Symbole dieser Tupel bilden dann
die i-te Spur.
Spur 1:
Spur 2:
Spur k:
···
···
ai−1,1
ai−1,2
..
.
···
ai−1,k
ai,1
ai,2
..
.
ai+1,1
ai+1,2
..
.
Technik 7 [Einseitig versus zweiseitig unendliche Bänder]
◮
Ein zweiseitig unendliches Band kann durch ein einseitig unendliches
Band ersetzt werden, indem wir das zweiseitig unendliche Band an
der 0-Position falten:
2-seitiges Band:
···
···
1-seitiges Band:
ai+1,k
···
↑
Speicherzelle i mit Symbol (ai,1 , . . . , ai,k ) ∈ Σk
ai,k
35
···
a−2
a−1
a0
a1
a2
···
a0
#
a1
a−1
a2
a−2
···
···
36
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Technik 9 [Verschieben und Kopieren von Teilen der Bandinschrift]
Technik 8 [Markieren von Speicherzellen]
◮
◮
Mit Hilfe einer zusätzlichen Spur können wir Positionen auf einem
Band markieren. Wir erweitern daher das Alphabet in
Σ × (M ∪ {β}), wobei mit M die Menge der Marken bezeichnen
und mit β die nichtgesetzte Marke.
Arbeitsspur:
Spur für Marken:
···
···
a−2
♥
a−1
β
a0
β
a1
♣
a2
♠
Ein Block auf einem Band ist eine Folge von benachbarten
Speicherzellen. Durch Verwendung von Marken kann eine TM die
Inschrift eines Blockes in einen anderen Block gleicher Länge
kopieren oder verschieben.
◮
···
···
◮
Bei einer 1-band TM muss die TM dafür sukzessive die Inhalte aller
Zellen von einem Block an die Position des anderen Blockes mit Hilfe
eines erweiterten Zustands transportieren.
Bei einer 2-band TM können wir den Block zunächst auf das zweite
Band kopieren und anschließend an dessen Zieladresse abspeichern.
Beachte, dass wir diese Operationen auch auf Blöcke einer Spur
ausführen können.
37
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
38
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Technik 10 [Zähler]
◮
···
···
a1
♣
···
···
Original
ai−1 ai
β
↑
···
···
ai wird im Zustand
gespeichert und transportiert
am
♠
···
···
l
(q, ai )
a1
♥
Kopie
· · · ai−1
···
♦
···
···
Auf einer zusätzlichen Spur können wir einen binären Zähler zk . . . z0
implementieren. Damit dieser Zähler sich immer an einer
ausgezeichneten Position befindet, verschieben wir diese Spur immer
so, dass sich z0 genau an der aktuellen Position des Kopfes befindet:
Arbeitsspur:
Zählerspur:
···
β
···
zk
···
ai−1
z1
ai
z0
l
q
ai+1
β
···
···
Will eine TM beispielsweise die Anzahl spezieller Schritte zählen, so
kann sie nach solch einem Schritt den Zähler um 1 erhöhen.
39
40
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Technik 12 [Schritt-für-Schritt Simulation]
Technik 11 [Weiterrechnen in einer Endkonfiguration]
◮
Andreas Jakoby
Universität zu Lübeck
◮
Kennen wir von einer TM eine obere Schranke t jedoch nicht die
exakte Laufzeit, so können wir mit Hilfe eines Zählers die
Berechnung nach ihrem eigentlichen Ende so fortsetzen, dass die
Berechnung genau t Schritte benötigt.
Eine TM M ′ simuliert eine TM M Schritt-für-Schritt, wenn für jeden
Schritt Ci ⊢ Ci+1 von M eine Folge von Schritten
Cj′i ⊢ Cj′i +1 ⊢ · · · ⊢ Cj′i+1 von M ′ existiert, wobei Cj′i eindeutig der
Konfiguration Ci und Cj′i+1 eindeutig der Konfiguration Ci+1
zugeordnet ist.
41
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
42
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Technik 13 [Hintereinanderschalten]
◮
Seien M1 und M2 zwei TMs mit Übergangsrelation ∆i ,
Zustandsmenge Qi , Startzustand q0,i und Endzustände Qf ,i .
◮
Sei nun M die TM die zunächst M1 Schritt-für-Schritt simuliert und
nach dem erreichen eines Endzustands aus Qf ,1 die Simulation der
TM M2 startet. Hierzu benutzt M die Zustandsmenge
Q
◮
Technik 14 [Unterprogramme]
◮
◮
:= (Q1 × {1}) ∪ (Q2 × {2}) .
Die Übergangsrelation von M besteht aus den Übergangsrelationen
∆1 ∪ ∆2 , wobei wir die Zustände q der Relationen aus ∆i zu (q, i)
und ferner die Zustände (q, 1) mit q ∈ Qf ,1 (d.h. die Endzustände
von M1 ) in (q0,2 , 2) (d.h. dem Startzustand von M2 ) abändern.
Sollen M2 nicht durch die von M1 beschriebenen Speicherzellen
beeinflußt werden, so können wir M1 und M2 auf zwei unabhängigen
Spuren arbeiten lassen.
◮
43
Die Technik des Unterprogramms ist mit der Technik des
Hintereinanderschaltens verwandt. Hierzu fügen wir in M1 zwei neue
Zustände qsub und qret und geeignete Übergänge für diese Zustände
ein.
Im Zustand qsub geht M in den modifizierten Startzustand (q0,2 , 2)
der zweiten TM über und im Zustand (q, 2) mit q ∈ Qf ,2 in den
Zustand qret .
Soll bei einem Unterprogrammaufruf der Speicherzustand der
Aufrufstelle erhalten bleiben, so muss die TM vor dem Start des
Unterprogramms noch in einen separaten Speicherbereich gehen,
und bei Bedarf den von M1 benutzten Speicherbereich verschieben.
44
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
◮
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Satz 1 [Bandreduktion] Jede t-zeit- und s-platzbeschränkte k-Band
TM M kann von einer O(t 2 )-zeit- und O(s)-platzbeschränkten 1-Band
TM M ′ simuliert werden.
Technik 15 [Nichtdeterministisches Raten]
◮
Andreas Jakoby
Universität zu Lübeck
Eine NTM rät in einer Konfiguration C nichtdeterministisch ein
Element aus einer Menge M, wenn sie von C aus eine Folge
nichtdeterministischer Schritte ausführt, die sie in eine von |M|
möglichen Konfigurationen C1 , . . . , C|M| überführt. Zu jedem
ai ∈ M korrespondiert eindeutig eine Konfiguration Ci .
Im Allgemeinen gehen wir bei einem solchen Rateschritt davon aus,
dass die TM das geratene Element entweder im Zustand oder im
Speicher abspeichert.
Beweis von Satz 1: Wir konstruieren eine TM M ′ mit 2k + 1 Spuren,
die M Schritt-für-Schritt simuliert. Nach der Simulation des i-ten
Rechenschritts sollen die Beschriftung des Arbeitsbandes von M ′ die
folgenden Bedingungen erfüllen:
◮
◮
Die Beschriftung der ungeraden Spuren entspricht der Beschriftung
des Speichers von M, d.h. Spur 2j − 1 speichert die Beschriftung des
j-ten Bandes von M (für alle j ∈ [1..k]) nach dem i-ten Schritt.
Die Beschriftung der geraden Spuren markiert die Kopfpositionen
der Köpfe von M, d.h. in Spur 2i steht an der Position des Kopfes
des j-ten Bandes von M das Symbol ↑ (für alle j ∈ [1..k]) nach dem
i-ten Schritt.
45
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Beweis von Satz 1 (Teil 2)
◮ Auf der (2k + 1)-te Spur ist die am weitesten links stehende bisher
besuchte Speicherzelle mit einem $ und die am weitesten rechts
stehende bisher besuchte Speicherzelle mit einem # markiert. Sind
diese beiden Adressen gleich, so steht hier ein △.
46
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Beweis von Satz 1 (Teil 3) Simulation des (i + 1)-ten Schritts:
◮ Phase 1 – Lesen des Speichers:
◮
◮
Der Kopf auf dem Arbeitsband von M ′ befindet sich auf der am
weitesten links stehenden bisher besuchten Position.
◮ Dem Zustand von M ′ ist eindeutig der Zustand von M nach dem
i-ten Schritt zugeordnet, d.h. M ′ speichert diesen Zustand von M im
endlichen Gedächtnis (Technik 4).
Es ist einfach zu sehen, dass die Initialisierung des Arbeitsbandes von M ′
in konstanter Zeit möglich ist. Wir wollen nun zeigen, dass jeder Schritt
von M in Zeit O(t) und auf Platz O(s) simuliert werden kann. Da der
Platz in jedem Simulationsschritt wieder benutzt werden kann, folgt die
Behauptung des Satzes unmittelbar.
◮
◮
◮
47
Der Kopf von M ′ läuft von der mit $ markierten Zelle nach rechts
bis sie die mit # markierte Zelle erreicht.
Bei diesem Durchlauf merkt sich M ′ die Inhalte der Spuren, die mit ↑
markierten sind im endlichen Gedächtnis (Technik 4).
Beim erreichen der mit # markierten Zelle speichert M ′ somit im
endlichen Gedächtnis den Inhalte der Speicherzellen, die M im
(i + 1)-ten Schritt liest.
Phase 2 – Ausführen des Rechenschritts:
Wie in Technik 5 beschrieben, kann M ′ nun den Rechnenschritt von
M simulieren. Hierbei speichert sie im endlichen Gedächtnis die
Auswirkungen dieses Schritts von M auf den Speicher – was wird
geschrieben, wie bewegen sich die Köpfe.
48
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Beweis von Satz 1 (Teil 4)
◮ Phase 3 – Aktualisierung des Speichers:
◮
◮
◮
◮
◮
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Beweis von Satz 1 (Teil 5)
Der Kopf von M ′ läuft von der mit # markierten Zelle nach links bis
sie die mit $ markierte Zelle erreicht.
Bei diesem Durchlauf aktualisiert M ′ die Inhalte der Spuren, die mit
↑ markiert sind, mit Hilfe ihres endlichen Gedächtnisses.
Ferner werden die ↑-Markierungen entsprechend der
Kopfbewegungen von M verschoben – je nach Bewegungsrichtung
um eine Zelle nach links oder nach rechts oder sie bleiben stehen.
Hierbei wandert der Kopf von M ′ bei einer Verschiebung einer Marke
nach rechts auch um eine Zelle nach rechts und setzt dann seine
Wanderung nach links fort.
Beachte, dass durch den simulierten Rechenschritt in manchen
Situationen es nötig sein kann die Marke # nach rechts und die
Marke $ nach links zu verschieben.
Nach dem Abschluß dieser Phase erfüllt die Konfiguration von M ′
unsere zu Beginn festgelegten Bedingungen bezüglich der
Speicherbeschriftung und des Zustandes von M nach dem (i + 1)-ten
Schritt.
Wie viel Platz benötigt die Simulation?
◮
Für jede Speicherzelle, die M ′ bei der Simulation besucht, existiert
zumindest eine Speicherzelle von M, die durch eine Spur der Zelle
von M ′ eineindeutig repräsentiert wird. M ′ benötigt somit maximal
soviel Platz wie M.
Wie viel Zeit benötigt die Simulation?
◮
Für jeden Schritt von M muss M ′ maximal viermal jede
Speicherzelle von M besuchen. Der Zeitbedarf ist somit beschränkt
durch 4 · ℓ · t, wobei ℓ der Anzahl der von M besuchten
Speicherzellen entspricht. Da diese Anzahl jedoch durch k · t
beschränkt ist – in einem Schritt kann M maximal k neue Zellen
besuchen, folgt die Zeitschranke von 4 · k · t 2 = O(t 2 ).
49
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
50
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
2.3 Komplexitätsmaße und -klassen
Bei der Simulation in Satz 1 werden die Eingabe und die Ausgabe der
TM M nicht gesondert betrachtet. Wir gehen hierbei davon aus, dass
beide TMs entweder über ein gesondertes Eingabe- bzw. Ausgabeband
verfügen oder beide nicht. Verfügt M über ein gesondertes Eingabe- und
Ausgabeband, die simulierende TM M ′ jedoch über keine solchen
Bänder, so müssen wir die Länge der Eingabe und der Ausgabe noch bei
der Platz- und somit bei der Zeitschranke berücksichtigen. Wir erhalten:
Wir erweitern zunächst unsere Definition von CM (x) auf
nichtdeterministische Maschinen:
Definition 6 Eine haltende Berechnung einer NTM M auf eine Eingabe
x ist eine Folge von Konfigurationen
C0 ⊢ C1 ⊢ · · · ⊢ Cm
Satz 2 [Bandreduktion – Teil 2] Jede t-zeit- und s-platzbeschränkte
k-Band TM M (mit separaten Eingabe- und Ausgabeband) kann von
einer O(t 2 + n · t)-zeit- und O(s + t + n)-platzbeschränkten 1-Band TM
M ′ (ohne separates Eingabe- und Ausgabeband) simuliert werden.
der NTM, wobei C0 die Startkonfiguration und Cm eine Endkonfiguration
von M auf x ist, d.h. M ist in Cm in einem Endzustand. Zur
Vereinfachung der Notation bezeichnen wir eine solche Berechnung auch
mit CM (x). Beachte, dass CM (x) nicht eindeutig sein muss! Die von einer
NTM berechnete Funktion ist demnach eine Relation, welche jeder
Eingabe mehrere Ergebnisse zuweisen kann.
51
52
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Definition 6 (Teil 2) Das Zeitkomplexitätsmaß mißt die Anzahl der
Rechenschritte einer TM M und das Platzkomplexitätsmaß mißt die
Anzahl der Speicherzellen im Speicher, die M während der Berechnung
besucht, d.h. in denen M Informationen speichert:
◮
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Definition 6 (Teil 3) Die Zeitkomplexität TM und Platzkomplexität SM
einer TM M definieren wir für alle n ∈ N als
TM (n) :=
Für eine DTM M auf Eingabe x definieren wir:
SM (n) :=
timeM (x) :=
spaceM (x) :=
◮
Anzahl der Schritte in der Berechnung CM (x)
Anzahl der besuchten Speicherzellen in der
Berechnung CM (x) .
spaceM (x) :=
max spaceM (x) .
x∈ΣnE
Eine TM M nennen wir
◮ T -zeitbeschränkt, falls TM ≤ T ist und
S-platzbeschränkt, falls SM ≤ S ist.
Einen nichtdeterministischer Akzeptor M nennen wir
◮ schwach T -zeitbeschränkt, falls für alle x ∈ L(M)
timeM (x) ≤ T (|x|) ist.
◮
Für eine NTM M auf Eingabe x definieren wir:
timeM (x) :=
max timeM (x)
x∈ΣnE
maximale Anzahl der Schritte in jeder
Berechnung CM (x)
maximale Anzahl der besuchten Speicherzellen
in jeder Berechnung CM (x) .
◮
schwach S-platzbeschränkt, falls für alle x ∈ L(M)
spaceM (x) ≤ S(|x|) ist.
53
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
54
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Definition 6 (Teil 5) Sei Mk die Menge der k-Band TMs ohne
separates Ein- und Ausgabeband.
◮
Definition 6 (Teil 4) Sind T und S Mengen von Funktionen, so nennen
wir eine TM M
◮ (schwach) T -zeitbeschränkt, falls ein T ∈ T existiert, so dass M
(schwach) T -zeitbeschränkt ist und
◮ S-platzbeschränkt, falls ein S ∈ S existiert, so dass M (schwach)
S-platzbeschränkt ist.
Für die Teilmenge der Akzeptoren in Mk mit k ∈ N definieren wir
DTimek (T ) := { L ⊆ Σ∗ | es existiert eine T -zeitb. DTM
M in Mk mit L(M) = L }
DSpacek (S) := { L ⊆ Σ∗ | es existiert eine S-platzb. DTM
M in Mk mit L(M) = L }
DTimeSpacek (T , S) := { L ⊆ Σ∗ | es existiert eine T -zeitb. und
S-platzb. DTM M in Mk mit
L(M) = L }
55
56
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Definition 6 (Teil 6)
◮
Für die Teilmenge der DTMs M in Mk mit k ∈ N, die eine Funktion
ϕ : Σ∗ → Σ∗ berechnen, definieren wir
FDTimek (T ) :=
FDSpacek (S) :=
FDTimeSpacek (T , S) :=
Definition 6 (Teil 7)
◮ In vielen Fällen (und auch Dank des Bandreduktionssatzes)
interessieren wir uns nicht für die Anzahl der Bänder. Wir definieren
daher
[
DTimek (T )
DTime(T ) :=
{ ϕ : Σ∗ → Σ∗ | es existiert eine T -zeitb.
DTM M in Mk mit ϕM = ϕ }
{ ϕ : Σ∗ → Σ∗ | es existiert eine S-platzb.
DTM M in Mk mit ϕM = ϕ }
k∈N
als die Menge von Sprachen, die wir von einer T -zeitbeschränkten
DTM mit konstanter Anzahl von Bändern akzeptieren können.
Analog definieren wir auch die Varianten der anderen
Komplexitätsklassen.
{ ϕ : Σ∗ → Σ∗ |es existiert eine T -zeitb. und
S-platzb. DTM M in Mk mit ϕM = ϕ }
Für NTMs definieren wir analog die Komplexitätsklassen NTimek (T ),
NSpacek (S), NTimeSpacek (T , S) sowie die entsprechenden
Komplexitätsklassen für Funktionen FNTimek (T ), FNSpacek (S),
FNTimeSpacek (T , S).
57
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Definition 6 (Teil 8)
◮ Mit Mk+E bezeichnen wir die Menge der k-Band TMs mit
separatem zweiweg Ein- aber ohne Ausgabeband und mit Mk+E +O
die Menge der k-Band TMs mit separatem zweiweg Ein- und
Ausgabeband. Wollen wir uns auf ein einweg Eingabeband
~.
beschränken, so ersetzen wir E durch E
◮ Analog zu den bisher definierten Komplexitätsklassen können wir
nun auch die entsprechenden Varianten für TMs mit Eingabe- bzw.
Ausgabeband definieren. Wir ersetzen in diesen Fällen in den
~ oder k + E
~ + O. Wir
Definitionen k durch k + E , k + E + O, k + E
müssen hierbei noch beachten, dass eine solche Ersetzung oft auch
mit einer Änderung des Eingabe- bzw. Ausgabealphabets verbunden
ist. Wir müssen daher in den Definitionen noch an einigen Stellen Σ
gegen ΣE bzw. gegen ΣA ersetzen.
58
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Definition 6 (Teil 9)
◮
Von zentralem Interesse sind oft nicht nur die Komplexitätsklassen,
die wir durch eine einzelne Funktion T oder S erhalten, sondern die
wir durch Funktionsmengen erhalten. Für eine Menge T von
Funktionen definieren wir daher:
DTimek (T ) = { L ⊆ Σ∗ | es existiert ein T ∈ T und eine
T -zeitb. DTM M in Mk mit
L(M) = L }
◮
59
Analog erweitern wir auch die anderen Komplexitätsklassen auf
Funktionenmengen.
60
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Sei N die Funktion, die die Eingabelänge angibt, dann sind die
folgenden Funktionenklassen von besonderer Bedeutung:
CON
Log
Lin
Pol
◮
= O(1)
= Θ(log(N ))
= S
Θ(N )
c
=
c∈N O(N )
3.1 Basistypen von Reduktionen
Ein wesentliches Hilfsmittel um Probleme miteinander vergleichen zu
können stellt die Reduktion dar:
(konstant)
(logarithmisch)
(linear)
(polynomial).
Definition 7 [Many-One-Reduktion]
◮
Die bekanntesten Komplexitätsklassen sind:
L
NL
P
NP
PSPACE
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
3 Reduzierbarkeit
Definition 6 (Teil 10) Ein kleiner Vorgriff:
◮
Andreas Jakoby
Universität zu Lübeck
:=
:=
:=
:=
DSpace(Log)
NSpace(Log)
DTime(Pol)
NTime(Pol)
:=
DSpace(Pol)
Seien L1 ⊆ Σ∗1 und L2 ⊆ Σ∗2 zwei Sprachen. Wir nennen L1
many-one-reduzierbar auf L2 , wenn es eine 1-stellige (totale)
rekursive Funktion f : Σ∗1 → Σ∗2 gibt, so dass
∀w ∈ Σ∗1 :
(w ∈ L1 ⇐⇒ f (w ) ∈ L2 )
gilt. Wir sagen dann auch, dass L1 auf L2 (via f ) m-reduzierbar ist
und schreiben kurz L1 ≤m L2 .
An Stelle von Σ∗1 und Σ∗2 können wir natürlich auch die Menge N
wählen.
61
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
62
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Eine Verallgemeinerung der Many-One-Reduktion erhalten wir über die so
genannte Turing-Reduktion:
Illustration der Many-One-Reduktion:
Σ∗1 :
Definition 8 [Turing-Reduktion]
◮ Seien L1 ⊆ Σ∗ und L2 ⊆ Σ∗ zwei Sprachen. Wir nennen L1
1
2
Turing-reduzierbar auf L2 (kurz L1 ≤T L2 ), wenn es eine DTM M1
gibt, die auf die charakteristischen Funktion von L2 (ähnlich wie auf
ein Unterprogramm) zurückgreifen kann, und die die
charakteristischen Funktion von L1 berechnet.
Σ∗2 :
L2
L1
◮
f
L1
L2
◮
◮
63
Wir nehmen hierbei an, dass das Unterprogramm für χL2 zur
Verfügung steht – unabhängig davon, ob L2 entscheidbar, nur
rekursiv aufzählbar oder nicht rekursiv aufzählbar ist.
Die Anfrage u ∈ L2 ? können wir somit als eine Art Orakelbefragung
verstehen. Daher auch der in der Literatur für M1 gebräuchliche
Ausdruck der Orakel Turing-Maschine.
Die Turing-Reduktion wie auch die Many-One-Reduktion können
naheliegend auch auf Funktion übertragen werden.
64
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
Die Reduktionen stellen ein sehr mächtiges Hilfsmittel dar, um die Frage
der Entscheidbarkeit zu entscheiden. Es gilt:
Im Zentrum unserer folgenden Untersuchungen steht die Frage: Wie
können wir zeigen, dass ein Problem nicht in einer vorgegebenen
Komplexitätsklasse liegt?
1. Ist L2 entscheidbar, dann ist auch L1 entscheidbar.
2. Ist L2 rekursiv aufzählbar, dann ist auch L1 rekursiv aufzählbar.
Satz 4 Seien L1 , L2 zwei Sprachen und L1 ≤T L2 , dann gilt:
1. Ist L2 entscheidbar, dann ist auch L1 entscheidbar.
◮
Korollar 1 Seien L1 , L2 zwei Sprachen, dann gilt:
◮
Wir versuchen es mit einer Diagonalisierung und einem
Widerspruchsbeweis.
Wie können wir verfahren, wenn wir keinen solchen Beweis finden?
◮ Wir versuchen das Problem mit anderen bekannten schwierigen
Problemen zu vergleichen.
Es folgt unmittelbar:
◮
Computational Complexity SS 08
1. Vorlesung, 07.04.2008
3.2 Einschränkungen von Reduktionen
Satz 3 Seien L1 , L2 zwei Sprachen und L1 ≤m L2 , dann gilt:
◮
Andreas Jakoby
Universität zu Lübeck
Ist L1 ≤m L2 und L1 nicht entscheidbar, dann ist auch L2 nicht
entscheidbar.
Ist L1 ≤T L2 und L1 nicht entscheidbar, dann ist auch L2 nicht
entscheidbar.
Ist L1 ≤m L2 und L1 nicht rekursiv aufzählbar, dann ist auch L2
nicht rekursiv aufzählbar.
◮
Wir versuchen ein bekanntes schwieriges Problem mit Hilfe der
Lösung unseres Problems zu lösen, indem wir einen Algorithmus
entwerfen, der auf die Lösungen zu unserem Problem zurückgreifen
kann. Hierbei darf der entworfene Algorithmus nicht an sich schon
zuviel Ressourcen benötigen.
65
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
Für eine Relation ∼⊆ U × U sei ∼∗ ⊆ U × U der reflexiv-transitive
Abschluß dieser Relation, d.h. für alle u, v ∈ U mit u 6= v gilt
(u, v ) ∈∼∗
⇐⇒
∃w1 , . . . , wn ∈ U : (u, w1 ), (w1 , w2 ), . . . ,
(wn−1 , wn ), (wn , v ) ∈∼ .
Zudem ist (v , v ) ∈∼∗ für alle v ∈ U.
◮
◮
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
Zurück zu den Reduktionen:
◮ Die Reduktionsrelationen ≤m und ≤T sind Beispiele für Relationen,
wie sie in der Definition 9 betrachtet wurden. Hierbei ist da
Universum U die Menge aller Sprachen über endlichen Alphabeten
Σ.
◮ Wollen wir eine Komplexitätsklasse C mit Hilfe einer Reduktion
untersuchen, so beschränken wir uns im Allgemeinen auf
Reduktionen ≤, die nicht zu mächtig sind, d.h. wir fordern in den
meisten Fällen
C = Γ≤ (C) .
Bevor wir uns näher mit der Suche nach sinnvollen Reduktionen
beschäftigen wollen wir noch einige hilfreiche Notationen einführen:
Definition 9 Sei U ein Universum. Wir definieren
◮
66
◮
Anstelle von (u, v ) ∈∼ und (u, v ) ∈∼∗ schreiben wir auch u ∼ v
und u ∼∗ v .
Für eine Teilmenge V ⊆ U sei
Zudem schränken wir die Reduktionen soweit ein, dass wir nicht mit
Hilfe der Reduktion ≤ alle Probleme aus einer Komplexitätsklasse C
lösen können, d.h. wir fordern für C ′ = {{0}}
Γ≤ (C ′ ) ⊂ C .
Γ∼ (V ) := { u ∈ U | ∃v ∈ V : u ∼∗ v } .
◮
Beobachtung 1 Ist eine Relation ∼ reflexiv und transitiv, so gilt ∼=∼∗ .
Wollen wir zwei Komplexitätsklasse C, C ′ mit Hilfe einer Reduktion
≤ miteinander vergleichen, so fordern wir
C′ ⊂ C
67
=⇒
Γ≤ (C ′ ) ⊂ C .
68
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
Wir wollen nun auf drei besondere Formen der Many-One-Reduktion
eingehen:
Definition 10 [Polynomialzeit-Reduktion]
Beobachtung 2 Sei L0 = {0} und U ein Universum mit 0 ∈ U und
|U| ≥ 2, dann gilt
◮
P, N P, PSPACE ⊂ Γ≤m ({{0}}) und
P, N P, PSPACE ⊂ Γ≤T ({{0}}).
Somit sind die allgemeine Many-One-Reduktion die allgemeine
Turing-Reduktion nicht geeignet um die für uns interessanten
Komplexitätsklassen zu untersuchen.
◮
◮
Seien L1 ⊆ Σ∗1 und L2 ⊆ Σ∗2 zwei Sprachen. Wir nennen L1
polynomialzeit-reduzierbar auf L2 , kurz L1 ≤pol L2 , falls es eine in
polynomieller Zeit deterministisch berechenbare Funktion
f : Σ∗1 → Σ∗2 gibt, so dass
∀w ∈ Σ∗1 :
◮
(w ∈ L1 ⇐⇒ f (w ) ∈ L2 )
gilt.
L1 und L2 heißen äquivalent bezüglich der Reduktionsrelation ≤pol ,
kurz ≡pol , wenn L1 ≤pol L2 und L2 ≤pol L1 gilt.
69
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
Illustration der Polynomialzeit-Reduktion:
L2
L1
f
L2
L1
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
Warum diese Einschränkung der Reduktion?
◮ Ohne eine solche Einschränkung der Reduktionsfunktion f auf
Funktionen, die in polynomieller Zeit berechnet werden können,
könnten wir mit der Funktion f schon das zu reduzierende Problem
lösen, dann könnten wir jede entscheidbare Sprache auf die triviale
Sprache {1} reduzieren.
◮ Im Allgemeinen wird angenommen, dass P =
6 N P ist, d.h.,
deterministische polynomielle Zeit genügt nicht um alle Probleme
aus N P zu lösen. Vergleichen wir also ein besonders schweres
Problem aus N P mit einem neuen Problem, so stellte die
Polynomialzeit-Reduktion eine adäquate Reduktion dar.
Σ∗2 :
Σ∗1 :
70
f ist in polynomialer
Zeit berechenbar
71
72
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
Definition 11 [Logspace-Reduktion]
Seien L1 ⊆ Σ∗1 und L2 ⊆ Σ∗2 zwei Sprachen. Wir nennen L1
logspace-reduzierbar auf L2 , kurz L1 ≤log L2 , falls es eine auf
logarithmischem Platz deterministisch berechenbare Funktion
f : Σ∗1 → Σ∗2 gibt, so dass
∀w ∈ Σ∗1 :
◮
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
Lemma 1 L1 ≤log L2 impliziert L1 ≤pol L2 .
Beweis von Lemma 1: Da jede logarithmisch-platzbeschränkte DTM,
die auf jede Eingabe hält, nur polynomiell viele unterschiedliche
Konfigurationen annehmen kann (ohne in eine Endlosschleife zu geraten),
muss diese DTM auch polynomiell-zeitbeschränkt sein.
Satz 5 ≤log und ≤pol sind transitiv.
Beweis von Satz 5: Die Transitivität bedeutet, dass für beliebige
Sprachen L1 , L2 , L3
Wollen wir Probleme aus P oder einer noch weiter eingeschränkten
Komplexitätsklasse miteinander vergleichen, so müssen wir auch die
Berechnungskapazität der Reduktionsfunktion weiter einschränken:
◮
Andreas Jakoby
Universität zu Lübeck
L1 ≤log L2
L1 ≤pol L2
(w ∈ L1 ⇐⇒ f (w ) ∈ L2 )
und L2 ≤log L3
und L2 ≤pol L3
=⇒
=⇒
L1 ≤log L3
L1 ≤pol L3
bzw.
gilt. Ist f1 eine Reduktion von L1 auf L2 und f2 eine Reduktion von L2 auf
L3 , dann ist f2 ◦ f1 eine Reduktion von L1 auf L3 , es gilt
gilt.
L1 und L2 heißen äquivalent bezüglich der Reduktionsrelation ≤log ,
kurz ≡log , wenn L1 ≤log L2 und L2 ≤log L1 gilt.
∀w ∈ Σ∗1 :
(w ∈ L1 ⇐⇒ f1 (w ) ∈ L2 ⇐⇒ f2 (f1 (w )) ∈ L3 ) .
Wir müssen noch zeigen, dass f2 ◦ f1 in den geforderten Schranken
berechnet werden kann.
73
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
◮
◮
◮
◮
in Zeit T1 (|w |) das Ergebnis f1 (w ) und dann
in Zeit T2 (|f1 (w )|) das Ergebnis f2 (f1 (w )).
Da |f1 (w )| maximal T1 (|w |) ist, ist die Laufzeit der
Hintereinanderschaltung O(T1 + T2 ◦ T1 ) = Pol.
◮
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
Beweis von Satz 5 (Teil 3): Wie können wir das Problem der
Platzschranke bei der Berechnung von f1 (w ) in den Griff bekommen?
Beweis von Satz 5 (Teil 2): Sei Mi eine logarithmisch-platzbeschränkte
bzw. polynomiell-zeitbeschränkte DTM, die fi berechnet. Die
Hintereinanderschaltung von M1 und M2 berechnet die Komposition
beider Funktionen.
◮ Im Fall der ≤pol -Reduktion sei das Polynom Ti die Zeitschranke für
Mi , dann berechnet die Hintereinanderschaltung von M1 und M2
◮
74
Bei einer Platzschranke unterhalb der Länge der Ausgabe,
betrachten wir TMs mit separatem Write-Only-Ausgabeband.
Die Ausgabe bei einer solchen TM M steht auf den
Ausgabepositionen 1 bis |fM (w )| auf dem Ausgabeband — fM sei die
von M berechnete Funktion.
Für ein gegebenes i ∈ [1..|fM (w )|] können wir M auch ohne
Ausgabeband simulieren, wenn wir log2 (|fM (w )|)/c Platz zur
Verfügung haben (c ∈ N konstant) und nur die i-te Position der
Ausgabe bestimmen wollen:
◮
Im Fall der ≤log -Reduktion ist der Beweis aufwendiger, da die
Ausgabe von M1 im Allgemeinen die Platzschranke überschreiten
wird.
◮
◮
75
Simuliere die Berechnung von M ohne auf das Ausgabeband zu
schreiben.
Wenn sich der Kopf auf dem Ausgabeband bewegt, dann simuliere
diese Kopfbewegung durch das Erhöhen bzw. Verkleinern eines
Zählers z, der die Kopfposition von M auf dem Ausgabeband angibt.
Ist z = i, dann merke das Symbol, welches M auf das Ausgabeband
schreiben will.
76
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
◮
◮
◮
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
Beweis von Satz 5 (Teil 5):
◮ Die Hintereinanderschaltung von M1 und M2 arbeitet wie folgt:
Beweis von Satz 5 (Teil 4): Jetzt können wir die
Hintereinanderschaltung von M1 und M2 betrachten:
◮
Andreas Jakoby
Universität zu Lübeck
◮
Da M1 logarithmisch-platzbeschränkt ist, ist diese DTM auch
polynomiell-zeitbeschränkt.
Die Länge der Ausgabe von M1 ist somit polynomiell in der
Eingabelänge n.
Es gilt ⌈log2 |f1 (w )|⌉ = O(log2 |w |). Wir haben somit den benötigten
Platz für den Zähler z aus der Simulation von Folie 76 zur
Verfügung.
◮
◮
◮
Beachte, dass wir uns auf 1-Band DTMs beschränken können, die
über separate Ein- und Ausgabebänder verfügen.
Für die Platzschranke der Hintereinanderschaltung gilt:
◮
◮
◮
◮
Wir teilen das Arbeitsband in drei Spuren. Auf der ersten Spur
simulieren wir M2 , auf der zweiten Spur bestimmen wir mit Hilfe
eines Zählers welche (Eingabe-)Position i M2 von f1 (w ) zur Zeit
lesen möchte und auf Spur 3 simulieren wir M1 auf w für die
Ausgabeposition i (Folie 76).
Wenn M2 eine Position i aus f1 (w ) lesen möchte, starten wir die
Simulation von M1 auf w für die Ausgabeposition i und lassen die
Berechnung von M2 so lange pausieren.
Nach Abschluß der Simulation von M1 können wir mit der
Berechnung von M2 fortfahren.
Die Simulation von M1 benötigt Platz O(log2 (|w |) + log2 (|f1 (w )|)).
Für den Zähler benötigen wir Platz O(log2 (|f1 (w )|)).
Die Simulation von M2 benötigt Platz O(log2 (|f1 (w )|)).
Es gilt O(log2 (|w |) + log2 (|f1 (w )|)) = O(log2 |w |).
77
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
78
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
Lemma 2 Die Relation L1 ≤pol L2 hat die folgenden Implikationen:
L2 ∈ P
L2 ∈ N P
L2 ∈ PSPACE
Noch aufwendiger wird unser Unterfangen eine adäquate Reduktion zu
finden, wenn wir uns für Komplexitätsklassen unterhalb von P oder noch
unterhalb von L interessieren.
Betrachten wir zum Beispiel eine Boolesche Funktion
f : {0, 1}n → {0, 1}m , so stellt ich uns zunächst das Problem, dass diese
Funktion nur auf Eingaben der Länge n definiert ist. Wir definieren
zunächst:
Definition 12 [Familien Boolescher Funktionen] Eine Familie
F = f1 , f2 , . . . von Booleschen Funktionen fi : {0, 1}i → {0, 1}mi
spezifiziert für jedes i ∈ N \ {0} eine solche Funktion fi . Analog
definieren wir eine Familie F = f1 , f2 , . . . von Funktionen fi : Ui → Ui′ ,
wobei der Definitionsbereich und der Wertebereich der Funktion fi von i
abhängt (und nicht die Kardinalität i haben muss).
=⇒ L1 ∈ P,
=⇒ L1 ∈ N P,
=⇒ L1 ∈ PSPACE.
Ferner gilt für k ≥ 1 und L1 ≤log L2
L2 ∈ DSpace(Logk )
L2 ∈ NSpace(Logk )
=⇒
=⇒
L1 ∈ DSpace(Logk ),
L1 ∈ NSpace(Logk ).
Beweis von Lemma 2: Der Beweis verläuft analog zum Beweis von Satz
5, nur dass wir jetzt an Stelle der DTM M2 für f2 eine DTM M2 zur
Lösung von L2 betrachten, diese DTM berechnet dann die Funktion χL2
und die Hintereinanderschaltung der TMs berechnet χL2 ◦ f . Beachte,
dass die Platz- und Zeitschranken bei dieser Hintereinanderschaltung in
den meisten Fällen von M2 bestimmt wird.
79
80
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
Definition 13 [Projektive-Reduktion]
◮ Seien F = f1 , f2 , . . . und G = g1 , g2 , . . . zwei Familien von
Booleschen Funktionen fi : {0, 1}i → {0, 1}mi und
′
gi : {0, 1}i → {0, 1}mi . Wir nennen F projektiv-reduzierbar auf G ,
kurz F ≤proj G , falls es ein Polynom p und eine Familie
Π = π1 , π2 , . . . mit
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
Mit Hilfe der Projektive-Reduktion können wir nur sehr wenige Probleme
direkt lösen oder auf die einfache Sprache L0 = {0} bzw. auf deren
charakteristische Funktion
0 für w ∈ {0, 1}∗ \ {0}
χL0 (w ) =
1 für w = 0
πi : {y1 , . . . , yp(i) } −→ {x1 , x 1 , . . . , xi , x i , 0, 1}
von einstelligen Projektionsfunktionen gibt, so dass
fi (x1 , . . . , xi ) = gp(n) (πi (y1 ), . . . , πi (yp(n) ))
reduzieren. Um dieses einzusehen transformieren wir χL0 zunächst in die
benötigte Darstellung als Familie Boolescher Funktionen χL0 = χ1 , χ2 , . . .:
0 für w = 1
χ1 (w ) =
und ∀i > 1 : χi ≡ 0 .
1 für w = 0
ist, und eine linear zeitbeschränkte DTM existiert, die auf Eingabe
von (i, j) den Wert πi (yj ) berechnet.
◮ F und G heißen äquivalent bezüglich der Reduktionsrelation ≤proj ,
kurz ≡proj , wenn F ≤proj G und G ≤proj F gilt.
Die Projektive-Reduktion stellt eine sehr einfache Form einer
Many-One-Reduktion dar, bei der wir unabhängig von der konkreten
Eingabe nur die einzelnen Bits einer Eingabe vertauschen und duplizieren
können. Zudem können wir einige Bits der neuen Eingabe auf konstante
Werte setzen.
81
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
82
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
Beweis von Beobachtung 3 Der Beweis erfolgt über einen
Widerspruch. Angenommen es gäbe eine solche Reduktion, dann müßte
p(n) = 1 sein und aufgrund von
Beobachtung 3 Sei nun F = f1 , f2 , . . . eine beliebige Familie Boolescher
Funktionen, so dass für zumindest eine Eingabelänge n > 1 eine Eingabe
x1 , . . . , xn ∈ {0, 1} und zwei Eingabepositionen i 6= j existieren, so dass
fn (x1 , . . . , xn ) 6= fn (x1 , . . . , xi−1 , x i , xi+1 , . . . , xn )
fn (x1 , . . . , xn ) 6= fn (x1 , . . . , xi−1 , x i , xi+1 , . . . , xn )
müssen wir
πn (y1 ) = xi
und
oder πn (y1 ) = x i
wählen. Da jedoch
fn (x1 , . . . , xi−1 , x i , xi+1 , . . . , xn ) = fn (x1 , . . . , xj−1 , x j , xj+1 , . . . , xn ),
fn (x1 , . . . , xn ) 6= fn (x1 , . . . , xj−1 , x j , xj+1 , . . . , xn )
dann gilt
F
6≤proj
gilt müssen wir auch
χL0 .
πn (y1 ) = xj
oder πn (y1 ) = x j
setzen. Beides ist jedoch nicht gleichzeitig möglich – ein Widerspruch. 83
84
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
Sei mult die Familie der Booleschen Funktionen, die Multiplikation
zweier Binärzahlen realisieren.
Da schon so einfache Boolesche Funktionen wie das or oder das xor die
Bedingungen aus der Beobachtung 3 erfüllen, erhalten wir:
Wir wollen zeigen, dass xor projektiv auf mult reduziert werden
kann.
◮ Da xori nur ein Bit als Ausgabe liefert, müssen wir mult noch
adäquat modifizieren. Wir gehen davon aus, dass die Eingabe von
multi aus drei Teilen besteht: die beiden Faktoren y und z sowie die
Position des Ergebnisbits im Produkt y · z für das wir uns
interessieren.
Satz 6 xor ≤proj mult.
◮
Korollar 2 Sei or = or1 , or2 , . . . und ori das Oder über i Bits, dann ist
or nicht projektiv auf χL0 reduzierbar.
Korollar 3 Sei xor = xor1 , xor2 , . . . und xori die Paritätsfunktion über i
Bits, dann ist xor nicht projektiv auf χL0 reduzierbar.
85
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
Beweis von Satz 6 Sei x1 , . . . , xi die Eingabe von xori , dann wählen wir
y , z als Binärzahlen der Länge i log i, wobei wir mit log i die Länge der
Binärdarstellung von i bezeichnen. Wir wählen
y =
i
X
j=1
xj · 2(j−1)·log i
und z =
i
X
w =
j=1
wobei
2(j−1)·log i .
Definition 14 [Boolesche Schaltkreise] Ein Boolescher Schaltkreis C
mit n Eingaben x1 , . . . , xn und m Ausgaben y1 , . . . , ym ist ein endlicher
gerichteter azyklischer Graph mit m Senken. Jeder Knoten v im Graph ist
mit einer Funktion σ markiert, hierbei gilt:
1. Ist der Eingrad von v gleich 0, so ist σ(v ) ∈ {x1 , . . . , xn , 0, 1}.
2. Ist der Ausgrad von v gleich 0, so ist σ(v ) ∈ {y1 , . . . , ym }. Der
Einfachheit halber nehmen wir an, dass alle Senken einen Eingrad
von 1 haben.
3. Ist der Eingrad d + (v ) ≥ 1 und der Ausgrad d − (v ) ≥ 1, so ist σ(v )
+
eine Funktion von {0, 1}d (v ) nach {0, 1}.
Die Knoten nennen wir auch Gatter. Der Einfachheit halber identifizieren
wir die Eingabe- und Ausgabegatter v mit den entsprechenden Werten
σ(v ).
(j−1)·log i
wj · 2
k=j−i+1 xk
für j ≤ i
für j > i
Pi
ist. Somit ist wi = k=1 xk und das niederwertigste Bit von wi ist das
Ergebnis der Paritätsfunktion auf Eingabe x1 , . . . , xi .
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
4.1 Das Schaltkreismodell
j=1
( P
j
xk
Pk=1
wj =
j
Andreas Jakoby
Universität zu Lübeck
4 Schaltkreiskomplexität
Es ist einfach zu erkennen, dass wir die beiden Binärzahlen y und z
einfach mit Hilfe einer Projektiven-Reduktion bestimmen können.
Für das Produkt w = y · z gilt
2i−1
X
86
87
88
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
Definition 14 (Teil 2) Über die Funktion σ(v ) können wir bei einer
gegebenen Eingabe x jedem Gatter C einen Wert Valv (x) zuordnen. Es
gilt:
1. Ist σ(v ) ∈ {x1 , . . . , xn , 0, 1}, so weisen wir Valv (x) den
entsprechenden Wert aus x bzw. den Wert der Konstante aus {0, 1}
zu.
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
Die in einem Schaltkreis benutzten Funktionen σ schränken wir im
Allgemeinen durch die Wahl einer Basis ein. Beschränken wir uns auf die
binären Operationen {∧, ∨} und auf die unäre Operation ¬, so nennen
wir diese Basis auch Standardbasis.
Um die Komplexität eines Schaltkreises zu messen, benutzen wir die
Maße
◮ Tiefe depth(C ) als die Länge des längsten Quellen-Senken Pfads,
und
2. Ist σ(v ) ∈ {y1 , . . . , ym }, so weisen wir Valv (x) den Wert des
Vorgängergatters zu.
3. In den verbleibenden Fällen berechnen wir Valv (x), indem wir die
Funktion σ(v ) auf Eingabe der Werte der Vorgängerknoten
auswerten.
Die durch den Schaltkreis C berechnete Funktion fC ergibt sich durch
Größe size(C ) als die Anzahl der (internen) Gatter in C .
Die Tiefe entspricht der parallelen Zeit einer Berechnung und die Größe
der parallelen Arbeit.
Beobachtung 4 Im Gegensatz zu dem Modell der Turing-Maschine
können Schaltkreise nur Berechnungen auf einer festen Eingabelänge
durchführen.
◮
fC (x) = ValC (x) = (Valy1 (x), Valy2 (x), . . . , Valym (x)) .
89
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
Definition 15 Eine Boolesche Schaltkreisfamilie C = (Ci )i∈N ist eine
unendliche Sequenz von Booleschen Schaltkreisen Ci , wobei Ci eine
Funktion von i Eingabewerten auf m(i) Ausgabewerten ist, d.h.
fCi : {0, 1}i → {0, 1}m(i) .
Die durch die Schaltkreisfamilie berechnete Funktion fC ergibt sich über
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
Definition 16 Eine Schaltkreisfamilie C = (Ci )i∈N nennen wir
fC (x) = fC|x| (x) .
◮
uniformen, wenn eine Turing-Maschine existiert, die auf Eingabe von
1n den Schaltkreis Cn generiert.
◮
nicht-uniform, wenn eine solche Turing-Maschine nicht existiert.
log-platzkonstruierbar, wenn eine log-platzbeschränkt
Turing-Maschine existiert, die auf Eingabe von 1n den Schaltkreis Cn
generiert.
◮
Die Komplexität einer Schaltkreisfamilie definieren über
depthC (n) = depth(Cn )
90
und sizeC (n) = size(Cn ) .
91
92
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
Definition 17 Für k ∈ N bezeichnet N C k die Menge aller Booleschen
Sprachen, d.h. Funktionen f : {0, 1}∗ → {0, 1}, die durch eine
log-platzkonstruierbare Schaltkreisfamilie C über der Standardbasis
akzeptiert werden kann. Hierbei gilt, dass depthC (n) ∈ O(logk (n)) und
sizeC (n) polynomiell sind.
Die Klasse N C, auch Nicks-Klasse genannt, ist
[
NC =
N Ck .
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
2. Vorlesung, 14.04.2008
Definition 18 Für k ∈ N bezeichnet AC k die Menge aller Booleschen
Sprachen, d.h. Funktionen f : {0, 1}∗ → {0, 1}, die durch
log-platzkonstruierbare Schaltkreisfamilien C über der Basis
{and, or, not} akzeptiert werden können, wobei wir den Eingrad der
and- und or-Gatter nicht beschränken. Ferner gelte, dass
depthC (n) ∈ O(logk (n)) und sizeC (n) polynomiell sind.
Die Klasse AC ist
[
AC =
AC k .
k∈N
k∈N
Die Klasse N C wird auch als die Klasse aller effizient parallel
entscheidbarer Sprachen angesehen. Aufgrund der Größenbeschränkung
können wir folgern:
Beobachtung 5 N C ⊆ P.
Beobachtung 6 Für alle i ∈ N gilt N C i ⊆ AC i ⊆ N C i+1 .
Und somit folgt aus Beobachtung 5:
Beobachtung 7 AC ⊆ P.
93
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
4.2 Grenzen Effizienter Schaltkreise
◮
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
Analog zur Normalform einer Booleschen Formel können wir auch eine
Normalform für Schaltkreise definieren:
Definition 20 Wir sagen, dass ein Schaltkreis in Normalform ist, wenn
◮ Negationen finden nur auf den Eingaben stattfinden, d.h. wenn wir
sowohl die negierten als auch die nicht-negierten Variable als
Eingabe zur Verfügung haben, dann existieren keine not-Gatter.
◮ Interne Gatter sind entweder or- oder and-Gatter.
◮ Auf jedem Pfade von einem Eingabegatter zum Ausgabegatter
alterniert die Gatter-Funktion von Gatter zu Gatter.
Definition 19 Sei F eine Boolesche Formel.
◮ Ein Literal ist eine Variable oder deren Negation.
◮ Eine Klausel ist eine Disjunktion, d.h. eine or-Verknüpfung, von
Literalen.
◮ Eine Monom ist eine Konjunktion, d.h. eine and-Verknüpfung, von
Literalen.
◮
94
F ist in konjunktiver Normalform, wenn F eine Konjunktion von
Klauseln ist.
F ist in disjunktiver Normalform, wenn F eine Disjunktion von
Monomen ist.
◮
95
Alle Pfade von einem Eingabegatter zum Ausgabegatter haben die
gleiche Länge.
96
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
◮
◮
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
Beweis von Lemma 3 (Teil 2):
Lemma 3 Für jeden Schaltkreis C auf n Variablen existiert ein funktionsäquivalenter Schaltkreis C ′ in Normalform mit depth(C ) ≥ depth(C ′ ) und
2 · size(C ) · (2 · depth(C ) + 1) + n ≥ size(C ′ ).
Beweis von Lemma 3:
◮
Andreas Jakoby
Universität zu Lübeck
◮
Mit Hilfe der Regeln von De Morgan können wir alle not-Gatter zu
den Eingabegattern schieben.
◮
Diese Aktion vergrößert nicht die Tiefe des Schaltkreises. Die Größe
wird um maximal size(C ) + n vergrößert, da im ungünstigsten Fall
nun jedes Gatter im Originalzustand und negiert vorkommt.
Der resultierende Schaltkreis erfüllt die erste zwei Bedingungen eines
Schaltkreises in Normalform.
◮
◮
Gibt es auf einem Pfad zwei Gatter die aufeinander folgen, und die
vom gleichen Gattertyp sind, wo vereinigen wir diese. Unter
Umständen muss jedoch eine Kopie des ersten Gatters erstellt
werden.
Der resultierende Schaltkreis erfüllt die dritte Bedingung eines
Schaltkreises in Normalform.
Durch diesen Schritt wird weder die Größe noch die Tiefe des
Schaltkreises erhöht.
Im letzten Schritt ergänzen wir zu kurze Pfade an den richtigen
Stellen mit and- und or-Gattern von Eingrad 1.
97
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
Mit Hilfe der konjunktiven bzw. disjunktiven Normalform können wir für
jede Funktion einen Schaltkreis der Tiefe 2 (mit Negationen 3) angeben,
der diese Funktion berechnet. Ein solcher Schaltkreis hat jedoch oft
exponentielle Größe.
Satz 7 Die Paritätsfunktion kann nicht durch einen zweistufigen and-oroder or-and-Schaltkreis polynomieller Größe berechnet werden. Zudem
müssen bei einem zweistufigen Schaltkreis zur Berechnung der Paritätsfunktion
in der ersten Ebene immer alle n Variablen miteinander verknüpft werden.
Vℓ
Beweis von Satz 7: Sei C eine Konjunktion i=1 Di von Disjunktionen
welche die Paritätsfunktion berechnet. Wir betrachten zunächst die Frage,
ob eine der Disjunktionen von C weniger als n Variablen beinhalten darf.
◮ Sei Di eine solche Disjunktion und xj eine der Variablen, welche in
Di nicht vorkommen.
◮ Dann gibt es eine Belegung der verbleibenden Variablen (alle bis auf
xj ), so dass Di nicht erfüllt ist und somit auch C , ohne dass wir den
Wert von xj festlegen müssen.
◮ C ist somit nicht erfüllt für die obige Belegung mit xj = 0 und
xj = 1. Die Paritätsfunktion ist jedoch für eine der Belegungen 0
und für die andere 1.
99
98
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
Beweis von Satz 7 (Teil 2):
◮
◮
◮
Jede Disjunktion muß alle n Variablen beinhalten.
Eine Disjunktion über n Variablen ist jedoch nur bei genau einer
Belegung erfüllt.
Die Paritätsfunktion über n Variablen weist jedoch 2n−1 erfüllende
Belegungen auf.
Somit muß ein zweistufiger or-and-Schaltkreis der die
Paritätsfunktion berechnet eine Größe ≥ 2n−1 + 1 haben.
Wℓ
Analog können wir eine Disjunktion i=1 Ki von Konjunktionen
analysieren.
◮
100
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
Beobachtung 8 Sei C ein Schaltkreis, der die Paritätsfunktion
berechnet. Dann können wir mit C auch die negierte Paritätsfunktion
berechnen, indem wir eine der Eingabevariablen bei jedem vorkommen in
C negieren (ursprünglich negierte Literale kommen dann unnegiert vor
und alle ursprünglich unnegierte dann negiert). Analog können wir jeden
Schaltkreis zur Berechnung der negierten Paritätsfunktion nutzen, um die
Paritätsfunktion zu berechnen.
Beweis von Beobachtung 8:
x1 ⊕ x2 ⊕ · · · ⊕ xn
=
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
Beobachtung 9 Sei C ein Schaltkreis, der die Paritätsfunktion
berechnet. Wählen wir einige der Eingabevariablen xi fest auf 0 und
einige auf 1 und einige weiter variabel, so berechnet C auf den
verbleibenden Variablen immer noch die Paritätsfunktion bzw. deren
Negation. Ist C ein Schaltkreis über der Standardbasis, so können wir
durch die oben beschriebene Vorbelegung einige Gatter streichen, da ihr
Wert bereits durch diese Belegung fest bestimmt ist. Der resultierende
Schaltkreis hat entsprechend weniger Variablen jedoch ist dessen Größe
und Tiefe durch die Größe und Tiefe von C nach oben beschränkt.
1 ⊕ (x1 ⊕ x2 ⊕ · · · ⊕ xn )
= (1 ⊕ x1 ) ⊕ x2 ⊕ · · · ⊕ xn
= x 1 ⊕ x2 ⊕ · · · ⊕ x n .
101
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
Satz 8 Die Paritätsfunktion ist nicht in AC 0 .
Beweisidee für Satz 8: Für jede Variable xi würfeln wir eine von drei
Belegungen: xi = 1, xi = 0, oder xi (d.h. xi ist noch variabel).
◮ Starten wir mit einem Schaltkreis, dessen Gatter auf der untersten
Ebene einen konstanten Eingrad haben, so wollen wir mit Hilfe
dieser Zufallsbelegung zeigen, dass wir mit positiver
Wahrscheinlichkeit einen Schaltkreis erhalten, dessen Gatter auf der
zweit untersten Ebene ebenfalls konstanten Eingrad haben.
◮ Mit Hilfe der Distributivgesetze
x1 ∧(x2 ∨x3 ) = (x1 ∧x2 )∨(x1 ∧x3 )
◮
◮
◮
und x1 ∨(x2 ∧x3 ) = (x1 ∨x2 )∧(x1 ∨x3 )
können wir die Gattertypen der beiden untersten Ebenen tauschen.
Die Gatter auf der untersten Ebene haben nun immer noch einen
konstanten Eingrad (auch wenn dieser viel größer ist) und die Größe
ist noch polynomial in der ursprünglichen Größe, aber wir können die
Gatter der zweit und dritt untersten Ebene verschmelzen.
Somit erhalten wir einen Schaltkreis, der um 1 flacher ist als der
ursprüngliche Schaltkreis.
Dieses können wir nutzen, um einen Widerspruch herzuleiten.
102
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
Wie auf der letzten Folie dargelegt, wollen wir die Eingabe für einen
Schaltkreis würfeln. Daher benötigen wir ein Paar Hilfsmittel aus der
Wahrscheinlichkeitsrechnung.
◮ Sei p die Wahrscheinlichkeit für einen Erfolg – was Erfolg bedeutet
soll später näher beschrieben werden – dann ist die
Wahrscheinlichkeit, dass wir bei n-maligem Wiederholen des
Experiments k mal Erfolg haben binomialverteilt, d.h.
n k
p (1 − p)n−k .
Pr[X = k] =
k
◮
◮
Für Erwartungswert und Varianz gilt E(X ) = np und V (X ) = np(1 − p).
Die Tschebyscheff-Ungleichung besagt
Pr[|X − E(X )| ≥ a] ≤
V (X )
.
a2
Zudem gilt
n n n X
X
X
n
n k
n k
p ≤ pa
p (1−p)n−k ≤
Pr[X ≥ a] =
≤ p a 2n .
k
k
k
◮
k=a
103
k=a
k=a
104
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
Wir wollen nun die Zufallsbelegung bzw. Zufallssubstitution der Variablen
näher beschreiben. Diese Substitution wird auch Zufallsrestriktion
genannt. Für jede Variable xi führen wir unabhängig von allen anderen
Variablen das folgende Zufallsexperiment durch:
◮ mit Wahrscheinlichkeit √1 lassen xi variable,
n
◮
mit Wahrscheinlichkeit
◮
mit Wahrscheinlichkeit
1− √1n
◮
◮
setzen wir xi = 1.
2
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
Betrachten wir jetzt die Frage, wieviele Variablen in C r noch vorhanden
sind.
setzen wir xi = 0 und
2
1− √1n
Andreas Jakoby
Universität zu Lübeck
◮
Mit r bezeichnen wir eine solche Zufallsrestriktion, mit xir das Resultat
von xi nach der Restriktion und C r den Schaltkreis C nach dem
Ausführen der Zufallsrestriktion und dem streichen der Gatter, deren
Wert durch r bestimmt ist. 1
◮
Im ungünstigsten Fall legt r den Wert von C fest, und C r hängt von
keiner Variablen mehr ab.
Da das Ergebnis der Paritätsfunktion von jeder einzelnen Variable
abhängt, sind in C r so viele Variablen übrig, wie in r vorkommen.
Für unsere Zwecke genügt es zu zeigen, dass mit positiver
Wahrscheinlichkeit in r hinreichend viele Variablen übrig bleiben.
Hieraus werden wir schließen, dass es eine geeignete Restriktion gibt.
1 Wie wir bereits oben gesehen haben, berechnet C r entweder die Paritätsfunktion,
oder deren Komplement. Im letzten Fall können wir C r so umgestalten, dass der modifizierten Schaltkreis wieder die Paritätsfunktion berechnet.
105
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
√
n,
V (X ) ≤
√
n
und
Pr[X ≤
√
n
2 ]
∈ O( √1n ) .
Beweis von Lemma 4
√
1
= n· √ = n
n
√
1
1
V (X ) = n · √ · 1 − √
≤ n
n
n
E(X )
Pr[X ≤
√
n
2 ]
≤ Pr[E(X ) − X ≥
√
n
2
=
Pr[C r 6≡ 0]
und E(X ) > X ]
+Pr[X − E(X ) ≥
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
Vℓ
Lemma 5 Sei C eine Konjunktion i=1 Di von Disjunktionen wobei jede
Disjunktion nur von maximal c Variablen abhängt, dann existiert eine
Konstante ec , so dass die Wahrscheinlichkeit, dass das and-Gatter nach
der Zufallsrestriktion von mehr als ec Variablen abhängt, höchstens
1
) ist.
O( nk+1
Beweis von Lemma 5: Der Beweis erfolgt über eine Induktion über c.
Induktionsanfang c = 1 (Eingrad der or-Gatter ist 1):
Fall 1: Das and-Gatter hängt von ≥ 4(k + 1) ln n Variablen ab.
Lemma 4 Sei X eine Zufallsvariable, die die Anzahl der Variablen in Cnr
nach der Restriktion beschreibt, dann gilt
E(X ) =
106
=
≤
≤
√
n
2
und E(X ) < X ]
√
√
V (X )
4 n
∈ O(1/ n) .
≤
Pr[|X − E(X )| ≥ 2n ] ≤ √n
n
( 2 )2
√
107
=
Pr[alle Eingänge des and-Gatters in r sind 6= 0]
Pr[eine beliebige aber feste Variable xi wird nicht 0]4(k+1) ln n
!4(k+1) ln n
„ «4(k+1) ln n
1 − √1n
3
≤
1−
2
4
n4(k+1) ln 3/4 ≤ n−(k+1)
Diese Abschätzung gilt für n ≥ 4. Die letzte Ungleichung folgt aus
ln(1 − x) ≤ −x.
Somit ist das Ergebnis mit großer Wahrscheinlichkeit konstant 0!
108
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
Pr[and-Gatter in C r hängt von mehr als a Variablen ab]
!„
«i „
«n−i
«a
„
4(k+1) ln n
X
n
1
1
1
√
√
≤
1− √
≤
· 24(k+1) ln n
i
n
n
n
i=a
≤ n
·n
4(k+1)
= n
4(k+1)−a/2
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
Beweis von Lemma 5 (Teil 3):
Induktionsschritt c > 1
Wir gehen im folgenden davon aus, dass für c − 1 eine entsprechende
Konstante ec−1 existiert.
Fall 1: Das and-Gatter hängt (vor der Restriktion) von mindestens
2c (k + 1) ln n variablendisjunkten or-Gattern ab.
Wie im ersten Fall des Induktionsanfangs wollen wir zeigen, dass in
diesem Fall mit großer Wahrscheinlichkeit, das and-Gatter konstant 0 ist.
Beweis von Lemma 5 (Teil 2):
Fall 2: Das and-Gatter hängt von < 4(k + 1) ln(n) Variablen ab.
−a/2
Andreas Jakoby
Universität zu Lübeck
Pr[C r 6≡ 0]
.
≤
≤
≤
Wählen wir a = 10(k + 1) so ist die Wahrscheinlichkeit, dass das
and-Gatter in C r von mehr als a Variablen abhängt in O(n−(k+1) ). Somit
bleiben mit großer Wahrscheinlichkeit nur noch eine konstante Anzahl
von Variablen übrig.
=
≤
≤
Pr[keines der oben genannten or-Gatter ist in C r konstant 0]
(Pr[ein beliebiges, festes or-Gatter ist in C r nicht 0])2
c
(k+1) ln n
(1 − (Pr[eine beliebige, feste Variable in C r ist nicht 0])c )2
!c !2c (k+1) ln n
1 − √1n
1− 1−
2
c
`
´
c
−c
2
(k+1)
ln n
= n2 (k+1) ln(1−2 )
1 − 2−c
n−2
c
(k+1)2−c
c
(k+1) ln n
= n−(k+1)
109
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
Beweis von Lemma 5 (Teil 4):
Fall 2: Dieser Fall wird uns bis zum Ende dieses Beweises beschäftigen!
Das and-Gatter hängt von weniger als 2c (k + 1) ln n variablendisjunkten
or-Gattern ab.
◮ Wir wählen eine maximale Menge solcher or-Gatter. Sei H die Menge
der Variablen die durch diese Disjunktionen zusammengefaßt werden.
◮ Da wir die Menge maximal gewählt haben, muss jede Disjunktion in
C eine Variable aus H besitzen.
◮ Da jede Disjunktion maximal c Variablen besitzt und die maximale
Anzahl der variablendisjunkten or-Gattern durch 2c (k + 1) ln n
beschränkt ist, gilt:
110
Andreas Jakoby
Universität zu Lübeck
Beweis von Lemma 5 (Teil 5):
◮
Da jede Disjunktion in Si von maximal c − 1 Variablen abhängt,
hängt nach einer Zufallsrestriktion das and-Gatter in Sir mit einer
Wahrscheinlichkeit O(n−(k+1) ) von mehr als einer konstanten
Anzahl ec−1 von Variablen ab (Induktionsvoraussetzung).
◮
Durch eine neue Numerierung der Variablen können wir erreichen,
dass H = {x1 , x2 , . . . , x|H| } ist.
◮
Wir definieren xi
◮
◮
Wir betrachten die ℓ := 2|H| möglichen Belegungen α1 , . . . , αℓ von
diesen Variablen.
Mit Si bezeichnen wir den Schaltkreis, den wir erhalten, wenn wir
die Variablen aus H mit αi belegen.
Da jede Disjunktion in C zumindest eine Variable aus H beinhaltet,
hat jede Disjunktion in Si noch maximal c − 1 Variablen.
h0i
F :=
h1i
= x i , xi = xi und schließlich:
_ hα [1]i
hα [2]i
hα [|H|]i
x 1 i ∧ x2 i
∧ . . . ∧ x|H|i
∧ Si ,
i∈{1,...,ℓ}
|H| ≤ c · 2c (k + 1) · ln n .
◮
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
wobei αi [j] die Belegung für xj in der partiellen Belegung αi ist.
◮
Beispiel: H = {x1 , x2 }, α1 = 00, α2 = 01, α3 = 10 und α4 = 11,
dann ist:
F = (x 1 ∧x 2 ∧S1 ) ∨ (x 1 ∧x2 ∧S2 ) ∨ (x1 ∧x 2 ∧S3 ) ∨ (x1 ∧x2 ∧S4 ) .
111
112
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
◮
◮
F und C berechnen die gleiche Funktion.
◮
Mit Hilfe des Terms x1 i ∧ . . . ∧ x|H|i
schalten wir den
entsprechenden Teilschaltkreis Si an oder aus.
◮
Wir wollen nun der Frage nachgehen, wieviele Variablen von H nach
einer Zufallsrestriktion noch keinen Wert haben.
Sei Y die Zufallsvariable, die angibt, wieviele Variablen in H übrig
bleiben, dann gilt:
a
c
c
1
·2|H| ≤ n−a/2 ·2c·2 (k+1)·ln n ≤ nc·2 (k+1)−a/2 .
Pr[Y > a] ≤ √
n
◮
◮
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
Beweis von Lemma 5 (Teil 7):
Beweis von Lemma 5 (Teil 6):
α [1]
Andreas Jakoby
Universität zu Lübeck
α [|H|]
◮
Dieses bedeutet auch, dass F nach einer Zufallsrestriktion mit einer
c
Wahrscheinlichkeit von O(nk+1 ) mehr als m := 22c·2 ·(k+1)+2(k+1)
r
Teilschaltkreise Si besitzt, die den Wert von F noch mitbestimmen
können. Dieses sind die Teilschaltkreise, deren Term
α [1]
α [|H|]
x1 i ∧ . . . ∧ x|H|i
noch nicht konstant 0 ist.
Wir fügen nun die einzelnen Abschätzungen zusammen:
Pr[C r hängt von mehr als ec = m · ec−1 Variablen ab]
= Pr[F r hängt von mehr als ec Variablen ab]
≤ Pr[es bleiben mehr als 2c · 2c · (k + 1) + 2(k + 1) Variablen in H
übrig oder ein Si hängt von mehr als ec−1 Variablen ab]
≤ Pr[Y > 2c · 2c · (k + 1) + 2(k + 1)]
+ m · Pr[ein festes Si hängt von mehr als ec−1 Variablen ab
≤ O(n−(k+1) ) + m · O(n−(k+1) ) = O(n−(k+1) ) .
Wählen wir a = 2c · 2c · (k + 1) + 2(k + 1) so ist die
Wahrscheinlichkeit, dass in H nach einer Zufallsrestriktion noch
mehr als a = 2c · 2c · (k + 1) + 2(k + 1) Variablen nicht mit einem
Wert belegt sind in O(n−(k+1) ).
Die letzte Zeile folgt aus der Induktionsvoraussetzung und der
Beobachtung, dass m konstant ist.
113
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
114
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
Satz 8 folgt nun unmittelbar aus dem folgenden Lemma:
Beweis von Lemma 5 (Teil 8):
Man beachte, dass dieser Induktionsschritt nur c-mal wiederholt werden
muß – c ist konstant. Es werden also zur Berechnung von ec nur
konstant viele Konstanten miteinander multipliziert. Zudem wird der
Wert der Wahrscheinlichkeit O(n−(k+1) ) nur konstant oft mit einer
Konstanten multipliziert.
Lemma 6 Für alle Konstanten t und c und für alle Polynome p gilt: Die
Paritätsfunktion kann nicht durch eine p(n)-größen- und
t-tiefenbeschränkte Schaltkreisfamilie in Normalform berechnet werden,
deren Gatter auf der untersten Ebene einen Eingrad von höchstens c
haben.
Beweis von Lemma 6 (Teil 1) Der Beweis folgt über eine Induktion.
Für t = 2 folgt die Aussage direkt aus Satz 7.
115
116
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
Beweis von Lemma 6 (Teil 3) Wir generieren einen Hilfsschaltkreis Hn′ :
◮ Wir wollen mit Hilfe einer geschickten Belegung einiger Variablen
aus einer t-tiefen- und polynomiell größenbeschränkten
Schaltkreisfamilie C1 , C2 , C3 , . . . in Normalform eine (t − 1)-tiefenund polynomiell größenbeschränkten Schaltkreisfamilie C1′ , C2′ , C3′ , . . .
in Normalform konstruieren.
◮ Durch die Vorbelegung einiger Variablen können wir den Schaltkreis
Ci nicht nutzen, um den Schaltkreis Ci′ zu generieren. Stattdessen
wollen wir durch eine geeignete Belegung von 4n2 − n Variablen aus
C4n2 einen Hilfsschaltkreis Hn′ über n Variablen generieren.
◮ Die Gatter der zweit untersten Ebene von H ′ hängen hierbei von nur
n
konstant vielen Variablen ab.
Beweis von Lemma 6 (Teil 2) Um die Aussage für ein t > 2 zu zeigen
nehmen wir an, dass sie falsch ist.
◮ Sei also t minimal, so dass es eine Konstante c und ein Polynom p
gibt und die Paritätsfunktion durch eine p(n)-größen- und
t-tiefenbeschränkte Schaltkreisfamilie in Normalform berechnet
werden kann, deren Gatter auf der untersten Ebene einen Eingrad
von höchstens c haben.
◮ Sei k der Grad dieses Polynoms.
◮ Da wir t minimal gewählt haben, gibt es für t − 1 somit keine solche
Konstante c und auch kein solches Polynom.
◮ Dieses soll im folgenden widerlegt werden.
◮
Mit Hilfe des Distributivgesetzes können wir die Gattertypen der
beiden untersten Ebenen vertauschen ohne die Größe des
Schaltkreises um mehr als einen konstanten Faktor aufzublähen.
117
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
118
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
Beweis von Lemma 6 (Teil 5) Anmerkungen zur Restriktion:
◮
Beweis von Lemma 6 (Teil 4) Wir generieren Ci′ :
◮ Nach Anwendung des Distributivgesetzes können wir dafür
garantieren, dass
◮
◮
◮
die Gatter der untersten Ebene nur von konstant vielen Variablen
abhängen und
die Typen der Gatter auf der zweit und dritt untersten Ebene gleich
sind.
◮
Durch verschmelzen dieser Ebenen erhalten wir den Schaltkreis Cn′ .2
Wir können
√ aus Lemma 4 schließen, dass mit hoher Wahrscheinlichkeit
mehr als 2n Variablen in Cnr übrig bleiben. Man beachte, dass bei
einer Restriktion auch mehr als die benötigten Variablen übrig
bleiben, um aus C4n2 den Schaltkreis Cn′ zu generieren. In diesem
Fall belegen die Variablen, die zuviel sind, mit 0.
Aus Lemma 4 können wir auch ersehen, dass wir das auftreten einer
ungünstigen Restriktion nicht gänzlich verhindern können. Dieses
wird auch bei den weiteren Schritten immer wieder passieren.
Können wir garantieren, dass die Summe dieser Wahrscheinlichkeiten
gegen 0 strebt, so haben wir bewiesen, dass zumindest eine
Restriktion mit einem positiven Ausgang existiert. Die Existenz
reicht jedoch aus, um die Existenz eines geeigneten Schaltkreises
nachzuweisen.
2 Die Größe von C ′ ist weiter polynomiell in n und der der Grad des Polynoms von
n
Cn′ ist höchstens doppelt so groß wie der Grad des Polynoms von Cn .
119
120
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
◮
◮
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
Beweis von Lemma 6 (Teil 7) Noch einmal zur Wiederholung:
Beweis von Lemma 6 (Teil 6) Lemma 5 kommt ins Spiel:
◮
Andreas Jakoby
Universität zu Lübeck
◮
Um den Beweis zu vereinfachen werden wir uns auf Schaltkreise
beschränken, deren unterste Schicht aus or-Gatter bestehen. Die
zweit unterste Schicht besteht folglich aus and-Gatter.
Nach dem Dualitätsprinzip folgt, dass wir durch tauschen von 0 mit
1, xi mit x i und and mit or eine analoge Aussage für Schaltkreise
herleiten können, deren untere Schicht aus and-Gattern besteht.
◮
Betrachten wir zunächst eines dieser and-Gatter so kommt Lemma 5
zum Einsatz:
Vℓ
Lemma 5 Sei C eine Konjunktion i=1 Di von Disjunktionen
wobei jede Disjunktion nur von maximal c Variablen abhängt,
dann existiert eine Konstante ec , so dass die Wahrscheinlichkeit,
dass das and-Gatter nach der Zufallsrestriktion von mehr als ec
1
) ist.
Variablen abhängt, höchstens O( nk+1
Es verbleibt also noch zu zeigen, wie wir Lemma 5 nutzen können,
um einen beliebigen Schaltkreis in Normalform zu transformieren.
◮
Wir haben die Konstanten k, t und c so gewählt, dass t minimal war
und es einen polynomiell größenbeschränkte und t tiefenbeschränkte
Schaltkreisfamilie in Normalform gibt, die die Paritätsfunktion
berechnet.
Hierbei war das Polynom, welches die Größe beschränkt, aus O(nk )
und die Gatter der untersten Stufe hingen von maximal c Variablen
ab.
Wir haben dann gezeigt, dass wir mit Hilfe einer Zufallsrestriktion
dafür sorgen können, dass ein beliebiges aber festes Gatter der zweit
untersten Stufe nur noch von einer konstanten Anzahl von Variablen
abhängt.
Die Wahrscheinlichkeit eines Fehlschlags war hierbei durch
O(n−(k+1) ) beschränkt.
Führen wir die Restriktion an allen Gattern der zweit untersten Ebene aus,
so ist die Wahrscheinlichkeit, dass es an einem solchen Gatter zu einem
Fehlschlag kommt, durch O(nk ) · O(n−(k+1) ) = O(n−1 ) beschränkt.
◮
121
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
Beweis von Lemma 6 (Teil 8) Wiederholen wir noch einmal diese
Beobachtung: Mit einer Wahrscheinlichkeit von 1 − O(n−1 ) hat C r auf
der untersten Ebene nur einen konstanten Eingrad und jedes Gatter auf
der zweit untersten Ebene hängen nur noch von einer konstanten Anzahl
von Variablen ab.
Somit gilt:
◮ Da der Eingard auf den beiden untersten Ebenen somit Konstant ist,
können wir mit Hilfe des Distributivgesetzes die Typen der Gatter
auf den untersten Ebenen vertauschen, und die Gatter der zweit und
dritt untersten Ebene verschmelzen.
◮ Der resultierende Schaltkreis hat also eine Tiefe von t − 1 und die
Gatter der untersten Ebene haben immer noch einen konstanten
Eingrad.
◮ Wir haben zudem gesehen, dass die Anzahl der Variablen, die in C r
√
übrig bleiben,
mit einer Wahrscheinlichkeit von O(1/ n) nach unten
√
durch 2n beschränkt werden kann.
122
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
3. Vorlesung, 21.04.2008
Beweis von Lemma 6 (Teil 9) Fassen wir zusammen:
◮
◮
◮
123
Die Wahrscheinlichkeit, dass eine Restriktion entweder zu wenige
Variablen übrig läßt oder die falschen Variablen mit Werte belegt ist
durch
O(n−1 ) + O(n−1/2 ) = O(n−1/2 )
beschränkt.
Mit einer Wahrscheinlichkeit von O((n2 )−1/2 ) können wir mit einer
r
′
Zufallsrestriktion C4n
2 so modifizieren, dass wir einen Schaltkreis Cn
polynomieller Größe und Tiefe t − 1 erhalten, der die
Paritätsfunktion oder deren Kompliment berechnet.
Da über die Konstruktion sicher gestellt ist, dass der Eingrad der
Gatter der untersten Stufe wieder konstant ist, erhalten wir einen
Widerspruch zu der Annahme, dass t minimal gewählt wurde.
124
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
4. Vorlesung, 28.04.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
4. Vorlesung, 28.04.2008
Definition 21 Seien n, m, s ∈ N.
◮
Wir wollen nun die Frage untersuchen, inwieweit alle Booleschen
Funktionen mit Hilfe von Schaltkreisen effizient berechnet werden
können.
◮
Satz 9 Jede Boolesche Funktion fn : {0, 1}n → {0, 1} kann von einem
Schaltkreise der Tiefe 3 bestehend aus or- und and-Gattern mit
unbeschränktem Eingard und not-Gattern berechnet werden.
Beweis von Satz 9 Um einen solchen Schaltkreis zu erhalten betrachten
wir einfach die Disjunktive- oder die Konjunktive-Normalform der
gewünschten Funktion.
◮
Bnm bezeichnet die Menge aller Booleschen Funktionen
f : {0, 1}n → {0, 1}m
m
Bn,s
⊆ Bnm bezeichnet die Teilmenge dieser Funktionen, für die ein
Schaltkreis der Größe ≤ s über der Basis bestehend aus allen
2-stelligen Booleschen Funktionen existiert.
1
Zur Vereinfachung sei Bn := Bn1 und Bn,s := Bn,s
.
n
Lemma 7 |Bn | = 22 .
Beweis von Lemma 7
◮
◮
Wir müssen uns hierbei jedoch die Frage stellen, wie groß diese
Schaltkreise werden können.
◮
Es gibt 2n mögliche Eingaben x ∈ {0, 1}n für jede Funktion f ∈ Bn .
Für jede Teilmenge I ⊆ {0, 1}n beschreibt Funktion f mit
f (x) = 1 ⇐⇒ x ∈ I eine neue Funktion aus Bn .
Über dieses Verhalten können wir über die Menge I alle Funktionen
aus Bn beschreiben.
n
◮
Es gibt 22 viele verschiedene Teilmengen I von {0, 1}n .
125
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
4. Vorlesung, 28.04.2008
Lemma 8 |Bn,s | ≤ 2n · e n · (16 · e · (n + s))s .
Beweis von Lemma 8
◮ Für jeden Schaltkreis der Größe s ′ < s können wir einen Schaltkreis
konstruieren, der aus exakt s Gattern besteht. Somit existiert für
jede Funktion f ∈ Bn,s ein Schaltkreis der Größe s.
◮
◮
◮
◮
◮
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
4. Vorlesung, 28.04.2008
Beweis von Lemma 8 (Teil 2)
◮
Wir wollen nun die Anzahl der Schaltkreise Cn,s der Größe s mit n
Eingabegattern untersuchen, die unterschiedliche Funktionen berechnen.
Jeder Schaltkreis aus Cn,s kann dadurch beschrieben werden, dass
wir für jedes interne Gatter dessen Funktionalität und dessen zwei
Vorgängergatter angeben. Zudem muß der Index des Ausgabegatters
spezifiziert werden.
Es gibt somit maximal 16s · (s + n)2s · s viele Beschreibungen, wobei
bei einer solchen Beschreibung die Gatter im Allgemeinen nicht
topologisch geordnet sind.
Es gilt
∞
X
sℓ
ss
<
= es
s!
ℓ!
and
ℓ=0
◮
1+
n s
≤ en .
s
Somit gilt
|Bn,s |
◮
Somit existieren für jede Funktion f ∈ Bn,s mindestens s! viele
Beschreibungen von Schaltkreisen C mit fC ≡ f .
Wir erhalten somit |Bn,s | ≤
126
s · 16s · (s + n)2s
≤
s s /e s
s
s +n
≤ s · (16e(n + s))s ·
s
≤ s · e n · (16e(n + s))s .
≤
s · 16s · (s + n)2s
s!
Für hinreichend große Werte n erhalten wir
|Bn,s | ≤ 2n · e n · (16e(n + s))s .
s·16s ·(s+n)2s
.
s!
127
128
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
4. Vorlesung, 28.04.2008
Satz 10 Als Basis betrachten wir die Menge aller 2-stelligen Booleschen
Funktionen. Für jedes δ > 0 existiert ein n0 (δ), so dass für alle n ≥ n0 (δ)
und für alle Booleschen Funktionen fn ∈ Bn bis auf einen Bruchteil von
n
23n−δ2 gilt
2n
size(fn ) > (1 − δ) ·
.
n
Beweis von Satz 10: Für s = (1 − δ) · 2n /n schließen wir aus Lemma 8:
2n
|Bn,s | ≤ 2 · e · 16e n + (1 − δ) ·
n
n
n
(1−δ)·2n /n
In den Beobachtungen 5 und 7 habe wir die Klassen N C und AC mit der
Klasse P verglichen. Wir wollen nun untersuchen, ob sich die
Schaltkreiskomplexität noch besser mit der Komplexität von
Turing-Maschinen vergleichen läßt.
Satz 11 Sei C eine s-platzkonstruierbare Familie von
d-tiefenbeschränkten Schaltkreisen (mit einem Ausgabegatter), wobei die
Eingrad aller Gatter durch eine Konstante κ beschränkt ist. Dann kann
die durch F beschriebene Funktion auch durch eine
O(d + s)-platzbeschränkte DTM berechnet werden.
Korollar 4 N C 1 ⊆ L.
(1−δ)·2n /n
= 23n+2
n
(1−δ)
.
Aus Lemma 7 schließen wir
|Bn,s |
|Bn |
Computational Complexity SS 08
4. Vorlesung, 28.04.2008
4.3 Die Klassen N C 1 und AC 1
und somit gilt für hinreichend große Werte von n
|Bn,s | ≤ 23n · (2n )
Andreas Jakoby
Universität zu Lübeck
n
≤
23n+2 (1−δ)
22 n
n
≤ 23n−δ2 .
129
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
4. Vorlesung, 28.04.2008
Beweis von Satz 11 (Teil 1): Um den Wert des Ausgabegatter zu
bestimmen wollen wir eine rekursive Prozedur vorstellen, die mit einem
möglichst kleinen Speicherbedarf versucht alle Quelle-Senke-Pfade eines
Schaltkreises zu durchlaufen. Hierbei müssen wir zunächst untersuchen,
wie der Schaltkreis gegeben ist:
◮ M ′ sei die s-platzbeschränkte DTM, die auf Eingaben x der Länge n
eine Beschreibung von Cn generiert.
◮
◮
◮
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
4. Vorlesung, 28.04.2008
Beweis von Satz 11 (Teil 2): Die nachfolgende rekursive Prozedur
berechnet den Wert eines Gatters v auf Eingabe x:
Algorithmus Value(v )
Eingabe: Gatter v
Ergebnis: Wert Valv (x)
1: simuliere M ′ auf Eingabe x#v
2:
um Γ− (v ) = (u1 , . . . , uk ) und σ(v ) zu bestimmen
3: if σ(v ) ∈ {x1 , . . . , xn , 0, 1} then
4:
bestimme den entsprechenden Wert Valv (x) aus x
5: else
6:
for i := 1 to k by +1 do
7:
Valui (x) := Value(ui )
8:
end for
9:
Valv (x) := σ(v )(Valu1 (x), . . . , Valuk (x))
10: end if
11: Return(Valv (x))
Wir erweitern M ′ insoweit, dass wir festlegen, welchen Teil der
Ausgabe uns interessiert: Sei v ein Gatter von Cn , dann berechnet
M ′ auf Eingabe von x#v alle Vorgänger Γ− (v ) von v in Cn .
Da C eine Familie von d-tiefenbeschränkten κ-eingradbeschränkten
Schaltkreisen und κ eine Konstante ist, gibt es in C maximal κd viele
Gatter. Wir gehen daher von den folgenden Vereinfachungen aus:
◮
130
Jedes Gatter kann durch einen Binärstring der Länge O(d)
spezifiziert werden.
M ′ kann die Folge Γ− (v ) der Vorgänger von v sowie die Funktion
σ(v ) auf Platz O(d + s) bestimmen, auch wenn die Ausgabe auf
einem Arbeitsband erfolgt.
131
132
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
4. Vorlesung, 28.04.2008
◮
◮
◮
◮
◮
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
Value(v ) bestimmt den Wert Valv (x) korrekt.
Ist v das Ausgabegatter, so bestimmt Value(v ) den Wert fC (x).
Die maximale Rekursiontiefe von ist durch die Tiefe von C gegeben.
Jede Stufe der Rekursion benötigt maximal κ · O(d) Speicherplätze
um die jeweiligen Listen Γ− (v ) sowie die Werte Valui (x) zu
speichern.
Der Speicherplatz den wir für die Simulation von M ′ benötigen
können wir bei jeder Simulation recyclen. Er fällt somit nur einmal
an!
◮
Der Gesamtplatzbedarf ist somit in O(d 2 + s).
◮
◮
simuliere M ′ auf x#v um Γ− (v ) = (u1 , . . . , uk ) und σ(v ) zu bestimmen
if σ(v ) ∈ {x1 , . . . , xn , 0, 1} then
bestimme den entsprechenden Wert Valv (x) aus x
else
for i := 1 to k by +1 do
Valui (x) := Value(ui )
end for
Valv (x) := σ(v )(Valu1 (x), . . . , Valuk (x))
end if
Return(Valv (x))
Wir können zwar Γ− (v ) beliebig berechnen aber nicht länger speichern.
Auch können wir nicht den Namen von v innerhalb des Aufrufs
Value(ui ) speichern!
Wenn wir auf diesen Speicher verzichten, benötigen wir für jede
Stufe der Reduktion nur O(κ) Platz und erhalten einen
Gesamtplatzbedarf von O(d + s).
133
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
4. Vorlesung, 28.04.2008
Beweis von Satz 11 (Teil 5): Um den Speicherbedarf zu reduzieren
müssen wir den Algorithmus so umgestalten, dass in jeder Stufe der
Rekursion nur konstanter Speicherplatz benötigt wird:
Beweis von Satz 11 (Teil 3): Wir beobachten:
◮
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
4. Vorlesung, 28.04.2008
Beweis von Satz 11 (Teil 6): Anstelle der Gatternamen speichern wir
im folgenden nur einen Pfad Πv in Cn vom Ausgabegatter y zum Gatter
v . Sei y = v0 , v1 , v2 , . . . , vℓ = v ein Pfad in Cn , dann kodieren wir Πv wie
folgt:
Πv = k1 #k2 # . . . #kℓ
wobei vi+1 der ki+1 Vorgänger von vi ist. Um den Namen eines Gatters
bei gegebenen Πv zu rekonstruieren wenden wir den folgenden
O(s + d)-platzbeschränkten Algorithmus an:
Algorithmus GiveGate(Πv )
Eingabe: Kodierung vom Pfad Πv = k1 #k2 # . . . #kℓ
Ergebnis: Name vom Gatter v
1: setze v auf das Ausgabegatter y
2: for i := 1 to ℓ by +1 do
3:
simuliere M ′ um x#v um Γ− (v ) = (u1 , . . . , uk ) zu bestimmen
4:
setze v auf uki
5: end for
6: Return(v )
135
134
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
4. Vorlesung, 28.04.2008
Beweis von Satz 11 (Teil 7):
Algorithmus Value-2(Πv )
Eingabe: Gatter v
Ergebnis: Wert Valv (x)
1: v := GiveGate(Πv )
2: simuliere M ′ auf x#v um k = |Γ− (v )| und σ(v ) zu bestimmen
3: if σ(v ) ∈ {x1 , . . . , xn , 0, 1} then
4:
bestimme den entsprechenden Wert Valv (x) aus x
5: else
6:
for i := 1 to k by +1 do
7:
v := GiveGate(Πv )
8:
simuliere M ′ auf x#v um den i-ten Vorgänger ui von v zu bestimmen
9:
ergänze Πv um ui zu Πui
10:
Valui (x) := Value-2(Πui )
11:
reduziere Πui um ui zu Πv
12:
end for
13:
Valv (x) := σ(v )(Valu1 (x), . . . , Valuk (x))
14: end if
15: Return(Valv (x))
136
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
4. Vorlesung, 28.04.2008
In einem zweiten Schritt wollen wir jetzt untersuchen, ob jede Sprache in
L auch effizient parallel entschieden werden kann. Wie schon im Satz 11
wollen wir einen etwas allgemeineren Satz beweisen.
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
4. Vorlesung, 28.04.2008
Beweis von Satz 12 (Teil 1): Wir betrachten zunächst die NTM und
beobachten:
∗
Satz 12 Sei s ≥ log und L ⊆ {0, 1} eine Sprache, die von einer s-platzund t-zeitbeschränkten NTM entschieden werden kann. Dann gibt es eine
uniforme Familie C von 2O(s) -größen- und O(log t)-tiefenbeschränkten
Schaltkreisen über der Basis {and, or, not} die L akzeptiert, wobei wir
den Eingrad der and- und or-Gatter nicht beschränken. Sind s und t auf
Platz s berechenbar (oder zumindest auf Platz s bis auf einen konstanten
Faktor approximierbar), so ist C auch s-platzkonstruierbar.
◮
◮
◮
Es gilt s ≤ t.
Wir können somit die NTM so modifizieren, dass sie nur in einer
festen partiellen Konfiguration Ca akzeptiert (ohne hierbei den Zeitoder Platzbedarf der NTM um mehr als den Faktor 2 zu erhöhen).
Mit C1 bezeichnen wir im Folgenden die partielle Startkonfiguration.
Korollar 5 N L ⊆ AC 1 .
Korollar 6 N C 1 = AC 1 =⇒ L = N L.
137
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
4. Vorlesung, 28.04.2008
Beweis von Satz 12 (Teil 2): Wir betrachten weiter:
◮
Andreas Jakoby
Universität zu Lübeck
Für s ≥ log kann jede s-platzbeschränkten NTM kann nur 2
viele verschiedene partielle Konfigurationen annehmen. Genauer
können wir einfach zeigen:
Für eine 1-Band NTM mit einseitig unbeschränktem Arbeitsband ist
Anzahle der verschiedenen möglichen partiellen Konfigurationen
gegeben durch
◮
Sei C1 , . . . , Cτ (n) eine Aufzählung aller möglichen partiellen
Konfigurationen, wobei wir annehmen, dass die partielle
Startkonfiguration C1 und die einzige partielle akzeptierende
Konfiguration Cτ (n) ist.
◮
Wir definieren nun die Übergangsmatrix AM (x) = (ai,j )1≤i,j≤τ (n) der
NTM M auf Eingabe x

 1 falls i = j ist oder die Übergang Ci ⊢ Cj bei
ai,j :=
der Eingabe x prinzipiell möglich ist

0 sonst.
τ (n) := n · |Q| · s(n) · |Σ|s(n) .
◮
Für eine k-Band NTM mit beidseitig unbeschränkten Arbeitsbändern
ist Anzahle der verschiedenen möglichen partiellen Konfigurationen
durch
τ (n) := n · |Q| · 2k · s(n) · |Σ|2k·s(n)
∈ 2O(s)
gegeben. Wir erhalten den Faktor 2k aus der Überlegung, dass wir
nicht wissen wie sich der Platzbedarf auf die k Bänder und auf die
zwei möglichen Richtungen verteilt.
◮
Computational Complexity SS 08
4. Vorlesung, 28.04.2008
Beweis von Satz 12 (Teil 3):
O(s)
◮
138
◮
Es gilt t ≤ τ (n).
139
Die Frage, ob Ci ⊢ Cj bei der Eingabe x möglich ist, hängt von dem
Symbol der Eingabe ab, welches M in der Konfiguration Ci von
gerade x ließt.
Die Übergangsmatrix kann von einer DTM auf Platz O(s(n))
konstruiert werden. Sie ist somit s-platzkonstruierbar, wenn wir s
berechnen oder approximieren können.
140
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
4. Vorlesung, 28.04.2008
Für t ∈ N mit t ≥ 1 definieren wir die Übergangsmatrix
[t]
[t]
AM (x) = (ai,j )1≤i,j≤τ (n) der NTM M auf Eingabe x
ai,j
:=

 1
falls i = j ist oder Cj in ≤ t Übergängen von Ci
bei Eingabe x erreicht werden kann

0 sonst.
1≤k≤τ (n)
[τ (n)]
◮
M akzeptiert genau dann die Eingabe x, wenn a1,τ (n) = 1 ist.
◮
Beachte, dass für den Fall, dass für ein t ∈ N ai,j = 1 ist, auch für
Computational Complexity SS 08
4. Vorlesung, 28.04.2008
Beweis von Satz 12 (Teil 5): Im nächsten Schritt fragen wir uns, wie
[t]
wir AM (x) berechnen können.
◮ Angenommen, wir wissen, dass wir in ≤ t − 1 Schritten auf Eingabe
x die partielle Konfiguration Ck von Ci erreichen und in einem Schritt
auf Eingabe x die partielle Konfiguration Cj von Ck erreichen, dann
können wir in ≤ t Schritten auf Eingabe x Cj von Ci erreichen, d.h.
_
[t]
[t−1]
[1]
ai,j =
(ai,k ∧ ak,j ) .
Beweis von Satz 12 (Teil 4): Im nächsten Schritt wollen wir die
Übergangsmatrix verallgemeinern.
◮
Andreas Jakoby
Universität zu Lübeck
◮
[t]
Somit erhalten wir AM (x) mit Hilfe des Booleschen Matrizenprodukts
[t]
[t]
[t−1]
AM (x) = AM
[t ′ ]
◮
alle anderen t ′ ≥ t ai,j = 1 ist.
Unser Ziel ist es jetzt für einen Wert t ≥ τ (n) zu entscheiden, ob
[t]
a1,τ (n) = 1 ist. Wir müssen also nicht unbedingt die Matrix
[1]
[1]
t-mal
◮
ℓ
Ist t = 2 , dann können wir aufgrund der Assoziativität des
[t]
Booleschen Matrizenprodukts AM (x) auch wie folgt bestimmen:
[τ (n)]
AM (x) konstruieren. Es ist vielmehr ausreichend für irgendeinen
[t]
Wert t ≥ τ (n) die Matrix AM (x) zu konstruieren.
[t]
[1]
AM (x) = ((. . . (AM (x) )2 . . .)2 )2 .
| {z }
ℓ-mal
141
Andreas Jakoby
Universität zu Lübeck
[1]
(x) · AM (x) = AM (x) · . . . · AM (x) .
{z
}
|
Computational Complexity SS 08
4. Vorlesung, 28.04.2008
Andreas Jakoby
Universität zu Lübeck
142
Computational Complexity SS 08
4. Vorlesung, 28.04.2008
Beweis von Satz 12 (Teil 7): Und jetzt setzen wir alles zusammen.
◮
Beweis von Satz 12 (Teil 6):
◮ Für t ≥ 1 erhalten wir
[2t]
ai,j
=
_
1≤k≤τ (n)
◮
◮
[t]
◮
[t]
(ai,k ∧ ak,j ) .
◮
[2t]
Wir können somit AM (x) mit einem Schaltkreis der Größe O(τ (n)3 )
und Tiefe 2 berechnen, wenn wir auf and- und or-Gatter mit
unbeschränkten Eingrad zurückgreifen können.
Dieser Schaltkreis ist zudem s-platzkonstruierbar – im Wesentlichen
benötigen wir nur ein paar Zähler, die bis τ (n) zählen.
◮
[t ]
Durch iteriertes Quartieren können wir aus AM (x) die Matrix AM0 (x)
berechnen, wobei t0 die kleinste Zweierpotenz größer gleich τ (n) ist.
Es gilt somit τ (n) ≤ t0 = 2ℓ0 < 2τ (n) oder ℓ0 < 1 + log τ (n).
Es genügen folglich ℓ0 Iterationen.
Aufgrund unserer Beobachtungen auf der letzten Folie ist der
resultierende Schaltkreis s-platzkonstruierbar, O(ℓ0 )-tiefen- und
O(ℓ0 · τ (n)3 )-größenbeschränkt.
Aufgrund unserer Konstruktion gilt:
O(ℓ0 ) = O(log t)
und
O(τ (n)3 · ℓ0 ) = O(τ (n)3 · log τ (n)) = O(τ (n)4 ) = 2O(s) .
143
144
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
4. Vorlesung, 28.04.2008
Computational Complexity SS 08
4. Vorlesung, 28.04.2008
Beobachtung 12 In AC 0 liegen die folgenden Funktionen:
Wir wollen jetzt der Frage nachgehen, welche Funktionen in welcher
Komplexitätsklasse liegen.
Beobachtung 10 In N C 1 liegen die folgenden Funktionen:
◮
Andreas Jakoby
Universität zu Lübeck
◮
◮
die Addition zweier n-Bit Binärzahlen,
◮
die Multiplikation zweier n-Bit Binärzahlen,
die Summe von n n-Bit Binärzahlen und
◮ das Produkt zweier Matrizen bestehend aus n-Bit Binärzahlen.
Beobachtung 11 In N C 2 liegen die folgenden Funktionen:
die Addition zweier n-Bit Binärzahlen,
die Vergleich zweier n-Bit Binärzahlen,
die Maximum zweier n-Bit Binärzahlen und
das Mergen (Zusammenfügen) zweier sortierter Folgen aus m n-Bit
Binärzahlen.
Beobachtung 13 In AC 1 liegen die folgenden Funktionen:
◮ die Parität über n-Bits,
◮ die Multiplikation von zwei n-Bit Binärzahlen,
◮
◮
◮
die Division zweier n-Bit Binärzahlen,
die Determinante einer Matrix bestehend aus n-Bit Binärzahlen,
◮ die Inverse einer Matrix bestehend aus n-Bit Binärzahlen und
◮ der Abschluß einer Booleschen Matrix bezüglich des Booleschen
Matrizenprodukts.
Abhängig von den Konstruierbarkeitsbedingungen kann für die Division
auch ein N C 1 -Schaltkreis angegeben werden.
◮
◮
◮
◮
◮
◮
◮
die Summe von m n-Bit Binärzahlen,
das Sortieren von m n-Bit Binärzahlen,
Pn
die Majorität von n Bits, d.h. i=1 xi ≥ n/2,
der Abschluß einer Booleschen Matrix bezüglich des Booleschen
Matrizenprodukts und
der Zusammenhang von Graphen.
145
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
146
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
Definition 22 Seien f , g zwei Funktionen. Wir sagen
◮ f ist bezüglich der Schaltkreistiefe reduzierbar auf g , kurz f ≤d g ,
wenn jede log-platzkonstruierbare Schaltkreisfamilie C mit
depthC (n) = d(n) für g in eine log-platzkonstruierbare
Schaltkreisfamilie C ′ mit depthC ′ (n) = O(d(n)) für f transformiert
werden kann.
4.4 Die N C 1 -Reduktionen
Im Folgenden wollen wir noch eine weitere Reduktion vorstellen, die vor
allem bei der Analyse von Schaltkreiskomplexitätsklassen und für die
Klassen L und P von Bedeutung ist.
Oft ist es hilfreich, anstelle des gesamten Schaltkreises nur eine Art
Hauptschaltkreis, der auf Hilfsschaltkreise zurückgreift, zu betrachten.
Dieses führt uns der Folgenden Form von Reduktionen.
◮
f ist bezüglich der Schaltkreisgröße reduzierbar auf g , kurz f ≤s g ,
wenn jede log-platzkonstruierbare Schaltkreisfamilie C mit
sizeC (n) = s(n) für g in eine log-platzkonstruierbare
Schaltkreisfamilie C ′ mit sizeC ′ (n) = O(s(n)) für f transformiert
werden kann.
f ist bezüglich der Schaltkreistiefe und -größe reduzierbar auf g ,
kurz f ≤sd g , wenn jede log-platzkonstruierbare Schaltkreisfamilie C
mit sizeC (n) = s(n) und depthC (n) = d(n) für g in eine
log-platzkonstruierbare Schaltkreisfamilie C ′ mit sizeC ′ (n) = O(s(n))
und depthC ′ (n) = O(d(n)) für f transformiert werden kann.
f nennen wir genau dann s-äquivalent zu g (kurz f ≡s g ), wenn f ≤s g
und g ≤s f ist. Analog definieren wir f ≡d g und f ≡sd g .
◮
147
148
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
Eine Reduktion von f auf g ist eine uniforme Schaltkreisfamilie (Ci )i∈N ,
welche f unter Zuhilfenahme von Orakel-Gattern für g berechnet. Ein
Orakel-Gatter für g berechnet auf Eingabe von (y1 , . . . , yr ) ∈ {0, 1}r das
Binärwort (z1 , . . . , zs ) = g (y1 , . . . , yr ). In der Analyse der Tiefe der
Schaltkreise von (Ci )i∈N berücksichtigen wir jedes Orakel-Gattern mit
einem logarithmischen Anteil in r . Für die Tiefe von Ni erhalten wir
somit:
depth(Ci ) =
max
(v1 ,...,vd ) ist
d
X
j=1
Eingabe-Ausgabe-Pfad in Ci
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
Definition 23 f nennen wir genau dann N C 1 -reduzierbar auf g (kurz
f ≤N C 1 g ), wenn eine log-platzkonstruierbare Schaltkreisfamilie
C = (Ci )i∈N für f mit depthC (n) = O(log(n)) und sizeC (n) = O(nO(1) )
existiert, welche auf Orakelgatter für g zurückgreifen kann.
Ferner nennen wir f N C 1 -äquivalent zu g (kurz f ≡N C 1 g ), wenn
f ≤N C 1 g und g ≤N C 1 f ist.
Satz 13 ≤N C 1 ist reflexiv und transitiv.
Satz 14 Für alle k ≥ 1 ist N C k abgeschlossen unter der N C 1 -Reduktion,
d.h. N C k = ΓN C 1 (N C k ).
⌈log2 max{2, Eingrad(vi )}⌉ .
149
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
◮
Bei der Betrachtung der Platzkomplexität von Problemen werden nicht
nur die bereits definierten Klassen L, N L und PSPACE untersucht. Um
einen kleinen Eindruck von der Vielfältigkeit der untersuchten
Platzkomplexitätsklassen zu geben, wollen wir im Folgenden drei weitere
Klassen einführen und untersuchen.
◮
Definition 24 Eine NTM nennen wir symmetrisch, wenn für jedes Paar
C1 , C2 von totalen Konfiguration der NTM gilt:
⇐⇒
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
Definition 24 (Teil 2) Eine Randomisierte Turing-Maschine (kurz RTM) M
definieren wir analog zum Modell der NTM mit der folgenden Änderung:
5 Das Labyrinth der logarithmischen
Platzklassen
C1 ⊢ C2
150
◮
C2 ⊢ C1 ,
d.h. jede Konfigurationsänderung, die die NTM vollziehen kann, muss
von ihr auch zurückgenommen werden können.
Für eine totale Konfiguration C sei S(C ) die Menge aller direkten
Nachfolgekonfigurationen C ′ von M auf C , d.h. aller C ′ mit C ⊢ C ′ .
Die Übergangswahrscheinlichkeit Pr[C ⊢ C ′ ] für zwei totale
Konfigurationen C und C ′ definieren wir wie folgt
0
falls C ′ 6∈ C(C ),
Pr[C ⊢ C ′ ] :=
1
sonst.
|S(C )|
Die Wahrscheinlichkeit für eine Berechnung Π = C0 , C1 , . . . , Cm
definieren wir als
Pr[Π] :=
m−1
Y
i=0
151
Pr[Ci ⊢ Ci+1 ] .
152
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
Definition 24 (Teil 3)
◮ Sei C0 (x) die Startkonfiguration von M auf Eingabe x und sei
Cakz (x) die Menge aller akzeptierenden Berechnungen von M auf
Eingabe x, d.h. die Menge aller Konfigurationsfolgen von M die in
C0 (x) beginnen und in einer akzeptierenden Konfiguration enden.
Dann definieren wir die Wahrscheinlichkeit pakz (x), dass M die
Eingabe x akzeptiert über
X
pakz (x) :=
Pr[Π] .
SL ist die Menge aller Sprachen, die von einer symmetrischen
logarithmisch-platzbeschränkten NTM akzeptiert werden.
◮ RL ist die Menge aller Sprachen L, für die von einer
logarithmisch-platzbeschränkten RTM M mit einseitigen Fehler von
1
2 akzeptiert werden.
Die Klasse SL scheint auf dem ersten Blick sehr nahe mit der Klasse N L
verwandt zu sein. Beiden Klassen liegt eine logarithmisch-platzbeschränkten NTM zugrunde. Es ist daher auf dem ersten Blick etwas
verwunderlich, dass vor kurzem SL = L gezeigt wurde, und die Frage, ob
SL = N L ist, immer noch offen ist. Das wesentliche Problem einer
platzbeschränkten symmetrischen NTM ist das Zählen, da sie jeden
Schritt wieder zurück nehmen können muss, könnte sie also
1, 2, 3, 2, 3, 2, 3, 4, 5, . . . zählen ohne es zu merken.
◮
Sei M eine RTM, dann definieren wir für einen Fehlerschranke ε mit
0 ≤ ε ≤ 1:
Lε (M) := { x | M akzeptiert x mit pakz (x) ≥ ε } .
◮
◮
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
Definition 24 (Teil 4) Die Zeit- und Platzbeschränkung einer
symmetrischen NTM und einer RTM definieren wir analog zur Zeit- bzw.
Platzbeschränkung einer NTM.
Mit Hilfe der so definierten Turing-Maschinen können wir nun zwei
weitere Komplexitätsklassen definieren:
Π∈Cakz (x)
◮
Andreas Jakoby
Universität zu Lübeck
Wir sagen, dass eine RTM M eine Sprache L mit einseitigem Fehler
ε akzeptiert, wenn L = Lε (M) ist und zudem für alle x 6∈ L
pakz (x) = 0 ist.
Wir erweitern die Menge Mk um alle k-Band RTMs und
symmetrische k-Band NTMs.
153
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
154
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
Wir wollen nun noch ein paar weitere Komplexitätsklasse einführen, die
im Umfeld der logarithmischen Platzklassen untersucht wird.
Definition 25 Sei C eine Komplexitätsklassen und F eine Menge von
Funktionen, dann definieren wir die C/F als die Menge der Sprachen L,
für die
◮ es eine Funktion f ∈ F,
In Definition 2 haben wir definiert, dass eine TM hält, sobald eine
Endkonfiguration erreicht ist, egal, ob dieses eine akzeptierende oder
verwerfende Konfiguration ist. Da für jede Konfiguration C einer DTM
M maximal eine Konfiguration C ′ existiert, so dass C ⊢ C ′ gilt, kann für
ein x 6∈ L(M) eine akzeptierende Endkonfiguration nicht ein von der
Startkonfiguration C0 (x) erreichbar sein, auch wenn wir der TM erlauben,
jeden gemachten Konfiguartionsübergang zurück zu nehmen, d.h., wenn
wir das der DTM eine symmetrische NTM machen. Es folgt:
eine TM M, die die Einschränkungen von C erfüllt, und
◮ eine Folge von Zeichenketten w0 , w1 , . . . mit f (i) = |wi | gibt,
so dass M die Sprache L akzeptiert, wobei M für jede Eingabe x die
Zeichenkette w|x| zur Verfügung hat. Die Zeichenkette w|x| wird auch
Advice genannt. Beachte, dass der Advice nicht konstruierbar sein muss,
und dass die Zeichenkette w|x| nur von der Länge jedoch nicht von der
konkreten Eingabe x abhängig ist.
Von besonderen Interesse sind hier die Klassen
◮
Beobachtung 14
L ⊆ SL ⊆ N L .
L/poly , N L/poly , RL/poly und P/poly .
155
156
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
5.1 Das Labyrinth-Problem
Wir wollen nun ein einfache und natürliches Problem vorstellen, welches
auf sehr einfache Art und Weise jeweils ein vollständiges Problem für L,
SL und N L liefert.
Um das Labyrinth-Problem zu lösen, betrachten wir den folgenden
nicht-deterministischen Algorithmus:
Algorithmus Walk-Labyrinth(s, t)
Eingabe: Graph G (global gegeben), Startknoten s, Zielknoten t
Ergebnis: 1 falls t von s erreichbar ist, 0 oder undefiniert sonst
1: if s 6= t then
2:
if es existiert ein Knoten, der von s aus direkt erreichbar ist then
3:
wähle einen Knoten z, der von s aus direkt erreichbar ist
4:
Return(Walk-Labyrinth(z, t))
5:
else
6:
Return(0)
7:
end if
8:
Return(1)
9: end if
Definition 26 [Labyrinth-Problem] Gegeben ist ein Graph G = (V , E )
und zwei ausgezeichnete Knoten s, t ∈ V . Wir nennen t von s in G
erreichbar, wenn es eine Folge von Konten v0 , . . . , vk+1 ∈ V mit s = v0
und t = vk+1 gibt, so dass für alle i ∈ {0, . . . , k}
◮ (vi , vi+1 ) ∈ E ist, falls G gerichtet ist, und
◮ {vi , vi+1 } ∈ E ist, falls G ungerichtet ist.
Wir untersuchen die folgenden Varianten des Labyrinth-Problems:
GAP := { (G , s, t) | G ist ein gerichteter Graph
und t ist von s erreichbar }
TREE-GAP := { (G , s, t) | G ist ein zur Wurzel gerichteter Baum
und t ist von s erreichbar }
UGAP := { (G , s, t) | G ist ein ungerichteter Graph
und t ist von s erreichbar }
Andreas Jakoby
Universität zu Lübeck
157
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
Es ist einfach zu erkennen, dass dieser Algorithmus das LabyrinthProblem löst. Betrachten wir den Algorithmus Walk-Labyrinth etwas
näher, so erkennen wir, dass bei einer herkömmlichen Kodierung des
Graphen, z.B. Adjazenzmatrix mit Knotennahmen der Länge O(log |V |),
der Platzbedarf dieses Verfahrens logarithmisch ist. Ferner fällt aus:
◮ Ist von jedem Knoten maximal ein anderer Knoten direkt erreichbar,
dann ist der Algorithmus deterministisch.
◮ Ist der Graph ungerichtet, dann ist der Algorithmus symmetrisch
nichtdeterministisch.
◮ Ist der Graph gerichtet, dann ist der Algorithmus
nichtdeterministisch.
◮
158
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
Fassen wir zusammen, so folgt:
Beobachtung 15
GAP ∈
UGAP ∈
TREE-GAP ∈
NL
SL
L
Im Folgenden werden wir zunächst zeigen, dass diese Probleme auch hart
für die entsprechenden Klassen sind.
Wählen wir den Knoten z zufällig unter allen Knoten, die von s aus
direkt erreichbar sind, und ist der Graph ungerichtet, dann ist der
Algorithmus randomisiert mit einseitigem Fehler.
159
160
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
Im Beweis von Satz 12 haben wir die Übergangsmatrix einer
logarithmisch-platzbeschränkten NTM kennen gelernt. In einer
Übungsaufgabe wurde gezeigt, dass es für jede
logarithmisch-platzbeschränkten NTM die Konstruktion dieser
Übergangsmatrizen in AC 0 und somit in N C 1 möglich ist. Interpretieren
wir nun die partiellen Konfigurationen als Knoten eines Graphen und die
Übergangsmatrix als Adjazenzmatrix dieses Graphen, dann erkennen wir:
Definition 27 Wir nennen ein Problem L hart oder schwer für eine
Komplexitätsklasse C bezüglich eines Reduktionstyps ≤, falls für alle
Probleme L′ ∈ C gilt:
L′ ≤ L .
Ein Problem L ist vollständig für eine Komplexitätsklasse C bezüglich
eines Reduktionstyps ≤, falls
◮ L hart für C bezüglich ≤ ist und ferner
◮
L in C liegt.
Frage: Wie können wir in endlicher Zeit zeigen, dass sich jedes Problem
einer unendlich großen Klasse auf ein Problem reduzieren läßt?
◮
◮
Der resultierende Graph einer NTM ist ein gerichteter Graph – für
einen Übergang C ⊢ C ′ muss es den Übergang C ′ ⊢ C nicht
unbedingt geben.
Der resultierende Graph einer symmetrischen NTM ist ein
ungerichteter Graph – für jeden Übergang C ⊢ C ′ muss es den
Übergang C ′ ⊢ C geben.
161
Andreas Jakoby
Universität zu Lübeck
◮
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
162
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
Der resultierende Graph einer DTM ist ein gerichteter Graph bei
dem jeder Knoten einen Ausgrad von maximal 1 hat.
◮
◮
Da es für jede Sprache in L, in SL oder in N L eine entsprechende TM
existiert, können wir folgern:
Fügen wir zu der DTM noch einen Schrittzähler hinzu, dann ist der
resultierende Graph G ein Wald aus Bäumen, die alle in Richtung zur
Wurzel gerichtet sind.
Addieren wir zu diesem Graph noch eine ausgezeichnete neue Wurzel
r , und verbinden wir jeden Knoten u aus G mit Ausgrad 0 mit r
durch eine Kante (u, r ), dann ist der resultierende Graph ein Baum,
der in Richtung zur Wurzel r gerichtet sind.
Satz 15
◮ GAP ist N L-vollständig bezüglich der N C 1 -Reduktion.
◮ UGAP ist SL-vollständig bezüglich der N C 1 -Reduktion.
◮ TREE-GAP ist L-vollständig bezüglich der N C 1 -Reduktion.
Wir haben bereits gesehen, dass wir jede TM durch eine TM ersetzen
können, die die gleiche Sprache akzeptiert und die gleichen
Platzschranken einhält, welche jedoch nur eine ausgezeichnete
akzeptierende Endkonfiguration Ca besitzt. Für diesen Typus von TM ist
die Frage ob die TM eine Eingabe akzeptiert folglich äquivalent zur
Frage, ob in dem entsprechenden Graph der Knoten Ca von C0 (x) (C0 (x)
entspricht der Startkonfiguration der TM) erreichbar ist.
Es ist einfach einzusehen, dass diese Vollständigkeiten auch bezüglich der
AC 0 -Reduktion gilt, wobei wir die AC 0 -Reduktion analog zur N C 1 -Reduktion
definieren.
163
164
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
5.2 Random-Walks und universelle Wegbeschreibung
Wir wollen jetzt zeigen, dass UGAP in RL und in L/poly ist. Da in der
heute bekannt ist, dass UGAL in L ist, verwundern uns diese Ergebnisse
nicht besonders. Wir zeigen dieses jedoch, indem wir den Algorithmus
Walk-Labyrinth(s, t) entsprechend anpassen. Dieses hat dann zur Folge:
◮
◮
Notationen:
◮
◮
Suchen wir in einer Stadt unser Ziel t, dann können wir dieses
erreichen, indem wir an jeder Kreuzung eine Münze werfen und
unsere Suche in die entsprechende Richtung fortsetzen.
Es gibt eine Wegbeschreibung, die in jeder Stadt mit gegebener
Größe gültig ist. Zudem ist die Wegbeschreibung unabhängig von
Start und Ziel.
◮
Hier soll noch davor gewarnt werden, diesen Strategien zu vertrauen,
wenn man es eilig hat. Der hierbei beschrittene Weg ist im Allgemeinen
erheblich länger als der kürzeste Weg und für die universelle
Wegbeschreibung werden wir nur deren Existenz nachweisen, sie jedoch
nicht konstruieren.3
Für einen Knoten v eines Graphen G sei d(v ) der Grad von v .
Mit dist(u, v ) bezeichnen wir die Distanz zwischen u und v , d.h. die
Länge es kürzesten Wegs von u nach v in G .
Wir betrachten nun die randomisierte Variante vom Algorithmus
Walk-Labyrinth, d.h. in Zeile 3 wählen wir zufällig einen Nachbarn z
vom aktuellen Knoten s. Genauer, sei z ein Nachbar von s, dann
1
als nächsten
wählen wir z mit einer Wahrscheinlichkeit von d(s)
Knoten.
◮
Der Algorithmus beschreibt somit einen randomisierten Lauf von
Knoten zu Knoten auf dem gegebenen Graphen.
◮
Dieses führt uns zu den sogenannten Markov-Kette.
3 Typisch Theorie: Schönes Ergebnis jedoch kein praktischer Nutzen, wenn man auf
Reisen geht.
165
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
Definition 28 (Teil 2) Die Übergangswahrscheinlichkeiten einer
Markov-Kette definieren eine Übergangsmatrix


p1,1 p1,2 . . . p1,n
 p2,1 p2,2 . . . p2,n 


P =  .
..
..  .
..
 ..
.
.
. 
pn,1 pn,2 . . . pn,n
Definition 28 [Markov-Kette] Sei X0 , X1 , . . . ∈ Σ eine Folge von
stochastischen Prozessen, die Werte aus einer endlichen oder unendlichen
Menge Σ annehmen können. Wenn für alle t ≥ 0 und alle i0 , . . . , it−1 gilt
pi,j
166
= Pr[Xt+1 = j|Xt = i, Xt−1 = it−1 , . . . , X0 = i0 ]
= Pr[Xt+1 = j|Xt = i] ,
Eine Verteilung π = (π1 , . . . , πn ) nennen wir stationär
P (in der Literatur
kennt man auch den Begriff invariant), wenn πi = j∈[1,n] πj · pj,i für alle
P
i ∈ [1, n] und 1 = i∈[1,n] πi , d.h. es gilt
so nennen wir diesen Prozess eine Markov-Kette. Die Wahrscheinlichkeiten
pi,j nennen wir die Übergangswahrscheinlichkeiten der Markov-Kette. Im
Folgenden wollen wir annehmen, dass Σ = [1..n] eine Teilmenge der
natürlichen Zahlen ist.
π = π·P .
167
168
Andreas Jakoby
Universität zu Lübeck
◮
◮
◮
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
Für die Übergangswahrscheinlichkeit pi,j von Knoten vi zum Knoten
vj erhalten wir
1
für {vi , vj } ∈ E
d(vi )
pi,j :=
0
sonst.
i∈[1,n]
=
X
1
d(vi ) =
2 · |E |
i∈[1,n]
Definition 29 Für die Übergangswahrscheinlichkeiten pi,j definieren wir
(t)
für t ≥ 1 pi,j als die Wahrscheinlichkeit vj von vi aus in t Schritten zu
erreichen, d.h.
(
pi,j
für t = 1
(t)
P
pi,j =
(t−1)
p
·
p
sonst. .
k,j
k∈Σ i,k
Eine Markov-Kette heißt irreduzibel, wenn für alle i, j ∈ Σ vj von vi aus
(t)
erreichbar ist, d.h. es existiert ein t ≥ 1, so dass pi,j > 0 ist.
1
· 2|E | = 1
2 · |E |
(0)
Sei Pi,j = 0 und für t > 0
(t)
Pi,j
und
X
j∈[1,n]
πj ·pj,i =
X
{vj ,vi }∈E
d(vj )
1
1
·
=
2 · |E | d(vj )
2 · |E |
X
1 =
{vj ,vi }∈E
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
Um den randomisierten Lauf besser verfolgen zu können, definieren wir:
Eine Verteilung π = (π1 , . . . , πn ) gibt die Wahrscheinlichkeiten πi
wieder, dass sich ein randomisierter Lauf im Konten vi befindet.
d(vi )
Sei P = (pi,j )i,j∈[1,n] , dann ist π = (π1 , . . . , πn ) mit πi = 2·|E
| für
i ∈ [1, n] eine stationäre Verteilung für G . Es gilt:
X d(vi )
2 · |E |
Andreas Jakoby
Universität zu Lübeck
d(vi )
.
2 · |E |
= Pr[ Xt = vj ∧ ∀k ∈ [0, t − 1] : Xk 6= vj | X0 = vi ] .
Wir nennen i rekurrent, wenn
P∞
t=0
(t)
Pi,i = 1 ist.
169
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
170
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
5. Vorlesung, 05.05.2008
Von großem Interesse ist in diesem Zusammenhang die erwartete Anzahl
von Schritten, um von einem Knoten vi zum ersten Mal zu einen Knoten
vj zu gelangen. Wir definieren für eine Folge X = x0 , x1 , . . . mit x0 = vi
Ti,j (X ) = min{ t ∈ N+ | xt = vj } .
Aus dem Satz 16 können wir für den randomisierten Lauf auf dem
ungerichteten Graphen G schließen:
Lemma 9 Für jeden Knoten vi ∈ V gilt
Satz 16 Sei X0 , X1 , . . . eine irreduzible Markov-Kette, dann sind die
folgenden Aussagen äquivalent:
1. Für alle i gilt E[Ti,i ] < ∞.
2. Für alle i, j gilt E[Ti,j ] < ∞.
E[Ti,i ] =
2 · |E |
.
d(vi )
3. Es existiert eine stationäre Verteilung π = (π1 , . . . , πn ). In diesem
Fall gilt
1
.
0 < πi =
E[Ti,i ]
Für einen endlichen Zustandsraum Σ sind die drei obigen Aussagen
immer erfüllt. Insbesondere gilt, dass eine irreduzible Markov-Kette mit
E[Ti,i ] < ∞ für alle vi genau eine stationäre Verteilung besitzt.
171
172
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
6. Vorlesung, 19.05.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
6. Vorlesung, 19.05.2008
Für die nun folgenden Untersuchungen über einen randomisierten Lauf
durch einen ungerichteten Graphen benötigen wir noch ein paar
Eigenschaften des Erwartungswerts:
Satz 17 Seien X1 , X2 zwei Zufallsvariablen deren Erwartungswerte
existieren, dann gilt:
1. Für alle c ∈ R existiert der Erwartungswert von c · X1 , und es gilt
E[c · X1 ] = c · E[X1 ].
2. Der Erwartungswert von X1 + X2 existiert, und es gilt
E[X1 + X2 ] = E[X1 ] + E[X2 ].
3. Sind X1 , X2 unabhängig, so existiert der Erwartungswert E[X1 · X2 ],
und es gilt E[X1 · X2 ] = E[X1 ] · E[X2 ].
4. Linearität des Erwartungswerts: Seien X1 , . . . , Xk Zufallsvariablen
und h : Rk → R eine lineare Funktion, dann gilt
Wir stellen fest:
◮
Die Wahrscheinlichkeit, dass wir eine bestimmte Kante {vi , vj }
wählen, wenn wir uns auf dem Knoten vi befinden, ist gleich d(v1 i ) .
◮
Die Wahrscheinlichkeit, dass wir diese Kante bei unserem t-en
Besuch von vi zum ersten Mal überschreiten ist geometrisch verteilt,
d.h. die Wahrscheinlichkeit, hierfür ist (1 − d(v1 i ) )t−1 · d(v1 i ) .
◮
Erwartungsgemäß wählen wir diese Kante bei jedem d(vi )-ten
Besuch von vi .
E[h(X1 , . . . , Xk )] = h(E[X1 ], . . . , E[Xk ]).
5. Seien X1 , X2 zwei unabhängige Zufallsvariablen und g , h zwei
beliebige Funktionen, dann gilt
E[g (X1 )f (X2 )] = E[g (X1 )] · E[f (X2 )] .
173
Andreas Jakoby
Universität zu Lübeck
◮
Computational Complexity SS 08
6. Vorlesung, 19.05.2008
Wir wählen g (X1 ) = Ti,i und f (X2 ) = t · (1 −
erhalten
E[g (X1 )f (X2 )] = E[g (X1 )]·E[f (X2 )] =
1
t−1
d(vi ) )
·
1
d(vi ) ,
174
Andreas Jakoby
Universität zu Lübeck
Lemma 10 Für eine Kante {vi , vj } in G gilt:
und
E[Ti,j ] + E[Tj,i ] ≤ 2 · |E | .
2 · |E |
·d(vi ) = 2·|E | .
d(vi )
Beweis von Lemma 10
◮
◮
◮
Computational Complexity SS 08
6. Vorlesung, 19.05.2008
Zusammenfassend gilt, dass die Kante {vi , vj } im Erwartungswert
nach 2 · |E | Schritten benutzt wird, bzw., dass wir diese Kante bei
einem langen Lauf alle 2 · |E | Schritte von vi nach vj überschreiten.
Die Frequenz des Übergangs von vi nach vj ist somit auf einem
1
langen Lauf auf diesem Graphen 2·|E
|.
◮
◮
175
Die erwartete Wartezeit zwischen zwei Überschreitungen der Kante
{vi , vj } von vi nach vj ist durch 2 · |E | beschränkt.
Hierfür muss es jedoch auch einen Lauf von vj zurück nach vi
zwischen zwei solchen Überschreitungen geben, d.h. innerhalb dieser
zwei Überschreitungen von {vi , vj }.
Die obere Schranke folgt unmittelbar.
176
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
6. Vorlesung, 19.05.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
6. Vorlesung, 19.05.2008
Sei Ti,· eine Zufallsvariable, welche einen zufälligen Rundweg durch G
von i nach i angibt, welcher alle Knoten von G besucht. Dann gilt:
Satz 18 E[Ti,· ] ≤ 2 · |E | · (n − 1) .
Beweis von Satz 18
◮
◮
◮
Beweis von Satz 18 (Teil 2)
◮
Sei H ein spannender Baum von G und
vi0 = vi , vi1 , . . . , vi2n−3 , vi2n−2 = vi ein Pfad in H, welcher alle Knoten
von H besucht (vi0 , vi1 , . . . , vi2n−3 , vi2n−2 traversiert H).
Dann ist E[Ti,· ] maximal gleich der erwarteten Zeit eines Laufs, bei
dem wir von vi0 nach vi1 , von vi1 nach vi2 , usw. laufen.
Es gilt also:
Wir können mit Hilfe von Lemma 10 den Wert von
E[Tik ,ik+1 ] + E[Tik ′ ,ik ′ +1 ] aus dieser Summe wie folgt begrenzen:
E[Tik ,ik+1 ] + E[Tik ′ ,ik ′ +1 ] = E[Tik ,ik+1 ] + E[Tik+1 ,ik ] ≤ 2 · |E | .
◮
Da die Summe in der obigen Abschätzung für E[Ti,· ] genau aus
n − 1 Paaren dieser Form besteht, gilt:
E[Ti,· ] ≤ 2 · |E | · (n − 1) .
E[Ti,· ] ≤ E[Ti0 ,i1 + Ti1 ,i2 + . . . + Ti2n−3 ,i2n−2 ]
= E[Ti0 ,i1 ] + E[Ti1 ,i2 ] + . . . + E[Ti2n−3 ,i2n−2 ] .
◮
Bei dieser Rundreise kommt jedes Paar u, v , welches in H durch eine
Kante verbunden ist, einmal in der Reihenfolge u, v und einmal in
der Reihenfolge v , u vor.
177
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
6. Vorlesung, 19.05.2008
Die oben gemachte Beobachtung, dass ein randomisierter Lauf durch
einen Graphen in erwarteter polynomieller Zeit ans Ziel führt, hat
Auswirkungen auf die Komplexität dieses Problems. Eine randomisierte
Turing-Maschine, welche einen solchen Lauf simuliert benötigt nur
logarithmischen Platz:
178
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
6. Vorlesung, 19.05.2008
Wir werden jetzt zeigen, dass für jedes Graphgröße n und für jeden Grad
d eine universelle Wegbeschreibung existiert:
Es existiert eine Wegbeschreibung wn,d die für jeden
ungerichteten Graphen G = (V , E ) mit |V | = n und d(v ) = d
für alle Knoten v einen Weg von jedem Start- zu jedem
Zielkonten beschreibt.
Satz 19 UGAP ist in RL.
179
180
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
6. Vorlesung, 19.05.2008
Definition 30
◮ Einen ungerichteten Graphen G nennen wir d-regulär falls alle
Knoten v in G den Grad d haben.
◮ Mit Γ(v ) := { u | {u, v } ∈ E } bezeichnen wir die Nachbarschaft
von v .
◮ Sei V ′ ⊆ V eine Teilmenge der Knoten von G , dann definieren wir
[
Γ(v )
Γ(V ′ ) :=
′
◮
◮
Computational Complexity SS 08
6. Vorlesung, 19.05.2008
Satz 20 Es existiert ein n-universeller Pfad der Länge
2dn(n − 1)(2dn + 2)⌈log2 n⌉ für Graphen mit Grad d.
Beweis von Satz 20:
◮ Sei Π eine zufällige gleichverteilte Sequenz aus {0, . . . , d − 1}∗ der
Länge 2dn(n − 1)(2dn + 2)⌈log2 n⌉.
◮ Für einen Graphen G von n Knoten und Grad d und Startknoten v
definieren wir die Zufallsvariable XG ,s (Π) wie folgt:

 1 wenn Π startend von s nicht alle
Knoten aus G besucht,
XG ,s (Π) =

0 sonst
v ∈V ′
′
Γ (V ) := V ∪ Γ(V ′ ) .
◮
′
Andreas Jakoby
Universität zu Lübeck
Mit nv : [0, d − 1] → Γ(v ) bezeichnen wir eine Aufzählung der
Nachbarn von v .
Eine Sequenz π = π1 . . . πm ∈ {0, . . . , d − 1}∗ interpretieren über die
Knotenfolge v0 , . . . , vm mit vi+1 = nvi (πi+1 ) als Pfad in einem
solchen Graphen G .
Eine Sequenz π nennen wir n-universell, wenn für jeden Graphen G
mit n Knoten und festem Grad d, für jede Wahl der Funktionen nv ,
und für jeden Startknoten s der Pfad π alle Knoten von G besucht.
ferner sei
X (Π) =
X
XG ,s (Π) .
G ,s
◮
◮
Für den Fall, dass Π eine n-universeller Pfad ist, gilt X (Π) = 0 ist.
Dieses folgt aus der Beobachtung, dass X (Π) die Anzahl der
Gegenbeispiele zu der Annahme, dass Π ein n-universeller Pfad ist,
zählt.
181
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
6. Vorlesung, 19.05.2008
182
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
6. Vorlesung, 19.05.2008
Beweis von Satz 20 (Teil 3): Aus der Linearität des Erwartungswerts
folgt:
X
E[X ] =
E[XG ,s ] .
G ,s
Wir wollen nun zeigen, dass E[XG ,s ] hinreichend klein ist:
◮ Wir zerlegen Π in Intervalle Π1 , Π2 , . . . , Π(2dn+2)⌈log n⌉ der Länge
2
2dn(n − 1).
◮ Aus Satz 18 folgt, dass E[Ts,· ] ≤ 2 · |E |(n − 1) = dn(n − 1) ist.
◮ Hier kommt die Markov-Ungleichung zur anwenden:
Beweis von Satz 20 (Teil 2): Die Schlüsselbeobachtung bei der nun
folgenden probabilistischen Methode ist:
Sei Π eine zufällige Sequenz. Ist der Erwartungswert E[X ] < 1,
dann hat dieses zur Folge, dass es einen Pfad π gibt, der in
jedem Graph G und von jedem Startknoten s, alle Knoten von
G besucht.
Satz 21 Sei T eine Zufallsvariable, die nur nicht-negative Werte
annimmt, dann gilt
Pr[T ≥ a] ≤
◮
183
E[T ]
.
a
Die Wahrscheinlichkeit, dass Π1 startend bei s alle Knoten aus G
besucht, ist zumindest 12 . Analog gilt, dass der Pfad Π2 startend von
dem Endknoten s ′ des Pfads Π1 alle Knoten aus G besucht,
zumindest 12 ist, usw.
184
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
6. Vorlesung, 19.05.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
6. Vorlesung, 19.05.2008
Beweis von Satz 20 (Teil 4):
◮
Die Wahrscheinlichkeit, dass keiner der Pfade Π1 , . . . , Π(2dn+2)⌈log2 n⌉
alle Knoten von G besucht, ist
≤ 2−(2dn+2)⌈log2 n⌉ ≤ n−(2dn+2) .
◮
Fügen wir jetzt zu jedem Knoten v noch n − d(v ) Schleifen der Form
{v , v } hinzu, so erhalten wir einen n-regulären Graphen (mit
Mehrfachkanten). Da Satz 20 auch für diese Form von Graphen gilt, gibt
es eine Sequenz der Länge O(n5 ⌈log2 n⌉) welche eine universelle
Wegbeschreibung für alle ungerichtete Graphen mit n darstellt. Stellen
wir diese Sequenz einer DTM als Advice zur Verfügung, so erhalten wir:
Das heißt: Für jeden Graphen G und für alle Knoten s gilt
E[XG ,s ] ≤ 2−(2dn+2)⌈log2 n⌉ ≤ n−(2dn+2) .
Da jeder Graph G vom Grad d für alle Funktion nv durch einen binären
String der Länge dn⌈log n⌉ beschrieben werden kann, ist die Anzahl
dieser Graphen durch n2dn beschränken. Somit gilt für alle Graphen mit
n ≥ 2 Knoten
P
P
−(2dn+2)
E[X ] =
G ,s E[XG ,s ] ≤
G ,s n
P 2dn −(2dn+2)
≤
·n
≤ n · n−2 = n1 < 1
sn
Satz 22 UGAP ist in L/poly .
185
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
6. Vorlesung, 19.05.2008
186
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
6. Vorlesung, 19.05.2008
5.3 UGAP ist in L
5.3.1 Expandergraphen
Im Wesentlichen basiert der Algorithmus von Reingold, mit dessen Hilfe
man UGAP auf logarithmischen Platz lösen kann, auf drei Beobachtungen:
In einem ersten Schritt werden wir Graphen untersuchen, die sich
besonders gut zum Ersetzen der Knoten mit hohem Grad eignen.
◮
◮
◮
Hat G einen konstanten Grad und liegen s und t nahe beieinander
(die Distanz von s und t ist nur logarithmisch), dann können wir
UGAP auf logarithmischen Platz deterministisch lösen.
Hat G einen hohen Grad, dann können wir diesen dadurch
reduzieren, indem wir jeden Knoten durch einen Graphen mit kleinen
Grad ersetzen, und jeden Knoten im eingesetzten Graphen mit
wenigen Kante im ursprünglichen Graphen inzidieren.
Definition 31 Sei G = (V , E ) ein ungerichteter Graph.
◮ G hat eine Knotenexpansion (k, a) falls für alle V ′ ⊆ V mit
|V ′ | ≤ k gilt
|Γ(V ′ )| ≥ a · |V ′ | .
Wir nennen einen Graphen mit Knotenexpansion (k, a) auch
(k, a)-Expander.
◮ Einen (|V |/2, a)-Expander nennen wir auch a-Expander.
Und noch eine Definition, deren Bedeutung für unsere Betrachtungen auf
den kommenden Folien deutlich werden sollte:
Sei A die Adjazenzmatrix von G und stehen auf der Diagonale von A
überall Einsen, dann halbiert sich der Abstand von s und t im
Graphen mit der Adjazenzmatrix A2 .
Leider verhalten sich die letzten beiden Punkte konträr zueinander und
leider ist es nicht so einfach einzusehen, dass die letzten beiden Punkt
auf beschränktem Platz durchgeführt werden können. Daher müssen wir
im Folgenden etwas tiefer in die Trickkiste greifen.
Definition 32 Für eine n × n-Matrix M ∈ Rn×n nennen wir einen Vektor
~v ∈ Rn Eigenvektor, falls für ein λ ∈ R M · ~v = λ · ~v ist. λ nennen wir
den zu ~v gehörigen Eigenwert.
187
188
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
6. Vorlesung, 19.05.2008
Andreas Jakoby
Universität zu Lübeck
Definition 32
◮ Für einen d-regulären ungerichteten Graphen G mit
Übergangsmatrix P sei
Beobachtung 16 Sei P die Übergangsmatrix eines ungerichteten
Graphens G und π = (π1 , . . . , πn ) ein stationäre Verteilung, d.h.
π = π · P, dann gilt P = P T und für den transponierten Vektor der
Verteilung π T = P · π T . Somit ist π T ein Eigenvektor der Matrix P mit
Eigenwert λ1 = 1.
λ2 =
◮
Im Folgenden gelte:
◮
◮
◮
Computational Complexity SS 08
6. Vorlesung, 19.05.2008
Wir betrachten d-reguläre (Multi-)Graphen – notfalls fügen wir noch
einige Schleifen {v , v } an Konten mit geringerem Grad an. Somit
sind die Einträge in der Übergangsmatrix P entweder d1 oder 0.
Die stationäre Verteilung setzen wir somit auf π = (π1 , . . . , πn ) mit
1
πi = |N|
.
◮
◮
max
kxk=1, x⊥π
kP · xk
der zweitgrößte Eigenwert von P.
G hat Spektralexpansion λ ∈ R falls für den zweitgrößten Eigenwert
λ2 ≤ λ gilt.
Die minimale Spektralexpansion von G bezeichnen wir auch mit
λ(G ).
Wir nennen einen d-regulären ungerichteten Graphen mit n Knoten
und mit Spektralexpansion λ auch (n, d, λ)-Expander.
Auf der folgenden Folie werden wir sehen, dass λ2 angibt, wie schnell
eine Graph dazu tendiert bei einem randomisierten Lauf die stationäre
Verteilung anzunehmen – je kleiner λ2 ist, desto schneller wird π
angenommen. λ beschreibt somit einen Wert für die Güte der
Expandereigenschaft des Graphen.
Wir betrachten π als Spaltenvektor.
189
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
6. Vorlesung, 19.05.2008
Beobachtung 17 Sei µP
∈ R eine Wahrscheinlichkeitsverteilungen, d.h.
n
µ1 , . . . , µn ∈ [0; 1] und i=1 µi = 1, und π = ( n1 , . . . , n1 ) dann gilt
entweder µ = π oder es existiert ein Vektor π̃ ∈ Rn , so dass
Satz 23 Sei G ein (n, d, λ)-Expander, dann verringert sich der Abstand
zwischen der stationären Verteilung π und einer beliebigen
Wahrscheinlichkeitsverteilung auf den Knoten der zu G gehörigen
Markov-Kette P bei jeder Schritt um einen Faktor ≤ λ.
Beweis von Satz 23 Sei π̃ = µ − π, dann gilt
P · µ − π = P · (π + π̃) − π = P · π − π + P · π̃ = P · π̃ .
Somit gilt für den zweitgrößten Eigenwert λ2
i=1
Folglich stehen π und π̃ orthogonal zueinander.
Computational Complexity SS 08
6. Vorlesung, 19.05.2008
i=1
π + π̃ = µ und π⊥π̃ .
◮
Andreas Jakoby
Universität zu Lübeck
Definition 33 Seien π und µ zwei Punkte im Rn , dann ist der Abstand
von π und µ bezüglich der euklidischen Norm
sX
kπ − µk = 2
|πi − µi |2 .
n
Beweis von Beobachtung 17 Wir untersuchen π̃ = µ − π.
◮ Sei s + die Summe der positiven Einträge in µ − π und s − die
Summe der negativen Einträge in µ − π.
Pn
Pn
+
−
◮ Da
i=1 πi =
i=1 µi = 1 ist, ist s = −s .
◮ Somit gilt
n
X
s+ + s−
π̃i
=
= 0.
π · π̃ =
n
n
190
kP · µ − πk = kP · π̃k ≤ λ2 · kπ̃k ≤ λ · kµ − πk .
191
192
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
6. Vorlesung, 19.05.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
6. Vorlesung, 19.05.2008
Die Bedeutung eines (n, d, λ)-Expander für UGAP folgt unmittelbar aus
Satz 23:
Korollar 7 Sei G ein (n, d, λ)-Expander, dann verringert sich der
Abstand zwischen der stationären Verteilung π und einer beliebigen
Wahrscheinlichkeitsverteilung auf den Knoten der zu G gehörigen
Markov-Kette P in ℓ Schritt um einen Faktor ≤ λℓ .
Die nachfolgenden beiden Korollare folgen unmittelbar aus Korollar 7 und
erlauben uns das UGAP-Problem für geeignete Expander in L zu lösen.
Beweis von Korollar 7 Der Beweis folgt per vollständiger Induktion über ℓ.
◮
Für ℓ = 1 folgt die Behauptung unmittelbar aus Satz 23.
◮
Wir gehen nun davon aus, dass für ℓ − 1 die Behauptung korrekt ist,
d.h. für µ̃ := P ℓ−1 µ gilt kµ̃ − πk ≤ λℓ−1 · kµ − πk.
Nach einer weiteren Iteration gilt
◮
Korollar 8 Sei G ein (n, d, λ)-Expander mit λ < 1, dann ist der Abstand
zwischen zwei beliebigen Knoten s, t des Expanders maximal 1 + log1/λ n.
Korollar 9 Sei G ein (n, d, λ)-Expander für konstante Werte d, λ mit
λ < 1, dann können wir UGAP auf G deterministisch auf Platz O(log n)
lösen.
kP ℓ · µ − πk = kP · µ̃ − πk ≤ λ · kµ̃ − πk ≤ λℓ · kµ − πk .
193
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
7. Vorlesung, 26.05.2008
Wie schon beschrieben, stellt die Gradreduktion ein wesentliches
Werkzeug für das Lösen des UGAP-Problem dar. Dieses erzielen wir
durch Substitution der Knoten mit hohem Grad im ursprünglichen
Graphen G durch spezielle Teilgraphen H. Als Substitutionsregel wählen
z
wir das sogenannte Zig-Zag Produkt G H.
Zunächst definieren wir uns
eine passende Graphenrepräsentation:
◮
Die Rotation-Map-Repräsentation von G definieren wir über eine
Funktion
RotG : V × [1..d] −→ V × [1..d]
Computational Complexity SS 08
7. Vorlesung, 26.05.2008
′
VG z H = { hv , ii | v ∈ V , i ∈ V }
Definition 34 Sei G = (V , E ) ein d-regulärer Graph.
Für einen Knoten v ∈ V bezeichnen wir mit (v , 1), . . . , (v , d) eine
Aufzählung der Kanten bzw. der Nachbarn von v .
Andreas Jakoby
Universität zu Lübeck
Definition 35 Sei G = (V , E ) ein (n, d1 , λ1 )-Expander und sei H = (V ′ , E ′ )
ein (d1 , d2 , λ2 )-Expander mit den dazugehörigen Rotation-Map-Repräsentationen RotG und RotH . Sei c : [1..d2 ] × [1..d2 ] → [1..d22 ] eine bijektive
Funktion. Ferner sei V = [1..n], V ′ = [1..d1 ] und hv , ii eine Paarungsfunktion
für v ∈ V und i ∈ V ′ .
z = (VG Das Zig-Zag Produkt G H
z H , EG z H ) von G und H ist ein
◮ d 2 -regulärer Graph mit n · d1 Knoten
2
5.3.2 Das Zig-Zag Produkt
◮
194
z die
wobei die Rotation-Map-Repräsentationen RotG z H von G H
folgende Bedingung erfüllen muss:
◮ Dann sei
RotG z H (hu, ii, c(a1 , a2 )) = (hv , ji, c(b1 , b2 ))
falls zwei Knote i ′ , j ′ ∈ V ′ existieren, so dass die folgenden
Bedingungen erfüllt sind:
wobei RotG (u, i) = (v , j) ist, falls v der i-te Nachbar von u und u
der j-te Nachbar von v ist.
◮
◮
◮
195
RotH (i, a1 ) = (i ′ , b2 ),
RotG (u, i ′ ) = (v , j ′ ) und
RotH (j ′ , a2 ) = (j, b1 ).
196
Andreas Jakoby
Universität zu Lübeck
G
Computational Complexity SS 08
7. Vorlesung, 26.05.2008
zH
G
3
1
2
2
2
1
3 3
2
1
4 3
2
5
2
3
◮
1
6
2
RotH (i , a1) = (1, b2)
2
RotH (3, a2) = (1, b1)
1
2
Die Teilgraphen Hv , die aus den Knoten hv , ii für ein festes v
bestehen nennen wir auch die Knotenwolke von v .
z besteht aus den folgenden Kanten
Die Kantenmenge von G H
EG zH
i ′ = 1 und j ′ = 3
2
1
2
2
3
H
◮
2
3
1
1
2
1
2
1
2
1
Computational Complexity SS 08
7. Vorlesung, 26.05.2008
z = (VG Für das Zig-Zag Produkt G H
z H , EG z H ) gilt:
◮ Die Knoten von G H
z bestehen aus allen Paaren hv , ii wobei v ein
Knoten aus G und i ein Knoten aus H ist.
3
2
1
Andreas Jakoby
Universität zu Lübeck
◮
3
= { {hu, ii, hv , ji} | sei i ′ , j ′ mit RotG (u, i ′ ) = (v , j ′ ) :
i ist ein Nachbar von i ′ in H und
j ist ein Nachbar von j ′ in H } .
Für die Rotation-Map-Repräsentationen ist es jetzt noch erforderlich
die Nachbarschaft von i ′ und j ′ in genauer zu untersuchen.
197
Andreas Jakoby
Universität zu Lübeck
G
Computational Complexity SS 08
7. Vorlesung, 26.05.2008
2
1
2
5
3
1
1
2
1
2
3
3
1−λ ≥
1
2
2
1
3
4
3
3
z
1 − λ(G H)
≥
3
2
1
2
5
6
3
3
1
· (1 − λ(G )) .
3
Satz 26 Sei G = (V , E ) ein (n, d1 , λ1 )-Expander und sei H = (V ′ , E ′ )
z ein (n · d1 , d22 , λ3 )-Expander mit
ein (d1 , d2 , λ2 )-Expander, dann ist G H
2
1
1
.
d · |V |2
Satz 25 Sei G = (V , E ) ein d-regulärer Graph und H ein d ′ -regulärer
Graph mit d Knoten mit λ(H) ≤ 21 , dann gilt
2
1
2
Computational Complexity SS 08
7. Vorlesung, 26.05.2008
Satz 24 Sei G = (V , E ) ein zusammenhängender d-regulärer
nicht-bipartiter Graph, dann hat G eine Spektralexpansion λ mit
1
6
2
2
1
4 3
2
1
Andreas Jakoby
Universität zu Lübeck
Aufgrund der Zeitbeschränkung dieser Vorlesung werden wir die folgenden
Sätze nicht beweisen.4
2
1
3 3
H
zH
G
3
198
λ3 ≤ λ1 + λ2 + λ22 .
4 Beweise finden wir im Skript von Dwork und Harsha, Expanders in Computer Science
(Stanford, 2005) und bei Reingold, Vadhan, Wigderson, Entropy Waves, The Zig-Zag
Graph Product, and New Constant-Degree Expanders and Extractors (Annals of Math,
2002).
199
200
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
7. Vorlesung, 26.05.2008
5.3.3 Konstruktion von (n, d, λ)-Expandergraphen
:= { hx, y i | x, y ∈ {0, . . . , q − 1} und y ≡ a · x − b mod q } .
La,b
Definition 36 Für zwei Graphen G = (VG , EG ), H = (VH , EH ) definieren
wir das Tensorprodukt G ⊗ H= (VG ⊗H , EG ⊗H ) über
Es gilt5
Satz 28 Der Graph APq = (V , E ) mit
:= { hu, v i | u ∈ VG , v ∈ VH }
:= { {hu, v i, hu ′ , v ′ i} | {u, u ′ } ∈ EG , {v , v ′ } ∈ EH } .
= { ha, bi | a, b ∈ {0, . . . , q − 1} }
V
= { {ha, bi, hx, y i} | a, b ∈ {0, . . . , q − 1} und hx, y i ∈ La,b }
E
Für die Rotation-Map-Repräsentationen von G ⊗ H definieren wir
⇐⇒
Computational Complexity SS 08
7. Vorlesung, 26.05.2008
Sei p eine Primzahl und q = p t eine Primzahlpotenz. Für
a, b ∈ {0, . . . , q − 1} sei
Zur Konstruktion von Expandergraphen benötigen wir noch eine weitere
Technik um zwei Graphen miteinander zu verknüpfen.
VG ⊗H
EG ⊗H
Andreas Jakoby
Universität zu Lübeck
ist ein (q 2 , q, √1q )-Expandergraph.
Rot(hu, v i, c(i, j)) := (hu ′ , v i′ , c(i ′ , j ′ ))
RotG (u, i) := (u ′ , i ′ ) und RotH (v , j) := (v ′ , j ′ ) .
Satz 27 Sei G = (V , E ) ein (n1 , d1 , λ1 )-Expander und sei H = (V ′ , E ′ )
ein (n2 , d2 , λ2 )-Expander, dann ist G ⊗ H ein (n1 · n2 , d1 · d2 , max{λ1 , λ2 })Expander.
Basierend auf APq können wir nun mit Hilfe von Tensorprodukt und
Zig-Zag Produkt immer größere Expandergraph generieren.
5 Beweis finden wir in Reingold, Vadhan, Wigderson, Entropy Waves, The Zig-Zag
Graph Product, and New Constant-Degree Expanders and Extractors (Annals of Math,
2002).
201
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
7. Vorlesung, 26.05.2008
Korollar 10 Sei APiq rekursive wie folgt definiert
APiq
:=
APq ⊗ APq
z
APi−1
q
q AP
dann ist APiq ein (q 2(i+1) , q 2 , √i q +
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
7. Vorlesung, 26.05.2008
Satz 29 Sei H = (V , E ) ein (d 4 , d, λ)-Expandergraphen mit λ ≤ 51 , dann
ist
2
H
falls i = 1
Gi :=
2 z
H falls i > 1
Gi−1
Aus den Sätzen 26 bis 28 folgt unmittelbar:
202
ein (d 4i , d 2 , λ′ )-Expandergraphen mit λ′ ≤ 25 .
falls i = 1
falls i > 1
Beweis von Satz 29 (Teil 1) Beachte:
◮
i−1
q )-Expandergraph.
◮
In der Literatur finden wir noch weitere (und effizientere) Konstruktionen
von Expandergraph. Für die Nachfolgenden Analysen genügt uns jedoch
dieses Ergebnis. Wählen wir q ≥ 149 so erhalten wir mit i = 3 eine
Familie von (d 4 , d, 51 )-Expandergraphen. Diese erweist sich als sehr
Hilfreich bei der Konstruktion weiterer Expandergraphen.
Wir betrachten Multigraphen. Somit ist G 2 ein d 2 -regulärer Graph,
wenn G ein d-regulärer Graph ist.
Sei P eine Übergangsmatrix, dann gilt für einen Eigenvektor π ′ mit
Eigenwert λ̃:
P 2 · π ′ = P · λ̃ · π ′ = λ̃2 · π ′ .
◮
203
Sind alle Eigenwerte positiv und ist λ̃ der zweitgrößte Eigenwert von
P, dann ist λ̃2 der zweitgrößte Eigenwert von P 2 .
Wir erhalten: H 2 ist ein (d 4 , d 2 , λ′ )-Expandergraphen mit
1
≤ 52 .
λ′ ≤ 25
204
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
7. Vorlesung, 26.05.2008
Gi−1 ein (d 4(i−1) , d 2 , λ′ )-Expandergraphen mit λ′ ≤
Somit ist
2
Gi−1
ein (d
4(i−1)
4
′′
2
5
ist.
′′
, d , λ )-Expandergraphen mit λ ≤
Algorithmus Reingold(G , s, t)
Eingabe: d 16 -regulärer nicht-bipartiter Graph G = (V , E ) und s, t ∈ V
Ergebnis: 1 falls t von s in G erreichbar ist
2ℓ
1: wähle ℓ ∈ N minimal, so dass 1 − d 161n2
≤ 12 ist
2: setze G0 = G
3: bestimme einen (d 16 , d, 21 )-Expandergraphen H
4: for i = 1 to ℓ by +1 do
z 8
5:
bestimme Gi := (Gi−1 H)
6: end for
7: teste ob t von s in Gℓ erreichbar ist
8: Return(1) falls ja und Return(0) sonst
4
25 .
Aus Satz 26 folgt: Gi ist bei (d 4i , d 2 , λ′′′ )-Expandergraphen mit
λ′′′ ≤ λ′′ + λ + λ2 =
1
1
4
+ +
25 5 25
=
Computational Complexity SS 08
7. Vorlesung, 26.05.2008
5.3.4 Reingold’s Algorithmus für UGAP
Beweis von Satz 29 (Teil 2) Induktiv nehmen wir nun an, dass
◮
Andreas Jakoby
Universität zu Lübeck
2
.
5
Mit Hilfe von Satz 29 können wir somit beliebig große Expandergraphen
mit festem Grad und fester Spektralexpansion generieren.
205
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
7. Vorlesung, 26.05.2008
Was ist zu zeigen?
◮ Gℓ hat konstante Spektralexpanson.
◮ Bei gegebener Rotation-Map-Repräsentation von Gℓ kann UGAP in
L gelöst werden. Dieses folgt analog zu Korollar 9.
◮ Die Rotation-Map-Repräsentation von Gℓ kann aus der Rotation-MapRepräsentation von G0 auf logarithmischen Platz konstruiert werden.
Im ersten Schritt wollen wir untersuchen, wie sich der Wert der
Spektralexpanson von Gi mit i entwickelt.
206
Andreas Jakoby
Universität zu Lübeck
Beweis von Lemma 11 (Teil 2)
◮ Fall 1: λ(Gi−1 ) ≤ 1 . Es gilt
2
λ(Gi ) =
◮
Lemma 11 λ(Gi ) ≤ max{ 12 , (λ(Gi−1 ))2 } für alle i ∈ {1, . . . , ℓ}.
8
z
λ(Gi ) = (λ(Gi−1 H))
.
λ(Gi ) ≤
1−
1 − λ(Gi−1 )
3
1−
1−x
3
4
1
2
≤ x ≤ 1 gilt
≤ x .
Somit gilt
λ(Gi ) ≤ (λ(Gi−1 ))2 .
Aus Satz 25 folgt
8
8
1
5
<
.
6
2
Fall 2: λ(Gi−1 ) > 12 . Für alle x ∈ R mit
Beweis von Lemma 11 (Teil 1) Wie wir im Beweis von Satz 29
gesehen haben gilt:
Computational Complexity SS 08
7. Vorlesung, 26.05.2008
.
207
208
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
7. Vorlesung, 26.05.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
7. Vorlesung, 26.05.2008
Lemma 12 Die Spektralexpanson von Gℓ ist maximal 21 .
Beweis von Lemma 12 Aus Satz 24 folgt
λ(G0 ) ≤ 1 −
1
.
d 16 · n2
◮
Wir müssen somit nur noch zeigen, dass die Rotation-Map-Repräsentation von Gℓ aus der Rotation-Map-Repräsentation von G0 auf
logarithmischen Platz konstruiert werden kann.
◮
Da wir zeigen wollen, dass UGAP in L liegt, können wir
Reingold(G , s, t) nicht so wie er angegeben ist ausführen. Wir
können ja Gℓ nirgends speichern! Vielmehr, müssen wir zeigen, dass
wir RotGℓ (u, i) auf Eingabe u, i, G0 und ℓ auf logarithmischen Platz
berechnen können.
Somit folgt aus Lemma 11
λ(Gi ) ≤
1−
1
d 16 · n2
2i
und folglich gilt
λ(Gℓ ) ≤
1
1 − 16 2
d ·n
2ℓ
≤
1
.
2
209
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
7. Vorlesung, 26.05.2008
◮
◮
◮
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
7. Vorlesung, 26.05.2008
Algorithmus Rot1(k, u, i)
Eingabe: globaler Graph F = (V , E ) und
als Parameter k ∈ N, u ∈ V , i = c(i1 , i2 ) ∈ N
Ergebnis: RotF 2k (u, c(i1 , i2 )) = (v , c(j1 , j2 ))
1: if k = 0 then
2:
Return(RotF (u, i))
3: else
4:
bestimme i1 , i2
5:
speichere i2 und berechne (w , j2 ) = Rot1(k − 1, u, i1 )
6:
speichere j2 und berechne (v , j1 ) = Rot1(k − 1, w , i2 )
7:
Return((v , c(j1 , j2 ))
8: end if
Zusätzlicher Platzbedarf um für einen Graphen F 2 den Wert
RotF 2 (u, c(i1 , i2 )) = (v , c(j1 , j2 )) zu bestimmen:
◮ Sei H ein d-regulärer Graph und c die Kodierungsfunktion, mit
dessen Hilfe wir ein Paar i1 , i2 kombinieren können. Wir suchen:
◮
210
RotF (u, i1 ) = (w , j2 ) und
RotF (w , i2 ) = (v , j1 ) und erhalten dann
RotF 2 (u, c(i1 , i2 )) = (v , c(j1 , j2 )).
Da uns nur das Ergebnis interessiert, können wir die Eingabe
(u, c(i1 , i2 )) überschreiben.
211
212
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
7. Vorlesung, 26.05.2008
Im zweiten und dritten Schritt merkt sich der Algorithmus nur i2 oder j2 .
Der Speicher für u bzw. w kann in der rekursiven Berechnung von Rot
benutzt werden. Der Platzbedarf s(k) ist somit
k
log Grad(F 2 ) + max{(log Grad(H 2
k−1
) + log k + log |V |), s(k − 1)} .
k
Der zusätzliche Platzbedarf ist somit logarithmisch im Grad von F 2 .
Um im Algorithmus von Reingold den Wert RotF (u, c(i1 , i2 )) = (v , c(j1 , j2 ))
zu bestimmen gehen wir ähnlich vor. Jedoch müssen wir berücksichtigen,
dass nach drei Quadrierungen ein Zig-Zag Produkt berechnet wird.
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
7. Vorlesung, 26.05.2008
Algorithmus Rot(k, r , u, h)
Eingabe: globale Graphen G , H und k, r ∈ N, u ∈ V , h = c(i1 , i2 ) ∈ N
Ergebnis: RotGk (u, c(i1 , i2 )) = (v , c(j1 , j2 )) für r = 3
1: if k = 0 then
2:
Return(RotF (u, h))
3: else
4:
bestimme i1 , i2 mit h = c(i1 , i2 )
5:
if r > 0 then
6:
speichere i2 und berechne (w , j2 ) = Rot(k, r − 1, u, i1 )
7:
speichere j2 und berechne (v , j1 ) = Rot(k, r − 1, w , i2 )
8:
Return((v , c(j1 , j2 ))
9:
else
10:
bestimme u ′ und i mit u = hu ′ , ii
11:
bestimme i ′ und j2 mit RotH (i, i1 ) = (i ′ , j2 )
12:
speichere j2 und i2 und berechne (v , j ′ ) = Rot(k − 1, 3, u, i ′ )
13:
bestimme j und j1 mit RotH (j ′ , i2 ) = (j, j1 )
14:
Return((hv , ji, c(j1 , j2 ))
15:
end if
16: end if
213
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
7. Vorlesung, 26.05.2008
Beachte:
◮ Der Grad aller betrachteten Graphen ist polynomiell in d.
◮ Der Graph H ist fest und der Speicherplatz zur Berechnung von
RotH (i, i1 ) = (i ′ , j2 ) kann in jeder Rekursionsstufe wiederverwendet
werden.
◮ Der Platzbedarf von Rot(k, r , u, i) ist somit in
214
Andreas Jakoby
Universität zu Lübeck
◮
◮
O(k · log d + size(RotG ) + size(RotH ))
◮
Starten wir bei dem Versuch UGAP zu lösen mit einer
Gradreduktion, dann können wir davon ausgehen, dass d konstant
ist.
Der Wert von k ist durch ℓ beschränkt, wobei wir ℓ ∈ N minimal
2ℓ
wählen, so dass 1 − d 161n2
≤ 21 ist. Da
wobei das additive size(RotG ) aus der Verankerung der Rekursion
folgt und size(RotH ) sich aus dem Platzbedarf für einen Aufruf von
RotH bei der Berechnung des Zig-Zag Produktes ergibt.
Für die meisten Graphdarstellungen können wir den Vergleich
RotG (u, i) = (v , j)
◮
Computational Complexity SS 08
7. Vorlesung, 26.05.2008
◮
◮
auf logarithmischen Platz überprüfen. Somit können wir alle
Viertupel (u, i, v , j) auch auf logarithmischen Platz prüfen, ob
RotG (u, i) = (v , j) ist.
Der Platzbedarf von Rot(k, r , u, i) ist somit in
1
1−
x
x
≤ e −1 ≤
1
2
ist, erhalten wir ℓ ≤ 16 log d + 2 log n.
Der Platzbedarf von Rot(ℓ, 3, u, i) ist somit in O(log |V |).
Da wir den Speicherplatz zur Berechnung von Rot(ℓ, 3, u, i) bei jeder
Berechnung wiederverwenden können, erhalten wir die gewünschte
Platzschranke.
Satz 30 UGAP ist in L.
O(k · log d + log |V |) .
215
216
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
8. Vorlesung, 02.06.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
8. Vorlesung, 02.06.2008
5.4 2-SAT und GAP
Zur Erinnerung: Sei F eine Boolesche Formel.
◮
◮
Definition 38 Wir definieren das k-SAT-Problem wie folgt:
Gegeben ist eine Boolesche Formel F in k-CNF. Entscheide, ob F
erfüllbar ist, d.h. existiert eine Belegung der Variablen von F , so dass F
bei dieser Belegung true ist.
Ein Literal ist eine Variable oder deren Negation.
Eine Klausel ist eine Disjunktion, d.h. eine or-Verknüpfung, von
Literalen.
Eine Monom ist eine Konjunktion, d.h. eine and-Verknüpfung, von
Literalen.
◮ F ist in konjunktiver Normalform, kurz CNF, wenn F eine
Konjunktion von Klauseln ist.
◮ F ist in disjunktiver Normalform, kurz DNF, wenn F eine
Disjunktion von Monomen ist.
Definition 37 Sei F eine Boolesche Formel und k ∈ N.
◮
◮
◮
Mit Hilfe des GAP-Problems wollen wir nun zeigen, dass das Komplement
von 2-SAT vollständig für N L ist. Um uns die Notation zu vereinfachen,
führen wir noch folgende Schreibweise ein:
Definition 39 Sei C eine Komplexitätsklasse, dann definieren wir
co-C
:= { L | L ∈ C }
als die Komplexitätsklasse der komplementären Sprachen von C.
F ist in k-CNF, falls F in CNF ist und jede Klausel aus genau k
Literalen besteht.
F ist in k-DNF, falls F in DNF ist und jedes Monom aus genau k
Literalen besteht.
217
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
8. Vorlesung, 02.06.2008
218
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
8. Vorlesung, 02.06.2008
Betrachten wir das Modell der nichtdeterministischen Turing-Maschine,
so können wir basierend auf diesen komplementären Sprachen ein neues
Modell einer Turing-Maschine vorstellen:
Definition 40 Wir definieren eine co-NTM M analog zur NTM mit dem
Unterschied, dass die von M akzeptierte Sprache wie folgt definiert wird
Der folgende Satz folgt unmittelbar aus der Definition der many-one
Reduktion:
L(M) := { x ∈ Σ∗E | für alle Berechnungen CM (x) gilt Res(CM (x)) = 1 } .
Satz 31 Sei C eine Komplexitätsklasse und L eine beliebige Sprache,
dann gilt: L ist genau dann C-vollständig bezüglich einer many-one
Reduktion ≤, wenn L co-C-vollständig bezüglich ≤ ist.
Um die NTM von der co-NTM unterscheiden zu können sagen wir auch
◮ die NTM rät existenziell und
◮ die co-NTM rät universell.
Die Komplexitätsmasse co-NTime, co-NSpace und co-NTimeSpace der
co-NTM definieren wir analog zu den entsprechenden Komplexitätsmassen
der NTM.
Unser Ziel ist es nun, den folgenden Satz zu beweisen:
Satz 32 2-SAT ist co-N L vollständig.
Beobachtung 18 Es gilt
co-N L
co-N P
=
=
co-NSpace(Log)
co-NTime(Pol) .
219
220
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
8. Vorlesung, 02.06.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
8. Vorlesung, 02.06.2008
Vm
Beweis von Satz 32 (Teil 1) Sei F = i=1 Ci mit Ci = li,1 ∨ li,2 und
li,0 , li,1 ∈ {x1 , x 1 , . . . , xn , x n } eine Boolesche Formel in 2-CNF. Zunächst
wollen wir zeigen, dass die Frage ob F erfüllbar ist mit Hilfe der
Erreichbarkeit entschieden werden kann.
◮
Beweis von Satz 32 (Teil 2)
Wir konstruieren einen Graph GF = (VF , EF ) wie folgt:
Analoges gilt für den Fall, dass es einen Pfad in GF von x i nach xi
gibt. Existiert ein solcher Pfad, dann gilt für jede Belegung mit
xi = 0, dass F durch diese Belegung nicht erfüllt werden kann.
◮ Gibt es in GF einen Pfad von xi nach x i und einen Pfad von x i nach
xi , dann ist F nicht erfüllbar.
Wir wollen jetzt zeigen, dass F erfüllbar ist, falls es kein solches Paar
xi , x i gibt.
◮
VF
EF
◮
◮
:= { xi , x i | i ∈ {1, . . . , n} }
:= { (l i,1 , li,2 ), (l i,2 , li,1 ) | i ∈ {1, . . . , m} }
Wir betrachten den Fall, dass es ein Knotenpaar xi , x i und einen
Pfad von xi nach x i in GF gibt. Sei xi , li1 , . . . , lik , x i dieser Pfad.
Aus der Definition von GF folgt, dass die Klauseln
(x i ∨ li1 ), (l i1 ∨ li2 ), . . . , (l ik−1 ∨ lik ), (l ik ∨ x i )
◮
in F vorkommen.
Für jede Belegung mit xi = 1 folgt aus dieser Beobachtung, dass F
durch diese Belegung nicht erfüllt werden kann.
221
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
8. Vorlesung, 02.06.2008
Beweis von Satz 32 (Teil 3) Den folgenden Schritt wiederholen wir, bis
alle Literale einen Wert besitzen.
◮ Sei li ein Knoten in GF , so dass es keinen Pfad von li nach l i gibt
und li noch keinen Wert besitzt. Wir setzen alle Literale (bzw.
Knoten) die vom Literal li erreichbar sind auf true. Die Negation
dieser Literale setzen wir auf false.
◮ Dieser Schritt ist wohl definiert. Begründung: In GF gibt es genau
dann eine Kante (la , lb ), wenn es auch die Kante (l b , l a ) gibt.
Angenommen, es gibt einen Pfad von li nach lj . Dann gibt es auch
einen Pfad von l j nach l i . Gibt es jetzt auch noch einen Pfad von li
nach l j , dann gibt es einen Pfad von li nach l i – ein Widerspruch zu
unserer Wahl von li .
222
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
8. Vorlesung, 02.06.2008
Beweis von Satz 32 (Teil 4) Wie sieht der Algorithmus der co-NTM
aus:
Algorithmus 2-SAT(F )
Eingabe: 2-CNF F
Ergebnis: 1 falls F erfüllbar ist
1: rate universell ein Literal li
2: überprüfe universell ob alle Pfade in GF nicht nach l i führen
3: if es existiert ein Pfad von li nach l i then
4:
überprüfe universell ob alle Pfade in GF nicht von l i nach li führen
5:
if es existiert ein Pfad von l i nach li then
6:
Return(0) und stoppe die Berechnung
7:
end if
8: end if
9: Return(1)
Analog zu der zuletzt gemachten Beobachtung können wir zeigen, dass
die so generierte Belegung der Knoten keine Kante von einem mit true
belegten Knoten zu einem mit false belegten Knoten besitzt. Somit ist in
jeder Klausel zumindest ein Literal mit true belegt.
Es bleibt jetzt noch zu zeigen, dass 2-SAT co-N L-hart ist.
223
224
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
8. Vorlesung, 02.06.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
8. Vorlesung, 02.06.2008
Beweis von Satz 32 (Teil 5) Wir erinnern uns: Ist eine Sprache L wie
das GAP Problem N L vollständig, so ist deren Komplement co-N L
vollständig. Unser Ziel ist somit eine Reduktion von GAP auf 2-SAT.
◮
◮
◮
◮
◮
◮
◮
Beweis von Satz 32 (Teil 6)
◮ Ist t von s nicht erreichbar, dann ist FG erfüllbar.
Sei G = (V , E ) und s, t ∈ V eine Instanz für das GAP Problem, d.h.
wir wollen Testen, ob t von s nicht erreichbar ist.
Wir generieren folgende 2-CNF FG :
◮
Die Menge der Variablen ist durch V gegeben.
Für jede Kante (u, v ) ∈ E generieren wir die Klausel (u ∨ v ).
Abschließend führen wir die Klauseln (s ∨ s) und (t ∨ t) hinzu.
◮
Diese Reduktion kann einfach auf logarithmischen Platz
durchgeführt werden.
Ist t von s über einen Pfad s, v1 , . . . , vk , t erreichbar, dann ist FG
nicht erfüllbar.
◮
◮
◮
◮
Wie wir oben gesehen haben, müssen wir alle Knoten (bzw.
Variablen) die von s aus erreichbar sind auf true setzten. Diese
Belegung erfüllt alle Klauseln, die von s aus erreichbar sind.
Setzten wir alle Knoten, die von s aus nicht erreichbar sind auf false,
so werden durch deren Negation alle Klauseln erfüllt, deren Kanten
in einem Knoten starten, der von s aus nicht erreichbar ist. Dieses
sind aber alle verbleibenden Klauseln – insbesondere auch die Klausel
(t ∨ t).
FG wird durch diese Belegung erfüllt.
Angenommen FG ist doch erfüllbar, dann muss s = 1 gelten.
Somit muss v1 = 1 gelten und weiter muss für alle Variablen vi = 1
gelten.
Da somit t = 1 sein muss, ist die Klausel (t ∨ t) nicht erfüllt.
225
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
8. Vorlesung, 02.06.2008
226
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
8. Vorlesung, 02.06.2008
Beweis von Satz 33 Satz 33 folgt unmittelbar aus den Sätzen 12 und
11.
5.5 N L versus L und co-N L
◮
Es ist einfach zu erkennen, dass L ⊆ N L gelten muss. Wir wollen nun
die Frage untersuchen, wie wir N L in deterministischen Platz einbetten
können und wie N L zu co-N L steht.
◮
Satz 33 Sei L ∈ NSpace(s) und sei s auf Platz s berechenbar, dann gilt
L ∈ DSpace(s 2 ).
◮
Aus diesem Satz folgt sofort:
Korollar 11 Jede Sprache aus N L kann von einem
log2 -platzbeschränkten DTM berechnet werden.
◮
Sei L ∈ NSpace(s), dann ist L ∈ NTimeSpace(2O(s) , s).
Nach Satz 12 kann L von einer 2O(s) -größen- und
log 2O(s) -tiefenbeschränkten s-platzkonstruierbaren Schaltkreisfamilie
mit unbeschränktem Eingrad akzeptiert werden.
Ersetzen wir die einzelnen Gatter durch Bäume, so kann L von einer
2O(s) -größen- und (log 2O(s) )2 -tiefenbeschränkten
s-platzkonstruierbaren Schaltkreisfamilie mit beschränktem Eingrad
akzeptiert werden.
Nach Satz 11 gilt somit
L ∈ DSpace(s + (log 2O(s) )2 ) = DSpace(s 2 ) .
227
228
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
8. Vorlesung, 02.06.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
8. Vorlesung, 02.06.2008
Beweis von Satz 34 (Teil 1) Es reicht aus die Inklusion
co-NSpace(s) ⊆ NSpace(s)
Der nachfolgende Satz ist in der Literatur unter dem Namen Satz von
Immerman/Szelepcsényi bekannt.
zu zeigen.
◮
Satz 34 Für auf Platz s berechenbare Funktionen s ≥ log gilt
◮
NSpace(s) = co-NSpace(s) .
◮
Aus diesem Satz folgt unmittelbar:
Satz 35 N L = co-N L
◮
Satz 36 2-SAT ist N L vollständig.
◮
◮
Sei L ∈ NSpace(s) und M eine s-platzbeschränkte NTM für L.
Da s s-platzberechenbar ist, können wir annehmen, dass s(n)
bekannt ist.
Wir können annehmen, dass M eine eindeutige akzeptierenden
Endkonfiguration Ca besitzt und dass jede Berechnung von M die
gleiche Länge TM (n) ≤ 2c·s(|x|) besitzt.
Sei Cx die Menge aller s(|x|)-platzbeschränkten Konfigurationen von
M auf Eingabe x. Es gilt |Cx | ≤ 2c·s(|x|) für eine Konstante c.
Sei Cx (t) die Menge aller s(|x|)-platzbeschränkten Konfigurationen
von M auf Eingabe x, die M in exakt t Schritten von der
Startkonfiguration aus erreicht.
Sei cx (t):= |Cx (t)|.
229
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
8. Vorlesung, 02.06.2008
230
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
8. Vorlesung, 02.06.2008
Beweis von Satz 34 (Teil 2)
◮
Für jede Konfiguration C gilt
C 6∈ Cx (t)
◮
⇐⇒
Cx (t) enthält cx (t) Konfiguration C ′ mit C 6= C ′ .
Ferner gilt
Beweis von Satz 34 (Teil 3)
◮ Ist cx (t) bekannt, dann können wir nichtdeterministisch testen, ob
C 6∈ Cx (t) ist:
◮
M akzeptiert x nicht ⇐⇒ Ca 6∈ Cx (TM (|x|))
⇐⇒ Cx (TM (|x|)) enthält cx (TM (|x|))
◮
verwerfende Konfiguration.
◮
◮
◮
Ist cx (t) bekannt, dann können wir nichtdeterministisch testen, ob
C ∈ Cx (t) ist:
◮
Rate existentiell sukzessive eine Berechnung
Setze einen Zähler z = 0.
Teste sukzessive für alle Konfiguration C ′ ∈ Cx mit C ′ 6= C , ob
C ′ ∈ Cx (t) ist. Ist dieses der Fall, dann setze z := z + 1.
Am Ende gilt genau dann C 6∈ Cx (t), wenn z = cx (t) ist.
Wir wollen nun diesen Test verallgemeinern, indem wir für einen
Schätzwert c von cx (t) überprüfen, ob eine Konfiguration von r
verschiedenen in t Schritten erreicht werden kann.
C0 (x) ⊢ C1 ⊢ . . . Ct
wobei wir beim raten einer Konfiguration Ci die Vorgängerkonfiguration
Ci−1 überschreiben. Akzeptiere genau dann, wenn Ct = C ist.
231
232
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
8. Vorlesung, 02.06.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
8. Vorlesung, 02.06.2008
Beweis von Satz 34 (Teil 4)
Beweis von Satz 34 (Teil 5)
Algorithmus IS-Reach(t, c, D1 , . . . , Dr )
Eingabe: Zeitpunkt t, Schätzwert c, Konfigurationen D1 , . . . , Dr
Ergebnis: true für Di ∈ Cx (t), false für Di 6∈ Cx (t), ? wenn noch unbekannt
1: anzahl := 0
2: for C ∈ Cx in lexikografischer Ordnung do
3:
rate existentiell die Berechnung C0 (x) ⊢ C1 ⊢ . . . ⊢ Ct auf Platz s(|x|)
4:
if Ct = C then anzahl := anzahl +1 end if
5:
if Ct ∈ {D1 , . . . , Dr } then Return(true) end if
6: end for
7: if anzahl = c then Return(false) end if
8: if anzahl < c then Return(?) end if
Lemma 13 Ist c = cx (t) und ist das Ergebnis von
IS-Reach(t, c, D1 , . . . , Dr ) true oder false, dann ist dieses Ergebnis
korrekt.
Beweis von Lemma 13
◮
◮
Ist das Ergebnis true, dann haben wir eine Berechnung existentiell
geraten, die diese Behauptung beweist.
Ist das Ergebnis false, dann haben wir c = cx (t) Berechnung
existentiell geraten, die Behauptung Di ∈ Cx (t) für irgend eine
Konfiguration Di ∈ {D1 , . . . , Dr } wiederlegen. Somit gilt Di 6∈ Cx (t)
für alle Di ∈ {D1 , . . . , Dr }.
Ist c = cx (t), dann gibt IS-Reach(t, c, D1 , . . . , Dr ) auf einer Berechnung
von IS-Reach das korrekte Ergebnis true oder false aus! Beachte ferner,
dass sich IS-Reach auf einer O(s(x))-platzbeschränkten NTM
implementieren läßt.
Liefert IS-Reach(t, c, D1 , . . . , Dr ) als Ergebnis ?, dann ist anzahl < c. In
diesem Fall wurden in der for-Schleife aufgrund des existenziellen Ratens
nicht alle Konfigurationen C ∈ Cx (t) gefunden. Wir können in diesem
Fall weder Di ∈ Cx (t) noch Di 6∈ Cx (t) ausschließen.
Im nächsten Schritt wollen wir zeigen, wie wir cx (t) berechnen können.
233
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
8. Vorlesung, 02.06.2008
234
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
8. Vorlesung, 02.06.2008
Beweis von Satz 34 (Teil 7)
Lemma 14 Ist c = cx (t − 1) und ist das Ergebnis von d = IS-Count(t, c)
in N, dann gilt d = cx (t).
Beweis von Satz 34 (Teil 6)
Algorithmus IS-Count(t, c)
Eingabe: Zeitpunkt t, c = cx (t − 1)
Ergebnis: cx (t) oder ? wenn noch unbekannt
1: d := 0
2: for C ∈ Cx in lexikografischer Ordnung do
3:
bestimme alle möglichen direkten Vorgängerkonfigurationen
D1 , . . . , Dr von C
4:
z = IS-Reach(t − 1, c, D1 , . . . , Dr )
5:
if z = true then d := d + 1 end if
6:
if z = ? then Return(?) end if
7: end for
8: Return(d)
Beweis von Lemma 14
◮
Stoppt IS-Count(t, c) nicht forzeitig mit Return(?), dann findet
IS-Count(t, c) alle Konfigurationen C ∈ Cx , für die eine
Vorgängerkonfiguration in t − 1 Schritten vom der
Startkonfiguration aus erreichbar ist – vergleiche hierzu Lemma 13.
Da in IS-Count(t, c) die Anzahl dieser Konfigurationen gezählt wird,
ist da Ergebnis entweder ? oder cx (t).
Ist c = cx (t − 1), dann gibt IS-Count(t, c, D1 , . . . , Dr ) auf einer Berechnung
von IS-Count das korrekte Ergebnis cx (t) aus! Beachte ferner, dass sich
IS-Count auf einer O(s(x))-platzbeschränkten NTM implementieren läßt.
◮
Im nächsten Schritt wollen wir zeigen, wie wir mit Hilfe von IS-Reach
und IS-Count nichtdeterministisch entscheiden können, ob M auf
Eingabe x keine akzeptierende Berechnung besitzt.
235
236
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
8. Vorlesung, 02.06.2008
Beweis von Satz 34 (Teil 8) Es verbleibt somit noch einen Algorithmus
zu präsentieren, mit dessen Hilfe wir das Komplement von L in
NSpace(s) akzeptieren können.
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
8. Vorlesung, 02.06.2008
Beweis von Satz 34 (Teil 9) Abschließend müssen wir noch die
Korrektheit von CompL(x) zeigen.
◮
Algorithmus CompL(x)
Eingabe: Eingabe x
Ergebnis: akzeptiere, falls x 6∈ L
1: cx (0) := 1
2: bestimme T (|x|)
3: for t = 1 to T (|x|) by +1 do
4:
if cx (t − 1) 6= ? then
5:
cx (t) := IS-Count(t, cx (t − 1))
6:
else
7:
cx (t) := ?
8:
end if
9: end for
10: if cx (T (|x|)) 6= ? then z := IS-Reach(T (|x|), cx (T (|x|)), Ca ) end if
11: if z = false then akzeptiere x else verwerfe x end if
◮
◮
◮
Aus Lemma 14 folgt, dass zumindest ein nichtdeterministischer
Berechnungspfad von CompL(x) alle Werte cx (t) korrekt bestimmt.
Alle Berechnungspfad, die nicht alle cx (t) korrekt bestimmen enden
mit cx (T (|x|)) = ?.
Nach Lemma 13 entscheidet zumindest ein Berechnungspfad von
IS-Reach(T (|x|), cx (T (|x|)), Ca ) die Frage korrekt, ob Ca ∈ Cx liegt,
d.h. ob M die Eingabe x akzeptiert. Alle Berechnungspfade, die
diese Frage nicht korrekt entscheiden enden mit z = ?.
Ist z = false, dann verwirft M die Eingabe x und CompL(x)
akzeptiert x.
Ist für alle Berechnungspfad von CompL(x) am Ende z = ? oder
z = true, dann akzeptiert M die Eingabe x und CompL(x) verwerft
x.
237
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
8. Vorlesung, 02.06.2008
238
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
8. Vorlesung, 02.06.2008
5.6 Weitere logarithmische Platzklassen
In der Literatur werden noch eine Menge weiterer logarithmische
Platzklassen untersucht, auf die wir jedoch nicht weiter eingehen werden.
Beispiele hierfür sind:
Bemerkungen:
◮
◮
Ist s und T nicht berechenbar, dann können wir s approximieren,
indem wir den Algorithmus für log n, 2 log n, usw starten. Hierfür
müssen wir nur die Prozedur IS-Count so umschreiben, dass wir in
der for-Schleife feststellen, ob eine Konfiguration C erreichbar ist,
von der eine Konfiguration C ′ erreichbar ist, die mehr Platz benötigt.
Für T können wir einfach eine obere Schranke einsetzten und beim
Durchlauf durch die for-Schleife testen, ob cx (t) = 0 ist. Haben alle
Berechnungspfade von M auf x die gleiche Länge, dann gilt
T (x) = t − 1.
◮
◮
◮
◮
239
#L: Bestimme die Anzahl der akzeptierenden Berechnungspfade
einer logarithmisch platzbeschränkten NTM auf Eingabe x.
C= L: Akzeptiert, falls die Anzahl der akzeptierenden
Berechnungspfade einer logarithmisch platzbeschränkten NTM auf
Eingabe x gleich der Anzahl der verwerfenden Berechnungspfade ist.
⊕L: Akzeptiert, falls die Anzahl der akzeptierenden
Berechnungspfade einer logarithmisch platzbeschränkten NTM auf
Eingabe x ungerade ist.
UL: Wir setzen voraus, dass die logarithmisch platzbeschränkten
NTM auf Eingabe x maximal einen akzeptierenden Berechnungspfad
hat. Akzeptiert, falls die NTM akzeptiert.
240
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
9. Vorlesung, 09.06.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
9. Vorlesung, 09.06.2008
6 Die polynomielle Platzklasse
Definition 41 (Teil 2) Sei nun
Wie wir aus den Sätzen 33 und 34 ableiten können, fallen deterministischer
polynomieller Platz, nichtdeterministischer polynomieller Platz und
co-nichtdeterministischer polynomieller Platz in der Klasse PSPACE
zusammen. Wir wollen nun im Folgenden ein paar vollständige Probleme
für PSPACE vorstellen. Wir betrachten in diesem Kapitel logspace bzw.
polynomialzeit Many-One-Reduktionen.
E0
E1
:= Q2 x2 . . . Qm xm : F (0, x2 , . . . , xm )
:= Q2 x2 . . . Qm xm : F (1, x2 , . . . , xm ) .
E heißt wahr, falls einer der folgenden Fälle zutrifft
m = 0 und F ≡ 1
Q1 = ∃ und E0 oder E1 sind wahr
◮ Q1 = ∀ und E0 und E1 sind wahr.
Definiere QBF:= { E | E ist eine wahre QBF } .
Als QBF Problem bezeichnen wir folgende Aufgabenstellung: Auf
Eingabe einer Quantifizierte Boolesche Formel E eintscheide, ob E wahr
ist, d.h. E ∈ QBF.
◮
6.1 Quantifizierte Boolesche Formeln
◮
Definition 41 Quantifizierten Booleschen Formeln [QBF]
Eine Quantifizierte Boolesche Formel QBF ist ein Ausdruck der Form
E
:=
Q1 x1 Q2 x2 . . . Qm xm : F (x1 , x2 , . . . , xm )
wobei Q1 , . . . , Qm ∈ {∃, ∀} die Quantoren des Ausdrucks sind und
F (x1 , x2 , . . . , xm ) eine Boolesche Formel in den Variablen x1 , x2 , . . . , xm
ist.
241
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
9. Vorlesung, 09.06.2008
Satz 37 QBF ist PSPACE-vollständig.
Beweis von Satz 37 (Teil 1) Um zu zeigen, dass QBF von einer
polynomiell platzbeschränkten Turing Maschine gelöst werden kann,
verwenden wir das folgende rekursive Verfahren:
Algorithmus Evaluate(E )
Eingabe: QBF E = Q1 x1 Q2 x2 . . . Qm xm : F (x1 , x2 , . . . , xm )
Ergebnis: Wert von E
1: berechne E0 = Q2 x2 . . . Qm xm : F (0, x2 , . . . , xm )
2: berechne E1 = Q2 x2 . . . Qm xm : F (1, x2 , . . . , xm )
3: if E hat mindestens einen Quantor then
4:
v0 := Evaluate(E0 )
5:
v1 := Evaluate(E1 )
6:
if Q1 = ∃ then v := v0 ∨ v1 end if
7:
if Q1 = ∀ then v := v0 ∧ v1 end if
8: else setze v auf den Wert von E end if
9: Return(v )
Für den Platzbedarf dieses Verfahrens gilt:
242
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
9. Vorlesung, 09.06.2008
Beweis von Satz 37 (Teil 2) Für eine Sprachen L ∈ PSPACE und eine
Polynom p sei M eine p-platzbeschränkte 1-Band DTM, welche die
Sprache L akzeptiert.
◮ Beachte, dass für eine Konstante c ∈ N und T := 2c·p die DTM M
T -zeitbeschränkt ist.
◮ Für die Reduktion betrachten wir die Berechnungsmatrix der DTM
M auf eine Eingabe x.
S(m) := S(m − 1) + O(|E |) = O(m · |E |) ≤ O(|E |2 ) .
243
244
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
9. Vorlesung, 09.06.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
9. Vorlesung, 09.06.2008
Beweis von Satz 37 (Teil 3)
Definition 42 Sei M eine T -zeit- und S-platzbeschränkten 1-Band TM.
Eine Berechnungsmatrix von M auf Eingabe w ist eine (t + 1) × s-Matrix
V
Beweis von Satz 37 (Teil 4) Zur Vereinfachung gelte:
= (vi,j )i∈[0,t],j∈[1,s]
◮
mit t = T (|w |) und s = S(|w |).
◮ V beschreibt eine der möglichen Berechnungen von M auf w .
◮
◮
◮
◮
◮
Die Einträge vi,j sind Elemente aus dem Alphabet (Σ × Q) ∪ Σ.
Die i-te Zeile repräsentiert die i-te Konfiguration von M, dass heißt
eine Konfiguration die M nach genau i Berechnungschritten
annehmen kann.
Die j-te Spalte repräsentiert die Beschriftung der j-ten Zelle im
Verlauf der Berechnung.
◮
◮
M startet im Zustand q0 .
Auf Eingaben x der Länge n ist das Band zu Anfang mit
x1 . . . xn β . . . β beschriftet.
Akzeptiert M, so befindet sie sich im Zustand qa in der
Ausgangsposition, und das Band ist leer.
M überschreitet bei einer Berechnung nicht die Ausgangsposition.
Falls der Kopf zur Zeit i auf der Zelle j steht, so wird in vi,j
zusätzlich der aktuelle Zustand q gespeichert, d. h. vi,j = (σ, q).
245
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
9. Vorlesung, 09.06.2008
Beweis von Satz 37 (Teil 5) Wir betrachten die (T (|x|) + 1) × p(|x|)-Berechnungsmatrix V von M auf eine Eingabe x.
◮ Eine Zeile von V kann mittels Boolescher Variablen
Y = { y [j, σ] | j ∈ [1, p(|w |)] und σ ∈ (Σ × Q) ∪ Σ }
◮
◮
beschrieben werden, wobei y [j, σ] = 1 bedeutet, dass in der j-ten
Zelle das Zeichen σ steht.
Analog definieren wir Z , U, V und W .
Ferner sei
Rk (Y , Z ) = 1 ⇐⇒
◮
246
Andreas Jakoby
Universität zu Lübeck
Beweis von Satz 37 (Teil 6)
◮ Die Formeln Fx (Y ) bzw. Fakz (Z ) sind aus M und x auf
logarithmischen Platz herleitbar.
◮ Analog kann auch die Formel R0 (Y , Z ), d. h. CY ⊢ CZ , generiert
werden.
◮ Um Ri (Y , Z ) für i > 0 zu bestimmen, betrachten wir die Formel:
Hi (Y , Z )
die durch Z repräsentierte Konfiguration CZ
wird von der durch Y repräsentierten Konfiguration
CY in höchstens 2k Schritten erreicht.
D.h. M akzeptiert w“ genau dann, wenn
”
EM (w ) := ∃ Y ∃ Z : Rc·p(|x|) (Y , Z ) ∧ Fx (Y ) ∧ Fakz (Z )
◮
=
∃ U ∀ V ∀ W : Ri−1(V , W )
∨ (V = Y ∧ W = U)
∧ (V = U ∧ W = Z ) .
Diese Formel ist genau dann wahr, wenn:
∃U : Ri−1 (Y , U) ∧ Ri−1 (U, Z )
◮
wahr ist, wobei Fx (Y ) und Fakz (Z ) Boolesche Formeln sind, die
genau dann wahr sind, wenn Y die Anfangs- bzw. Z die
akzeptierende Endkonfiguration von M beschreibt.
Computational Complexity SS 08
9. Vorlesung, 09.06.2008
gilt.
Hi (Y , Z ) gibt somit eine lineare rekursive Beschreibung von Ri ,
welche die Formel für EM (w ) nur polynomiell vergrößert:
|Ri (Y , Z )|
◮
247
≤
2
|Ri−1 (Y , Z )| + O(p) .
Somit gilt |Ri (Y , Z )| ≤ O(p ).
248
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
9. Vorlesung, 09.06.2008
Andreas Jakoby
Universität zu Lübeck
◮
Beweis von Satz 37 (Teil 7) Da die vollständige Ersetzung von M und
w durch EM (w ) mit Hilfe von Zählern erfolgen kann, und jedes Polynom
auf logarithmischen Platz approximierbar ist, ist das QBF-Problem
PSPACE-hart bezüglich der logspace-Reduktion.
◮
Computational Complexity SS 08
9. Vorlesung, 09.06.2008
Mit Hilfe einer Umformung, wie sie bei der Reduktion des
Satisfiability Problems in das 3-SAT Problem gebräuchlich ist, kann
die PSPACE-Härte auch für das QBF-Problem gezeigt werden,
dessen Boolesche Formel in 3-CNF vorliegt.
Auf diese Umformung werden wir später noch einmal genauer
eingehen.
Satz 38 QBF ist PSPACE-vollständig auch wenn wir uns auf Boolesche
Formeln beschränken, die in 3-CNF vorliegen.
249
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
9. Vorlesung, 09.06.2008
Das alternieren Quantoren ein einer QBF kann das Abwechseln von
Spielern verstanden werden:
◮
◮
◮
◮
◮
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
9. Vorlesung, 09.06.2008
Definition 43 Eine Spielstellung eines Zwei-Personen-Spiels beschreibt
eine Spielkonfiguration des Zwei-Personen-Spiels. Diese setzt sich
folgenden Informationen zusammen:
◮ Verteilung der Figuren auf dem Spielfeld,
6.2 PSPACE: Eine verspielte Klasse
◮
250
∃: Es existiert ein Zug für mich, so dass
∀: für alle Züge meines Gegners,
Angabe des Spielers, welcher den nächsten Zug ausführt und
Sonderangaben wie: Wichtige Angaben, die man der Verteilung der
Figuren nicht ansieht, Informationen über die Einhaltung von
Fortschrittsregeln, etc.
Der Stellungsgraph eines Zwei-Personen-Spiel ist ein gerichteten Graphen
H, dessen Knotenmenge VH der Menge der möglichen Spielstellungen
repräsentiert. Zwischen zwei Knoten v1 und v2 eines Stellungsgraphen
existiert genau dann eine Kante (v1 , v2 ), wenn die mit v1 assoziierte
Spielstellung mit Hilfe eines Spielzuges in die mit v2 assoziierte
Spielstellung überführt werden kann.
◮
◮
∃: ein Zug für mich existiert, so dass
∀: für alle Züge meines Gegners,
...
F (x1 , . . . , xn ): ich das Spiel gewonnen habe!
Es verwundert daher nicht, dass viele 2-Personen Spiele PSPACE-vollständige Varianten besitzen. Im Folgenden wollen wir eines dieser Spiele
– das sogenannte Geographie-Spiel – näher betrachten.
251
252
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
9. Vorlesung, 09.06.2008
Definition 43 (Teil 2)
◮ Besitzt ein Knoten v1 des Stellungsgraphen keinen Nachfolger, so
nennen wir die zu v1 gehörige Spielstellung eine Endstellung.
◮ Entsprechend den Spielregeln unterscheiden wir zwischen einer
gewinnenden Endstellung und einer unentschiedenen Endstellung.
Eine gewinnenden Endstellung für einen Spieler impliziert im
folgenden eine verlierende Endstellung für den zweiten Spieler.
◮ Eine Spielstellung C heiße Gewinnstellung für einen Spieler S, wenn
entweder C eine gewinnenden Endstellung für S ist oder
◮
◮
◮
◮
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
9. Vorlesung, 09.06.2008
Definition 44 Geographie-Spiel
Der Spielfeld des Geographie-Spiels ist ein gerichteter Graph G = (V , E )
mit Startknoten s. Die beiden Spieler markieren abwechselnd Knoten aus
G nach den folgenden Regeln:
1. Die beiden Spieler führen abwechselnd ihre Züge aus.
2. Im ersten Zug markiert Spieler 1 s.
3. Im t-ten Zug, t > 0, markiert der jeweilige Spieler der am Zug ist
einen direkten Nachfolgeknoten des Knotens, welcher im t − 1-ten
Zug markiert wurde.
4. Ein Knoten darf nicht mehrmals markiert werden.
5. Es gewinnt der Spieler, welcher den letzten Zug ausführt.
S am Zug ist und eine Nachfolgespielstellung C ′ von C existiert,
welche auch eine Gewinnstellung für S1 ist oder
S nicht am Zug ist und für alle Nachfolgespielstellung C ′ von C gilt,
dass C ′ eine Gewinnstellung für S ist.
Ist C eine Gewinnstellung für den Gegenspieler von S, so nennen wir
C eine Verluststellung für S. Ist C weder eine Gewinnstellung noch
eine Verluststellung für S, so nennen wir C eine Remisstellung.
Kann ein Spieler S in einer Spielstellung C seinen Gewinn innerhalb
von maximal ℓ Zügen realisieren, so sagen wir, S besitzt eine
Gewinnstrategie in C der Länge ℓ.
Andreas Jakoby
Universität zu Lübeck
GEO := { (G , s) | G ist ein Spielgraph eines Geographie-Spiels, auf
dem Spieler 1 eine Gewinnstrategie besitzt. }
planar-GEO := { (G , s) | G ist ein planarer, bipartiter Spielgraph eines
Geographie-Spiels, auf dem Spieler 1 eine
Gewinnstrategie besitzt. }
253
Computational Complexity SS 08
9. Vorlesung, 09.06.2008
254
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
9. Vorlesung, 09.06.2008
Satz 39 GEO und planar-GEO sind in PSPACE-vollständig.
Beweis von Satz 39 (Teil 1)
◮ Da wir schon gesehen haben, dass GEO in PSPACEliegt, müssen
wir noch zeigen, dass planar-GEO PSPACE-hart ist.
◮ Im Folgenden wollen wir uns der Komplexität der planaren Variante
des Geographie-Spiels zuwenden.
Für das Geographie-Spiel gilt:
◮ Nach Regel 4 darf kein Knoten mehrmals markiert werden.
◮ Da in jeder Runde ein Knoten markiert wird, endet jedes Spiel nach
spätestens |V | Runden.
◮ Jede Spielstellung können wir auf polynomiellen Platz speichern.
◮
Analog zum Algorithmus Evaluate(E ) können wir auch für eine
Instanz (G , s) des Geographie-Spiels entscheiden, ob Spieler 1 eine
Gewinnstrategie besitzt.
Lemma 15 GEO und planar-GEO sind in PSPACE.
◮
◮
◮
◮
255
·
Durch eine bipartite Zerlegung V1 ∪ V2 der Knotenmenge des
Spielgraphen erhalten wir zugleich eine Aufteilung der Knotenmenge
unter den beiden Spielern.
Wir suchen eine Reduktion des auf 3-CNF Formeln eingeschränkten
QBF-Problems auf planar-GEO.
Sei
E = Q1 x1 . . . Qm xm : C1 ∧ . . . ∧ Cℓ
mit Cj = xjα1 1 ∨ xjα2 2 ∨ xjα3 3 eine Instanz dieses QBF-Problems.
Bei dem im Folgenden konstruierten Graphen GE werden wir zunächst
auf die Eigenschaft der Planarität verzichten und diese erst zum
Anschluß durch eine leichte Modifikation erreichen.
256
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
9. Vorlesung, 09.06.2008
Beweis von Satz 39 (Teil 2)
◮ GE besteht aus einer Folge von Teilgraphen H1 , . . . , Hm , welche die
Quantoren Qi xi repräsentieren.
◮ Für jede Klausel Cj enthält GE einen zusätzlichen Knoten vj und
Kanten von vj zu einem ausgezeichneten Knoten des Teilgraphen Hjr
mit r = 1, 2, 3.
Andreas Jakoby
Universität zu Lübeck
Beweis von Satz 39 (Teil 3) Die nachfolgende Abbildung illustriert, wie
die Teilgraphen H1 , . . . , Hm sowie die Knoten v1 , . . . , vℓ zusammengefügt
werden.
ai
ci1
di
ei
ai
zi0
di
ci0
Qi xi = ∃xi
1
zm
e2
a2
e1
v1
em
am
H1
H2
Hm
z10
z20
0
zm
v2
ei
zi0
vℓ
Es gilt:
Qi xi = ∀xi
◮
◮
a1
zi1
bi
z21
z11
s
zi1
Computational Complexity SS 08
9. Vorlesung, 09.06.2008
Für die Knotenmengen des Graphen G (F ) und der Graphen Hi gilt
◮
·
·
Die bipartite Zerlegung V1 ∪ V2 der letzten Folie bleibt erhalten.
Ferner erhalten wir
hierbei die folgende bipartite Zerlegung V1 ∪ V2 :
Sm
Sm
0 1
0 1
und
i=1 {zi , zi , bi , ei } ⊆ V1
i=1 {ci , ci , ai , di } ⊆ V2
s ∈ V1
und {v1 , . . . , vℓ } ⊂ V2 .
sofern die entsprechenden Knoten vorhanden sind.
257
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
9. Vorlesung, 09.06.2008
Beweis von Satz 39 (Teil 4) Die nachfolgende Abbildung illustriert, wie
die noch fehlenden Kanten von den Knoten v1 , . . . , vℓ zu den Teilgraphen
H1 , . . . , Hm gezogen werden.
258
Andreas Jakoby
Universität zu Lübeck
Beweis von Satz 39 (Teil 5) Die nachfolgende Abbildung illustriert den
Graphen GE für die Formel
E
1−α1
zj
1
Computational Complexity SS 08
9. Vorlesung, 09.06.2008
∃ x1 ∀ x2 ∃ x3 : (x 1 ∨ x2 ∨ x 3 ) ∧ (x1 ∨ x2 ∨ x 3 ) .
=
1−α3
zj
3
α
zj 2
2
s
em
Hj3
Hj2
Hj1
vj
α1
zj
1
1−α2
zj
2
α3
zj
3
z11
z21
z31
z10
z20
z30
s
Die noch fehlenden Kanten von den Knoten v1 , . . . , vℓ zu den Knoten
0
1
z10 , z11 , . . . , zm
, zm
werden wie folgt gesetzt:
◮
v1
v2
Sei Cj = xjα1 1 ∨ xjα2 2 ∨ xjα3 3 die j-te Klausel von E , dann verbinden wir:
3
2
1
)} ⊂ E .
), (vj , zj1−α
), (vj , zj1−α
{(vj , zj1−α
3
2
1
·
Es gilt: Die bipartite Zerlegung V1 ∪ V2 der letzten Folie bleibt erhalten.
259
260
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
9. Vorlesung, 09.06.2008
Beweis von Satz 39 (Teil 6) Für ein Spiel auf einem solchen gegebenen
Graphen gilt folgende Aussage:
Beobachtung 19 Sei GE ein wie oben konstruierter Graph. Dann gilt:
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
10. Vorlesung, 16.06.2008
Beweis von Satz 39 (Teil 7) Zunächst ein paar Notationen:
1. Spieler 1 markiert nur Knoten aus V1 und Spieler 2 Knoten aus V2 .
2. Ist Qi ein Existenzquantor, so hat Spieler 1 die Wahl, ob er nach
dem ai markiert wurde den Knoten zi0 oder zi1 markiert.
3. Ist Qi ein Allquantor, so entscheidet Spieler 2, ob er nach dem ai
markiert wurde den Knoten ci0 oder ci1 markiert, d.h. Spieler 2
entscheidet, ob zj0 oder zj1 markiert wird.
4. Spieler 2 entscheidet, welcher Klauselknoten v1 , . . . , vℓ markiert wird.
◮
Sei Mi eine Menge von Markierungen der Teilgraphen s, H1 , . . . , Hi ,
welche jeweils einer Belegung der Variablen x1 , . . . , xi entspricht,
wobei die Markierung von zj1 die Belegung xj = 1 und die
Markierung von zj0 die Belegung xj = 0 repräsentiert.
◮
Für eine Folge von Wahrheitswerten e1 , . . . , ek ∈ {0, 1} mit k ≤ m
sei
F [e1 , . . . , ek ](xk+1 , . . . , xn ) ,
die Formel, die wir aus der 3-CNF F erhalten, indem wir alle
Vorkommen der Variablen xj mit j ≤ k durch die Wahrheitswerte ej
ersetzen.
5. Spieler 1 hat auf GE genau dann eine Gewinnenstrategie, wenn für
jede Wahl von Spieler 2, also insbesondere auch für jeden
ausgewählten Klauselknoten vj noch einen nichtmarkierten direkten
3
2
1
von vj existiert.
oder zj1−α
, zj1−α
Nachfolger zj1−α
3
2
1
261
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
10. Vorlesung, 16.06.2008
262
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
10. Vorlesung, 16.06.2008
Beweis von Satz 39 (Teil 9), Beweis von Lemma 16 Der Beweis
erfolgt über eine vollständige Induktion über i von m + 1 nach 1.
Beweis von Satz 39 (Teil 8)
Lemma 16 Sei 1 ≤ i ≤ m + 1, B ∈ Mi eine Startmarkierung in GE und
e1 , . . . , ei−1 ∈ {0, 1} die entsprechende Belegung der Variablen
x1 , . . . , xi−1 für B. Dann impliziert:
◮
Qi xi . . . Qm xm : F [e1 , . . . , ei−1 ](xi , . . . , xm ) = 1 ,
dass Spieler 1 eine Gewinnstrategie auf GE besitzt, wenn im nächsten
Zug ai bzw. ein Knoten aus {v1 , . . . , vℓ } für i = m + 1 von Spieler 2
markiert werden muss.
◮
263
Verankerung Sei e1 , . . . , em eine erfüllende Belegung der Variablen in
F , dann existiert für jede Klausel Ci ein Literal xiαj aus Ci mit
eiαj = 1. In der mit e1 , . . . , em assoziierten Markierung B ∈ Mm+1
sind andererseits die jeweiligen Knoten ziei markiert. Wählt Spieler 2
in der Markierung B den mit der Klausel Ci assoziierten Knoten vi ,
1−ei
so besitzt vi einen nichtmarkierten Nachfolgeknoten zi1−α
= zij j .
j
Dieser kann von Spieler 1 markiert werden. Da in B der Knoten dij
bereits markiert ist, hat Spieler 1 gewonnen.
Induktionsschritt folgt unmittelbar aus Beobachtung 19.
264
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
10. Vorlesung, 16.06.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
10. Vorlesung, 16.06.2008
Beweis von Satz 39 (Teil 11), Beweis von Lemma 17 Der Beweis
erfolgt über eine vollständige Induktion über i von m + 1 nach 1.
Beweis von Satz 39 (Teil 10)
Lemma 17 Sei 1 ≤ i ≤ m + 1, B ∈ Mi eine Vormarkierung in GE und
e1 , . . . , ei−1 ∈ {0, 1} die entsprechende Belegung der Variablen
x1 , . . . , xi−1 für B. Dann impliziert die Aussage, dass Spieler 1 eine
Gewinnstrategie auf GE besitzt und im nächsten Zug ai bzw. ein Knoten
aus {v1 , . . . , vℓ } für i = m + 1 von Spieler 2 markiert werden muss, die
Aussage
◮
Qi xi . . . Qn xn : F [e1 , . . . , ei−1 ](xi , . . . , xn ) = 1 .
◮
Verankerung Sei B ∈ Mm+1 eine Vormarkierung in GE und
e1 , . . . , em ∈ {0, 1} die entsprechende Belegung der Variablen
x1 , . . . , xm . Dann besitzt Spieler 1 in B nur dann eine
Gewinnstrategie, wenn es für jede Wahl eines Klauselknotens vi von
Spieler 2 einen unmarkierten Nachfolgeknoten zj1−α
gibt. Dieses
i
impliziert jedoch, dass das entsprechende Literal xjαi der Klausel Ci
durch die Belegung eji erfüllt wird. Da diese Bedingung für alle
Klauseln gelten muss, erfüllt die Belegung e1 , . . . , em die Formel F .
Induktionsschritt folgt unmittelbar aus Beobachtung 19.
265
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
10. Vorlesung, 16.06.2008
266
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
10. Vorlesung, 16.06.2008
Beweis von Satz 39 (Teil 13) In einem ersten Schritt wollen wir aus
GE einen Graphen GE′ mit beschränktem Grad konstruieren.
v1
v2
=⇒
em
Beweis von Satz 39 (Teil 12) Setzt man in Lemma 16 und 17 den
Parameter i = 1 so folgt, dass Spieler 1 auf GE genau dann eine
Gewinnstrategie besitzt, wenn E wahr ist. Wir erhalten:
v1
v2
vℓ−1
vℓ
em
p1
q2
p2
qℓ−1
vℓ
vi 1
vi 2
GEO ist PSPACE-vollständig.
Es verbleibt somit noch die Aufgabe GE in einen planaren Graphen zu
transformieren, ohne dass er die oben gezeigten Eigenschaften verliert.
=⇒
vi 1
vi k
vi 3
vi 2
ziα
q2′
p3′
q3′
pk′
ziα
vi k
◮
◮
◮
267
Wir ersetzen alle Knoten mit einem Eingrad (d.h. em ) bzw. Ausgrad
0
1
(d.h. z10 , z11 , . . . , zm
, zm
) größer 2 durch eine Kette von Knoten.
Der resultierende Graph ist weiterhin bipartit, wobei pi , pi′ ∈ V1 und
qi , qi′ ∈ V2 gilt.
Für GE′ gelten weiterhin die Aussagen aus Beobachtung 19 sowie
Lemma 16 und 17.
268
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
10. Vorlesung, 16.06.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
10. Vorlesung, 16.06.2008
Beweis von Satz 39 (Teil 14) Im letzten Schritt ersetzen wir sukzessive
alle Kantenkreuzungen in GE′ durch den folgenden Teilgraphen:
z′
z′
Beweis von Satz 39 (Teil 15) Um zu erkennen, dass diese Ersetzung
der Kreuzungen die Gewinn-Eigenschaften auf dem Graphen nicht
verändert, verfahren wir wie folgt:
s4
y1
r4
r3
s3
s2
z
v
v
◮
z
r2
=⇒
s1
r0
◮
r1
y2
v′
v′
◮
◮
◮
Die Herleitung von GE′′ aus der QBF E kann durch eine
logarithmisch platzbeschränkte DTM erfolgen kann.
Können wir jetzt noch zeigen, dass ein Spieler auf GE′′ genau dann
eine Gewinnstrategie hat, wenn dieser Spieler auf GE′ eine
Gewinnstrategie besitzt, dann haben wir
Kreuzungen erlauben wir nur zwischen den Kanten vom Typ (vi , zj )
und (vi ′ , zj ′ ).
Sei t ein Spielzug, in dem der Spieler 2 den Knoten v auf GE′
markiert. Ferner wähle Spieler 1 den Knoten z im Zug t + 1.
Zu zeigen ist nun, dass dieses in eine Folge von Zügen übertragen
werden kann, in denen nach dem Markieren von v und anschließend
r0 (bzw. r1 ) der Spieler 1 gezwungen wird, nach Ablaufen dieser
Folge z zu markieren, ohne, dass einen Knoten außerhalb des
Kreuzungs- graphen markiert wird.
QBF ≤log planar-GEO
bewiesen.
269
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
10. Vorlesung, 16.06.2008
′
z
Computational Complexity SS 08
10. Vorlesung, 16.06.2008
z′
z′
′
s4
y1
r4
r3
s2
z
v
s4
y1
r4
r3
s3
s2
z
z
v
v
s1
s1
r1
r1
y2
y2
v
◮
◮
◮
z
r0
r0
′
s3
r2
=⇒
r2
=⇒
v
Andreas Jakoby
Universität zu Lübeck
Beweis von Satz 39 (Teil 17)
Beweis von Satz 39 (Teil 16)
z
270
v
v
′
Nach dem Markieren von v wählt Spieler 1 anstelle von z den
Knoten r0 .
Im folgenden müssen beide Spieler der Reihe nach die Knoten
s1 , r2 , s2 markieren.
Markiert Spieler 1 nun r4 , so kann Spieler 2 y1 markieren und hat
somit gewonnen.
v
′
◮
Somit muss Spieler 1 den Knoten r3 markieren.
◮
In dieser Spielstellung hat Spieler 2 die Wahl. Markiert Spieler 2 y2 ,
so kann Spieler 1 anschließend r1 markieren, und hat gewonnen.
Analoges können wir auch für den Weg von v ′ nach z ′ beobachten.
Beide Spieler müssen somit eine gezwungen eine bestimmte
Zugreihenfolge einzuhalten, um nicht sofort zu verlieren.
◮
◮
271
′
272
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
10. Vorlesung, 16.06.2008
6.3 Games Against Nature
Im Folgenden wollen wir uns einer weiteren Menge von Spielen zuwenden,
in denen die Aktionen des zweiten Spielers durch einen randomisierten
Prozeß bestimmt werden.
◮ Da im Allgemeinen der zweite Spieler keine optimale Gewinnstrategie
verfolgt, werden wir vom ersten Spieler nicht mehr fordern, dass für
ihn eine absolute Gewinnstellung vorliegt, sondern, dass er sein Spiel
mit hinreichend großer Wahrscheinlichkeit gewinnt – es liegt für ihn
somit eine Entscheidungsfindung bei verbleibender Unsicherheit vor.
◮ Ein einfaches Spiel, welches dieser Bedingung genügt ist das aus
dem Anfängen der Computerspiele bekannte PAC-MAN.
◮ Ein interessanteres Spiel ist hier das Katz und Maus Spiel. In diesem
Spiel muss sich die Maus durch ein Labyrinth von einem Start zu einem
Zielpunkt bewegen. Die Katze kann jedoch von oben her kommend
jeden Punkt des Labyrinths in einem Schritt erreichen. Um der Maus
eine Gewinnchance zu lassen, verbinden wir der Katze die Augen
und verstopfen ihre Nase, so dass sie nur zufällig im Labyrinth nach
der Maus greifen kann. Zu entscheiden ist, ob die Maus ihr Ziel mit
einer Wahrscheinlichkeit größer 21 erreicht.
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
10. Vorlesung, 16.06.2008
Formal können wir das Gewinnverhalten bei einem derartigen Spiel durch
eine einfache Abänderung der QBFs beschreiben:
Definition 45 Probabilistisches Erfüllbarkeitsproblem (SSAT)
Gegeben sei eine Boolesche Formel F in 3CNF über den Variablen
x1 , . . . , xn . Ferner sei R ein Quantor, der einer Variable xi mit
Wahrscheinlichkeit 12 den Wert 1 und mit Wahrscheinlichkeit 21 den Wert
0 zuweist. Eine probabilistische quantifizierte Boolesche Formel (PrQBF)
ist eine Boolesche Formel F deren Variablen durch existenzielle und
probabilistische Quantoren gebunden sind. Eine solche PrQBF ist erfüllt,
wenn
R
= ∃x1 Rx2 ∃x3 · · · Rxn : Pr[F (x1 , . . . , xn ) = 1] >
1
2
gilt. Ferner sei
SSAT := { R | R ist eine probabilistische quantifizierte Boolesche
Formel, welche die obige Bedingung erfüllt } .
273
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
10. Vorlesung, 16.06.2008
Satz 40 SSAT ist PSPACE-vollständig bezüglich der
logspace-Reduktion.
274
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
10. Vorlesung, 16.06.2008
Beweis von Satz 40 (Teil 2) Die Auswertung einer QBF bzw. einer
PrQBF entspricht nun der Aufgabe eines Gärtners, der den Baum
zurechtschneiden muss: Bei jedem Knoten, der mit max markiert ist,
muss er genau einen der beiden Kinderäste abschneiden.
◮ Wir nennen einen solchen korrekt zurechtgeschnitten Teilbaum im
Folgenden Bewertungsteilbaum.
◮ Es ist einfach zu erkennen, alle Bewertungsteilbäume einer QBF
bzw. einer PrQBF die gleichen Anzahl von Blättern haben.
◮ Die Aufgabe des Gärtners ist es nun einen Bewertungsteilbaum zu
finden, der für QBF nur akzeptierende Blätter besitzt, bzw., wenn
wir SSAT lösen wollen, von dessen Blätter mehr als Hälfte
akzeptierend sind.
Beweis von Satz 40 (Teil 1) Wir müssen uns zunächst ein paar
Gedanken darüber machen, wie wir eine PrQBF lesen müssen:
◮ Die Belegungen der Variablen einer PrQBF sowie einer QBF
definieren einen Baum, dessen Knoten durch die Zeichenketten
{0, 1}≤n gegeben sind.
◮ Ein Knoten w ∈ {0, 1}<n hat die beiden Kinder w 0 und w 1.
◮ Die Wurzel des Baums ist gegeben durch den leeren String λ.
◮ Jedes Blatt korrespondiert nun zu einer Belegung aller Variablen und
jedes Level im Baum (bis auf das Blattlevel) korrespondiert zu einem
Quantor.
◮ Werten wir die gegebene Boolesche Formel nun für die gegebenen
Belegungen der Blätter aus, so erhalten wir eine Markierung der
Blätter mit den korrespondierenden Wahrheitswerten.
◮ Markieren wir ferner die Knoten eines ∃-Levels mit max und die
Knoten der ∀- bzw. R-Levels mit + so erhalten wir einen
arithmetischen Bewertungsbaum.
max
λ
0
∃
1
max
+
+
+
R
00
01
10
max
11
max
max
max
max
max
∃
000 010
001 011
275
100 110
101 111
0 1 0 1
1 0 0 0
0
1
276
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
10. Vorlesung, 16.06.2008
Beweis von Satz 40 (Teil 3) Die folgenden Beobachtungen sind für
unseren Beweis sehr hilfreich:
◮ Über eine vollständige Induktion können wir einfach zeigen, dass
jeder Bewertungsteilbaum einer QBF bzw. einer PrQBF genau 2k
Blätter besitzt, wenn k die Anzahl der ∀- bzw. der R-Quantoren der
QBF bzw. der PrQBF angibt.
◮ Werten wir den arithmetischen Bewertungsbaum einer QBF bzw.
einer PrQBF aus, so sind die Zwischenergebnisse an allen Konten
durch 2k beschränkt.
◮ Auf Eingabe einer QBF bzw. einer PrQBF können wir den
dazugehörigen arithmetischen Bewertungsbaum auf polynomiellem
Platz auswerten.
Sei h das Ergebnis der Auswertung eines solchen arithmetischen
Bewertungsbaums, dann ist die dazugehörige PrQBF genau dann wahr,
wenn
h > 2k−1
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
10. Vorlesung, 16.06.2008
Beweis von Satz 40 (Teil 4) Um zu zeigen, dass SSAT
PSPACE-vollständig ist, wollen wir das QBF auf SSAT reduzieren.
◮
Sei
E
=
Q1 x1 . . . Qn xn : F (x1 , . . . , xn )
eine gegebene QBF. Wir generieren nun die folgende PrQBF
R
=
Rx0 Q1′ x1 . . . Qn′ xn : (x0 ∧ F (x1 , . . . , xn )) ∨
n
^
xi
i=0
wobei Qi′ = R ist, falls Qi = ∀ ist. Ansonsten lassen wir
Qi′ = Qi = ∃.
Was können wir über R und E sagen:
◮
◮
ist. Wir erhalten somit unmittelbar:
Sei k die Anzahl der ∀-Quantoren in E , dann ist k + 1 die Anzahl
der R-Quantoren in R.
Jeder Bewertungsteilbaum von E hat 2k Blätter und jeder
Bewertungsteilbaum von R hat 2k+1 Blätter.
SSAT ist in PSPACE .
277
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
10. Vorlesung, 16.06.2008
278
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
10. Vorlesung, 16.06.2008
Beweis von Satz 40 (Teil 5) Wir haben
E
=
Q1 x1 . . . Qn xn : F (x1 , . . . , xn )
Wie schon QBF für PSPACE stellt SSAT eine kanonisches Problem für
Games Against Nature dar. Wir wollen nun noch ein Spiel vom Typus
Games Against Nature vorstellen:
und
R
=
Rx0 Q1′ x1 . . . Qn′ xn : (x0 ∧ F (x1 , . . . , xn )) ∨
n
^
Definition 46 Gegeben sei ein gerichteter, azyklischer Graph
G = (V , E ), zwei ausgezeichnete Knoten s, z ∈ V und eine Funktion
p : E × V → P wobei P := { k · 2−pol(|V |) | k ∈ {0, . . . , 2pol(|V |) } für
ein Polynom pol ist.
Das dynamische Grapherreichbarkeitsproblem ist wie folgt definiert:
Spieler 1 startet auf Knoten s und soll Knoten t durch Ziehen entlang der
Kanten des Graphen erreichen. Der probabilistische Spieler 2 versucht
dieses jedoch durch Entfernen von Kanten zu verhindern und bedient sich
dazu der Wahrscheinlichkeitsfunktion p.
xi .
i=0
Ist E wahr, dann ist das Ergebnis des Bewertungsbaums von E 2k
und das Ergebnis des Bewertungsbaums von R 2k + 1 (2k vom
linken Teilbaum der Wurzel und 1 vom rechten Teilbaum).
◮ Ist E falsch, dann ist das Ergebnis des Bewertungsbaums von E
< 2k und das Ergebnis des Bewertungsbaums von R ≤ 2k (< 2k
vom linken Teilbaum der Wurzel und 1 vom rechten Teilbaum).
Somit ist E ∈ QBF genau dann, wenn R ∈ SSAT ist. Es ist ferner einfach
zu erkennen, dass wir die Transformation von E nach R auf
logarithmischen Platz durchführen können.
◮
279
280
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
10. Vorlesung, 16.06.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
10. Vorlesung, 16.06.2008
Definition 46 (Teil 2) Durch Entfernen von Kanten entsteht wie folgt
eine Folge von noch verfügbaren Kanten E0 , E1 , E2 , . . .:
◮
◮
◮
◮
◮
In der Startkonfiguration befindet sich Spieler 1 auf Knoten s und
die ihm zur Verfügung stehende Kantenmenge ist durch E0 = E
gegeben.
Bevor er jedoch einen Knoten weiter ziehen darf, entfernt Spieler 2
aus E0 Kanten e ∈ E0 mit der jeweiligen Wahrscheinlichkeit p(e, s).
Jetzt darf Spieler 1 über eine der verbleibenden Kanten (wenn
möglich) zu einem direkten Nachfolger von s ziehen, und so weiter.
Definition 46 (Teil 3) Eine Zugstrategie von Spieler 1 besteht nun also
aus einer Funktion S : V × 2E → V welche die jeweiligen Züge von
Spieler 1 bestimmt. Ferner sei reachS (G , p, s, z) die Wahrscheinlichkeit,
dass Spieler 1 mit der Strategie S Erfolg hat. Wir definieren nun
DGR := { (G , p, s, z) | es existiert eine Strategie S für Spieler 1
mit reachS (G , p, s, z) > 12 } .
Allgemein gilt somit: Befindet sich Spieler 1 nach t Zügen auf einem
Knoten qt und ist die aus den vorhergehende Zügen verbleibende
Kantenmenge Et , so entfernt Spieler 2 in der ersten Phase die
Kanten e ∈ Et aus Et mit Wahrscheinlichkeit p(e, qt ). Die
verbleibende Kantenmenge bezeichnen wir mit Et+1 .
Auf dieser Menge zieht Spieler 1 zu einem Nachfolger qt+1 von qt
und versucht so, z zu erreichen.
281
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
10. Vorlesung, 16.06.2008
Zunächst ein paar Beobachtungen:
◮ Da G azyklisch ist und der erste Spieler in jeder Runde einen Knoten
weiter ziehen muss, ist ein Spiel des dynamischen
Grapherreichbarkeitsproblems nach spätestens |V | − 1 Runden
beendet.
◮ Eine Spielstellung besteht aus dem aktuellen Graph (Eingabegarph
ohne die entfernten Knoten) und der Markierung des vom Läufer des
ersten Spielers besetzten Knotens. Eine Spielstellung kann somit auf
linearem Platz abgespeichert werden.
◮ Konstruieren wir jetzt einen Baum, der alles möglichen Spielverläufe
wieder gibt, so erhalten wir einen Baum mit maximaler Tiefe |V |
(für die Züge von Spieler 1) plus |E | · |V | (für die Züge von Spieler 2
– er kann ja für jedem Zug des ersten Spielers jede Kante ausfallen
lassen) und mit maximalem Grad |V |.
◮ Ein Wurzel-Blatt Pfad beschreibt einen möglichen Spielverlauf von
der Anfangs- bis zur Endstellung. Ein solcher Pfad kann auf Platz
O(|V |2 · |E | · |G |) dargestellt werden.
◮ Um den Baum zu traversieren, genügt ebenfalls Platz
O(|V |2 · |E | · |G |).
282
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
10. Vorlesung, 16.06.2008
◮
Sei q ein Polynom, so dass jede Wahrscheinlichkeit p(e, v ) einer
gegebenen Instanz G , s, z, p entweder 0 oder ein Vielfaches von
2−q(|V |) ist.
◮
Die Wahrscheinlichkeit für einen gegebenen Wurzel-Blatt Pfad ist
2
somit ein Vielfaches von 2−|V | ·|E |··q(|V |) . Diese Wahrscheinlichkeit
können wir somit auf Platz |V |2 · |E | · q(|V |) als Binärzahl darstellen
und bei gegebenen Pfad auch auf diesem Platz berechnen.
Ersetzen wir nun in dem Baum der möglichen Spielverläufe jeden
Knoten in dem Spieler 1 am Zug ist durch ein max und jeden
Knoten in dem Spieler 2 am Zug ist durch ein + so erhalten wir
wieder eine arithmetische Formel, die uns die Wahrscheinlichkeit
angibt, mit der Spieler 1 gewinnen kann. Diesen Baum können wir
wieder auf polynomiellen Platz auswerten.
◮
Wir erhalten:
Lemma 18 DGR ist in PSPACE.
283
284
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
◮
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
Schritt 1 der Reduktion von SSAT auf DGR:
Zum Abschluß unseres Exkurses in die Games Against Nature wollen wir
jetzt noch zeigen, dass DGR hart für PSPACE ist. Dieses folgt über eine
Reduktion von SSAT auf DGR.
◮
Andreas Jakoby
Universität zu Lübeck
Zunächst nehmen wir an, dass die Boolesche Formel der PrQBF in
3-CNF vorliegt. Das diese Variante von SSAT immer noch
PSPACE-vollständig ist, können wir analog zu den Umformungen des
Erfüllbarkeitsproblems in das 3-SAT Problem zeigen. Sei also
Die Reduktion verlangt eine ausführliche Diskusion der verwendeten
Wahrscheinlichkeiten.
Wir werden die Reduktion in mehreren Schritten angeben, und
jeweils den erhaltenen Graphen bzw. die entsprechenden Werte der
Wahrscheinlichkeitsfunktion p besprechen.
R := ∃x1 Rx2 . . . ∃xn−1 Rxn :
m
^
Cj
mit
i=1
Cj = xjα1 1 ∨ xjα1 1 ∨ xjα1 1
eine Instanz des SSAT Problems.
285
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
286
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
Wir definiere folgende Knoten- und Kantenmengen:
VX ,0
VX
EX
:=
:=
:=
n
[
i=1
n
[
i=1
n
[
i=1
EC ,j
:=
{xi0 }
VX ,1 :=
n
[
Und nun definieren wir den Graph G = (V , E ) mit
i=1
{xi1 }
V
{xi }
{(xi , xi0 ), (xi , xi1 )}
3
[
3
[
k=1 ℓ=1
ℓ
{(cjk , cj+1
)}
EC :=
m
[
E
EC ,m :=
k=1
:= EX ∪
EC ,j
j=1
3
[
:= VX ∪ VX ,0 ∪ VX ,1 ∪
∪
k
{cm
, z} .
287
3
[
k=1
n−1
[
i=1
m
[
j=1
{cj1 , cj2 , cj3 } ∪ {s, z}
{(xi0 , xi+1 ), (xi1 , xi+1 )}
{(xn0 , c1k ), (xi1 , c1k )} ∪ EC ∪ {(s, x1 )} ∪ {(s, z)} .
288
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
In einem ersten Schritt definieren wir die Wahrscheinlichkeitsfunktion p
wie folgt:

0 für q 6∈ VX ,0 ∪ VX ,1




0 für e 6∈ EC



 0 für e ∈ EC ,j und q ∈ VX ,0 ∪ VX ,1 mit q = xiα



und e = (cjk , w ) wobei xi1−α nicht das k-te
p(e, q) :=
Literal der j-ten Klausel ist




1
für
e ∈ EC ,j und q ∈ VX ,0 ∪ VX ,1 mit q = xiα




und e = (cjk , w ) wobei xi1−α das k-te Literal



der Klausel Cj ist
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
Für den so konstruierten Graphen gilt nun folgende Beobachtung:
Beobachtung 20 Durchläuft Spieler 1 einen Pfad von x1 zu einem der
Knoten c1k , wobei er die Knoten xiαi passiert, so löscht Spieler 2 alle
Kanten, welche von einem Knoten cjℓ ausgehen, wenn xi1−αi das ℓ-te
Literal der Klausel Cj ist. Interpretiert man nun die auf dem Pfad
liegenden Knoten xiαi als eine entsprechende Belegung xi := αi der
Variablen der Booleschen Formel von F , so ist diese genau dann erfüllt,
wenn es noch einen Pfad von einem Knoten c1k nach u gibt.
für q ∈ V und e ∈ E .
289
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
290
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
x10
s
Schritt 2 der Reduktion von SSAT auf DGR:
◮
Wir modifizieren nun die Funktion p derart, dass sie in einem
Zustand xi , wobei der zur entsprechenden Variable gehörende
Quantor Qi ein probabilistischer Quantor ist, der probabilistische
Spieler die Kanten (xi , xi0 ) und (xi , xi1 ) mit einer bestimmten
Wahrscheinlichkeit löscht.
◮
Hierbei kann es jedoch geschehen, dass Spieler 2 beide Kanten oder
keine der beiden Kanten entfernt.
◮
Um diese Abweichung in den Griff zu bekommen, haben wir die
Kante (s, z) eingefügt, welche im ersten Schritt mit einer noch zu
bestimmenden Wahrscheinlichkeit entfernt wird.
x1
x11
c31
c32
c33
z
291
292
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
◮
◮
◮
◮
und p((xi , xij ), xi ) = β
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
Sei p1,i die Wahrscheinlichkeit, dass das Problem P beim Knoten x2·i
zum ersten mal auftritt, dann gilt für n = 2 · ℓ (d. h. es gibt genau ℓ
probabilistische Quantoren):
Pℓ
Pℓ
2
2
2
p1 =
=
(2 · (β − β ))i−1 · β · (2 · β − β )ℓ−i
i=1 p1,i
Pi=1
2
2
ℓ
ℓ−1
·β
≤
i=1 (2 · β − β )
2 ℓ−1
2
= ℓ · (2 · β − β )
· β =: p3
Wir modifizieren also die Funktion p folgendermaßen:
p((s, z), s) = α
Andreas Jakoby
Universität zu Lübeck
für j ∈ {0, 1} und Qi = R .
Die Werte von α und β werden wir im folgenden konstruieren.
Wir definieren α := 1 − α und β := 1 − β.
Wir berücksichtigt: In einem Knoten xi mit Qi = R löscht Spieler 2
2
mit einer Wahrscheinlichkeit von β keine der Kanten (xi , xi0 ) und
(xi , xi1 ) und ein Pfad von s zu einem Knoten c1j existiert weiterhin.
und
2
p2 = (β − β )ℓ .
Es gilt nun:
Diesem Problem P wird dadurch begegnet, dass β so gewählt wird,
dass die Wahrscheinlichkeit p1 seines Auftretens kleiner ist, als die
Wahrscheinlichkeit p2 für das Auftreten eines ganz bestimmten
Pfades.
p3 < p2
⇐⇒
ℓ·
ℓ−1
β
β
· 2+
< 1.
1−β
1−β
Wählen wir β := 2−3·ℓ so folgt:
ℓ−1
β
β
ℓ·
· 2+
< ℓ · 2 · 2−3·ℓ 4ℓ−1 < 2 · ℓ · 2−ℓ ≤ 1 .
1−β
1−β
293
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
294
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
Unter der Voraussetzung, dass Spieler 2 in seinem ersten Zug die Kante
(s, z) entfernt, ist die maximale Wahrscheinlichkeit für eine erfolgreiche
Strategie für von Spieler 1 genau dann größer
Kann dieser Wert nicht exakt durch eine logarithmisch platzbeschränkte
DTM bestimmt werden, so approximieren wir ihn derart, dass durch
diesen angenäherten Wert die obigen Ungleichungen erfüllt werden.
2
(2 · β − 2 · β )ℓ
p4 := p3 +
,
2
Es folgt
wenn F ∈ SSAT.
◮ Für die Wahl von α muss gelten:
α + p4 · (1 − α)
◮
≤
1
2
SSAT
≤log
DGR
und somit
<
α + (p4 + p2 ) · (1 − α) .
Satz 41 DGR ist PSPACE-vollständig bezüglich der
logspace-Reduktion.
Wir bestimmen den Wert von α somit durch
α
:=
1 − 2 · p4
.
2 − 2 · p4
295
296
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
6.4 Alternative Charakterisierungen für PSPACE
Eine maschinennahe Betrachtung der QBFs bzw. der PrQBFs legt es
nahe, eine Erweiterung des Turing-Maschinen Modells zu betrachten: die
alternierende Turing-Maschine (ATM).
◮ Eine Alternierende Turing-Maschine besitzt vier Typen von
Zuständen: akzeptierende, verwerfende, existentielle und universelle
Zustände.
◮ In einem Berechnungsbaum einer solchen Maschine fassen wir alle
möglichen Berechnungspfade einer solchen Maschine auf einer
Eingabe zusammen.
◮ Eine (zulässiger) Berechnungsteilbaum besteht jetzt aus einem
Teilbaum des Berechnungsbaums, in dessen Blätter die TM
entweder in einem akzeptierenden oder in einem verwerfende
Zustand ist. Ferner fordern wir für alle Konfigurationen der TM im
Berechnungsteilbaum, in der die TM in einem universellen Zustand
ist, dass diese Knoten die gleichen direkten Nachfolgekonfigurationen
im Berechnungsteilbaum haben, die sie auch im vollständigen
Berechnungsbaum haben. In einem existentielle Zustand soll
hingegen nur eine direkten Nachfolgekonfiguration vorhanden sein.
◮
Die ATM akzeptiert eine Eingabe, falls es einen
Berechnungsteilbaum für die Eingabe gibt, dessen Blätter alle
akzeptiert sind.
◮
Eine ATM nennen wir T -zeitbeschränkt, falls die Tiefe des
Berechnungsbaum der ATM für jede Eingabe x durch T (|x|)
beschränkt ist.
AP ist jetzt Menge aller Sprachen, die von einer
polynomiell-zeitbeschränkten ATM akzeptiert werden.
◮
Analog können wir auch die alternierende probabilistische
Turing-Maschine (APrTM) definieren, wobei wir die universellen Zustände
gegen probabilistische Zustände austauschen. Wir definieren dann:
◮ Die APrTM akzeptiert eine Eingabe, falls es einen
Berechnungsteilbaum für die Eingabe gibt, der mehr akzeptierende
als verwerfende Blätter besitzt.
◮ APP ist jetzt Menge aller Sprachen, die von einer
polynomiell-zeitbeschränkten APrTM akzeptiert werden.
297
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
298
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
Eine weitere Verwandte Komplexitätsklasse erhalten wir, wenn Spiele
betrachten, bei denen wir die Erfolgswahrscheinlichkeit der zweiten
Person deutlich von 12 separieren. Bekannt wurde diese Form eines
interaktiven Systems unter dem Namen Arthur-Merlin Spiele. Die Idee
eines Arthur-Merlin Spiels kann durch folgende Situation am Hofe dieses
mystischen Königs beschrieben werden:
Betrachten wir die Ergebnisse dieses Kapitels, so verwundert uns nicht
das folgende Ergebnis:
König Arthur (A), ein gerechter König, regiert England mit
Hilfe seines allwissenden Ratgebers Merlin (M). Oft treffen die
beiden mystischen Gestalten aufeinander und diskutieren über
vielerlei anstehender Fragen. Hierbei versucht Merlin Arthur
immer wieder von seiner Allwissenheit mit Hilfe von Frage- und
Antwortspielen zu überzeugen. Diese Spiele haben den
folgenden Ablauf: Arthur stellt mit Hilfe von randomisierten
Bits sukzessive verschiedene Fragen, die von Merlin auf die
bestmögliche Art und Weise beantwortet werden. Merlin hat bei
einem solchen Spiel eine Gewinnstrategie, wenn es ihm gelingt
Arthur mit einer Wahrscheinlichkeit von 32 zu überzeugen.
Satz 42 PSPACE = AP = APP.
299
300
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
Basierend auf dieser Idee läßt sich nun eine neue Form der APrTM
beschreiben, bei der es möglich ist, die Fehlerwahrscheinlichkeit beliebig
zu verkleinern. Wir definieren daher eine fehlerbeschränkte APrTM
analog zur APrTM mit dem Unterschied, dass diese TM eine Sprache L
akzeptiert, wenn
1. für jedes x ∈ L ein zulässiger Berechnungsteilbaum existiert, so dass
2
3 aller Blätter akzeptierend sind und
2. für jedes x 6∈ L und jeden zulässigen Berechnungsteilbaum maximal
1
3 aller Blätter akzeptierende Endkonfigurationen darstellen.
AM(pol) ist jetzt Menge aller Sprachen, die von einer
polynomiell-zeitbeschränkten fehlerbeschränkten APrTM akzeptiert
werden.
Hierbei müssen wir beachten, dass es im Allgemeinen nicht möglich für
eine APrTM zu entscheiden, ob auch fehlerbeschränkt ist. Wie sollen wir
entscheiden, ob nicht für eine Eingabe x ∈ L und für jeden zulässigen
Berechnungsteilbaum exakt die Hälfte aller Blätter akzeptierend sind.
Eine solche APrTM ist jedoch nicht fehlerbeschränkt.
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
Das folgende Ergebnis ist daher etwas verwunderlich soll aber in dieser
Vorlesung nicht bewiesen werden:
Satz 43 PSPACE = AM(pol).
Kommen wir zurück zu unserer Charakterisierung von AM(pol) mit Hilfe
der beiden mythischen Gestalten Arthur und Merlin. Betrachten wir das
anfängliche Arthur-Merlin Szenario etwas genauer, so erkennen wir, dass
im unterschied zu fehlerbeschränkte APrTM Merlin nicht unbedingt die
benutzten Zufallsbits von Arthur kennen muss. Dieses können wir jedoch
in dem Szenario voraussetzten. Wir erhalten somit ein interaktives
Protokoll mit öffentlichen Zufallsbits. Dieses hat zur Folge, dass Merlin
das Verhalten von Arthur simulieren kann. Wir können uns jetzt die
Frage stellen, was passiert, wenn die Zufallsbits privat sind.
301
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
302
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
Definition 47 (Teil 2) Die Zusammenarbeit zwischen zwei ITMs M1 und
M2 wird mit Hilfe eines interaktiven Protokolls geregelt.
◮ Zu Beginn der Berechnung befinden sich beide Maschinen in ihren
Startzuständen, die Eingabe steht auf den beiden Eingabebändern
(bzw. auf dem Eingabeband) und die jeweiligen Arbeits- und
Kommunikationsbänder sind leer.
◮ Das Protokoll legt fest, welche der Maschinen beginnt, o.B.d.A. sei
dieses M1 .
◮ Eine Berechnung wird in Runden aufgeteilt, welche sich aus jeweils
zwei Phasen zusammensetzen.
◮ In der ersten Phase startet M1 seine Berechnung während M2 in
einer Art Wartezustand verharrt.
◮ Hierbei beschreibt M1 auch das Kommunikationsband für M2 .
◮ Nach Abschluß seiner Berechnung wechselt M1 in einen
Wartezustand und aktiviert die Berechnungsphase von M2 , die auf
die Nachricht von M1 reagieren kann und seinerseits im Verlaufe
seiner Berechnung eine Nachricht für M1 generiert. Abschließend
übergibt M2 die Initiative wieder an M1 .
Als nächstes wollen wir den Begriff der interaktiven Maschine definieren.
Definition 47 Eine interaktive Turing Maschine (ITM) ist eine Turing
Maschine,
◮ welche neben ihren Eingabe-, Ausgabe- und Arbeitsbändern noch
einige Paare von Kommunikationskanälen besitzt.
Ein solches Paar besteht aus einem write-only Kommunikationsband
zum Versenden und einem read-only Kommunikationsband zum
Empfangen von Nachrichten.
◮ Zwei ITMs teilen sich ein derartiges Paar und können mit dessen
Hilfe Informationen austauschen.
Wir werden uns hier auf ITMs mit einem solchen Paar beschränken.
◮
303
304
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
Andreas Jakoby
Universität zu Lübeck
Beweissystem mit zwei ITMs
Definition 47 (Teil 3)
Eingabeband
◮
Die Berechnung eines interaktiven Protokolls besteht aus einer Folge
von Runden.
◮
Das Ergebnis wird durch das Ergebnis einer der beiden ITMs, welche
wir Verifizierer V nennen, festgelegt, d.h. sie entscheidet, ob eine
Eingabe x akzeptiert oder verworfen wird.
Die andere Maschine wollen wir als Beweiser P bezeichnen.
Das Ergebnis wird mit [P, V](x) bezeichnet.
Der Zeitbedarf einer ITM ist die Anzahl ihrer aktiven Schritte, d.h.
Schritte, in denen sie sich in einem Wartezustand befindet, werden
nicht mitgezählt.
◮
◮
◮
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
@1 1 1 1 0 0 1 0 1 0 1 0 1 0 1 0 0 0 1 0 1 1 1 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 1
1001
P
1100
V
@1 1 0 1 0 0 0 1 1 0 1 1 1 0 1
@1 1 0 1 1 0 1 1 1 0 1 0 1 0 1
Ausgabeband von P
Ausgabeband von V
305
Andreas Jakoby
Universität zu Lübeck
◮
◮
◮
◮
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
306
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
Definition 48
◮ Ein interaktives Protokoll [P, V] akzeptiert eine Sprache L, wenn für
alle Eingaben x ∈ L [P, V] mit einer Wahrscheinlichkeit von
mindestens 23 akzeptiert.
Von besonderem Interesse für praktische Anwendungen sind
interaktive Protokolle, bei denen der Verifizierer durch eine
zeiteffiziente Turing Maschinen dargestellt wird.
Wir werden uns daher auf Protokolle beschränken, bei denen V eine
polynomiell zeitbeschränkte probabilistische Turing Maschine ist.
Die ihr gegenüber stehende TM, d.h. P, bekommt eine beliebige
Zeitkomplexität — wir gehen davon aus, dass jede Berechnung von
P in einem Schritt durchgeführt werden kann.
◮
◮
Es hat sich jedoch gezeigt, dass wir uns bei P auf eine
polynomiellzeitbeschränkte NTM beschränken können, ohne die
Mächtigkeit des Beweissystems einzuschränken.
◮
◮
307
Um andererseits ein interaktives Protokoll robust gegenüber einem
falschen Propheten abzusichern, verlangen wir für jeden beliebigen
Beweiser P′ und jedes x 6∈ L, dass [P′ , V] die Eingabe x nur mit einer
Wahrscheinlichkeit von höchstens 13 akzeptiert.
Mit IP(k) bezeichnen wir die Menge der Sprachen, von einem
unbeschränkten Beweiser und einem polynomiell zeitbeschränkten
Verifizierer in k Runden akzeptiert werden können.
IP bezeichnet die Menge der Sprachen, die von einem solchen
Protokoll ohne weitere Beschränkung der Rundenzahl akzeptiert
werden.
Man beachte hierbei, dass die Anzahl der Runden durch die
Zeitschranke des Verifizierers implizit vorgegeben ist.
308
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
7 Echte Hierarchien
Satz 45 Sei T2 zeitkonstruierbar auf einer (k + 1)-Band DTM und sei
T1 ∈ o(T2 ), dann gilt
DTimek (T1 ) ⊂ DTimek+1 (T2 ) .
Es gilt wieder (ohne Beweis):
Unter Verwendung sogenannter distributiver Zähler und auf einer k-Band
DTM zeitkonstruierbar Funktionen T2 können wir sogar zeigen, dass
Satz 44 PSPACE = IP.
DTimek (T1 ) ⊂ DTimek (T2 ) .
Beweis von Satz 45 (Teil 1) Wir wollen hier nur das erste Ergebnis zeigen.
◮ Ist T2 zeitkonstruierbar auf einer (k + 1)-Band DTM, so gibt es eine
4 · T2 -zeitbeschränkte (k + 1)-Band DTM, die auf Eingabe x und
den Wert T2 (|x|) auf das k + 1-te Band Schreibt und dann auf
diesem Band sukzessive die Binärdarstellungen
T2 (|x|) − 1,
T2 (|x|) − 2,
...,
0
erzeugt, und dann anhält.
309
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
Beweis von Satz 45 (Teil 2) Interpretieren wir eine beliebige
Zeichenkette x als Kodierung einer Deterministischen Turing-Maschine,
z.B. in Form einer Adjazenzliste für die Zustandsübergangsfunktion mit
Kantengewichte, dann erkennen wir:
◮ Gegeben x, dann können wir in linearer Zeit erkennen, ob x eine
korrekte Kodierung ist.
◮ Wir können die Kodierung mit Hilfe von isolierten Zuständen beliebig
aufblähen, ohne, dass wir die Funktionalität der Maschine ändern.
◮ Sei x eine solche aufgeblähte Kodierung, dann können wir die
isolierten Zustände aus der Kodierung in Zeit 4|x| − |ρ(x)|2
entfernen, wobei ρ(x) die Kodierung der DTM ist, bei der wir die
isolierten Zustände entfernt haben.
◮ Für eine gegebene Kodierung x bezeichnen wir mit Mx die DTM mit
Kodierung x.
◮ Um einen Schritt von Mρ(x) zu simulieren benötigen wir maximal
3|ρ(x)| Schritte.
◮
In T Schritten können wir somit
simulieren.
T −4|x|−|ρ(x)|2
3|ρ(x)|
310
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
Beweis von Satz 45 (Teil 3) Wir betrachten nun die folgende DTM M:
◮
◮
◮
Auf Eingabe x bestimmt M zunächst T2 (|x|) und ρ(x).
Jetzt simuliert M die Maschine Mρ(x) für maximal T2 (|x|)−4|x|−|ρ(x)|
3|ρ(x)|
Schritte.
M akzeptiert genau dann x, wenn Mρ(x) die Eingabe x in
T2 (|x|)−4|x|−|ρ(x)|2
3|ρ(x)|
2
Schritten verwirft.
Die Laufzeit von M ist durch die Laufzeit des Zählers 4 · T2
beschränkt.
Da T1 mindestens linear in der Eingabelänge ist, können wir diese
Maschine linear beschleunigen — wir fassen mehrere Symbole zu einem
Symbol zusammen und simulieren immer mehrere Schritte in einem
Schritt. Wir können somit davon ausgehen, dass die Laufzeit von M
durch T2 beschränkt ist, d.h.
◮
L(M) ∈ DTime(T2 ) .
Schritte von Mρ(x)
311
312
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
11. Vorlesung, 23.06.2008
Beweis von Satz 45 (Teil 4) Wir wollen nun zeigen, dass
L(M) 6∈ DTime(T1 )
Satz 46 Sei T2 zeitkonstruierbar und sei T12 ∈ o(T2 ), dann gilt
ist. Angenommen, L(M) ∈ DTime(T1 ), dann gibt es eine DTM M ′ für
L(M) mit Kodierung x, so dass die DTM mit Kodierung ρ(x) auf
2
Eingabe x in T2 (|x|)−4|x|−|ρ(x)|
Schritten von M bis zum Abschluß der
3|ρ(x)|
Berechnung simuliert werden kann. Es gilt einerseits
DTime(T1 ) ⊂ DTime(T2 ) .
Beweis von Satz 46 Angenommen, es gelte DTime(T1 ) = DTime(T2 ),
dann gilt auf Grund des Bandreduktionssatzes
L(M) = L(Mx ) = L(Mρ(x) ) .
DTime(T2 ) = DTime(T1 ) ⊆ DTime1 (T12 ) ⊂ DTime2 (T2 ) ⊆ DTime(T2 ) .
Auf der anderen Seite gilt
Wenden wir eine schärfere Form des Bandreduktionssatzes an, so können
wir den Satz auch für T1 log T1 ∈ o(T2 ) beweisen.
x ∈ L(M) ⇐⇒ x 6∈ L(Mρ(x) )
und somit
L(M) 6= L(Mρ(x) )
— ein Widerspruch.
313
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
12. Vorlesung, 30.06.2008
314
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
12. Vorlesung, 30.06.2008
7.1 Allgemeiner Hierarchiesatz
Wir wollen nun untersuchen, wie wir zwei Komplexitätsklassen
vergleichen kann.
Definition 49 (Teil 2)
◮ D ist bezüglich C T2 -kontrollierbar, falls die universelle TM M bei
der Simulation von Maschinen in C sicherstellen kann, dass sie die
Schranke T2 nicht überschreitet.
In der Regel genügt hierzu, dass T2 konstruierbar ist.
Definition 49 Seien C, D zwei beliebige Ressourcen wie zum Beispiel
DTime, DSpace und C(T1 ), D(T2 ) zwei Komplexitätsklassen.
D(T2 ) ist universell für C(T1 ), falls es in D eine universelle TM M
gibt, die jede TM M ′ in der Klasse C simulieren kann. Hierbei gilt
für alle bis auf endlich viele n: Zur Simulation von M ′ mit
Ressourcenschranke T1 (n) auf Eingaben der Länge n benötigt M
von ihrer Ressource nicht mehr als T2 (n).
Diese Bedingung impliziert bereits, dass C(T1 ) ⊆ D(T2 ) ist. Um zu
zeigen, dass D(T2 ) \ C(T1 ) 6= ∅ ist, genügt es, wenn für unendliche viele
n zur Simulation von M ′ mit Ressourcenschranke T1 (n) auf Eingaben der
Länge n benötigt M von ihrer Ressource nicht mehr als T2 (n).
◮
◮
315
D(T2 ) ist abgeschlossen gegenüber Komplementierung, d.h.
co-D(T2 ) ⊆ D(T2 ).
316
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
12. Vorlesung, 30.06.2008
Satz 47 Ist die Komplexitätsklasse D(T2 ) universell für C(T1 ),
abgeschlossen gegenüber Komplementierung und die Ressource D
bezüglich C T2 -kontrollierbar, so gilt
Beweis von Satz 47 (Teil 1)
◮
◮
Angenommen, es gibt eine TM M ′ in C(T1 ), die L akzeptiert.
Sei x eine genügend lange Kodierung von M ′ , so dass die universelle
Maschine M die Simulation von M ′ korrekt zu Ende führen kann.
◮
Es gilt
◮
Es ist jetzt einfach zu erkennen, dass Satz 46 nur ein Korollar von Satz 47 ist.
◮
Computational Complexity SS 08
12. Vorlesung, 30.06.2008
Beweis von Satz 47 (Teil 2)
C(T1 ) ⊂ D(T2 ) .
◮
Andreas Jakoby
Universität zu Lübeck
Sei M eine universelle TM für C(T1 ), die auf Eingabe x die TM Mx
auf x simuliert, falls x eine korrekte Kodierung einer TM für die
Ressource C ist.
M kontrolliert, ob sie bei der Simulation die Schranke T2 nicht
überschreitet. Sollte die Simulation nicht innerhalb der Ressourcenschranke T2 von D zu Ende geführt werden, so akzeptiert M die
Eingabe x nicht.
Nach Konstruktion gilt für L = L(M) L ∈ D(T2 ) und somit auch
L ∈ D(T2 ).
x ∈ L ⇐⇒ x 6∈ L ⇐⇒
⇐⇒
◮
M akzeptiert x nicht
M ′ akzeptiert x nicht.
Somit unterscheiden sich L und L(M ′ ) zumindest im dem Element x. 317
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
12. Vorlesung, 30.06.2008
318
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
12. Vorlesung, 30.06.2008
Satz 48 Sei S2 ≥ log platzkonstruierbar und S1 ≤ o(S2 ), dann gilt
Beweis von Satz 48 (Teil 2) Wir müssen nun noch zeigen, dass
DSpace(S2 ) universell für DSpace(S1 ) ist.
◮ Wir betrachten nun eine beliebige S1 -platzbeschränkten DTM M ′ .
◮ Sei ρ die Kodierung einer S1 -platzbeschränkten DTM M ′ .
DSpace(S1 ) ⊂ DSpace(S2 ) .
Beweis von Satz 48 (Teil 1) Wir beschreiben im Folgenden eine
S2 -platz- beschränkte DTM M, so dass L(M) nicht von einer
S1 -platzbeschränkte DTM erkannt werden kann. Auf Eingabe x arbeitet
M wie folgt:
◮ M berechnet s = S2 (|x|) auf Platz S2 (|x|) und markiert S2 (|x|)
aufeinanderfolgende Speicherzellen. Hierbei achten wir darauf, dass
die für die Berechnung benötigten Speicherzellen zu den markierten
Speicherzellen gehören.
◮ M simuliert Mx auf den markierten s Speicherzellen für t = 22s
Schritte (mit Hilfe eines Zählers auf einer separaten Spur).
◮ Falls die Simulation mehr Platz benötigt oder die Maschine Mx nicht
in t Schritten hält, verwirft M.
◮ Nach Konstruktion ist M exakt S2 -platzbeschränkt.
Es folgt, dass DSpace(S2 ) bezüglich DSpace(S1 ) S2 -kontrollierbar ist.
Zudem ist einfach zu erkennen, dass DSpace(S2 ) auch abgeschlossen
gegenüber Komplementierung ist.
◮
Sei n ≥ |ρ| mit
log S1 (n) + |ρ| · S1 (n) ≤ s
= S2 (n).
Da S1 ≤ o(S2 ), S2 ≥ log und |ρ| eine feste Kodierung von M ′ und
somit konstant ist, können wir eine Schranke n0 finden, so dass die
obige Bedingung für alle n ≥ n0 erfüllt ist.
◮
319
Sei x eine Kodierung von M ′ der Länge n. Sie schon im Satz 46
können wir annehmen, dass es eine Verlängerung x der Kodierung ρ
auf Länge n gibt, die wir effizient zurücknehmen können, d.h. wir
können auf Platz |ρ| · log n die Kodierung ρ aus x bestimmen.
320
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
12. Vorlesung, 30.06.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
12. Vorlesung, 30.06.2008
Beweis von Satz 48 (Teil 4) Versuchen wir uns nun aber einmal direkt
an der Diagonalisierung:
Beweis von Satz 48 (Teil 3) Die von uns konstruierte DTM M hat
jetzt auf Eingabe x genügend Platz reserviert, um
◮
Wir wissen, dass L(M) in DSpace(S2 ) ist. Angenommen, L(M) ist
auch in DSpace(S1 ).
Sei M ′ eine S1 -platzbeschränkte DTM für L(M) und ρ eine
Kodierung von M ′ . Ferner sei x eine Verlängerung der Kodierung ρ
auf Länge n.
◮
Es gilt
◮
entweder die Simulation von Mρ = M ′ auf Eingabe x und Platz
|ρ| · S1 (n) vollständig durchzuführen – der Faktor |ρ| sorgt dafür,
dass diese unabhängig vom Bandalphabet und der Zustandsmenge
von Mρ gilt – oder
◮ die Simulation so lange zu verfolgen, bis diese nach spätestens
n · S1 (n) · |ρ|S1 (n) Schritten in eine Endlosschleife gerät.
DSpace(S2 ) ist somit universell für DSpace(S1 ).
◮
x ∈ L(M) ⇐⇒
⇐⇒
x ∈ L(M ′ ) ⇐⇒ x ∈ L(Mρ )
M akzeptiert x ⇐⇒ x ∈ L(M) .
Wir erhalten einen Widerspruch.
321
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
12. Vorlesung, 30.06.2008
322
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
12. Vorlesung, 30.06.2008
7.2 Translation
Translation ist eine Technik, um eine Inklusion zwischen zwei
Komplexitätsklassen mit Schranken T1 und T2 auf entsprechende Klassen
mit grössere Klassen mit Schranken T1′ und T2′ zu übertragen. Die Idee
hierbei ist, eine Eingabe künstlich zu verlängern. Diese Technik wird auch
als Padding bezeichnet. Eine entsprechende Technik haben wir schon in
den Beweisen von Satz 46 und 48 kennen gelernt.
Satz 49 Sei S2 ≥ log platzkonstruierbar und S1 ≤ o(S2 ), dann gilt
NSpace(S1 ) ⊂ NSpace(S2 ) .
Beweis von Satz 49 Der Beweis erfolgt analog zum Beweis von Satz 48.
Hierbei spielt der Abschluss von NSpace(S2 ) gegenüber
Komplementierung eine entscheidende Rolle.
Satz 50 [Translationssatz für Zeitschranken] Seien T1 , T2 , f
zeitkonstruierbare Funktionen mit T1 , T2 ≥ (1 + α)N für ein α > 0 und
f ≥ N . Dann gilt
Wir sollten hier noch hervorheben, dass ein entsprechendes Ergebnis für
nichtdeterministische Zeit nicht aus Satz 47 gefolgert werden kann.
DTime(T1 ) ⊆ DTime(T2 ) =⇒ DTime(T1 ◦ f ) ⊆ DTime(T2 ◦ f )
und
NTime(T1 ) ⊆ NTime(T2 ) =⇒ NTime(T1 ◦ f ) ⊆ NTime(T2 ◦ f ) .
323
324
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
12. Vorlesung, 30.06.2008
Beweis von Satz 50 (Teil 1) Da die Beweise des deterministischen Falls
und des nichtdeterministischen Falls analog verlaufen, werden wir uns
hier nur auf den deterministischen Fall konzentrieren.
◮ Sei L1 ∈ DTime(T1 ◦ f ), M1 eine (T1 ◦ f )-zeitbeschränkte DTM für
L1 ∈ Σ∗ und ♯ 6∈ Σ ein Sondersymbol, mit dem wir die Eingabe
verlängern können.
◮ Sei
◮
Andreas Jakoby
Universität zu Lübeck
L2 ∈ DTime(T1 ) und somit L2 ∈ DTime(T2 ).
Sei M3 eine T2 -zeitbeschränkte DTM für L2 .
Wir konstruieren nun eine (T2 ◦ f )-zeitbeschränkte DTM M4 für L1 :
◮
◮
◮
◮
◮
326
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
12. Vorlesung, 30.06.2008
Satz 51 [Translationssatz für Platzschranken] Seien S1 , S2 , f
platzkonstruierbare Funktionen mit S2 ≥ Ω(log) und f ≥ N . Dann gilt
Beweis von Satz 50 (Teil 3) Für die von M4 akzeptierte Sprache gilt
⇐⇒
Auf Eingabe x bestimmt M4 den Wert f (|x|) und erweitert die
Eingabe um f (|x|) − |x| Symbole ♯.
M4 simuliert nun M3 für T2 (f (|x|)) Schritte.
Die Laufzeit von M4 ist somit in O(f + T2 ◦ f ). Mit Hilfe der
linearen Beschleunigung folgt L1 ∈ DTime(T2 ◦ f ).
325
Computational Complexity SS 08
12. Vorlesung, 30.06.2008
x ∈ L(M4 ) ⇐⇒
⇐⇒
⇐⇒
Computational Complexity SS 08
12. Vorlesung, 30.06.2008
Beweis von Satz 50 (Teil 2) Fassen wir die Beobachtungen der letzten
Folie zusammen, so erkennen wir:
L2 := { x♯r | M1 akzeptiert x in T1 (|x| + r ) Schritten } .
Da T1 zeitkonstruierbar ist, gibt es eine O(T1 )-zeitbeschränkte
DTM M2 , die ähnlich einer universellen DTM mit Hilfe eines Zählers
L2 akzeptiert.
Speichern wir mehrere Zellen einer TM in einer Zelle einer TM, so
ist es möglich, dass die neue TM in jedem Schritt eine konstante
Anzahl von Schritten der ursprünglichen TM ausführt. Hierfür ist es
jedoch erforderlich, dass für die ursprünglichen TM die Laufzeit
zumindest (1 + α) · N beträgt. Wir nennen dieses auch lineare
Beschleunigung: Die Laufzeit T einer TM kann um einen konstanten
Faktor beschleunigt werden, solange die resultierende Laufzeit
zumindest N beträgt.
Andreas Jakoby
Universität zu Lübeck
DSpace(S1 ) ⊆ DSpace(S2 ) =⇒ DSpace(S1 ◦ f ) ⊆ DSpace(S2 ◦ f )
M3 akzeptiert x♯f (|x|)−|x| in T2 (f (|x|)) Schritten
x ∈ L2
M1 akzeptiert x in T1 (f (|x|)) Schritten
und
NSpace(S1 ) ⊆ NSpace(S2 ) =⇒ NSpace(S1 ◦ f ) ⊆ NSpace(S2 ◦ f ) .
x ∈ L1
Beweis von Satz 51 (Teil 1) Da auch hier die Beweise des
deterministischen Falls und des nichtdeterministischen Falls analog
verlaufen, werden wir uns hier nur auf den deterministischen Fall
konzentrieren.
327
328
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
12. Vorlesung, 30.06.2008
Beweis von Satz 51 (Teil 2) Der Beweis von Satz 51 folgt dem Beweis
von Satz 50. Als Besonderheiten müssen wir jedoch ein paar Punkt
beachten:
◮
Liegt die Eingabe auf einem separatem Eingabeband vor, so kann
das Analogon zur DTM M4 aus dem Beweis von Satz 50 nicht die
benötigten ♯ Symbole hinter die ursprüngliche Eingabe schreiben. An
Stelle der tatsächlichen ♯ Symbole in der Eingabe führt M4 einen
Zähler auf einer separaten Spur, der mit f (|x|) − |x| initialisiert wird.
Mit Hilfe dieses Zählers zählt die DTM die Anzahl der fiktiven ♯
Symbole rechts vom Eingabekopf, die sich dort bei der modifizierten
Eingabe noch befinden würden. Der Zähler benötigt an Platz nur
eine Spur auf O(log f ) ≤ O(S2 ◦ f ) Speicherzellen.
Da der verbleibende Teil des Beweises sich analog zum Beweis von Satz
50 ergibt, werden wir hier auf diesen verzichten.
◮
DSpace(⌈ε · S⌉)
NSpace(⌈ε · S⌉) .
=
=
Computational Complexity SS 08
12. Vorlesung, 30.06.2008
Beweis von Satz 51 (Teil 3) Die letzte Bemerkung führt uns noch zu
einem weiteren Problem:
Das Analogon zur linearen Beschleunigung nennen wir
Bandkompression: Für jede beliebige Platzschranke S und alle
0 < ε < 1 gilt
DSpace(S)
NSpace(S)
Andreas Jakoby
Universität zu Lübeck
Um dieses zu beweisen Speicher wir wieder mehrere Speicherzellen
in einer Zelle. Strenggenommen müssen wir hier noch beachten, dass
eine Platzschranke kleiner N nur erreicht werden kann, wenn wir ein
separates Eingabeband zur Verfügung haben – die Eingabe soll ja
unverändert vorliegen, da wir ansonsten die Sprache verändern.
329
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
12. Vorlesung, 30.06.2008
330
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
12. Vorlesung, 30.06.2008
7.3 Klassen ohne vollständige Probleme
Beweis von Satz 52 (Teil 1) Der Beweis basiert auf zwei
Beobachtungen:
Als interessanter Nebeneffekt der hier betrachteten Inklusionen erhalten
wir, dass es Komplexitätsklassen ohne vollständige Probleme gibt. Wir
definieren die Komplexitätsklasse
[
POLYLOG :=
DSpace(O(logi )) .
◮
Für alle i ist DSpace(logi ) abgeschlossen gegenüber der logspace
Many-One-Reduktion, d.h. für alle L, L′ gilt
L′ ≤log L und L ∈ DSpace(logi )
i∈N
=⇒
L′ ∈ DSpace(logi ) .
Für alle i ist DSpace(logi+1 ) \ DSpace(logi ) 6= ∅ (Satz 48).
Wäre also L vollständig für POLYLOG, dann gäbe es ein i mit
L ∈ DSpace(logi ). Nach der zweiten Beobachtung gäbe es auch ein
L′ ∈ DSpace(logi+1 ) \ DSpace(logi ), welches wir aber auf L reduzieren
könnten. Somit wäre L′ aber nach der ersten Beobachtung in
DSpace(logi ) – ein Widerspruch.
Mit Hilfe der Bandkompression können wir auf das O verzichten und
erhalten
[
DSpace(logi ) .
POLYLOG =
◮
i∈N
Es gilt nun:
Satz 52 Es gibt keine vollständigen Probleme für POLYLOG bezüglich
der logspace Many-One-Reduktion.
331
332
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
12. Vorlesung, 30.06.2008
◮
Sei also L′ ≤log L und L ∈ DSpace(logi ). Dann gibt es eine
log-platzbeschränkte DTM M1 , die L′ auf L reduziert, und eine
logi -platzbeschränkte DTM M2 , die L akzeptiert.
Wir generieren nun eine neue DTM M3 für L′ :
◮
◮
◮
i∈N
Ähnliches gilt auch für den Schnitt von Komplexitätsklassen, z.B. für
M3 simuliert M2 wobei sie nicht auf die Eingabe direkt zugreift.
Anstelle auf die Eingabe zuzugreifen benutzt M3 einen Zähler, der
angibt auf welche Position k der Eingabe die Maschine M2 aktuell
zugreifen möchte.
Bei jedem Zugriff auf die Eingabe von M2 startet M3 eine Simulation
von M1 , wobei jedoch nur das Symbol der benötigten Eingabeposition bestimmt werden soll.
M3 ist eine logi -platzbeschränkte DTM für L′ und somit ist
L ∈ DSpace(logi ).
Computational Complexity SS 08
12. Vorlesung, 30.06.2008
Ähnliche Aussagen können wir für eine ganze Reihe von Komplexitätsklassen zeigen, die mit Hilfe der Vereinigung von unendlich vielen
Komplexitätsklassen definiert werden, z.B.
[
2n
··
·
i .
DTime(Ti ) für Ti (n) = 22
Beweis von Satz 52 (Teil 2) Wir müssen somit nur noch die erste
Beobachtung zeigen:
◮
Andreas Jakoby
Universität zu Lübeck
N P ∩ co − N P ,
dass heißt, die Menge der Sprachen L, die sowohl in N P als auch in
co − N P sind. Intuitiv ergibt sich für die Sprachen L ∈ N P ∩ co − N P
folgendes Problem: angenommen, wir kennen eine polynomiell-zeitbeschränkte NTM für eine Sprache L, wie sollen wir nun entscheiden, ob
es auch eine polynomiell-zeitbeschränkte co-NTM für diese Sprache gibt.
Da im Zentrum der Definition einer solchen Sprache eine semantische
Forderung steht, die wir nicht ohne Probleme entschärfen können, nennen
wir solche Komplexitätsklassen auch semantische Komplexitätsklassen.
333
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
12. Vorlesung, 30.06.2008
334
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
12. Vorlesung, 30.06.2008
Weitere Beispiele für semantische Komplexitätsklassen sind:
UP
:= { L | es existiert eine polynomiell-zeitbeschränkte NTM
für L, die auf jeder Eingabe maximal einen akzep-
RP
tierenden Berechnungspfad besitzt }
:= { L | es existiert eine polynomiell-zeitbeschränkte NTM
für L, die für x ∈ L auf mindestens 23 aller Berech-
Die Komplexitätsklassen L, N L, P, N P, PSPACE nennen wir
syntaktische Komplexitätsklassen. Für diese können wir eine universelle
TM angeben, welche einerseits eine beliebige zu den Komplexitätsmassen
passende TM simuliert und andererseits überprüft, ob die geforderte
Komplexitätsschranke auch eingehalten wird. Für eine syntaktische
Komplexitätsklassen C sei M(C) die Menge aller TMs, die Elemente der
Klasse C beschreiben. Hierbei gehen wir davon aus, dass die TMs
entsprechend standardisiert sind – z.B. Laufzeitüberprüfung mittels eines
Zählers, Platzschrankenüberprüfung, etc. Für eine syntaktische
Komplexitätsklassen C existiert das folgende kanonische vollständige
Problem
nungspfade akzeptiert, und für x 6∈ L auf maximal
1
3
aller Berechnungspfade akzeptiert } .
Für diese Klassen ist es sehr schwierig eine standardisierte NTM zu
finden, welche die Voraussetzungen für diese Klassen erfüllt. Vergleichen
wir jetzt die letzte dieser Klassen mit IP oder AM(pol), so können wir
vermuten, dass auch diese Klassen semantische Komplexitätsklassen sind.
Da jedoch
IP = AM(pol) = PSPACE
LC
:= { (M, x) | M ∈ M(C) und M akzeptiert x } .
ist, können wir einfach ein vollständiges Problem für diese Klassen
angeben.
335
336
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
8 Die Klasse P oder die Grenzen
effizienter paralleler Algorithmen
◮
und
ts (n) ≤ s(n) · d(n) .
Um jetzt zu zeigen, dass ein Problem von diesem Typ ist, gibt es die
Möglichkeit direkt zu beweisen, dass alle effizienten parallelen
Algorithmen dieses Problem fehlerhaft lösen, oder wir zeigen, dass
wir ein anderes Problem, welches inhärent sequentiell ist, effizient
parallel lösen können, wenn wir unser Problem effizient parallel lösen
können.
◮
Im Folgenden verstehen wir unter effiziente sequentielle Lösbarkeit
die Lösbarkeit mit Hilfe einer polynomiell-zeitbeschränkten DTM.
Wir nennen ein Problem effizient parallel Lösbar, wenn wir dieses in
N C liegt. In vielen Fällen verlangen wir, dass das Problem in N C 2
liegt.
Wir können somit die Frage, ob es inhärent sequentielle Probleme
?
gibt, als eine Verallgemeinerung der Frage L = P verstehen.
◮
Somit ist jedes Problem, welches effizient parallel zu lösen ist, auch
effizient sequentiell lösbar. Es ist eine der großen offenen Fragen der
Informatik, ob dieses auch umgekehrt gilt.
Es scheint Probleme zu geben, die zwar in polynomieller sequentieller
Zeit gelöst werden können, jedoch inhärent sequentiell sind.
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
◮
Vergleichen wir sequentielle Zeit ts und den parallelen Aufwand um
eine Sprache L zu akzeptieren, so gilt für jeden t-zeit- und
p(n)-prozessorbeschränkten parallelen Algorithmus für L sowie für
jede d-tiefen- und s-größenbeschränkt Schaltkreisfamilie für L,
ts (n) ≤ p(n) · t(n)
◮
Andreas Jakoby
Universität zu Lübeck
◮
337
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
8.1 Adäquate Reduktionen für P
338
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
Definition 51 f nennen wir genau dann N C k -reduzierbar auf g (kurz
f ≤N C k g ), wenn eine log-platzkonstruierbare Schaltkreisfamilie
C = (Ci )i∈N für f mit depthC (n) = O(logk (n)) und sizeC (n) = O(nO(1) )
existiert, welche auf Orakelgatter für g zurückgreifen kann.
Ferner nennen wir f N C k -äquivalent zu g (kurz f ≡N C k g ), wenn
f ≤N C k g und g ≤N C k f ist.
f nennen wir genau dann N C-reduzierbar auf g (kurz f ≤N C g ), wenn ein
k ∈ N existiert, so dass f auf g N C k -reduzierbar ist. f ist N C-äquivalent
zu g (kurz f ≡N C g ), wenn f ≤N C g und g ≤N C f ist.
Definition 50 Sei ≤ eine Reduktion und C eine Komplexitätsklasse. Wir
nennen ≤ adäquat für C, wenn für alle Sprachen L1 und L2 mit L1 ≤ L2
und L2 ∈ C auch L1 ∈ C gilt.
Für die Komplexitätsklasse P haben wir bereits die folgenden adäquaten
Reduktionen kennen gelernt:
◮ die projektive Reduktion,
◮ die N C 1 -Reduktion und
◮ die logspace-Reduktion.
Satz 53 P und N C sind abgeschlossen unter der N C k -Reduktion für alle
k und unter der N C-Reduktion.
Wollen wir untersuchen, ob die Klasse P inhärent sequentielle Probleme
enthält, dann können wir die Menge der adäquaten Reduktionen auf alle
effizient parallel berechenbare Funktionen ausdehnen. Dieses führt uns zu
den folgenden Verallgemeinerungen der N C 1 -Reduktion aus Definition 23.
339
340
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
Satz 54 Die Reduktion ≤N C ist adäquat für N C und P.
◮
◮
◮
◮
◮
◮
◮
Somit existiert ein k mit L1 ≤N C k L2 .
Sei C = (Ci )i∈N eine log-platzkonstruierbare Schaltkreisfamilie für
L1 mit depthC (n) = O(logk (n)) und sizeC (n) = O(nO(1) ), welche
auf Orakelgatter für L2 zurückgreifen kann.
Aus der Platzkonstruierbarkeit von C folgt, dass diese Familie auch
in polynomieller Zeit Konstruiert werden kann.
Um L1 zu entscheiden, benutzen wir die folgende DTM M:
◮
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
Beweis für Satz 54 (Teil 2): Sei L1 ≤N C L2 und L2 ∈ N C.
Beweis für Satz 54 (Teil 1): Sei L1 ≤N C L2 und L2 ∈ P.
◮
Andreas Jakoby
Universität zu Lübeck
◮
◮
Auf Eingabe x ∈ Σn berechne Cn .
Werte Cn aus, wobei bei jedem Orakelgatter die DTM für L2
simuliert wird.
◮
Es ist einfach zu erkennen, dass M in polynimieller Zeit die Sprache
L1 akzeptiert.
◮
Somit existiert ein k mit L1 ≤N C k L2 und ein ℓ mit L2 ∈ N C ℓ .
Sei C = (Ci )i∈N eine log-platzkonstruierbare Schaltkreisfamilie für
L1 mit depthC (n) = O(logk (n)) und sizeC (n) = O(nO(1) ), welche
auf Orakelgatter für L2 zurückgreifen kann.
Sei C ′ = (Ci′ )i∈N eine log-platzkonstruierbare Schaltkreisfamilie für
L2 mit depthC (n) = O(logℓ (n)) und sizeC (n) = O(nO(1) ).
Setzen wir die Schaltkreise für L2 in C ein, so erhalten wir eine
Schaltkreisfamilie für L1 mit depthC (n) = O(logk+ℓ−1 (n)) und
sizeC (n) = O(nO(1) ).
Diese Schaltkreisfamilie ist log-platzkonstruierbar, da wir bei der
Verschachtelung der beiden logspace DTMs die bekannten
Techniken anwenden können.
L1 ist somit in N C k+ℓ−1 .
341
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
342
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
Wie wir oben angedeutet haben, gibt es Probleme mit der Transitivität
von N C k -Reduktionen, für k > 1. Diese Probleme entstehen nicht mehr,
wenn wir uns der Many-One Variante dieser Reduktion zuwenden.
Definition 52 L1 nennen wir genau dann many-one N C k -reduzierbar auf
L2 (kurz L1 ≤m,N C k L2 ), falls es eine log-platzkonstruierbare
Schaltkreisfamilie C = (Ci )i∈N mit depthC (n) = O(logk (n)) und
sizeC (n) = O(nO(1) ) existiert, so dass
Für die N C k -Reduktion mit k > 1 können wir das folgende Problem
feststellen:
Berücksichtigen wir bei der Bestimmung der Tiefe des
Reduktionsschaltkreises die Tiefe der Orakelgatter nur
logarithmisch im Eingrad der Gatter, dann können wir nicht
mehr garantieren, dass für alle i, k ≥ 1 mit i ≥ k die Klasse
N C i abgeschlossen unter der N C k -Reduktion ist. Dieses
Problem tritt bei der N C-Reduktion nicht mehr auf.
∀w ∈ Σ∗1 :
(w ∈ L1 ⇐⇒ C|w | (w ) ∈ L2 )
gilt. Wir nennen L1 many-one N C-reduzierbar auf L2 (kurz L1 ≤m,N C L2 ),
falls ein k ∈ N existiert, so dass L1 ≤m,N C k L2 ist. Formal müssten wir hier
eigentlich fordern, dass L1 , L2 ⊆ {0, 1}∗ sind.
L1 und L2 heißen äquivalent bezüglich der Reduktionsrelation ≤m,N C k ,
kurz ≡m,N C k , wenn L1 ≤m,N C k L2 und L2 ≤m,N C k L1 gilt. Wir nennen L1
und L2 äquivalent bezüglich many-one N C-Reduzierbarkeit (kurz
L1 ≡m,N C L2 ), falls ein k ∈ N existiert, so dass L1 ≡m,N C k L2 ist.
343
344
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
Aus Korollar 5 folgern wir:
Korollar 12 Sei L1 logarithmisch platzreduzierbar auf L2 , dann ist L1
auch many-one N C 2 reduzierbar auf L2 .
Da ein Schaltkreis mit polynomieller Größe eine Eingabe nur polynomiell
vergrößern kann, und da für alle i, k ∈ N
logk ni
Aus unseren bisherigen Beobachtungen folgt:
Haben wir erst einmal ein inhärent sequentielles Problem
gefunden haben und dieses mittels einer many-one N C
Reduktion auf ein anderes Problem reduziert werden kann, dann
ist auch dieses zweite Problem inhärent sequentiell.
∈ O(logk n)
ist, erhalten wir nach dem hintereinander schalten zweier
log-platzkonstruierbare Schaltkreisfamilie C = (Ci )i∈N und D = (Di )i∈N
mit depthC (n), depthD (n) = O(logk (n)) und
sizeC (n), sizeD (n) = O(nO(1) ) wieder eine log-platzkonstruierbare
Schaltkreisfamilie E = (Ei )i∈N mit depthE (n) = O(logk (n)) und
sizeE (n) = O(nO(1) ). Diese Beobachtung impliziert:
Um zu zeigen, dass P =
6 N C ist, genügt es ein Problem in P zu finden,
welches nicht effizient parallel gelöst werden kann. Besonders gute
Kandidaten für solche Probleme sind die P-vollständigen Probleme.
Satz 55 Die Reduktionen ≤m,N C k und ≤m,N C sind reflexiv und transitiv.
Zudem sind P und für alle i ≥ k ≥ 1 die Klassen N C i abgeschlossen
unter der many-one N C k -Reduktion. ≤m,N C k und ≤m,N C sind adäquate
Reduktionen für P.
345
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
346
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
8.2 Ein generisches P-vollständiges Problem
Satz 56 GMSP ist P-vollständig unter ≤m,N C 1 -Reduktion.
Wie wir schon bei der Beschreibung von syntaktischen
Komplexitätsklassen angedeutet haben, erhalten wir einen Kandidaten für
ein P-vollständiges Problem über die Simulation einer polynomiell
zeitbeschränkten Turing-Maschine.
Beweis für Satz 56 (Teil 1):
◮
Definition 53 Das generische Maschinen-Simulations-Problem (eng.
Generic Machine Simulation Problem, kurz. GMSP) ist wie folgt definiert:
Gegeben ist eine Zeichenkette x, eine Kodierung σ(M) einer
Turing-Maschine M und eine Zahl t ∈ N, wir definieren
◮
Um x#σ(M)#1t ∈ GMSP zu entscheiden benutzen wir eine
universelle Turing-Maschine, die M auf x simuliert.
Die Simulation eines Schrittes erfolgt bei einer Standardkodierungen
für σ(M) in polynomieller Zeit (in der Länge von x und σ(M)).
Wir simulieren M für maximal t Schritte.
Hält M spätestens im t-ten Schritt, so akzeptieren wir. Ansonsten
ist x#σ(M)#1t kein Element der Sprache.
GMSP ist folglich in P.
◮
◮
GMSP := { x#σ(M)#1t | M hält auf x in t Schritten } ,
d.h. die Eingabe ist gegeben als Zeichenkette x#σ(M)#1t wobei #
nicht in x oder σ(M) vorkommt. Frage: Hält M auf x in t Schritten.
347
348
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
Andreas Jakoby
Universität zu Lübeck
Beweis für Satz 56 (Teil 3): Wir müssen nun noch zeigen, wie eine
solche Instanz x#σ(M)#1t mit Hilfe einer N C 1 -Schaltkreisfamilie
generiert werden kann.
Beweis für Satz 56 (Teil 2): Wir müssen noch die P-härte von GMSP
nachwiesen. Eine Reduktion von einer beliebigen Sprache L ∈ P auf das
GMSP ist relativ einfach.
◮
Sei M eine Turing-Maschine welche L in polynomieller Zeit
akzeptiert.
◮
◮
Sei p(n) = nc eine obere Schranke für die Laufzeit von M.
Wir modifizieren M derart, dass M nur dann in t = p(|x|) Schritten
hält, wenn M die Eingabe x akzeptiert.
Dieses kann dadurch erreicht werden, dass M bei Erreichen einer
verwerfenden Endkonfiguration zunächst p(n) berechnet und dann
noch p(n) Schritte ausführt.
◮
◮
◮
◮
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
◮
◮
Es gilt somit, dass x#σ(M)#1t genau dann ein Element der
Sprache GMSP ist, wenn M auf x in t Schritten hält.
Da L fest ist, ist auch M und c fest. Die Maschinenkodierung σ(M)
und der String #σ(M)# sind somit konstant und unabhängig von x.
Ferner ist 1p(n) für alle x der Länge n eine feste Zeichenkette.
Da wir das Polynom nc auf logarithmischen Platz auswerten können
ist auch eine Schaltkreisfamilie die #σ(M)#1p(n) ausgibt uniform
auf logarithmischen Platz konstruierbar.
Die Instanz x#σ(M)#1p(n) kann somit von einer
log-platzkonstruierbaren Schaltkreisfamilie generiert werden. Die
Tiefe dieser Schaltkreise ist 1, da jedes Ausgabe-Gatter auch ein
Eingabe-Gatter oder eine Konstante ist. Die Größe dieser
Schaltkreise ist n + c + p(n) für eine Konstante c.
349
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
350
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
Lemma 19 CVP ist in P.
Beweis von Lemma 19:
8.3 Das Problem, einen Schaltkreis auszuwerten
◮
Definition 54 Das Schaltkreis-Auswertungs Problem (eng. Circuit Value
Problem, kurz. CVP) ist wie folgt definiert:
Gegeben ist ein Schaltkreis in Standardkodierung σ(C ), ein Ausgabegatter y von C und eine Eingabe x1 , . . . , xn ∈ {0, 1} für diesen
Schaltkreis, wir definieren
◮
CVP := { σ(C )#y #x1 . . . xn | y hat den Wert 1 auf
Eingabe x1 , . . . , xn } .
◮
351
Liegen die Gatter in der Standardkodierung des Schaltkreises in einer
topologischen Ortnung vor, d.h. in der Liste der Gatter liegen die
Vorgängergatter vl , vr jedes Gatters v vor dem Gatter v , so können
wir alle Gatter von links nach rechts gehend auswerten.
Dieses ist in vielen Maschinen-Modellen in linearer Zeit möglich. Um
die Gatter des Schaltkreises in linearer Zeit in eine topologische
Ortnung zu bringen, können wir den Algorithmus topological-sort
aus Cormen, Leiserson, Rivest, Introduction to Algorithms, 1990,
S. 485-488 benutzen.
Eine Auswertung des Schaltkreises über die Tiefensuche kann auf
einer DTM auch direkt in quadratischer Zeit erfolgen.
352
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
Lemma 20 Für alle Sprachen L ∈ P gilt L≤m,N C 1 CVP.
Beweis von Lemma 20 (Teil 1): Sei L ∈ P.
◮
◮
◮
◮
Aufgrund der Bandreduktionssätze, gibt es eine polynomiell
zeitbeschränkte 1-Band Turing-Maschine M, die L akzeptiert und
bei Erreichen eines akzeptierenden Zustands stoppt.
Sei c eine Konstante, so dass M für alle x = x1 . . . xn ∈ L in
maximal t(n) = nc Schritten akzeptiert.
Der maximale Platzbedarf von M ist durch t(n) + 1 beschränkt – M
kann in t(n) Schritten höchstens t(n) + 1 Zellen des Bandes besuchen.
Wir können noch folgende Vereinfachungen für M festlegen:
◮
◮
◮
Vor Beginn der Berechnung befindet sich die Eingabe x = x1 . . . xn in
den ersten n Zellen des Bandes und M bewegt seinen Kopf nie auf
eine Zelle links von der ersten Zelle.
Damit können wir die Berechnung von M auf die Zellen b1 , . . . , bt(n)+1
des Bandes der Turing-Maschine beschränken.
Ferner können wir davon ausgehen, dass der Kopf von M beim Erreichen
des akzeptierenden Endzustandes sich auf b1 befindet, und dass Zelle
b1 das Ergebnis der Berechnung speichert.
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
Beweis von Lemma 20 (Teil 2): Um eine Konfiguration der
Turing-Maschine nach dem j-ten Schritt zu beschreiben, weisen wir jeder
z
Zelle bi mit 1 ≤ i ≤ t(n) + 1 einen Vektor ri,j von |Σ| + |Q| + 1 Bits ri,j
mit z ∈ Σ ∪ Q ∪ {•} zu. Sei • 6∈ Q ∪ Σ. Diesen Bits kommt die folgende
Bedeutung zu:
◮
◮
◮
z
= 1 für ein z ∈ Σ genau dann, wenn nach dem j-ten Schritt von
ri,j
M in bi das Symbol z steht.
•
= 1 genau dann, wenn nach dem j-ten Schritt von M der Kopf
ri,j
nicht auf der Zelle bi steht.
z
ri,j
= 1 für ein z ∈ Q genau dann, wenn nach dem j-ten Schritt von
M der Kopf auf der Zelle bi steht und der Zustand von M z ist.
Simulieren wir eine Berechnung der Maschine M korrekt, so existiert für
•
jeden Schritt j maximal eine Position i mit ri,j
= 0 und es existiert
z
höchstens ein Zustand z ∈ Q mit ri,j = 1. Zudem gilt für jede Zelle bi ,
z
dass es höchstens ein Symbol z ∈ Σ gibt mit ri,j
= 1.
353
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
Beweis von Lemma 20 (Teil 3): Da eine Turing-Maschine ihren Kopf
auf dem Band immer nur um eine Zelle bewegen kann, hängt jeder
Vektor ri,j nur von den drei Vektoren ri−1,j−1 , ri,j−1 und ri+1,j−1 ab. Die
Vektoren r0,j und rt(n)+2,j werden vom Kopf der DTM nicht besucht.
◮ Wir definieren:
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
Beweis von Lemma 20 (Teil 4): Wir wollen nun einen Schaltkreis
beschreiben, der aus den Vektoren ri−1,j−1 , ri,j−1 und ri+1,j−1 einen
Vektor ri,j für ein i ∈ {1, t(n) + 1} und j ∈ {1, t(n)} berechnet:
◮ Für ein z ∈ Σ sei Az die Menge der Paare (q, z ′ ) ∈ Q × Σ so dass M
beim Lesen von z ′ im Zustand q ein z schreibt. Man beachte, dass
M im j-ten Schritt eine Zellenbeschriftung nur dann ändern kann,
wenn sich der Kopf von M nach dem (j − 1)-ten Schritt auf der
entsprechenden Zelle befindet. Es gilt somit für alle i, j und z ∈ Σ


_
′
q
z
•
z
z
ri,j
= (ri,j−1
∧ ri,j−1
∧ ri,j−1
) ∨ 
) .
(ri,j−1
z
∀j ∈ {0, .., t(n)} : r0,j
= 1 ⇐⇒ z ∈ {β, •}
z
∀j ∈ {0, .., t(n)} : rt(n)+2,j
= 1 ⇐⇒ z ∈ {β, •} .
◮
354
Um die Startkonfiguration von M zu beschreiben, definieren wir
z
= 1 ⇐⇒ z ∈ {β, •}
∀i ≥ n + 1 ∀z ∈ Σ ∪ Q ∪ {•} : ri,0
z
= 1 ⇐⇒ z ∈ {xi , •}
∀i ∈ {2, . . . , n} ∀z ∈ Σ ∪ Q ∪ {•} : ri,0
z
∀z ∈ Σ ∪ Q ∪ {•} : r1,0 = 1 ⇐⇒ z ∈ {x1 , q0 }
(q,z ′ )∈Az
wobei q0 der Startzustand von M ist.
355
356
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
Beweis von Lemma 20 (Teil 6):
◮ Bedingung 2: Die Turing-Maschine bewegt ihren Kopf im j-ten Schritt
nach rechts, und der Kopf steht nach dem (j − 1)-ten Schritt auf bi−1 .
Beweis von Lemma 20 (Teil 5): Um den Zustand der Maschine M zu
bestimmen, müssen wir unter anderem die Kopfbewegung von M
verfolgen. Man beachte hierbei, dass der Kopf auf eine Speicherzelle bi
nach dem j-ten Schritt steht, wenn eine der folgenden drei Bedingungen
erfüllt ist:
◮
Andreas Jakoby
Universität zu Lübeck
Für einen Zustand q ∈ Q definieren wir daher die Menge Bqr als die
Menge der Paare (q ′ , z) ∈ Q × Σ so dass M beim Lesen von z im
Zustand q ′ in Zustand q wechselt und ihren Kopf nach rechts
bewegt. Wir definieren einen Hilfswert
_
q′
q
z
(ri−1,j−1
Ri,j
:=
∧ ri−1,j−1
).
Bedingung 1: Die Turing-Maschine macht im j-ten Schritt keine Kopfbewegung, und der Kopf steht nach dem (j − 1)-ten Schritt auf bi .
(q ′ ,z)∈Bqr
Für einen Zustand q ∈ Q definieren wir daher die Menge Bqo als die
Menge der Paare (q ′ , z) ∈ Q × Σ so dass M beim Lesen von z im
Zustand q ′ in Zustand q wechselt und ihren Kopf nicht bewegt. Wir
definieren einen Hilfswert
_
q′
q
z
(ri,j−1
Oi,j
:=
∧ ri,j−1
).
◮
Bedingung 3: Die Turing-Maschine bewegt ihren Kopf im j-ten Schritt
nach links, und der Kopf steht nach dem (j − 1)-ten Schritt auf bi+1 .
Für einen Zustand q ∈ Q definieren wir daher die Menge Bql als die
Menge der Paare (q ′ , z) ∈ Q × Σ so dass M beim Lesen von z im
Zustand q ′ in Zustand q wechselt und ihren Kopf nach links bewegt.
Wir definieren einen Hilfswert
_
q′
z
(ri+1,j−1
∧ ri+1,j−1
).
Lqi,j :=
(q ′ ,z)∈Bqo
(q ′ ,z)∈Bqr
357
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
358
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
Beweis von Lemma 20 (Teil 8):
◮
Beweis von Lemma 20 (Teil 7): Um nun festzustellen, ob der Kopf
q
q
nach dem j-ten Schritt nicht auf bi steht, darf keiner der Werte Oi,j
, Ri,j
oder Lqi,j wahr sein. Es gilt daher:
•
ri,j
=
_
q∈Q
◮
q
q
(Oi,j
∨ Ri,j
∨ Lqi,j ) .
◮
Um den Zustand q nach dem j-ten Schritt zu bestimmen, wählen wir
◮
q
q
q
= Oi,j
∨ Ri,j
∨ Lqi,j .
ri,j
359
Modifizieren wir M nun so, dass M bei Erreichen des akzeptierenden
Zustands qa in diesem bleibt, so ist das Ausgabebit des Schaltkreises
qa
. Dieses kann mit einer vollständigen Induktion bewiesen
gleich r1,t(n)
werden.
Die Größe des oben konstruierten Schaltkreises ist polynomiell in
t(n).
Jeder Teilschaltkreis, der ri,j aus ri−1,j−1 , ri,j−1 und ri+1,j−1
berechnet, ist uniform auf logarithmischem Platz konstruierbar.
Da zur Kombination dieser Teilschaltkreise nur zwei Zähler zum
Indizieren der Vektoren benötigt werden, ist der ganze Schaltkreis
auf logarithmischem Platz konstruierbar, wenn t(n) auf
logarithmischem Platz berechnet werden kann. Dieses ist auf Grund
der Wahl von t(n) = nc immer erfüllt.
360
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
13. Vorlesung, 07.07.2008
Zwei weiter wichtige P-vollständige Probleme, die in der Praxis häufiger
gelöst werden müssen, sind lineare Programmierung und maximaler Fluss.
Für beide Probleme gibt es daher keinen effizienten parallelen
Algorithmus falls N C 6= P ist. Wir wollen hier die Optimierungsvariante
dieser Probleme vorstellen:
Es folgt nun unmittelbar:
Satz 57 Das CVP-Problem ist P-vollständig unter many-one
N C 1 -Reduktion.
Definition 55 Das Problem der linearen Programmierung (kurz LP):
Gegeben ist eine n × d Integer-Matrix A, ein n-dimensionaler
Integer-Vektor b und ein d-dimensionaler Integer-Vektor c. Bestimme
einen d-dimensionalen rationalen Vektor x, so dass A · x ≤ b und c · x
maximal ist.
Das CVP-Problem ist auch unter einer ganzen Serie von Einschränkungen
P-vollständig.
Der maximale Fluss (kurz MaxFlow): Gegeben ist ein gerichteter Graph
G = (V , E ) dessen Kanten e mit einer Kapazität c(e) ≥ 0 gewichtet
sind. Ferner ist eine Quelle s, eine Senke t und eine Schranke f gegeben.
Frage: Ist der maximale Fluss von s nach t größer oder gleich f ?
361
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
362
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
9.1 Ein generisches N P-vollständiges Problem
Wie schon für P, erhalten wir einen Kandidaten für ein N P-vollständiges
Problem über die Simulation einer polynomiell zeitbeschränkten
Turing-Maschine.
9 Die Klasse N P oder die Grenzen
effizienter sequentieller Algorithmen
Definition 56 Das generische nichtdeterministische
Maschinen-Simulations-Problem (eng. Generic Nondeterministic Machine
Simulation Problem, kurz. GNMSP) ist wie folgt definiert:
Gegeben ist eine Zeichenkette x, eine Kodierung σ(M) einer NTM M
und eine Zahl t ∈ N, wir definieren
Im Gegensatz zur Diskussion, ob es inhärent sequentielle Probleme gibt,
ist die Wahl der Reduktion bei der Analyse der Frage welche Probleme
sich nicht effizient sequentiell lösen lassen relativ einfach. Wir
beschränken uns auf die beiden sequentiellen Reduktionen: logspace und
polynomialzeit Many-One-Reduktion.
GNMSP := { x#σ(M)#1t | M akzeptiert x in t Schritten } ,
d.h. die Eingabe ist gegeben als Zeichenkette x#σ(M)#1t wobei #
nicht in x oder σ(M) vorkommt. Frage: akzeptiert M x in t Schritten.
363
364
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Beweis für Satz 58 (Teil 1):
◮
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Beweis für Satz 58 (Teil 2): Wir müssen noch die N P-härte von
GNMSP nachweisen. Auch dieser Teil des Beweises verläuft analog zum
Beweis von Satz 56. Wir betrachten wieder eine Reduktion von einer
beliebigen Sprache L ∈ N P auf GNMSP.
Satz 58 GNMSP ist N P-vollständig unter ≤log -Reduktion.
◮
Andreas Jakoby
Universität zu Lübeck
Um x#σ(M)#1t ∈ GNMSP zu entscheiden benutzen wir eine
universelle Turing-Maschine, die M auf x simuliert.
Die Simulation eines Schritts erfolgt bei einer Standardkodierungen
für σ(M) in polynomieller Zeit (in der Länge von x und σ(M)).
◮
◮
◮
Wir simulieren M für maximal t Schritte.
◮ Akzeptiert M spätestens im t-ten Schritt, so akzeptieren wir.
Ansonsten ist x#σ(M)#1t kein Element der Sprache.
GNMSP ist folglich in N P.
◮
Sei M eine NTM welche L in polynomieller Zeit akzeptiert.
Sei p(n) = nc eine obere Schranke für die Laufzeit von M.
Wir modifizieren M derart, dass M in jeder Berechnung in genau
t = p(|x|) Schritten hält, wobei das Akzeptanzverhalten unverändert
bleibt.
Es gilt somit, dass x#σ(M)#1t genau dann ein Element der
Sprache GNMSP ist, wenn M x in genau t Schritten akzeptiert.
Da c Konstant für L und M ist, können wir nc auf logarithmischen Platz
bestimmen. Somit kann auf Eingabe von x die Zeichenkette x#σ(M)#1t
auch auf logarithmischen Platz von einer DTM generiert werden.
◮
365
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
366
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Lemma 22 Für alle Sprachen L ∈ N P gilt L≤log Circuit-SAT.
9.2 Das Schaltkreis Erfüllbarkeitsproblems
Beweis von Lemma 22 (Teil 1): Auch dieser Beweis folgt analog zum
Beweis von Lemma 20. Sei L ∈ N P.
◮ Aufgrund der Bandreduktionssätze, gibt es eine polynomiell
zeitbeschränkte 1-Band NTM M, die L akzeptiert und bei Erreichen
eines akzeptierenden Zustands stoppt.
◮ Ferner können wir ohne Beschränkung der Allgemeinheit annehmen,
dass M in jedem Schritt einer Berechnung nichtdeterministisch
zwischen genau Alternativen wählen kann:
Definition 57 Das Schaltkreis-Erfüllbarkeitsproblem (eng. Circuit
Satisfiability Problem, kurz. Circuit-SAT) ist wie folgt definiert:
Gegeben ist ein Schaltkreis in Standardkodierung σ(C ) mit einem
Ausgabegatter y , wir definieren
Circuit-SAT := { σ(C ) | existiert eine Eingabe x1 , . . . , xn für
C , so dass C auf Eingabe x1 , . . . , xn
den Wert 1 hat } .
◮
Lemma 21 Circuit-SAT ist in N P.
◮
Beweis von Lemma 21: Nichtdeterministisch können wir eine Belegung
der Variablen in linearer Zeit raten und im Anschluß den Schaltkreis in
quadratischer Zeit auswerten.
367
Jeden Übergang ∆(q, s) mit |∆(q, s)| > 2 ersetzen wir durch einen
binären Baum von Übergängen.
Jeden Übergang ∆(q, s) mit |∆(q, s)| = 1 ergänzen wir durch einen
zusätzlichen Übergang.
◮
Die beiden Alternativen in ∆(q, s) nennen wir im Folgenden die 0te
und die 1te Alternative.
◮
Sei c eine Konstante, so dass M für alle x = x1 . . . xn ∈ L in
maximal t(n) = nc Schritten akzeptiert.
368
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Beweis von Lemma 22 (Teil 2):
◮ Jede Berechnung von M auf einer Eingabe x ∈ Σn können wir mit
Hilfe einer binären Zeichenkette w ∈ {0, 1}p(n) darstellen:
◮
◮
Sei C0 ⊢ C1 ⊢ . . . ⊢ Cp(n) eine Berechnung, dann ist
◮
genau dann, wenn
wi
◮
◮
◮
Sei M̃ eine DTM, die auf Eingabe von x#w die Berechnung Cw von
M auf Eingabe w wie auf der letzten Folie beschrieben simuliert.
Da M eine polynomiell zeitbeschränkte NTM ist, ist die DTM M̃
ebenfalls polynomiell zeitbeschränkt.
Analog zu Lemma 20 können wir einen Schaltkreis C und eine
Eingabe z für C konstruieren, so dass
ist.
Wir erkennen, dass jede Zeichenkette w ∈ {0, 1}p(n) für genau eine
Berechnung C0 ⊢ C1 ⊢ . . . ⊢ Cp(n) steht, und umgekehrt.
Sei Cw die zu w ∈ {0, 1}p(n) gehörige Berechnung C0 ⊢ . . . ⊢ Cp(n) .
Gegeben eine solche Zeichenkette w ∈ {0, 1}
deterministische Berechnung:
◮
◮
= b
p(n)
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Beweis von Lemma 22 (Teil 3):
Ci ⊢ Ci+1 ist die bte Alternative (für b ∈ {0, 1}
◮
Andreas Jakoby
Universität zu Lübeck
◮
◮
◮
, dann ist Cw eine
◮
Die erste Eingabe stellt x und die zweite Eingabe w dar.
Im iten Schritt der Berechnung, bestimmt die DTM zunächst das ite
Bit wi von w und wählt im Anschluß die wi te Alternative zur
Fortsetzung Ci der Berechnung in Ci−1 .
◮
die Konstruktion von C nur von der Länge von x#w jedoch nicht
von der konkreten Form von x#w abhängt,
x#w ein Teil der Eingabe z darstellt und
C (z) genau dann den Wert 1 liefert, wenn M̃ die Eingabe x#w
akzeptiert.
Es gibt |w | Positionen in der Eingabe z, an denen die Bits w stehen.
Somit liefert C (z) genau dann den Wert 1, wenn M die Eingabe x
auf der Berechnung Cw akzeptiert.
369
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
370
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Beweis von Lemma 22 (Teil 4):
◮ Sei C ′ der Schaltkreis, bei dem wir die Bits der Eingabe fest halten,
die nicht zu w gehören, dann gilt:
◮
◮
◮
◮
◮
C ′ (w ′ ) = 1 ⇐⇒ M akzeptiert x auf Cw ′
∃w ∈ {0, 1}n : C ′ (w ) = 1 ⇐⇒ ∃w ∈ {0, 1}n : M akzeptiert x auf Cw
∃w ∈ {0, 1}n : C ′ (w ) = 1 ⇐⇒ ∃w ∈ {0, 1}n : M akzeptiert x
Da die Reduktion in Lemma 20 auf logarithmischen Platz
berechenbar ist, ist auch diese Reduktion auf logarithmischen Platz
berechenbar.
Somit erhalten wir L≤log Circuit-SAT.
371
Es folgt nun unmittelbar:
Satz 59 Circuit-SAT ist N P-vollständig unter der logspace many-one
Reduktion.
372
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Satz 61 N P = Γ≤log ({Circuit-SAT}).
Beweis von Satz 61 Da Circuit-SAT vollständig ist für N P bezüglich
der logspace-Reduktion, gilt für jede Sprache L ∈ N P
9.3 Alternative Charakterisierungen von N P
Satz 60 L ∈ N P genau dann, wenn es eine Sprache L′ ∈ P und ein
Polynom p gibt, wobei
L ∈ Γ≤log ({Circuit-SAT}) .
Sei nun L′ ∈ Γ≤log ({Circuit-SAT}), dann gibt es eine Funktion f , die auf
logarithmischen Platz (und somit auch in polynomieller Zeit) berechnet
werden kann, so dass für alle Eingaben x gilt
L = { x | ∃w ∈ {0, 1}p(|x|) : x#w ∈ L′ } .
Beweis von Satz 60 Der Beweis folgt analog zu unserer Konstruktion
im Lemma 22.
x ∈ L′
Wir können Satz 60 auch wie folgt interpretieren: N P ist die Klasse der
Sprachen L, für die es effiziente Beweise für das Element-Problem gibt,
d.h. es gibt effiziente Beweise für x ∈ L.
⇐⇒
f (x) ∈ Circuit-SAT .
Da die Hintereinanderausführung von zwei polynomiell zeitbeschränkten
NTMs wieder eine polynomiell zeitbeschränkte NTM ergibt, erhalten wir
L′ ∈ N P .
373
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
374
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
9.4 Das Satisfiability Problem
Zur Wiederholung:
Lemma 24 Circuit-SAT≤log SAT.
Definition 38 Wir definieren das k-SAT-Problem wie folgt:
Gegeben ist eine Boolesche Formel F in k-CNF. Entscheide, ob F
erfüllbar ist, d.h. existiert eine Belegung der Variablen von F , so dass F
bei dieser Belegung true ist.
Beweis von Lemma 24 (Teil 1): In dem wir jedes Gatter mit Eingrad
größer 2 durch einen Baum ersetzen, können wir das Circuit-SAT auf
solche Schaltkreise einschränken, bei denen jedes Gatter einen Eingrad
kleiner oder gleich 2 hat.
Somit ist:
Im ersten Schritt zeigen wir, wie wir einen Schaltkreis C mit n
Eingabevariablen und m Gattern durch einen Schaltkreis C ′ mit n + m
Eingabevariablen ersetzen können, so dass für alle Eingaben
x1 , . . . , xn ∈ {0, 1} gilt
k-SAT := { F in k-CNF | F ist erfüllbar } .
Wir ergänzen diese Definition durch:
Definition 58 Wir definieren das SAT-Problem wie folgt: Gegeben ist
eine Boolesche Formel F in CNF. Entscheide, ob F erfüllbar ist, d.h.
C (x1 , .., xn ) = 1
⇐⇒
∃y1 , .., ym ∈ {0, 1} : C ′ (x1 , .., xn , y1 , .., ym ) .
SAT := { F in CNF | F ist erfüllbar } .
Lemma 23 SAT und somit k-SAT für alle k ∈ N sind in N P.
375
376
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Beweis von Lemma 24 (Teil 2) Wir verfahren hierbei nach der
folgenden Idee:
◮ Für jedes Gatter gi fügen wir eine neue Variable yi ein, mit deren
Hilfe wir den Wert von gi nichtdeterministisch raten.
◮ Seien gj und gk die Vorgänger von gi , dann ersetzen wir gi durch
i
i
ein Gatter mit den Vorgängern yji und yki .
◮ Für jedes Gatter gi fügen wir einen kleinen Schaltkreis hinzu, der
darauf testet, dass gi und vi den gleichen Wert haben.
◮ Für die Ausgabe benutzen wir ein großes AND-Gatter, welches die
Ausgabe aller Vergleiche und das Ergebnis des ursprünglichen
Ausgabegatters verknüpft.
Somit erhalten wir für jedes Gatter gi eine kleine Formel
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Beweis von Lemma 24 (Teil 3) Für ein AND-Gatter gi erhalten wir
Fi (yi , yji , yki ) =
=
((yji ∧ yki ) ∨ y i ) ∧ ((y ji ∨ y ki ) ∨ yi )
(yji ∨ y i ) ∧ (yki ∨ y i ) ∧ (y ji ∨ y ki ∨ yi )
und OR-Gatter gi erhalten wir
Fi (yi , yji , yki ) =
=
((yji ∨ yki ) ∨ y i ) ∧ ((y ji ∧ y ki ) ∨ yi )
(yji ∨ yki ∨ y i ) ∧ (y ji ∨ yi ) ∧ (y ki ∨ yi ) .
Ist gm das Ausgabegatter von C so erhalten wir
F
Fi (yi , yji , yki ) := (gi (yji , yki ) ∨ y i ) ∧ (gi (yji , yki ) ∨ yi )
:= F1 ∧ . . . ∧ Fm ∧ ym .
Da für die lokalen Ersetzungen nur einige Zähler benötigt werden, kann
diese Reduktion auf logarithmischen Platz durchgeführt werden. Wir
müssen somit nur noch die Korrektheit dieser Reduktion überprüfen.
und für den Fall, dass gi ein NOT-Gatter ist, erhalten wir
Fi (yi , yji ) := (y ji ∨ y i ) ∧ (yji ∨ yi ) .
377
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Beweis von Lemma 24 (Teil 4) Um die Korrektheit zu überprüfen
beginnen wir mit der folgenden Beobachtung, die unmittelbar aus der
Konstruktion von Fi folgt:
Unter der Annahme, dass yji und yki die korrekten Werte der
beiden Vorgängergatter gji und gki angeben gilt: Der Wert von
Fi ist genau dann 1, wenn yi den Wert von gi angibt.
378
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Fassen wir Lemma 23 und 24 zusammen, so erhalten wir:
Satz 62 SAT ist N P-vollständig.
Mit Hilfe einer vollständigen Induktion über die Tiefe der Teilschaltkreise
mit jeweiligem Ausgabegatter gi können wir jetzt folgern:
F hat genau dann den Wert 1, wenn C den Wert 1 hat und die
Werte y1 , . . . , ym die Werte der jeweiligen Gatter g1 , . . . , gm
angeben.
Es folgt unmittelbar:
Mit Hilfe einiger einfacher Umformungen erhalten wir nun:
Satz 63 Für alle k ≥ 3 ist k-SAT N P-vollständig.
F ist genau dann erfüllbar, wenn C erfüllbar ist.
379
380
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Andreas Jakoby
Universität zu Lübeck
Beweis von Satz 63 (Teil 2): Die Reduktion: Sei Ci eine Klausel von F .
Wir unterscheiden die folgenden 4 Fälle:
◮ Fall 1: Ci = ti , d.h. Ci besteht aus dem einen Literal ti
Wir wählen zwei neue Variablen zi,1 , zi,2 und generieren die Klauseln
Beweis von Satz 63 (Teil 1): Dass k-SAT in N P ist, haben wir bereits
gesehen. Wir wollen nun eine Reduktion von SAT auf 3-SAT angeben
(Die Reduktion für k ≥ 4 erfolgt analog). Sei F eine Formel in CNF.
Unsere Reduktion betrachtet jede Klausel Ci von F und transformiert
diese in eine Folge von Klauseln Ci,j , wobei die Klauseln Ci,j jeweils aus
drei Literalen bestehen. Die ∧-Verknüpfung (Konjunktion) dieser neuen
Klauseln ergibt eine Formel F ′ in 3-CNF.
Ci,1
Ci,3
◮
Abschließend zeigen wir dann noch:
◮
◮
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Die Transformation der Formel kann deterministisch auf
logarithmischen Platz erfolgen.
◮
Ci,2
Ci,4
:= (ti ∨ z i,1 ∨ zi,2 )
:= (ti ∨ z i,1 ∨ z i,2 )
Fall 2: Ci = (ti,1 ∨ ti,2 )
Wir wählen eine neue Variablen zi und generieren die Klauseln
Ci,1
F ist genau dann erfüllbar, wenn F ′ erfüllbar ist.
:= (ti ∨ zi,1 ∨ zi,2 )
:= (ti ∨ zi,1 ∨ z i,2 )
:=
(ti,1 ∨ ti,2 ∨ zi )
Ci,2
:=
(ti,1 ∨ ti,2 ∨ z i )
Fall 3: Ci = (ti,1 ∨ ti,2 ∨ ti,3 )
Wir wählen
Ci,1
:= Ci
= (ti,1 ∨ ti,2 ∨ ti,3 )
381
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Beweis von Satz 63 (Teil 3):
◮ Fall 4: Ci = (ti,1 ∨ . . . ∨ ti,ℓ ) mit ℓ > 3
Wir wählen ℓ − 3 neue Variablen zi,k und generieren die Klauseln
Ci,1
Ci,ℓ−2
:=
:=
:=
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Beweis von Satz 63 (Teil 4): Wir wollen nun zeigen, dass für alle
Formeln F in CNF gilt
(ti,1 ∨ ti,2 ∨ zi,1 )
(z i,ℓ−3 ∨ ti,ℓ−1 ∨ ti,ℓ )
F ∈ SAT =⇒ f (F ) ∈ 3-SAT .
sowie für alle k ∈ [2..ℓ − 3]
Ci,k
382
Zur Erinnerung, eine Formel F in CNF ist in SAT, wenn es eine erfüllende
Belegung für F gibt. Analoges gilt für 3-SAT. Eine Formel F ′ in 3-CNF
ist in 3-SAT, wenn es eine erfüllende Belegung für F ′ gibt. Sei F eine
Formel über n Variablen und b = (b1 , . . . , bn ) eine erfüllende Belegung
für F , d.h. F (b) = 1. Wir müssen nun zeigen, dass auch F ′ = f (F )
erfüllbar ist. Wir untersuchen wieder die 4 Fälle und generieren eine
erfüllende Belegung b ′ aus b für F ′ . Somit ist F ′ ∈ 3-SAT.
(z i,k−1 ∨ ti,k+1 ∨ zi,k ) .
Somit erhalten wir für (ti,1 ∨ ti,2 ∨ ti,3 ∨ ti,4 ∨ ti,5 ∨ ti,6 )
(ti,1 ∨ ti,2 ∨ zi,1 ) ∧ (z i,1 ∨ ti,3 ∨ zi,2 ) ∧ (z i,2 ∨ ti,4 ∨ zi,3 ) ∧ (z i,3 ∨ ti,5 ∨ ti,6 )
Es ist einfach zu erkennen, dass diese Transformation von einer
logarithmisch-platzbeschränkten DTM durchgeführt werden kann. Im
Wesentlichen muss diese DTM nur die Anzahl der Literale der einzelnen
Klauseln aus F bestimmen und kann dann diese Klauseln in die
gewünschte Form bringen. Im Folgenden wollen wir diese Transformation
mit f bezeichnen.
383
384
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Beweis von Satz 63 (Teil 5): Wir wählen in b ′ die Belegung der alten
Variablen genauso wie in b und beobachten:
◮
◮
◮
◮
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Beweis von Satz 63 (Teil 6): Es verbleibt nun noch zu zeigen, dass für
alle Formeln F in CNF gilt
Fall 1: Der Wert des Literals ti erfüllt alle vier neuen Klauseln.
Fall 2: Der Wert der Teilklausel ti,1 ∨ ti,2 erfüllt beide neuen
Klauseln.
Fall 3: Hier gab es keine Änderung. Ist die Klausel Ci erfüllt, so gilt
dieses auch für die Klausel Ci,1 .
F ∈ SAT ⇐= f (F ) ∈ 3-SAT .
Sei b ′ eine erfüllende Belegung für F ′ . Wir müssen nun zeigen, dass auch
F mit F ′ = f (F ) erfüllbar ist. Wir untersuchen wieder die 4 Fälle und
generieren eine erfüllende Belegung b aus b ′ für F indem wir die
Belegungen der neuen Variablen streichen. Somit ist dann F ∈ SAT.
Fall 4: Sei ti,k ein Literal aus Ci , welches auf die Eingabe b den Wert
1 annimmt. Für die neuen Variablen zi,q wählen wir
1 für q ≤ k − 2
zi,q bekommt den Wert
0 für q ≥ k − 1 .
◮
Somit werden die Klauseln Ci,q mit q ≤ k − 2 durch den Wert von
zi,q erfüllt, die Klauseln Ci,q mit q ≥ k durch den Wert von z i,q
erfüllt und die Klausel Ci,k−1 durch ti,k erfüllt.
Fall 1: Sind alle vier neuen Klauseln erfüllt, dann müssen diese durch
ti erfüllt werden, da für alle Belegungen von zi,1 und zi,2 genau eine
der Kombinationen von zi,1 und zi,2 den Wert 0 liefert:
zi,1 = 0, zi,2 = 0 =⇒ zi,1 ∨ zi,2 = 0
zi,1 = 1, zi,2 = 0 =⇒ z i,1 ∨ zi,2 = 0
zi,1 = 0, zi,2 = 1 =⇒ zi,1 ∨ z i,2 = 0
zi,1 = 1, zi,2 = 1 =⇒ z i,1 ∨ z i,2 = 0 .
385
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Beweis von Satz 63 (Teil 7):
◮ Fall 2: Sind beide neuen Klauseln erfüllt, dann können wir analog
zum ersten Fall schließen, dass diese Klauseln durch ti,1 ∨ ti,2 erfüllt
werden. Die alte Klausel Ci ist somit auch erfüllt.
◮
◮
386
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Beweis von Satz 63 (Teil 8):
◮ Weiter mit Fall 4:
◮
Fall 3: Hier gab es keine Änderung. Ist die Klausel Ci,1 erfüllt, so gilt
dieses auch für die Klausel Ci .
Fall 4: Sind alle neuen Klauseln Ci,k erfüllt, dann können wir die
Folge die Belegungen der neuen Variablen zi,k analysieren. Sei

falls ein solches k existiert
 min{ k | die Belegung
von zi,k ist 0 }
h :=

ℓ−2
sonst.
◮
◮
Ist h = 1, dann wird Ci,1 durch die Disjunktion ti,1 ∨ ti,2 erfüllt. Diese
Disjunktion ist jedoch auch ein Teil der Klausel Ci und garantiert
uns, dass Ci erfüllt ist.
Ist h = ℓ − 2, dann hat z i,ℓ−3 den Wert 0 und Ci,ℓ−2 wird durch die
Disjunktion ti,ℓ−1 ∨ ti,ℓ erfüllt. Diese Disjunktion ist jedoch auch ein
Teil der Klausel Ci und garantiert uns, dass Ci erfüllt ist.
Ist 1 < h < ℓ − 2, dann haben beide Literale zi,h und z i,h−1 den Wert
0 und Ci,h wird durch das Literal ti,h+1 erfüllt. Dieses Literal
garantiert uns daher, dass auch Ci erfüllt ist.
Wir analysieren nun die Belegung der Literale in Ci,h .
387
388
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
FORMEL-SAT-artiges existentielles Raten einer Belegung:
x1
◮
◮
◮
1
0
Können wir auch für die Probleme Tautologie und QBF zeigen, dass
diese N P-vollständig sind?
Die Antwort lautet: Nein, es sei denn, einige Komplexitätsklassen
fallen zusammen — wovon jedoch die meisten Theoretiker zurzeit
nicht ausgehen.
x2
x2
1
0
x3
x3
Betrachten wir einmal kurz die unterschiedliche Struktur dieser
Probleme.
1
0
x3
x3
0
1
0
1
0
1
0
1
0
1
1
0
0
0
0
0
xi
existiert eine Belegung für xi
389
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
390
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
QBF-artiges existentielles und universelles Raten einer Belegung:
Tautologie-artiges universelles Raten einer Belegung:
x1
x1
x2
x2
x2
1
0
x3
1
0
1
0
1
0
1
0
1
1
0
0
0
0
0
1
0
x3
x3
x3
0
xi
x2
1
0
1
0
x3
x3
1
0
1
0
x3
x3
0
1
0
1
0
1
0
1
0
1
1
0
0
0
0
0
xi
existiert eine Belegung für xi
xi
für alle Belegungen von xi
für alle Belegungen von xi
391
392
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Definition 59 Das Cliquen-Problem:
Gegeben ein ungerichteter Graph G = (V , E ) und ein
k ∈ [0..|V |], existiert ein vollständiger Teilgraph G ′ = (V ′ , E ′ )
der Größe k = |V ′ | in G ?
Einen Graphen G ′ = (V ′ , E ′ ) nennen wir vollständig, wenn für alle
Knotenpaare u, v ∈ V ′ (u 6= v ) die Kante {u, v } in E ′ existiert. Wir
sagen, dass G eine k-Clique besitzt, wenn es eine Teilmenge V ′ ⊆ V mit
|V ′ | = k gibt, so dass für alle Knotenpaare u, v ∈ V ′ (u 6= v ) eine Kante
{u, v } in E existiert. Wir definieren
9.5 N P-vollständige Probleme auf Graphen
In den letzten 30 Jahren sind mehrere tausend Probleme als
N P-vollständig klassifiziert worden. Hierunter fallen zahlreiche Probleme
aus der Graphentheorie, zahlreiche Partitionierungsprobleme und viele
weitere Probleme aus allen Bereichen der Informatik. Wir wollen im
Folgenden einige dieser Probleme vorstellen und für die wichtigsten eine
kurze Skizze der Reduktion angeben.
CLIQUE := { (G , k) | G hat eine k-Clique } .
393
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
394
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Beweis von Satz 64 (Teil 2): Warum hat G eine k-Clique, wenn F
erfüllbar ist?
Satz 64 CLIQUE ist N P-vollständig.
Beweis von Satz 64: Es ist einfach zu sehen, dass CLIQUE in N P ist.
Wir wollen uns hier auf die Reduktion 3-SAT≤log CLIQUE konzentrieren.
◮
Sei b = (b1 , . . . , bn ) eine erfüllende
Belegung.
◮
Dann gibt es pro Klausel mindestens ein
Literal, welches bei dieser Belegung den
Wert 1 hat.
Sei ti,ji ein Literal aus der Fi , welches
den Wert 1 bei der Belegung b hat.
Dann gilt für alle Paare vi,ji , vi ′ ,ji ′ mit
i 6= i ′ , dass ti,j 6= t i ′ ,ji ′ ist — denn beide
Literale müssen ja den Wert 1 bei der
Belegung b haben.
(x1 ∨ x2 ∨ x3 ) ∧ (x1 ∨ x 2 ∨ x4 ) ∧ (x 1 ∨ x2 ∨ x 4 )
Sei F = F1 ∧ . . . ∧ Fk eine Boolesche Formel in 3-CNF, d.h.
Fi = ti,1 ∨ ti,2 ∨ ti,3 mit Literalen ti,j ∈ {x1 , . . . , xn , x 1 , . . . , x n }. Wir
generieren nun einen Graphen G = (V , E ) mit 3k Knoten
x1
x2
x3
v1,1
v1,2
v1,3
◮
V
E
= { vi,j | i ∈ [1..k], j ∈ [1..3] }
= { {vi,j , vi ′ ,j ′ } | i, i ′ ∈ [1..k], j, j ′ ∈ [1..3]
mit i 6= i ′ und ti,j 6= t i ′ ,j ′ } .
x1
x2
x4
v2,1
v2,2
v2,3
◮
Ferner wählen wir k als die geforderte Cliquengröße.
Wir behaupten somit, dass G genau dann eine k-Clique hat, wenn F
erfüllbar ist!
395
x1
x2
x4
v3,1
v3,2
v3,3
◮
Die Knotenpaare vi,ji , vi ′ ,ji ′ sind alle
paarweise in G verbunden und bilden eine
k-Clique.
396
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
14. Vorlesung, 14.07.2008
Beweis von Satz 64 (Teil 3): Warum ist G erfüllbar, wenn G eine
k-Clique hat?
(x1 ∨ x2 ∨ x3 ) ∧ (x1 ∨ x 2 ∨ x4 ) ∧ (x 1 ∨ x2 ∨ x 4 )
x1
x2
x3
v1,1
v1,2
v1,3
◮
◮
Verbotene Kanten
x1
x2
x4
v2,1
v2,2
v2,3
◮
x1
x2
x4
v3,1
v3,2
v3,3
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Definition 60 Das Hamiltonsche Kreis Problem:
Gegeben ein gerichteter Graph G = (V , E ), existiert ein Kreis
in G , der jeden Knoten genau einmal besucht?
Sei V ′ die Knotenmenge einer k-Clique,
dann gibt es in V ′ für jedes i ∈ [1..k]
genau einen Knoten vi,j ∈ V ′ . Wir
bezeichnen diesen Knoten als vi,ji .
Wir erhalten eine erfüllende Belegung für
F , indem wir die Werte der b1 , . . . , bn so
wählen, dass die Literale ti,ij den Wert 1
haben.
Dieses ist möglich, da wir in V ′ keine
zwei Knoten haben, die sowohl für eine
Variable xi das Literal xi als auch das
Literal x i repräsentieren.
Es ist möglich, diese Frage sowohl für gerichtete als auch für ungerichtete
Graphen zu stellen. Wir wollen im Folgenden den gerichteten Fall
betrachten.
Einen Kreis in einem Graphen nennen wir Hamiltonsch, wenn er jeden
Knoten genau einmal Besucht. Wir definieren
HAMILTON := { G | G hat einen Hamiltonschen Kreis } .
397
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
398
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Beweis von Satz 65(Teil 2):
Satz 65 HAMILTON ist N P-vollständig.
H′:
Hi :
ai
Beweis von Satz 65 (Teil 1): Es ist einfach zu sehen, dass HAMILTON
in N P ist. Wir wollen uns hier auf die Reduktion 3-SAT≤pol HAMILTON
konzentrieren.
H1
bi,0
Sei F = F1 ∧ . . . ∧ Fk eine Boolesche Formel in 3-CNF, d.h.
Fi = ti,1 ∨ ti,2 ∨ ti,3 mit Literalen ti,j ∈ {x1 , . . . , xn , x 1 , . . . , x n }. Für eine
Variable xi sei
ci,0
H2
bi,1
ci,1
m(xi ) := die Anzahl der Vorkommnisse von xi in F
m(x i ) := die Anzahl der Vorkommnisse von x i in F
mi := m(xi ) + m(x i ) .
Hn−1
ci,m
i
bi,m
i
Für jede Variable xi konstruieren wir einen Graphen Hi und verbinden
diese Graphen H1 , . . . , Hn kreisförmig zu einem Graphen H ′ .
Hn
di
399
400
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Beweis von Satz 65
(Teil 3):
◮
Hi :
ai
Hi besteht aus 2mi + 4 Konten, die in
mi + 3 Schichten unterteilt sind:
◮
◮
bi,0
◮
ci,0
◮
bi,1
◮
◮
bi,m
i
ci,m
i
di
◮
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Beweis von Satz 65 (Teil 4): Im Folgenden wollen wir die beiden Pfade
durch Hi als die beiden Möglichkeiten interpretieren, der Variablen xi
einen Wert zuzuweisen:
Schicht 0 besteht aus einem Knoten ai .
Die Schichten 1 bis mi + 1 besteht aus
jeweils zwei Knoten bi,j und ci,j .
Schicht mi + 2 besteht aus einem Knoten
di .
◮
Den Pfad
ai , bi,0 , ci,0 , bi,1 , ci,1 , . . . , bi,mi , ci,mi , di
In Hi verbinden wir
◮
ci,1
Andreas Jakoby
Universität zu Lübeck
ai mit bi,0 , ci,0 und bi,mi , ci,mi mit di ,
bi,j mit ci,j und ci,j mit bi,j für alle
j ∈ [0..mi + 1] und
bi,j mit ci,j+1 und ci,j mit bi,j+1 für alle
j ∈ [0..mi ].
◮
werden wir als xi = 0 interpretieren. Wir nennen einen solchen Pfad
einen 0-Pfad durch Hi .
Den Pfad
ai , ci,0 , bi,0 , ci,1 , bi,1 , . . . , ci,mi , bi,mi , di
werden wir als xi = 1 interpretieren. Wir nennen einen solchen Pfad
einen 1-Pfad durch Hi .
Es gibt zwei Pfade durch Hi , welche alle
Knoten besuchen:
(0) ai , bi,0 , ci,0 , bi,1 , ci,1 , . . . , bi,mi , ci,mi , di
(1) ai , ci,0 , bi,0 , ci,1 , bi,1 , . . . , ci,mi , bi,mi , di .
401
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
402
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Beweis von Satz 65 (Teil 6):
Beweis von Satz 65 (Teil 5): Für jede Klausel Fj = tj,1 ∨ tj,2 ∨ tj,3
konstruieren wir einen Graphen Tj bestehend aus 6 Knoten sj,k , rj,k mit
k ∈ [1..3]. Diese 6 Knoten verbinden wir mithilfe der Kanten:
Hi :
ai
(rj,k , sj,k ), (rj,k , rj,(k mod 3)+1 ), (sj,(k mod 3)+1 , sj,k ) für k ∈ [1..3] .
Wir verbinden Tj mit H ′ wie folgt:
◮ Sei Fj die ℓ-te Klausel, in der ein Literal von xi vorkommt, d.h. es
existieren ℓ − 1 Klauseln Fq mit q < j, in denen wir ein Literal xi
oder x i finden.
Fj mit tj,2 = x i :
bi,0
ci,0
bi,1
ci,1
Tj :
Sei tj,k = x i , dann fügen wir die Kanten (ci,ℓ , rj,k ) und (sj,k , bi,ℓ+1 )
ein.
◮ Sei tj,k = xi , dann fügen wir die Kanten (bi,ℓ , rj,k ) und (sj,k , ci,ℓ+1 )
ein.
Sei H der resultierende Graph.
rj,1
rj,2
rj,3
sj,1
sj,2
sj,3
◮
ci,m
i
bi,m
i
di
403
404
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Beweis von Satz 65 (Teil 7): Sei b = (b1 , . . . , bn ) eine erfüllende
Belegung für F , dann können wir folgenden Hamiltonschen Kreis
generieren:
1. Wir generieren einen Hamiltonschen Kreis für H ′ in dem wir einen
Kreis von a1 durch H1 , H2 ,. . . , Hn zurück nach a1 erzeugen, der in
jedem Teilgraph Hi einen bi -Pfad benutzt.
2. Wir ergänzen nun diesen Pfad, indem wir für jede Klausel Fj einen
Pfad durch den Teilgraph Tj in diesen Kreis einbauen:
◮
◮
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Beweis von Satz 65 (Teil 8): Wir müssen nun noch zeigen, dass wir
aus einem Hamiltonschen Kreis eine erfüllende Belegung generieren
können. Betrachten wir zunächst einen Hamiltonschen Kreis und dessen
Form in Tj :
rj,1
rj,2
rj,3
◮
?
Sei i der kleinste Index einer Variablen xi , so dass ein zu xi gehöriges
Literal tj,k auf b Fj erfüllt.
Sei Fj die q-te Klausel, in der ein Literal von xi vorkommt.
3. Unter den oben dargestellten Bedingungen benutzt unser bisher
konstruierter Kreis bei bi = 0 die Kante (ci,q , bi,q+1 ). Diese Kante
ersetzen wir durch den Pfad:
ci,q , rj,k , rj,(k mod 3)+1 , rj,(k+1 mod 3)+1 ,
sj,(k+1 mod 3)+1 , sj,(k mod 3)+1 , sj,k , bi,q+1 .
sj,1
sj,2
sj,3
rj,1
rj,2
rj,3
sj,1
sj,2
sj,3
◮
Betritt der Pfad Tj über einen Knoten rj,k und
verlässt der Pfad Tj nicht über sj,k , so kann der
Kreis entweder den Knoten sj,k nicht mehr
erreichen, oder, wenn der Kreis rj,((k+2) mod 3)+1
erreicht, dann können wir den Kreis nicht mehr
schließen.
Jedesmal, wenn der Pfad Tj über einen Knoten
rj,k betritt, dann bewegt sich der Pfad in Tj , bis
er Tj wieder über sj,k verlässt.
Für bi = 1 verfahren wir analog.
Der resultierende Kreis ist Hamiltonsch.
405
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
406
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Definition 61 Das ungerichtete Hamiltonsche Kreis Problem:
Gegeben ein ungerichteter Graph G = (V , E ), existiert ein Kreis
in G , der jeden Knoten genau einmal besucht?
Wir definieren
Beweis von Satz 65 (Teil 9):
◮
Für jeden Teilpfad, der sich ganz in einem Teilgraph Tj befindet,
gibt es eine Kante in H ′ die parallel zu diesem Teilpfad liegt.
◮
Ersetzen wir diese Teilpfade durch diese parallel laufenden Kanten,
dann erhalten wir einen Hamiltonschen Kreis durch H ′ .
Dieser Kreis besteht aus einer Folge von Pfaden durch die
Komponenten Hi .
Ist ein Pfad durch Hi ein bi -Pfad mit bi ∈ {0, 1}, so setzen wir
xi := bi .
Die so aufgebaute Belegung ergibt eine erfüllende Belegung für F .
◮
◮
◮
HC := { G | G hat einen Hamiltonschen Kreis } .
Satz 66 HC ist N P-vollständig.
Beweis von Satz 66 (Teil 1): Wie schon für den gerichteten Fall,
können wir auch für den ungerichteten Fall einen einfachen
nichtdeterministischen polynomial-zeitbeschränkten Algorithmus für das
HC-Problem angeben. Wir wollen uns daher hier auf die Reduktion
HAMILTON≤log HC
konzentrieren.
407
408
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
ein Hamiltonscher Kreis in G ′ .
◮
G ′:
v1
v1,out
v5
v3
vi1 ,in , vi1 , vi1 ,out , vi2 ,in , vi2 , . . . , vin , vin ,out , vi1 ,in
:= { vi,in , vi,out , vi | vi ∈ V }
:= { {vi,in , vi }, {vi,out , vi } | vi ∈ V }
∪ { {vi,out , vj,in } | (vi , vj ) ∈ E }
G:
Wir müssen nun noch zeigen, wie wir aus einem Hamiltonschen Kreis
für G ′ einen Hamiltonschen Kreis für G konstruieren können. Ist
dieses möglich, dann haben wir für unsere Transformation f gezeigt:
v5,in
v3,out
v2
v2,in
v2
G ∈ HAMILTON ⇐⇒ f (G ) = G ′ ∈ HC .
v2,out
v4
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Beweis von Satz 66 (Teil 3):
◮ Sei vi , . . . , vi , vi ein Hamiltonscher Kreis in G , dann ist
1
n
1
Beweis von Satz 66 (Teil 2): Sei G = (V , E ) eine Eingabe für
HAMILTON. Wir generieren eine Eingabe G ′ = (V ′ , E ′ ) für HC wie folgt:
V′
E′
Andreas Jakoby
Universität zu Lübeck
Somit ist f eine Reduktion von HAMILTON auf HC. Es ist einfach
zu erkennen, dass f von einer logarithmisch- platzbeschränkten
DTM berechnet werden kann. HAMILTON ist somit
logspace-reduzierbar auf HC.
v4,in
v4,out
409
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
410
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Beweis von Satz 66 (Teil 5):
◮
Beweis von Satz 66 (Teil 4): Sei u = u0 , . . . , u3n−1 , u0 ein
Hamiltonscher Kreis in G ′ . Dann gilt:
◮
◮
◮
Da die Knoten vi in G ′ nur zwei Nachbarn haben, muss ein
Hamiltonscher Kreis jeden Knoten vi über den einen Nachbarn
betreten und über den anderen Nachbarn verlassen.
Für u0 , . . . , u3n−1 , u0 haben wir somit zwei prinzipielle
Wahlmöglichkeiten:
vi1 ,in , vi1 , vi1 ,out , vi2 ,in , vi2 , . . . , vin , vin ,out , vi1 ,in
oder
vi1 ,out , vi1 , vi1 ,in , vi2 ,out , vi2 , . . . , vin , vin ,in , vi1 ,out .
Die Kanten {vi,in , vi }, {vi,out , vi } müssen von dem Hamiltonschen
Kreis benutzt werden. Somit ist entweder vi,in , vi , vi,out oder
vi,out , vi , vi,in ein Teil unseres Pfades.
◮
Somit ist ein Pfadnachbar jedes Knotens vi,in und jedes Knotens
vi,out festgelegt. Als zweiter Nachbar kommt aufgrund unserer
Konstruktion für jeden Knoten vi,in nur ein Knoten vj,out und
umgekehrt in Frage.
◮
◮
411
Drehen wir die Reihenfolge der Knoten in der zweiten Form, so
erhalten wir einen Kreis der ersten Form. Wir können somit davon
ausgehen, dass bei u ein Kreis der ersten Form vorliegt.
Das Vorhandensein einer Kante {vi1 ,out , vi2 ,in } in G ′ impliziert das
Vorhandensein einer Kante (vi1 , vi2 ) in G .
Somit ist vi1 , vi2 , . . . , vin , vi1 ein Kreis in G . Da dieser Kreis alle
Knoten aus G genau einmal besucht, ist dieser Kreis ein
Hamiltonscher Kreis.
412
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Die beiden Probleme CLIQUE und HAMILTON stellen eine gute
Ausgangsbasis für die komplexitätstheoretische Analyse weiterer
Graphenprobleme dar.
d(π) := d(vin , vi1 ) +
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
In der Literatur werden verschiedene Varianten des TSP-Problems
untersucht:
Definition 62 Das Problem der kürzesten Rundreise
(Handlungsreisenden-Problem, traveling salesman problem, traveling
salesperson problem) ist wie folgt definiert:
Gegeben sei ein ungerichteter vollständiger Graph G = (V , E )
mit Gewichtsfunktion d : E → N ∪ {∞} und eine Schranke
k ∈ N. Existiert einen Hamiltonschen Kreis π = vi1 , . . . , vin , vi1
in G mit
n−1
X
Andreas Jakoby
Universität zu Lübeck
◮
symmetrisches TSP: für alle Kontenpaare u, v gilt d(u, v ) = d(v , u).
◮
metrisches TSP: die Distanzen erfüllen die Dreiecksungleichung, d.h.
für alle Konten u, v , w gilt d(u, w ) ≤ d(u, v ) + d(v , w ).
TSPk : die Distanzwerte stammen aus dem Intervall [1..k].
TSPsym,∆,k : diese Form des TSP ist symmetrisch, metrisch und die
Distanzwerte stammen aus dem Intervall [1..k].
◮
◮
Es gilt:
d(vij , vij+1 )
j=1
≤
Satz 67 TSPsym,∆,2 ist N P-vollständig.
k .
Beweis von Satz 67 (Teil 1): Auch für dieses Problem ist ein
polynomiell-zeit- beschränkter nichtdeterministischer Algorithmus einfach
zu finden. Wir wollen uns daher auf die Reduktion von HC auf
TSPsym,∆,k konzentrieren.
Wir wählen
TSP := { (G , d, k) | G hat einen Hamiltonschen
Kreis π der Länge d(π) ≤ k } .
413
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Beweis von Satz 67 (Teil 2): Die Reduktion von HC auf TSPsym,∆,k ist
wieder sehr einfach:
◮ Sei G = (V , E ) eine Eingabe für das HC Problem.
◮ Sei K = (V , E ′ ) der vollständige Graph, den wir erhalten, wenn wir
in G noch alle fehlenden Kanten einfügen.
◮
◮
414
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Beweis von Satz 67 (Teil 3):
◮
Die Richtung
G ∈ HC
Für alle Knotenpaare u, v ∈ V definieren wir
1 wenn {u, v } ∈ E ist
d(u, v ) :=
2 sonst.
◮
Es ist einfach zu sehen, dass diese Transformation von einer
logarithmisch-platzbeschränkten DTM durchgeführt werden kann. Es
verbleibt somit noch zu zeigen, dass für alle ungerichteten Graphen G gilt
⇐⇒
⇐=
(K , d, k) ∈ TSPsym,∆,2
betrachten wir eine Tour in K mit Gesamtlänge |V |.
◮
◮
G ∈ HC
(K , d, k) ∈ TSPsym,∆,2
ist einfach einzusehen: Da ein Hamiltonscher Kreis in G nur Kanten
in K benutzt, die ein Gewicht von 1 haben, hat diese Tour ein
Gesamtlänge von |V |.
Für die Rückrichtung
G ∈ HC
Für die Schranke k wählen wir k := |V |.
=⇒
(K , d, k) ∈ TSPsym,∆,2 .
◮
415
Diese Tour muss alle Knoten besuchen, sie ist somit eine
Hamiltonscher Kreis in K .
Da die Länge der Tour gleich |V | ist, darf sie nur Kanten mit
Gewicht 1 benutzen, diese Kanten sind somit auch in G vorhanden.
Diese Tour stellt somit auch einen Hamiltonschen Kreis in G dar. 416
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Definition 63 Das Problem der Knotenüberdeckung (vertex cover
problem) wie folgt:
Gegeben ein ungerichteter Graph G = (V , E ) und ein
k ∈ [0..|V |]. Eine Teilmenge V ′ ⊆ V nennen wir eine
Knotenüberdeckung, wenn alle Kanten aus E mit mindestens
einen Knoten aus V ′ inzident sind. Existiert ein
Knotenüberdeckung V ′ ⊆ V der Größe k in G ?
Definition 63 Das Problem der unabhängigen Menge (independent set
problem) ist wie folgt definiert:
Gegeben ein ungerichteter Graph G = (V , E ) und ein
k ∈ [0..|V |], existiert ein unabhängige Menge V ′ der Größe k in
G , d.h. existiert eine Teilmenge V ′ ⊆ V mit |V ′ | = k, so dass
es zwischen den Knoten aus V ′ keine Kanten gibt?
Wir wählen
Wir wählen
VC := { (G , k) | G hat eine Knotenüberdeckung
der Größe k } .
IS := { (G , k) | G hat eine unabhängige Menge V ′
der Größe k } .
Das Knotenüberdeckungsproblem können wir auch wie folgt
interpretieren: Gegeben ein Gebäude, welches in erster Linie aus geraden
Gänge besteht, die rechteckige Räume miteinander verbinden. Wir
können in jeden Raum eine Kamera postieren, um die an den Raum
grenzenden Gänge zu überwachen. Wieviele Kameras sind notwendig um
alle Gänge zu überwachen?
417
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Satz 68 CLIQUE ≡log IS ≡log VC.
◮
◮
◮
◮
◮
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Definition 64 Das Rucksackproblem (knapsack problem):
Gegeben eine Menge O = {o1 , . . . , on } von n Objekten, eine
Kostenfunktion g : O → N, eine Nutzenfunktion h : O → N
und zwei Schranken G , H. Frage: Gibt es eine Teilmenge
O ′ ⊆ O mit
P
P
und
oi ∈O ′ g (oi ) ≤ G
oi ∈O ′ h(oi ) ≥ H ?
Sei (G , k) eine Eingabe für CLIQUE.
Sei G = (V , E ) der komplementärer Graph zu G , d.h. V = V und E
besteht genau aus den Kanten aus V × V , die nicht in E sind.
Eine Teilmenge V ′ ∈ V mit |V ′ | = k ist genau dann eine k-Clique in
G , wenn es zwischen diesen Knoten in G keine Kanten gibt, d.h.
wenn V ′ eine unabhängige Menge ist.
Die Reduktionen in beide Richtungen erhalten wir über
f ((G , k)) = (G , k).
Wir suchen also eine Teilmenge aus O, die unsere Gewichtsschranke G
nicht überschreitet jedoch einen Nutzen von mehr als H hat. Wir
definieren die Menge KP wie folgt
IS ≡log VC:
◮
Andreas Jakoby
Universität zu Lübeck
9.6 Weitere N P-vollständige Probleme
Beweis von Satz 68:
◮ CLIQUE ≡log IS:
◮
418
Eine unabhängige Menge von k Knoten impliziert, dass die
verbleibenden n − k Knoten alle Kanten überdecken, und umgekehrt
— wobei n der Anzahl an Knoten in G entspricht.
Die Reduktionen in beide Richtungen erhalten wir über
f ((G , k)) = (G , n − k).
(O, g , h, G , H) ∈ KP ⇐⇒ es gibt eine Lösung des Rucksackproblems für (O, g , h, G , H) .
419
420
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Definition 66 (Teil 1)
Definition 65 as Partitionsproblem:
Gegeben eine Menge O = {o1 , . . . , on } von
P n Objekten und eine
Kostenfunktion g : O → N. Sei G := 12 oi ∈O g (oi ). Frage:
Gibt es eine Teilmenge O ′ ⊆ O mit
P
oi ∈O ′ g (oi ) = G ?
◮
Ein lineares Programm stellt eine Folge von linearen Ungleichungen
über den Variablen x1 , . . . , xn dar:
n
X
j=1
Wir definieren die Menge PARTITION wie folgt
ai,j · xj ≤ bj
bzw.
n
X
j=1
ai,j · xj ≥ bj .
Die Werte ai,j stellen hierbei die Koeffizienten der i-ten Ungleichung
dar.
(O, g ) ∈ PARTITION ⇐⇒ Es gibt eine Lösung des Partitionsproblems für (O, g ) .
◮
Ergänzt wurde dieses Ungleichungssystem durch eine lineare
Funktion, die maximiert (oder minimiert) werden sollte:
Satz 67 Bei binärer Kodierung der Gewichtsfunktionen sind KP und
PARTITION N P-Vollständig. Bei unärer Kodierung der
Gewichtsfunktion ist PARTITION mit Hilfe der dynamischen
Programmierung lösbar und somit in P.
n
X
j=1
a0,j · xj .
421
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
◮
j=1
ai,j · xj ≥ bi
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Das rationale lineare Programmierungsproblem
RLP := { (A, b) | ∃x ∈ Qn : A · x ≥ b }
und das ganzzahlige lineare Programmierungsproblem
ILP := { (A, b) | ∃x ∈ Zn : A · x ≥ b } .
Sei A ∈ Zm×n eine m × n Matrix und b ∈ Zm ein Spaltenvektor.
Gibt es einen Zeilenvektor x der Länge n mit A · x ≥ b, d.h.
n
X
Andreas Jakoby
Universität zu Lübeck
Definition 66 (Teil 3) Wir unterscheiden zwei Varianten des linearen
Programmierungsproblems:
Definition 66 (Teil 2)
◮ Wenn wir zudem eine Schranke angeben, die mit dieser linearen
Funktion erreicht werden soll, dann können wir ein solches lineares
Programm vollständig als eine Folge von Ungleichungen darstellen.
◮ Multiplizieren wir jetzt noch die ≤-Ungleichungen mit −1 so können
wir das Problem der linearen Programmierung auch wie folgt
darstellen:
◮
422
Für die Eingabe betrachten wir hierbei eine binäre Kodierung von A und
b, wobei eine Zahl ai,j bzw. bi durch
für alle i ∈ [0..m − 1] ?
sgn(ai,j )#bin(|ai,j |)
bzw.
sgn(bi )#bin(|bi |)
dargestellt wird.
423
424
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Die Liste der N P-vollständigen Probleme könnten wir hier noch für
einige Zeit fortsetzen:
Färbungsproblem für Graphen, Bin-Packing-Problem,
verschiedene Scheduling-Probleme, 3DM, X3C, etc.
Mit Hilfe der Ellipsoidmethode können wir das Problem RLP in
polynomieller Zeit lösen. Für das ILP-Problem ist kein solcher
Algorithmus bekannt. Es gilt sogar
Interessanter Weise gibt es nur wenige Probleme, für die bekannt ist, dass
sie in N P liegen und für die nicht bekannt ist, ob sie N P-vollständig
sind oder sogar in P liegen. Eines dieser wenigen Probleme ist das
Problem der Graphisomorphie
Satz 68 RLP ist P-vollständig und ILP ist N P-vollständig.
Gegeben zwei Graphen, sind diese Graphen isomorph?
Es konnte jedoch gezeigt werden, dass egal was man für dieses Problem
zeigt, ob es in P oder ob es in N PC liegt, beides hätte weitreichende
Folgen für die Komplexitätstheorie.
425
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
9.7 Selbstreduzierbarkeit
426
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Beweis von Satz 69 (Teil 1): Wir setzen voraus, dass T monoton
wächst — sollte T nicht monoton wachsen, dann können wir die Formel
so verändern, dass durch Aufblähen der Formel die Laufzeit reduziert
wird, ohne die Komplexität des Entscheidungsproblems zu verändern.
Bisher haben wir uns nur mit Entscheidungsproblemen beschäftigt. Wir
wollen nun kurz auf die Frage eingehen, welche Aussagen wir für ein
konstruktives Problem herleiten können, wenn wir die Komplexität des
Entscheidungsproblems kennen. Als Beispiel wollen wir wieder auf das
SAT-Problem eingehen.
◮
Wir definieren fSAT als die Relation, die einer Booleschen
Formel F eine erfüllende Belegung x zuordnet bzw. den Wert 0,
wenn F nicht erfüllbar ist.
◮
◮
Satz 69 Gibt es einen T -zeitbeschränkten Akzeptor für SAT, dann kann
die korrespondierende Relation fSAT in Zeit O(N · T ) berechnet werden.
427
Sei M ein T -zeitbeschränkter Akzeptor (deterministisch oder
nichtdeterministisch) für das SAT-Problem.
Mit Hilfe von M wollen wir eine TM M ′ herleiten, die fSAT in der
geforderten Zeitschranke berechnet.
Sei F eine Eingabe-Formel mit den Variablen x1 , . . . , xn .
428
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Beweis von Satz 69 (Teil 3):
Beweis von Satz 69 (Teil 2):
F erfüllbar?
M ′ simuliert M auf F . Ist F nicht erfüllbar, dann gebe 0 aus.
Ansonsten wiederholen wir die folgenden Schritte, bis wir eine
Formel erhalten, die keine freie Variable mehr besitzt. Wir
initialisieren i := 1.
1. Setze αi = 0.
2. Setze x1 , . . . , xi in F auf die Konstanten α1 , . . . , αi .
3. Sei Fα1 ,...,αi die resultierende Formel.
4. Ist Fα1 ,...,αi nicht erfüllbar, dann setze αi := 1.
5. Setze i := i + 1.
Das oben angegebene Verfahren ruft M genau n-mal auf. Bei geschickter
Implementierung können wir die einzelnen Zeilen 1 bis 3 und 5 in linearer
Zeit in n implementieren. Zeile 4 benötigt Laufzeit T (n). Da T (n)
mindestens linear in n wachsen muss, ist die Gesamtlaufzeit in O(N · T ).
◮
nein
ja
Gebe 0 aus!
F0 erfüllbar?
nein
ja
ja
nein
F10 erfüllbar?
nein
F00 erfüllbar?
ja
F10α3 ...αn−1 0 erfüllbar?
nein
Gebe
10α3 . . . αn−1 1
aus!
ja
Gebe
10α3 . . . αn−1 0
aus!
429
Andreas Jakoby
Universität zu Lübeck
Computational Complexity SS 08
15. Vorlesung, 21.07.2008
Analoge Selbstreduktionen können wir für die meisten hier untersuchten
Probleme herleiten.
Aber Vorsicht:
Es ist bekannt, dass der Test, ob eine gegebene Zahl keine
Primzahl ist, in P durchgeführt werden kann. Ein
polynomiell-zeitbeschränktes Verfahren, welches für eine
Nichtprimzahl die Faktorisierung in Primzahlen liefert ist nicht
bekannt. Die Sicherheit vieler Verfahren in der Kryptologie
basieren auf der Annahme, das Faktorisierung nicht in
polynomieller Zeit deterministisch gelöst werden kann.
Eine Selbstreduktion ist nicht für alle Probleme so einfach möglich.
431
430

Zugehörige Unterlagen

6 - Mathematik

Computational Complexity 1 Einleitung

Zugehörige Unterlagen

Dieses Dokument Sammlung (en)

Dieses Dokument gespeichert

Schlagen Sie uns vor, wie wir StudyLib verbessern können