Skript zur Vorlesung Komplexitätstheorie im SS 1996

Skript zur Vorlesung
Komplexitätstheorie
im SS 1996
Technische Universität Ilmenau
Fakultät für Informatik und Automatisierung
Institut für Technische und Theoretische Informatik
Fachgebiet Automaten und Formale Sprachen
Prof. Dr. Manfred Kunde, Andre Osterloh

Inhaltsverzeichnis
Einleitung 1
1 Probleme und Algorithmen 1
1.1 Erreichbarkeit in Graphen (REACHABILITY) . . . . . . . . 1
1.2 O-Notation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Maximaler Fluß . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.4 Problem des Handlungsreisenden . . . . . . . . . . . . . . . . 10
2 Turing-Maschine 10
2.1 Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2 Turing-Maschinen als Algorithmen . . . . . . . . . . . . . . . 14
2.3 Turing-Maschinen mit mehreren Bändern . . . . . . . . . . . 15
2.4 Lineare Beschleunigung (Linear Speedup) . . . . . . . . . . . 18
2.5 Platzschranken . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.6 Random Access Machine (RAM) . . . . . . . . . . . . . . . . 22
2.7 Nichtdeterministische Maschinen . . . . . . . . . . . . . . . . 23
3 Beziehungen zwischen Komplexitätsklassen 26
3.1 Komplexitätsklassen . . . . . . . . . . . . . . . . . . . . . . . 26
3.2 Hierarchiesätze . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.3 Die Erreichbarkeitsmethode . . . . . . . . . . . . . . . . . . . 33
3.3.1 Nichtdeterministischer Platz . . . . . . . . . . . . . . . 35
4 Reduktionen und Vollständigkeit 40
4.1 Reduktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4.2 Vollständigkeit . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5 NP-vollständige Probleme 50
5.1 Varianten von SAT . . . . . . . . . . . . . . . . . . . . . . . . 51
5.2 Graphentheoretische Probleme . . . . . . . . . . . . . . . . . 53
5.3 Mengen- und Zahlenprobleme . . . . . . . . . . . . . . . . . . 55
5.4 Weitere NP-vollständige Probleme . . . . . . . . . . . . . . . 60
6 coNP 60
6.1 NP und coNP . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
6.2 Primzahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
7 Schlußbetrachtungen 65
7.1 P gegen NP . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
7.2 Orakel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
7.3 PSPACE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
7.4 Parallele Komplexitätsklassen . . . . . . . . . . . . . . . . . . 68

1 PROBLEME UND ALGORITHMEN 1
Einleitung
Dieses Skript ist als vorlesungsbegleitendes Material zur Vorlesung Komplexitätstheorie
gedacht, die an der TU Ilmenau im Bereich der Theoretischen
Informatik angeboten wird.
Im Inhalt und Aufbau orientiert es sich sehr stark an dem Buch ” Computational
Complexity“ von Christos H. Papadimitriou. Einige Teile entstammen
dem Buch ” Computers and Intractability, A Guide to the Theory of
NP-completeness“ von M. R. Garey und D. S. Johnson. In diesem und den
in der Literaturliste angegebenen Büchern findet der Leser weitere Informationen
über die in diesem Skript angesprochenen und nicht angesprochenen
Teilbereiche der Komplexitätstheorie.
Entstanden ist das vor Ihnen liegende Skript durch die Mitarbeit mehrer
Personen, denen hiermit dafur gedankt sei. Ein besonderer Dank geht an
Herrn Björn-Hendrik Moritz, der das handgeschriebene Skript in ein L ATEXfile
verwandelte und an Herrn Michael Sommer, der bei der Fehlersuche sehr
erfolgreich war.
Fehler oder Verbesserungsvorschläge, die das Skript betreffen, können sie an
folgende e-mail-Adresse schicken: osterloh@theoinf.tu-ilmenau.de.
1 Probleme und Algorithmen
1.1 Erreichbarkeit in Graphen (REACHABILITY)
Definition 1.1 Ein Graph G = (V, E) ist ein Tupel aus
1. einer endlichen Menge V von Knoten und
2. einer Menge E ⊆ V × V von Kanten
Im folgenden werden die Knoten (oft) als Zahlen 1, . . . , |V | geschrieben.
Sei G = (V, E) ein Graph; dann lautet die Frage bei REACHABILITY: Gibt
es einen Pfad von Knoten v1 nach v2?
Beispiel: v1 = 1, v2 = 5. Existiert ein Weg von 1 nach 5?
1 4
✻ 5
2 ✲ 3
❄
❤ ✲ ❤
❦
❤
✸
❤ ❤
Antwort: Ja, (1, 4, 3, 5).
Wäre allerdings statt des Paars (4, 3) das Paar (3, 4) eine Kante im Graph, so
gäbe es keinen Pfad von 1 nach 5. Obiges Beispiel ist ein Fall oder Instanz des
Problems REACHABILITY. Ein Fall ist durch folgendes gekennzeichnet:

1 PROBLEME UND ALGORITHMEN 2
• ein mathematisches Objekt (hier ein Graph und zwei Knoten)
• eine Fragestellung
• ein Antwort auf die Fragestellung: ja oder nein (ein sogenanntes Entscheidungsproblem)
Entscheidungsprobleme werden eine zentrale Rolle in dieser Vorlesung spielen.
Man löst ein gegebenes Problem mit einem Lösungsverfahren (Algorithmus).
Formale Modelle zum Ausdrücken von Algorithmen sind:
• Turing-Maschine
• Random Access Machine (RAM)
• PASCAL
• Informelle Beschreibung (meist in der Vorlesung)
Algorithmus 1.1 (REACHABILITY) Idee: Aufbauen einer Menge
S ⊆ V :
• Anfang: S = {1}
• Knoten werden markiert oder nicht
• Knoten i markiert, falls i zu einem Zeitpunkt gerade zu S gehört
Dazu wird folgende Schleife durchlaufen:
• In jeder Iteration wird ein Knoten i ∈ S gewählt und entfernt. Das
neue S entsteht dann aus S := S\{i}
• Behandle alle Kanten (i, j) ∈ E nacheinander. Falls j nicht markiert
ist, markiere j. S = S ∪ {j}
Wiederhole die Schleife bis S = ∅ (eigentlich reicht es, die Schleife zu wiederholen,
bis n ∈ S). Falls zu diesem Zeitpunkt n markiert ist, dann Ausgabe
” ja“. Falls n nicht markiert, dann Antwort ” nein“.
Beweis der Korrektheit des Suchalgorithmus durch das Beweisen der Behauptung:
Der Knoten i ist markiert ⇔ Es gibt einen Weg von 1 nach i
(Übungsaufgabe).

1 PROBLEME UND ALGORITHMEN 3
Ungenauigkeiten:
1. Genaue Darstellung des Graphen (Fallbeschreibung) möglich durch:
• Knotenliste: 1, . . . , 5 und Kantenliste: (1, 4), (2, 1), (2, 3), (3, 5),
(4, 3), (5, 4) oder
• n × n-Matrix (Adjazenzmatrix):
1
aij =
0
falls
sonst
(i, j) ∈ E
⎛
⎜
Im obigen Beispiel: ⎜
⎝
0 0 0 1 0
1 0 1 0 0
0 0 0 0 1
0 0 1 0 0
0 0 0 1 0
Es wird sich später zeigen, daß die genaue Darstellung keine große
Rolle spielt.
2. Ungenaue Darstellung des Algorithmus: Wie wird der Knoten i ∈ S
ausgewählt? Z. B.
• Wähle Knoten i, der am längsten in S war (S als Warteschlange).
Resultierender Algorithmus: Breitensuche (breadth-first).
• Wähle Knoten i, der am kürzesten in S war (S als Stapel, Stack).
Resultierender Algorithmus: Tiefensuche (depth-first).
Es gibt viele Möglichkeiten, S zu verwalten. Der Algorithmus arbeitet
korrekt für alle Auswahlen.
Effizienz des Algorithmus: Jede Zeilenmatrix wird nur einmal besucht, d. h.
es gibt ≤ n 2 Operationen auf den Kanten, die zu den ausgewählten Knoten
gehören. Die Annahme dabei ist, daß der Zeitaufwand konstant ist für:
• Auswahl der Knoten aus S
• Markieren von Knoten
• Auskunft, ob Knoten markiert oder nicht
Der Algorithmus löst das Problem proportional zu n 2 oder in O(n 2 ).
1.2 O-Notation
Definition 1.2 Seien f, g : N → N, n, n0 ∈ N und c ∈ R
⎞
⎟
⎠
1. f ∈ O(g) :⇔ ∃c > 0, ∃n0 ∀n ≥ n0 f(n) ≤ cg(n).
Dies wird auch als f(n) = O(g(n)) geschrieben.

1 PROBLEME UND ALGORITHMEN 4
2. f ∈ Ω(g) :⇔ g ∈ O(f)
Dies wird auch als f(n) = Ω(g(n)) geschrieben.
3. f ∈ θ(g) :⇔ f ∈ O(g) ∩ Ω(g)
Dies wird auch als f(n) = θ(g(n)) geschrieben.
Nachbemerkung: f ∈ Ω(g) ist manchmal definiert als:
:⇔ ∃c ∃unendlich viele n f(n) ≥ cg(n)
Sprechweise für f ∈ O(g): f wächst größenordungsmäßig langsamer oder genauso
wie g. Sprechweise für f ∈ θ(g): f und g wachsen größenordungsmäßig
gleichschnell.
Beispiele und Bemerkungen:
1. n ∈ O(n 2 ), n log n ∈ O(n 2 )
2. Falls f(n) ∈ N, meinen wir: max (⌈f(n)⌉, 0)
3. Für Polynome p vom Grad m, also
p(n) = am · n m + am−1n m−1 + · · · + a1n + a0 (am > 0)
gilt: p(n) ∈ O(n m )
4. ∀m : n m ∈ O(2 n ), aber 2 n ∈ O(n m )
5. Es gilt: O(1) < O(log n) < O(n) < O(n log n) < O(n 2 ) < O(n 3 ) <
O(2 n )
Zeitabschätzung durch ein Polynom: O(n 2 ) für REACHBILITY wird
als behandelbarer Zeitaufwand angesehen.
Im Rahmen dieser Vorlesung wird generell polynomielles Wachstum als
vernünftig behandelbar angesehen. Dagegen ist nicht polynomielles Wachs-
tum nicht mehr vernünftig behandelbar. Dazu einige Zahlenbeispiele.
Kritik hierbei: n 100 ist polynomiell und behandelbar, aber 2 n
100 ist nicht mehr
behandelbar? Wenn das n und damit die Problemgröße sehr groß wird, wird
2 n
100 jedes Polynom irgendwann übertreffen.
Kleine Problemgrößen, die in der Praxis oft vorkommen, werden mit einem
in exponentieller Zeit arbeitenden Algorithmus eventuell schneller gelöst.
Beispielsweise wird beim Linearen Programmieren die Simplex-Methode (exponentieller
Aufwand) praktisch genutzt, wohingegen die Ellipsoid-Methode
(polynomieller Aufwand) praktisch nicht nutzbar ist.

1 PROBLEME UND ALGORITHMEN 5
Komplexitätsfunktion
10 20 30
Größe n
40 50 60
n 0.00001 0.00002 0.00003 0.00004 0.00005 0.00006
s s s s s s
n2 0.0001 0.0004 0.0009 0.0016 0.0025 0.0036
s s s s s s
n3 0.001 s 0.008 s 0.027 s 0.064 s 0.125 s 0.216 s
n5 0.1 s 3.2 s 24.3 s 1.7 5.2 13.0
min min min
2n 0.001 s 1.0 s 17.9 12.7 35.7 366
min Tage Jahre Jhdte
3n 0.059 s 58 min 6.5 3855 2.0 ×
Jahre Jhdte 108 1.3 ×
10
Jhdte
13
Jhdte
Tabelle 1: Vergleich einiger polynomieller und exponentieller Zeitkomplexitätsfunktionen
(1 Schritt ≡ 10 −6 Sekunden), Jhdte – Jahrhunderte
Verhalten im schlechtesten Fall: Basis unserer Betrachtung ist der
schlechteste Fall (worst case).
Vielfach wäre es günstiger, ein Verhalten im Mittel zu beschreiben, z. B.
REACHABILITY: Knoten n wird bei gewissen Graphenklassen nach durchschnittlich
log n Iterationen markiert: REACHABILITY ∈ O(n log n) im
Mittel.
Diese Analyse wird bei Algorithmen gemacht. Schwierig ist es jedoch, eine
angemessene Eingabeverteilung zu finden und daraus einen mittleren Wert
zu ermitteln.
Standpunkt in der Komplexitätstheorie: Polynomiell zeitbeschränktes
Verhalten im schlechtesten Fall wird als Kriterium für Effizienz benutzt.
Dies ergibt eine nützliche Theorie, die Bedeutendes über praktische Berechnung
aussagen kann und die ohne diese Vereinfachung wohl nicht möglich
wäre.
1.3 Maximaler Fluß
Definition 1.3 Ein Netzwerk N = (V, E, s, t, c) ist ein Graph G = (V, E).
s ist dabei der Anfangsknoten (die sogenannte Quelle, d. h. keine Kante geht
nach s) und t ist der Endknoten (die sogenannte Senke, d. h. keine Kante
verläßt t). Für jede Kante (i, j) ∈ E gibt c(i, j) ≥ 0 die Kapazität der Kante
an.

1 PROBLEME UND ALGORITHMEN 6
Definition 1.4 Ein Fluß in N ist eine Zuordnung f : E → N 0 mit
f(i, j) ≤ c(i, j) für alle (i, j) ∈ E derart, daß für jeden Knoten die Summe
der f’s der hereinkommenden Kanten gleich der Summe der f’s der
herausgehenden Kanten ist, d. h. es gilt für alle v ∈ V \ {s, t}:
(i,v)∈E
f(i, v) =
(v,j)∈V
f(v, j)
Definition 1.5 Der Wert eines Flusses f ist die Summe aller Flüsse, die
die Quelle s verlassen (bzw. die Senke t erreichen). Mathematisch formuliert
gilt:
Wert(f) =
f(s, i) −
f(j, s) =
f(i, t) −
f(t, j)
(s,i)∈E
(j,s)∈V
(i,t)∈E
(t,j)∈V

1 PROBLEME UND ALGORITHMEN 7
Beispiel-Netz:
s
✉ 1 ✲ ✉
2 ✒ ✼
✉ 2
3
❘ ✉ 1 ✲
✉
4
❘ ✉t
✒
3
s
✉
Fluß f
✉ ✲ ✉
✒
2
✼ ✼
3 ❘ ❘ ✉ ✲
✲
1
✉
2
❘
❘ ✉t
✒
✼
1
MAXFLOW: Finde Fluß mit dem größten Wert. Dies ist ein Optimierungsproblem,
das unter den möglichen Lösungen die beste sucht. Es ist kein
Entscheidungsproblem.
Das zugehörige Entscheidungsproblem ist MAXFLOW(D): Gegeben ist ein
Netzwerk und k ∈ N. Die Frage lautet: Existiert im Netzwerk ein Fluß mit
Wert(f) ≥ k?
Dieses Entscheidungsproblem kann natürlich sofort durch einen Algorithmus
für MAXFLOW gelöst werden, da nur der Wert eines maximalen Flusses
mit der Schranke k verglichen werden muß. Falls wir einen Algorithmus für
das Entscheidungsproblem haben, so können wir den Wert eines maximalen
Flusses mit Hilfe von binärer Suche finden. Dies ist nicht ganz trivial, später
genauer.
Algorithmus 1.2 (MAXFLOW) (für Graphen ohne Paare von entgegengesetzten
Kanten)
Sei ein Fluß f gegeben. Frage: Ist f optimal?
Falls es einen Fluß f ′ mit größerem Wert als f gibt, d. h. es gilt: Wert
(f ′ ) > Wert (f), dann ist
∆f := f ′ − f mit ∆f(i, j) = f ′ (i, j) − f(i, j), (i, j) ∈ E
selbst ein Fluß mit positivem Wert, also Wert(∆f) = Wert(f ′ )− Wert(f) >
0.
Problem hierbei ist: ∆f(i, j) kann negativ werden. Dies kann als positiver
Fluß entlang der Kante (j, i) angesehen werden. Dieser umgekehrte Fluß
entlang von (j, i) ist ≤ f(i, j).
Falls ∆f(i, j) ≥ 0, dann gilt: ∆f(i, j) ≤ c(i, j) − f(i, j).
Anders betrachtet ist ∆f als Fluß in einem abgeleitetem Netzwerk N(f) =
(V, E ′ , s, t, c ′ ) mit
• E ′ = E\{(i, j)|f(i, j) = c(i, j)} ∪ {(i, j)|(j, i) ∈ E, f(j, i) > 0}
• c ′
c(i, j) − f(i, j)
(i, j) =
f(j, i)
für
für
(i, j) ∈ E
(i, j) ∈ E ′ \E

1 PROBLEME UND ALGORITHMEN 8
Beispiel: Fortsetzung von oben:
s ✉
■
3
✉ 1 ✲ ✉✾
2 ✒
2
✉✴ ✛1
2
2
2
✿ ✉
✿
t
✉✮
1
Man kann einfach einsehen: f ist maximal ⇔ Es gibt keinen positiven Fluß
in N(f).
Das Finden eines positiven Flusses in einem Netzwerk mit positiven Kapazitäten
entspricht der Frage: Gibt es einen Weg von s nach t in N(f)?, d.
h. es ist ein Fall von REACHABILITY. Wir können also zu einem gegebenen
Fluß entscheiden, ob er maximal ist oder nicht. Daraus ergibt sich der
folgende
Algorithmus 1.3 (MAXFLOW) Führe folgende Schleife aus:
1. Beginne mit Fluß f = 0 (d. h. f(i, j) = 0 für alle (i, j) ∈ E)
2. Konstruiere N(f)
3. Gibt es keinen Weg von s nach t?
(a) Ja: f ist optimal. Ende.
(b) Nein: Suche auf einem Weg von s nach t die kleinste Kapazität
c ′ entlang seiner Kanten.
4. Addiere c ′ zu f für alle Kanten, die auf dem Weg liegen:
Gehe zu 2.
⎧
⎨
f(i, j) =
⎩
f(i, j) + c ′ (i, j) auf Weg
f(i, j) − c ′ (j, i) auf Weg
f(i, j) sonst
Zeitaufwand: Jede Iteration (Aufbau N(f), Finden eines Weges) dauert
O(n 2 ) und erhöht den Wert des Flusses um mindestens 1 (da Flüsse und
Kapazitäten ganzzahlig sind). Sei C die maximale Kapazität an einer Kante.
Es gibt n Knoten insgesamt, d. h. ≤ n Kanten verlassen s. Also ist der
maximale Flußwert ≤ n · C. Dies impliziert, daß es höchstens n · C Iterationen
gibt und der Zeitaufwand somit in O(n 3 · C) liegt. Ω(n 3 · C) kann leider
erreicht werden.

1 PROBLEME UND ALGORITHMEN 9
Beispiel:
s
i❥
C ✒ ✻
C
1 ✒ ❘ t
❘ ❥
j
Wenn der Algorithmus für REACHABILITY immer die Kanten (i, j) oder
(j, i) durchläuft, werden mindestens 2C Iterationen benötigt!
Bei binärer Kodierung benötigt die Darstellung von C ⌈log C⌉ Bits. Wenn
etwa log C > n2 ist, wird die Länge der Problembeschreibung, d. h. die Beschreibung
des aktuellen Problemfalls durch O(n2 log C) beschränkt. Wählt
man beispielsweise im obigen Beispiel C = 2n3, dann ist die Laufzeit
O(n3C) = O(n32n3) eine exponentielle Funktion der Eingabelänge, der Algorithmus
für MAXFLOW ist exponentiell.
Einfache Verbesserung: Statt irgendeinen Pfad von s nach t in N(f) zu
suchen, gehe den Weg mit den wenigsten Knoten (z. B. mit der ” breadthfirst“-Version
bei REACHABILITY). Man kann dann zeigen, daß höchstens
n 3 Iterationen mit diesem Algorithmus nötig sind, also MAXFLOW in O(n 5 )
ist. (Anmerkung: Es geht sogar noch schneller.) Damit ist die Schranke von
einem exponentiellen zu einem polynomiellen Algorithmus durchbrochen.
Wir werden sehen, daß das leider wohl nicht immer möglich ist.
Bipartites Matching (Heiratsproblem): Gegeben sei ein bipartiter
Graph B(U, V, E) mit U, V Knoten, E ⊆ U × V und |U| = |V | = n.
Frage: Gibt es ein (perfektes) MATCHING, d. h. existiert eine Menge M ⊆
E mit |M| = n, und für alle (u, v), (u ′ , v ′ ) ∈ M gilt: u = u ′ und v = v ′ ?
Beispiel:
C
C
U V
Wir suchen also Paare von Männern und Frauen, die sich sympathisch sind.
Jede Person soll einen Partner finden. Wir können dieses Problem reduzieren
auf ein Flußproblem in folgendem Netzwerk:
Die Knotenmenge ist U ∪ V ∪ {s, t}, die Kantenmenge {(s, u)|u ∈ U} ∪ E ∪
{(v, t)|v ∈ V } und die Kapazität aller Kanten ist 1. Das zugehörige Netzwerk
sieht dann folgendermaßen aus:

2 TURING-MASCHINE 10
s
❃
✯
✲
❥
⑦
✼
❥
❥
❥
❥✲
⑦❥✲ ✶❃
t
Sofort einzusehen ist dann: Es gibt ein Matching genau dann, wenn das
zugehörige Netzwerk einen Fluß mit Wert n hat. Das Problem ” Bipartites
Matching“ wurde reduziert auf MAXFLOW.
Algorithmus 1.4 (MATCHING) Erstelle zugehöriges Netzwerk und
wende dann polynomiellen Lösungsalgorithmus auf MAXFLOW (D) an.
Bei diesem Algorithmus ist der MAXFLOW-Algorithmus sogar polynomiell,
der MATCHING-Algorithmus liegt in O(n 3 ).
Hier gab es eine Reduktion auf ein Problem, das gut gelöst werden kann.
Später ist es sehr wichtig, Probleme zu reduzieren, für die wir keine praktikable
Lösung kennen.
1.4 Problem des Handlungsreisenden
TSP (Traveling Salesman Problem)
Gegeben sind n Städte und dij ≥ 0 Distanzen zwischen zwei Städten i und
j.
Finde kürzeste Tour durch alle Städte, d. h. finde Permutation Π mit
n−1
dΠ(l),Π(l+1) + dΠ(n),Π(1) l=1
minimal. Das Entscheidungsproblem TSP (D) lautet: Finde zu gegebenen
D eine Tour mit Länge ≤ D.
Algorithmus 1.5 Einfacher Algorithmus: Probiere alle (n−1)! Touren aus
(Start immer mit 1) und wähle davon die kürzeste aus.
Die Laufzeit ist hier O(n!), also exponentiell. Derzeit gibt es für dieses Problem
keinen bekannten Algorithmus, der polynomiellen Zeitaufwand hat!
Das berührt die berühmte P = NP Frage, die Gegenstand dieser Vorlesung
ist.
2 Turing-Maschine
Eine Turing-Maschine ist eine sehr einfache Maschine mit nur einem Datentyp,
nämlich Wörter von Symbolen, die aber letztlich alles kann, was wir
uns unter einer Berechnung vorstellen.

2 TURING-MASCHINE 11
2.1 Grundlagen
Definition 2.1 Eine Turing-Maschine (TM) ist ein Viertupel M =
(K, Σ, δ, s) mit
• K — endliche Menge von Zuständen
• s ∈ K — Startzustand
• Σ — endliches Alphabet. Es gilt: K ∩ Σ = ∅. Spezielle Zeichen in Σ:
– ⊔ — Blank
– ⊲ — Anfangszeichen, erstes Symbol auf dem Band
• δ — Übergangsfunktion (Programm) mit
Dabei ist:
δ : K × Σ → (K ∪ {h, ” yes“, ” no“}) × Σ × {←, –, →}
– h — Haltezustand
– ” yes“ — akzeptierender Zustand
– ” no“ — zurückweisender Zustand
– ← — Bewegung des Lese/Schreibkopfes nach links
– – — Keine Bewegung des L/S-Kopfes
– → — Bewegung des L/S-Kopfes nach rechts
←, – und → sind nicht in K ∪ Σ.
Genaue Definition von δ: Sei q ∈ K, σ ∈ Σ. Dann ist:
wobei
• p — nächster Zustand
δ(q, σ) = (p, ρ, D)
• ρ — Zeichen, mit dem σ überschrieben wird
• D ∈ {←, –, →} – Richtung des L/S-Kopfes
Für ⊲ fordern wir, daß es nie überschrieben und nie nach links passiert wird,
d. h.
∀q ∈ K : δ(q, ⊲) = (p, ⊲, →)
Die Eingabe auf dem Band ist anfangs: ⊲x, x ∈ (Σ\{⊔}) ∗

2 TURING-MASCHINE 12
s
δ
✠
⊲ x1 x2 . . . xn ⊔ ⊔
Da die Turing-Maschine niemals über den linken Rand des Bandes (⊲) hinausgeht,
gibt es nur einen Grund, warum die Maschine nicht fortfährt,
nämlich die Haltezustände h, ” yes“ und ” no“.
Berechnung (Ausgabe) M(x): bei Eingabe x
Haltezustand Ausgabe der Berechnung
yes M(x) = ” yes“
no M(x) = ” no“
h M(x) = y
Die Bandinschrift zum Zeitpunkt h ist dabei: ⊲y ⊔ ⊔ . . . .
• y = ɛ (leeres Wort), falls die Bandinschrift die Form ⊲x mit x ∈ {⊔} ∗
hat
• y = x, falls die Bandinschrift die Form ⊲xv mit v ∈ {⊔} ∗ und x ∈
Σ ∗ (Σ\{⊔}) hat.
Falls M nicht hält: M(x) :=↗ (Sondersymbol).
Beispiel: Maschine mit Eingabe x, x ∈ {0, 1} ∗ und M(x) = ⊔x (Verschieben
von x um ein Feld nach rechts).
K Σ δ
s ⊲ (s, ⊲, →)
s i (∈ {0, 1}) (qi, ⊔, →)
s ⊔ (h, ⊔, –)
qi 0 (q0, i, →)
qi 1 (q1, i, →)
qi ⊔ (h, i, –)

2 TURING-MASCHINE 13
Beispiellauf:
s ⊲010
s ⊲ 010
q0 ⊲⊔ 10
q1 ⊲⊔ 0 0
q0 ⊲⊔ 0 1 ⊔
h ⊲⊔ 0 1 0
Weiteres Beispiel: Addition einer Eingabe x ∈ {0, 1} ∗ mit 1.
Methode: Invertiere vom Ende alle Einsen zu Null bis zu erster Null, die dann
zu Eins invertiert wird (10010 011 → 10010 100 ). Problem dabei: 111111
Definition 2.2 Eine Konfiguration einer Turing-Maschine ist ein Tripel
(q, w, u) mit:
• q ∈ K ∪ {h, ” yes“, ” no“}
• u ∈ Σ ∗ , w ∈ (⊲ · Σ ∗ )
• wu ist die Bandinschrift (L/S-Kopf steht auf letztem Buchstaben von
w)
Definition 2.3 Eine Turing-Maschine M = (K, Σ, δ, s) geht von der Konfiguration
(q, w, u) = (q, w ′ σ, αu ′ ) in einem Schritt über zu der Konfiguration
(p, x, y) (Notation: (q, w, u) M → (p, x, y)), falls: δ(q, σ) = (p, ρ, D) mit
• D =– (keine Bewegung): x = w ′ ρ, y = u
• D =→: x = w ′ ρα, y = u ′
• D =←: x = w ′ , y = ρu
Dabei sind p, q ∈ K, w, x ∈ ⊲Σ ∗ , u, y, w ′ , u ′ ∈ Σ ∗ und σ, α, ρ ∈ Σ.
Transitive Hülle:
M k
1. (q, w, u) → (p, x, y): M geht in k Schritten über ⇔ Es gibt Konfigurationen
(qi, wi, ui), für die gilt:
2. (q, w, u)
• (qi, wi, ui) M → (qi+1, wi+1, ui+1), i = 1, . . . , k und
• (q, w, u) = (q1, w1, u1) und
• (p, x, y) = (pk+1, wk+1, uk+1)
M ∗
M k
→ (p, x, y) ⇔ ∃k(q, w, u) → (p, x, y)

2 TURING-MASCHINE 14
2.2 Turing-Maschinen als Algorithmen
Definition 2.4 Sei L ⊆ (Σ\{⊔}) ∗ , f : (Σ\{⊔}) ∗ → Σ ∗ .
1. Eine Turing-Maschine M akzeptiert L (Notation: L = L(M)) :⇔
∀x ∈ (Σ\{⊔}) ∗ (x ∈ L ⇔ M(x) = ” yes“)
L ist dann rekursiv aufzählbar
2. Eine Turing-Maschine M entscheidet L :⇔
∀x ∈ (Σ\{⊔}) ∗
L ist dann rekursiv entscheidbar .
(x ∈ L ⇔ M(x) = ” yes“) und
(x ∈ L ⇔ M(x) = ” no“)
3. Eine Turing-Maschine M berechnet f :⇔
f ist dann rekursiv berechenbar .
∀x ∈ (Σ\{⊔}) ∗ M(x) = f(x)
Probleme und Sprachen: Turing-Maschinen eignen sich offenbar gut
dazu, um Wörter (Strings) zu verarbeiten. Um Probleme mit Turing-
Maschinen zu lösen, müssen wir jeden Fall eines Problems in geeigneter
Weise als Wort (String) darstellen. Haben wir das erst einmal gemacht, so
ist ein Entscheidungsproblem dadurch zu lösen, daß die zugehörige Sprache
der mit ja ( ” yes“) beantworteten Fälle zu entscheiden ist. Oder alle zu
Fällen gehörige Strings eines Optimierungsproblems dienen als Eingabe, um
den gewünschten Wert zu berechnen.
Beschreibung von Fällen eines Problems (oder Darstellung), z. B. REACHA-
BILITY. Gegeben ist folgender Graph G = (V, E):
1❤ ✲ 2❤
❄ ❄
3❤
✛ 4❤
Darstellung: {(1, 10), (1, 11), (10, 100), (100, 11)} oder
(0110, 0001, 0000, 0010) (als Adjazenzmatrix).
Es gibt sehr viele adäquate Darstellungen, die sehr unterschiedlich sein
können.
Sei PROB ein Problem und F ein Fall. F wird dargestellt als A(F ) ∈ X ∗
bzw. als B(F ) ∈ Y ∗ , X und Y sind dabei Alphabete mit Klammern, usw.
Sei |A(F )| = n die Anzahl der Zeichen in der Beschreibung, also die Länge
von A(F ).
Falls A und B vernünftige Darstellungen sind, dann gibt es ein Polynom p
derart, daß |B(F )| ≤ p(n)

2 TURING-MASCHINE 15
Definition 2.5 Die Beschreibungen (Kodierungen) A und B eines Problems
PROB heißen polynomiell verwandt genau dann, wenn es Polynome p1
und p2 gibt, so daß für alle Fälle F des Problems PROB |A(F )| ≤ p1(|B(F )|)
und |B(F )| ≤ p2(|A(F )|) gilt.
Diese Polynome sind für gängige Problembeschreibungen, Graphen, Mengen,
Zahlen, usw. im allgemeinen nicht allzu groß. Zahlen stellen wir normalerweise
binär dar. Nicht zugelassen ist dagegen die Darstellung von Zahlen in
unärer Weise (5 ≡ 101, nicht 5 ≡ 11111).
2.3 Turing-Maschinen mit mehreren Bändern
⊲ x1 . . .
♦
Kontrolle δ
✠ . . .
⊲ x1
☛
⊲ x1 . . .
Definition 2.6 Eine k-Band-Turing-Maschine M = (K, Σ, δ, s) ist eine Turing-Maschine
mit mehreren (k) Bändern, wobei K, Σ, s wie bei der (ursprünglichen)
1-Band-Turing-Maschine definiert sind.
Die Übergangsfunktion δ ist wie folgt definiert:
δ : K × Σ k → (K ∪ {h, ” yes“, ” no“}) × (Σ × {←, –, →}) k
(q, σ1, . . . , σk) ↦→ (p, s1, D1, . . . , sk, Dk)
Auf dem i-ten Band wird σi gelesen, ρi geschrieben und Di beschreibt die
Bewegung des i-ten Kopfes. ⊲ ist auf jedem Band die Begrenzung nach links.
Die Eingabe x ist nur auf dem ersten Band, die Ausgabe M(x) (falls Halt
mit h) erfolgt nur auf dem letzten (k-ten) Band. In einem Schritt werden
sämtliche Operationen aller k L/S-Köpfe gleichzeitig ausgeführt.
Konfiguration: Eine Konfiguration sieht folgendermaßen aus
(q, w1, u1, . . . , wk, uk)
Der i-te L/S-Kopf zeigt auf das letzte Zeichen des Wortes wi.
Die Anfangskonfiguration bei Eingabe von x:
(s, ⊲, x, ⊲, ɛ, . . . , ⊲, ɛ)
Die Haltekonfigurationen sind die folgenden:
(h, . . . ), (yes, . . . ), (no, . . . )

2 TURING-MASCHINE 16
Ein Übergang ist folgendermaßen definiert:
(q, w1, u1, . . . , wk, uk) M → (p, x1, y1, . . . , xk, yk)
Analog zur 1-Band-Turing-Maschine mit parallelem Arbeiten auf jedem der
k Bänder.
M l
Ein Übergang in l Schritten: →, ein Übergang in endlich vielen Schritten:
M ∗
→ analog zur 1-Band-Turing-Maschine.
Definition 2.7 Sei M eine k-Band-Turing-Maschine, x eine Eingabe und
f : N → N eine Funktion.
1. M benötigt zur Berechnung von M(x) t Schritte (Zeit t) :⇔
(s, ⊲, x, ⊲, ɛ, . . . , ⊲, ɛ)
Falls H = h, dann ist M(x) = wkuk.
M t
→ (H, w1, u1, . . . , wk, uk), H ∈ {h, ” yes“, ” no“}
2. M arbeitet in Zeit f(n) :⇔
für jede Eingabe x berechnet M die Ausgabe M(x) nach höchstens
f(|x|) Schritten.
3. Werde L ⊆ (Σ\{⊔}) ∗ von einer k-Band-Turing-Maschine entschieden,
die in Zeit f(n) arbeitet. Dann ist L ∈ TIME (f(n)). TIME(f(n)) ist
eine Menge von Sprachen, die in Zeit f(n) entschieden werden können,
TIME(f(n)) heißt Komplexitätsklasse.
Komplexitätsklassen und ihre zugehörigen Probleme sind genau der Gegenstand
dieser Vorlesung.
Welchen Einfluß haben nun diese k Bänder auf die Komplexität?
Theorem 2.1 Zu jeder k-Band-Turing-Maschine M, die in Zeit f(n) arbeitet,
gibt es eine 1-Band-Turing-Maschine M ′ , die in O(f(n) 2 ) arbeitet,
wobei für alle Eingaben x gilt: M(x) = M ′ (x).
Beweis: Die k-Band-Turing-Maschine M = (K, Σ, δ, s) soll durch die 1-
Band-Turing-Maschine M ′ = (K ′ , Σ ′ , δ ′ , s) simuliert werden.
Idee: Die Bandinhalte der k Bänder werden hintereinander auf dem einen
Band von M ′ geschrieben, allerdings ohne die ⊲’s (ersetze diese durch ⊲ ′ , die
nach links überschritten werden dürfen). Das Merken der k Köpfe geschieht
durch Unterstreichen des entsprechenden Symbols.
Σ ′ = Σ ∪ Σ ∪ {⊲, ⊳, ⊳ ′ } mit
• Σ = {σ|σ ∈ Σ} für die Markierung der Position der i-ten Köpfe.
• ⊲ ′ – ” linke Ende eines Bandes“, kann nach links passiert werden

2 TURING-MASCHINE 17
• ⊳ – markiert Ende einer Bandinschrift
• ⊳ ′ – siehe weiter unten...
Eine Konfiguration von M der Form (q, w1, u1, . . . , wk, uk) wird simuliert
durch eine Konfiguration von M ′ der Form (q, ⊲, w ′ 1 u1 ⊳ w ′ 2 u2 ⊳ . . . w ′ k uk ⊳ ⊳).
Dabei entsteht w ′ i aus wi wie folgt: ⊲ wird durch ⊲ ′ und σi (letztes Symbol
von wi) durch σi ersetzt, ⊳⊳ signalisiert das Ende des Strings von M ′ .
Anfang der Simulation: Die Eingabe ⊲x wird geändert in ⊲⊲ ′ x⊳⊲ ′ ⊳ . . . ⊲ ′ ⊳
k−1 mal
⊲ ′ ⊳ steht für ein leeres i-tes Band, i ≥ 2. Diese Eingabeänderung kann erreicht
werden durch: ⊲⊔x (Verschieben, siehe frühere Maschinen) und Schreiben
von ⊲ ⊲ ′ x. Dies erfordert 3 + 1 + 2(k − 1) = 2(k + 2) neue Zustände.
Ein Übergang von M wird im wesentlichen durch zwei Scans von links nach
rechts und zurück in M ′ simuliert.
• Beim ersten Scan merkt sich M ′ die markierten Symbole (σi entspricht
i-ter Kopf liest σi). Ein Zustand in M ′ ist [q, σ1, . . . , σk], wobei q der
Originalzustand aus M ist.
• Beim zweiten Scan wird in Übereinstimmung mit der Übergangsfunktion
δ von M im i-ten Bandabschnitt σi überschrieben und entsprechend
der Kopfbewegung ein neues Zeichen markiert.
Problem: Falls im i-ten Bereich der i-te Kopf über das bisherige Ende hinaus
will, d. h. der Kopf zeigt im i-ten Band der Originalmaschine M auf ⊔.
Hierzu markiere an all diesen Stellen das ” Bandende“ im Bereich mit ⊳ ′ . Für
jede dieser Stellen muß dann ein ⊔ eingefügt werden und der Rest um eine
Position nach rechts verschoben (analog zu unserer ersten Maschine).
Die Simulation fährt solange fort, bis M hält. Dann löscht M ′ alle Teilstrings
bis auf den letzten und hält.
Aufwand bei Eingabe von x: M hält innerhalb Zeit f(|x|), d. h. auf keinem
Band von M steht ein Wort länger als f(|x|), da in dieser Zeit höchstens
f(|x|) Symbole betrachtet und geschrieben werden können. Also ist die
Länge des Strings auf Band von M ′ ≤ k(f(|x|) + 1) + 2 (wegen der zusätzlichen
⊳’s und ⊲ am Anfang). Das heißt, daß für die beiden oben erwähnte
Scans 4k(f(|x|) + 1) + 8 Schritte benötigt werden.
Mit dem Einfügen von problematischen ” ⊔“ ’s in jedem der k Teilbereiche
summieren sich die Anzahl der Schritte auf 2k(k(f(|x|) + 1)) + 2), d. h., es
werden O(k 2 f(|x|) 2 ) Schritte in M ′ für jeden Schritt in M benötigt.
Da k aber konstant und unabhängig von |x| ist, ist der Gesamtzeitbedarf in
O(f(|x|) 2 . q.e.d.
Bemerkung: Dieses Theorem demonstriert also, daß die Hinzunahme einer
beschränkten (konstanten) Anzahl von Bändern die Effizienz der Berechnung
höchstens polynomiell beeinflußt.
⊳.

2 TURING-MASCHINE 18
2.4 Lineare Beschleunigung (Linear Speedup)
Das folgende Theorem spricht für die Stärke der O-Notation, in der konstante
Faktoren keine Rolle spielen.
Theorem 2.2 Sei L ∈ TIME (f(n)). Dann gibt es für jedes ɛ > 0 eine
Funktion f ′ (n) = ɛf(n) + n + 2 mit L ∈ TIME (f(n) ′ ).
Beweis: Sei M = (K, Σ, δ, s) eine k-Band-Turing-Maschine, die L in f(n)
Schritten entscheidet. Wir konstruieren eine k ′ -Band-Turing-Maschine M ′ =
(K ′ , Σ ′ , δ ′ , s ′ ), die L in f ′ (n) Schritten entscheidet.
Setze k ′
2 k = 1
=
k sonst
m sei eine Zahl, die nur von M und ɛ abhänge.
Der Trick wird sein, daß Wörter der Länge m zu einem Symbol in Σ ′ kodiert
werden, und zahlreiche Bewegungen von M auf Strings mit wenigen
Bewegungen in M ′ simuliert werden.
Setze Σ ′ = Σ ∪ [Σ m ] mit [Σ m ] = {[σ1, . . . , σm]|σi ∈ Σ}
⊲ x1
♦
M
δ
✠
⊲ ⊔ . . .
☛
⊲ ⊔ . . .
. . . xn ⊲ x1 . . . xn ⊲ ⊔ . . .
✯
⊲ y1
δ ′
. . .
⊲ ⊔ . . .
M ′
y ⌈ n
m ⌉
Hierbei ist yi = [x (i−1)(m+1), . . . , xim] mit xn+1 = · · · = x m·⌈ n
m ⌉ = ⊔ für
m | n.
Anfangs liest M ′ jeweils m Symbole von x σ1, . . . , σm und schreibt dann
das Symbol [σ1, . . . , σm] auf das zweite Band. Das wird erreicht, indem K ′
Zustände der Form K × Σ i , i = 1, . . . , m − 1 zugefügt werden. (q, σ1, . . . , σi)
bedeutet im Zustand q von M und σ1 bis σi gelesen. Falls |x| kein Vielfaches
von m ist, werden Blanks hinzugenommen.
Nach m + 2 Schritten enthält das zweite Band von M ′ den konzen-
|x|
m
trierten Input. Auf Band 1 in M ′ wird nach x ein ⊲ geschrieben als neue
Bandbegrenzung, die nach links nicht überschritten werden kann. Es bietet
sich folgende Situation:

2 TURING-MASCHINE 19
nur Blanks
⊲ x1 . . . xn ⊲ ⊔
✯
. . ✎.
✠
⊲ y1
δ ′
. . .
⊲ ⊔ . . .
✮
yl
konzentriert
Band 2
übrige Bänder (leer)
Wir betrachten nun das Band 2 als Eingabeband und alle anderen Bänder
als Arbeitsbänder. Alle Bänder werden nur noch mit m-Tupeln beschrieben.
M ′ wird nun m Schritte von M in weniger als 6 Schritten simulieren.
Man kann sich das so vorstellen, daß jeweils m Stellen hintereinander auf
einem beliebigen Band wie eine neue Stelle aufgefasst werden:
m m m
⊲ A C B
✻
Kopf
✻
Kopf
✲
nach m Schritten
von M
✲ ⊲ A B C
jeweils m
Symbole dick
Die Köpfe von M ′ zeigen nun allerdings auf m-Tupel. Wir müssen uns die
Position innerhalb der m-Tupel merken. Das heißt, daß die Zustände nun
von der Form (q, j1, . . . , jk), q ∈ K, ji ≤ m sind, wobei ji die genaue Position
des Kopfes auf dem i-ten Band angibt.
Situation auf Band i:
A B C
x ji
✻
i-ter L/S
von M ′
✲
A B C
x ji neu
Wenn M nun m Schritte ausführt, dann wird M ′ auf Band i höchstens die
Tupel A, B und C verändern. Dazu reicht es, daß K ′ Zustände hat, die
sich dies alles merken können. K ′ umfaßt alle Zustände K × {1, . . . , m} k ×
[σ 3mk ], d. h. für jeden Zeitpunk cm der Berechnung in M enthält (nach der
Anfangsphase) M ′ eine genaue Beschreibung der Konfiguration von M.
Auf jedem Band i geht nun der entsprechende L/S-Kopf um eine Position
nach links und korrigiert dort das m-Tupel, dann geht er in die Mitte sowie

2 TURING-MASCHINE 20
nach rechts und wandert schließlich auf das korrekte Endtupel. Bewegungen
der Köpfe in M ′ sind maximal folgende: ←, →, →, ←, ←.
Nach den drei Schritten mit Bewegungen ←, →, → (bzw. –, falls ein ← oder
→ nicht möglich) hat M ′ alle Informationen, die in M nötig sind, um m
Schritte in M auszuführen. Diese Information wird von M ′ in einem Zustand
gemerkt (K × {1, . . . , m} × Σ 3mk ⊆ K ′ ) und für die höchstens drei letzten
Schritte der Simulation benutzt.
Wenn schließlich M die Eingabe akzeptiert oder zurückweist, so tut M ′
dasselbe.
Die Schrittzahl von M ′
f(|x|)
bei Eingabe x ist höchstens |x| + 2 + 6 m . Mit
m =
6
ɛ folgt das Theorem. q.e.d.
Bemerkungen:
1. In gewisser Weise sagt das Theorem, daß erhöhter Hardwareeinsatz
die Konstanten bedeutungslos machen kann. Daher die Begründung
für die O-Notation. Allerdings kann der ” Hardwareaufwand“ enorm
werden. Die Anzahl der Zustände von M muß mit einem Faktor ≥
m k | | 3mk multipliziert werden.
2. Normalerweise sind nur Zeitfunktionen f mit f(n) ≥ n interessant, da
zumindest der Input gelesen werden sollte.
3. Ist f(n) = cn mit c > 1, dann sagt das Theorem, daß c beliebig nahe
an 1 herankommen kann.
4. Wenn f(n) superlinear (etwa 4n 2 + 5n), dann sagt das Theorem, daß
wir beliebigen linearen Speedup (Beschleunigung) erreichen können.
5. Falls L in polynomieller Zeit entscheidbar, dann ist L ∈ TIME (n k )
für ein k ≥ 1
6. P = ∞
k=1 TIME (nk ) ist die Klasse aller in polynomieller Zeit entscheidbaren
Sprachen.
2.5 Platzschranken
Bisher haben wir bei Berechnungen den nötigen Speicherplatz nicht beachtet.
Betrachte etwa folgende Berechnung:
Start = (s, ⊲, x, ⊲, ɛ, . . . , ⊲, ɛ)
M ∗
→ (H, w1, u1, . . . , wk, uk) = Ende
Da (nach unserer Definition) die Bandinhalte der Turingmaschine sich
während einer Berechnung niemals verkürzen (Blanks ⊔“ werden gezählt),
”
erscheint als Platzbedarf k i=1 |wiui| sinnvoll zu sein. Es zeigt sich, daß dies
eine nicht sinnvolle Überbewertung darstellt.

2 TURING-MASCHINE 21
Definition 2.8 Sei M eine Turing-Maschine mit k Bändern.
1. Band 1 ist das Eingabeband, von dem nur gelesen wird, d. h. gelesene
Symbole σ werden wieder mit sich selbst überschrieben. Außerdem
soll der L/S-Kopf des ersten Bandes nicht in den Bereich der Blanks
hineinwandern (wird ⊔ gelesen, dann D1 =←)
2. Band k ist nur Ausgabeband, auf dem der L/S-Kopf nie nach links
bewegt wird (d. h. Dk =←).
Eine derartige Turing-Maschine heißt Turing-Maschine mit Ein- und Ausgabe
(TM mit E/A).
Satz 2.1 Jede k-Band-Turing-Maschine M, die in Zeit f(n) arbeitet, kann
durch eine (k + 2)-Band-Turing-Maschine mit E/A M ′ in Zeit O(f(n)) simuliert
werden.
Beweis: M ′ kopiert die Eingabe auf Band 2 und arbeitet dann auf den
Bändern 2 bis k + 1 wie M. Nach einem ” Stop“ von M kopiert sie die
Ausgabe auf Band k + 2. q.e.d.
Definition 2.9 Es gelte für eine k-Band-Turing-Maschine M bei Eingabe
M ∗
x (s, ⊲, x, ⊲, ɛ, . . . , ⊲, ɛ) → (H, w1, u1, . . . , wk, uk) mit H ∈ {h, yes“, no“}
” ”
1. Falls M eine Turing-Maschine mit Ein- und Ausgabe ist, dann ist der
Speicherbedarf von M bei Eingabe von x k−1 i=2 |wiui|.
Falls M keine Turing-Maschine mit Ein- und Ausgabe ist, dann ist
der Speicherbedarf k i=1 |wiui|.
Falls für ein f : N → N für alle Eingaben x der Speicherbedarf ≤
f(|x|) ist, dann arbeitet M mit Platzbedarf f(n) (oder einfach mit
Platz f(n))
2. Sei L eine Sprache. L ∈ SPACE (f(n)) ⇔
∃ Turing-Maschine mit Ein- und Ausgabe (TM mit E/A) M, die L
entscheidet und mit Platz f(n) arbeitet. SPACE ist eine Platzkomplexitätsklasse.
Es gibt Sprachen, die in SPACE (log n) liegen. REACHABILITY liegt z. B.
in SPACE (log 2 n).
Analog zum Linearen Speedup gibt es
Theorem 2.3 Sei L ∈ SPACE (f(n)). Dann gilt für alle ɛ > 0: L ∈ SPACE
(2 + ɛf(n)).
Beweis: ähnlich zu Beweis von Theorem 2.2 (Seite 18).

2 TURING-MASCHINE 22
2.6 Random Access Machine (RAM)
Obwohl die Turing-Maschine ein ausreichendes Modell für Berechnungen
aller Art ist (Churche These), erscheint sie für Algorithmen, wie wir sie in
der Praxis lösen wollen, als reichlich unhandlich.
Es hat daher verschiedene Bemühungen gegeben, Modelle von Maschinen
zu entwickeln, die unserem Verständnis von Computern näherstehen. Ein
solches Modell, das sich durchgesetzt hat, ist die Random Access Machine
(RAM).
Eine ihrer vielen ähnlichen Versionen soll hier kurz vorgestellt werden:
Register
0
1
2
RAM Programm
0 π0
1 π1
2
. . .
Die Register sind mit 0, 1, . . . , i, . . . durchnummeriert. Sie sind für die jeweilige
Berechnung endlich, es gibt aber beliebig viele. Jedes Register kann
beliebig große ganze Zahlen enthalten (Register i enthält ri ∈ Z).
Das Programm ist eine Folge von Instruktionen Π = (π1, . . . , πm). κ ist ein
Befehlszähler, der nach Ausführung eines Befehls, der kein Sprung und kein
Halt ist, inkrementiert wird. Nach einem Sprung ist κ := j (wobei j die
Sprungadresse angibt), nach einem Halt wird κ := 0 gesetzt. Im Berechnungsverlauf
wird die jeweils aktuelle Instruktion (Befehl) πκ ausgeführt.
Eine Eingabe ist ein Tupel I = (i1, . . . , in) mit ij ∈ Z in Register j. Die
Länge von I ist n
j=1 ⌈log(|ij| + 1)⌉
Befehlssatz
Instruktion Operand Semantik
READ j r0 := ij
READ
STORE
↑ j
j
r0 := irj
rj := r0
STORE
LOAD
↑ j
x
rrj := r0
r0 := x
ADD x r0 := r0 + x
SUB
HALF
x r0 := r0 − x
r0 := JUMP j
r0
2
κ := j
JPOS j if r0 > 0 then κ := j else κ := κ + 1
JZERO j if r0 = 0 then κ := j else κ := κ + 1
JNEG j if r0 < 0 then κ := j else κ := κ + 1
HALT κ := 0
m
πm

2 TURING-MASCHINE 23
Zusammenhang mit Turing-Maschine:
1. Sei L ∈ TIME (f(n)). Dann gibt es ein RAM-Programm, das
1 x ∈ L
χL(x) =
0 sonst
in O(f(n)) berechnet.
2. Falls ein RAM-Programm Π eine Funktion ϕ in Zeit f(n) berechnet,
dann gibt es eine 7-Band-Turing-Maschine, die ϕ in Zeit O(f(n) 3 )
berechnet.
2.7 Nichtdeterministische Maschinen
Nichtdeterministische Maschinen spielen für die Charakterisierung und Klassifizierung
von Problemen eine große Rolle. Sie sind aber ein unrealistisches
Modell für Berechnungen.
Definition 2.10 Eine Nichtdeterministische Turing-Maschine ist ein Viertupel
N = (K, Σ, ∆, s). Dabei sind K, Σ und s wie bei der deterministischen
Turing-Maschine definiert. ∆ ist eine Übergangsrelation:
∆ ⊆
K × Σ k
×
(k ∪ {h, ” yes“, ” no“}) × (σ × {→, −−, ←}) k
In diesem Abschnitt wird nur mit der 1-Band-Turing-Maschine gearbeitet.
Nichtdeterministisch heißt, daß es statt eines legalen Übergangs mehrere
oder gar keinen Übergang geben kann.
Für gegebenes q ∈ K und σ ∈ Σ ist
bzw.
∆(q, σ) ∈ P ((k ∪ {h, ” yes“, ” no“}) × Σ × {→, −−, ←})
∆(q, σ) = {δ1(q, σ), . . . , δr(q, σ)}
mit δi wie bei deterministischen Maschinen und r abhängig von q und σ
(∆(q, σ) = {(p1, ρ1, D1), . . . , (pr, ρr, Dr)})
Definition 2.11 Eine Konfiguration A = (q, w, u) erzeugt eine Konfiguration
B = (q, x, y) :⇔
A geht über zu B gemäß einem δi(q, σ) ∈ ∆(q, σ) (wie bei deterministischen
Maschinen bezüglich δi).
Dies wird auch geschrieben als: A = (q, w, u) N → (q, x, y) = B
N k N ∗
→ sowie → werden auch analog zu deterministischen Maschinen definiert.
N k
Aber: → ist nun keine Funktion mehr.
Wie löst nun so eine nichtdeterministische Maschine Probleme?

2 TURING-MASCHINE 24
Definition 2.12 Eine Nichtdeterministische Turing-Maschine N akzeptiert
eine Sprache L :⇔
x ∈ L ⇔ ∃w, u ∈ Σ ∗ mit (s, ⊲, x)
N ∗
→ ( ” yes“, w, u)
Definition 2.13 Eine nichtdeterministische Turing-Maschine N akzeptiert
eine Sprache L in Zeit f(n) :⇔ N akzeptiert L und
∀x ∈ Σ ∗ gilt: falls (s, ⊲, x)
N k
→ (q, u, w) dann ist k ≤ f(|x|)
Diese Definition bedeutet, daß keine Berechnungen länger als f(n), n Länge
der Eingabe, stattfinden.
Unterschiede zur deterministischen Berechnung:
• Asymmetrie zwischen ” yes“ und ” no“: Eine nichtdeterministische
Turing-Maschine akzeptiert eine Eingabe x nicht, wenn es keine Berechnung
gibt, die im Zustand ” yes“ endet.
• Die Berechnung einer nichtdeterministischen Turing-Maschine stellt
einen Berechnungsbau dar:
❡
❡
❡ Startkonfiguration S
✎☞ ✎☞
A1 A2
✍✌ ✍✌
❡
❡
✎☞ ✎☞ ✎☞
C1 C2 C3
✍✌ ✍✌ ✍✌
❡
❡ ❡ ❡
Es gilt: S N → A1, S N → A2, A2 N → C1, A2 N → C2, A2 N N 2
→ C3 und S → C3.
Die Zeit zur Berechnung entspricht der Tiefe des Baums. Nichtdeterministische
Berechnung in Zeit f(n) kann unter Umständen tatsächlichem
(deterministischen) Rechenaufwand von exponentiellen Aufwand
darstellen.
Neue Komplexitätsklasse: NTIME (f(n)) = {L ⊆ Σ∗ |L wird von einer
nichtdeterministischen Turingmaschine N in Zeit f(n) akzeptiert}.
Die wichtigste Klasse ist NP =
j>0 NTIME (nj ).
Natürlich gilt: P ⊆ NP, weil die deterministischen Turing-Maschinen eine
Unterklasse der nichtdeterministischen Turiung-Maschinen bilden, in der ∆
gerade eine Funktion ist.

2 TURING-MASCHINE 25
Beispiel: TSP (D) mit Schranke D. Gegeben sei eine nichtdeterministische
Turingmaschine N mit zwei Bändern:
• Band 1: Das Eingabeband mit der Beschreibung des Problemfalls, auf
dem die Städte mit Entfernungen sowie die Schranke D stehen. Die
Länge der Beschreibung sei n.
• Band 2:
Phase 1: Beschreibe das Band mit beliebigem Wort w, |w| ≤ n. Dies
geschieht in Zeit O(n).
Phase 2: Teste, ob w eine Tour beschreibt (d. h. Permutation). Zeitbedarf
hier: O(n 2 ).
Phase 3: Falls Tour beschrieben wurde:
1. Aufaddieren der Distanzen. Zeitbedarf: O(n 2 ).
2. Falls Summe ≤ D, Übergang zu Zustand ” yes“, sonst: ” Abbruch“
der Berechnung (Übergang in ” no“ oder einfach in einen Zustand
von dem es nicht weiter geht).
Diese Maschine entscheidet TSP(D). Falls es eine Tour der Länge ≤ D gibt,
dann kann N eine solche Berechnungsfolge erzeugen und im Zustand ” yes“
halten, und zwar mit einer Folge von Konfigurationen, die nicht länger als
O(n 2 ) ist bei Eingaben der Länge n. Falls es keine Tour mit Länge ≤ D gibt,
dann findet die Maschine keine Berechnungsfolge von Konfigurationen, die
mit Zustand ” yes“ enden.
Das Problem ist nun: Wie komme ich von einer polynomiellen nichtdeterministischen
Berechnung zu einer möglicherweise schnellen deterministischen
Berechnung?
Nach heutigem Kenntnisstand können wir etwa zu obigem nichtdeterministischen
Algorithmus für TSP(D) keinen deterministischen polynomiellen
Algorithmus angeben.
Folgendes Resultat liegt derzeit vor:
Theorem 2.4 Sei L ∈ NTIME (f(n)). Dann kann L von einer deterministischen
Turingmaschine in O(c f(n) ) für eine Konstante c > 1 entschieden
werden.
Beweisskizze (nur Idee):
1. Gehe systematische alle Berechnungspfade des Baums durch.
2. Sei d maximaler Verzweigungsgrad, d ≥ 2 und d konstant.
3. An jedem Knoten kann man damit der Wahl des Weges eine Zahl
i, 1 ≤ i ≤ d zuordnen.

3 BEZIEHUNGEN ZWISCHEN KOMPLEXITÄTSKLASSEN 26
4. Das heißt: (i1, i2, . . . , ir) stellt Berechnungspfad der Länge r dar. Da
die nichtdeterministische Turing-Maschine nach ≤ f(|x|) Schritten
auf einem Berechnungspfad anhält, ist r ≤ f(|x|). Gehe jeweils soweit
zurück in (i1, . . . , ir), daß ein ij erhöht werden kann, d. h. zuerst
(1, 1, . . . , 1), dann (1, 1, . . . , 1, 2), usw.
Das heißt: f(|x|)
t=1 dt ∈ O(d f(|x|)+1 )
Definition 2.14 Eine nichtdeterministische Turing-Maschine N = (K, Σ,
∆, s) mit Ein- und Ausgabe akzeptiert eine Sprache L mit Platzbedarf f(n)
⇔ N akzeptiert L und
∀x ∈ (Σ\{⊔}) ∗ gilt: falls (s, ⊲, x, ⊲, ɛ, . . . , ⊲, ɛ)
dann
k−1
|wiui| ≤ f(|x|)
i=2
N ∗
→ (q, w1, u1, . . . , wk, uk)
Das heißt also, N benötigt auf ihren Arbeitsbändern 2, . . . , k − 1 niemals
mehr als f(|x|) Platz. Es wird dabei noch nicht einmal verlangt, daß N
überhaupt hält bei allen Eingaben!
Beispiel: REACHABILITY hat deterministischen Platz O(log 2 n) und
nichtdeterministischen Platz O(log n) (ohne Beweis!).
3 Beziehungen zwischen Komplexitätsklassen
3.1 Komplexitätsklassen
Komplexitätsklassen sind spezifiziert durch:
• Berechnungsmodell: Turing-Maschine, RAM, u. a.
• Art der Berechnung: deterministisch, nicht deterministisch, (randomistisch,
parallel)
• Maße: Zeit, Platz
• Schranken: Funktionen f : N → N
Es hat sich gezeigt, daß man für Schranken Komplexitätsfunktionen wählen
sollte, die in gewisser Weise sinnvoll oder passend sind. Zum Beispiel kann
man Funktionen definieren, die selbst nicht einmal in dem Platz oder der Zeit
berechnet werden können, die sie selbst beschreiben. Oder auch sonderbare
Funktionen wie
f(n) =
2 n falls n Primzahl
die kleinste Zahl mit irgendeiner Eigenschaft sonst

3 BEZIEHUNGEN ZWISCHEN KOMPLEXITÄTSKLASSEN 27
Nicht einmal berechenbar ist beispielsweise: χL mit L nicht entscheidbar.
Das kann zu sehr merkwürdigen Ergebnissen führen (Später: Theorem 3.3).
Daher schränken wir uns ein.
Definition 3.1 f : N → N heißt eigentliche (proper) Komplexitätsfunktion
⇔
1. ∀n ∈ Nf(n) ≤ f(n + 1)
2. Es gibt eine k-Band-Turing-Maschine mit E/A Mf = (K, Σ, δ, s) derart,
daß für jede Eingabe x mit |x| = n gilt:
(s, ⊲, x, ⊲, ɛ, . . . , ⊲, ɛ) M t f
→ (h, ⊲, x, ⊲, ⊓ i2 ik−1 f(n)
, . . . , ⊲, ⊓ , ⊲, ⊓ )
mit t ∈ O(n + f(n)) und ij ∈ O(f(n)), j = 2, . . . , k − 1.
(t und ij hängen nur von der Länge der Eingabe ab).
Das heißt, Mf berechnet für jede Eingabe x einen String von Quasi-Blanks
⊓ f(|x|) in O(|x| + f(|x|)) Schritten und O(f(|x|)) Platz.
Bemerkungen:
• Eigentliche Komplexitätsfunktionen sind beispielsweise: f(n) = c =
konstant, f(n) = n, f(n) = ⌈log n⌉, f(n) = n log n und f(n) = n 3 .
Falls f(n) /∈ N, dann ist ⌈f(n)⌉ gemeint.
• Sind f, g eigentliche Komplexitätsfunktionen, dann sind auch f + g,
f · g, 2 g eigentliche Komplexitätsfunktionen.
• Eigentliche Komplexitätsfunktionen sind auch √ n und n!.
Für eigentliche Komplexitätsfunktionen gelten im weiteren die Klassen:
• TIME (f) – deterministische Zeit
• SPACE (f) – deterministischer Platz
• NTIME (f) – nichtdeterministische Zeit
• NSPACE (f) – nichtdeterministischer Platz
f ist nicht nur spezielle Funktion, machmal sind auch Familien von Funktionen
gemeint, parametrisiert durch k:
• P = TIME (n k ) =
j>0 TIME (nj )
• NP = NTIME (n k ) =
j>0 NTIME (nj )
Weitere Klassen von Funktionen sind:

3 BEZIEHUNGEN ZWISCHEN KOMPLEXITÄTSKLASSEN 28
• PSPACE = SPACE (n k ) =
j>0 SPACE (nj )
• NPSPACE = NSPACE (n k ) =
j>0 NSPACE (nj )
• EXP =
j>0 TIME (2nj)
• L = SPACE (log n)
• NL = NSPACE (log n)
Komplemente von nichtdeterministischen Klassen: Wir haben
schon und werden noch sehen, daß es gravierende Unterschiede bei nichtdeterministischen
Berechnungen bezüglich der Endzustände ” yes“ und ” no“
gibt.
Definition 3.2 (Komplement einer Sprache) Sei L ⊆ Σ ∗ eine Sprache.
Das Komplement zu L ist ¯ L = Σ ∗ \L.
Bei Entscheidungsproblemen PROB gibt es das Komplement PROB. Ein
Fall F in PROB hat die Antwort ” ja“ genau dann, wenn der Fall F in
PROB die Antwort ” nein“ hat.
Beispiel: TSP(D). Das Komplement zu TSP(D) hat die Fragestellung:
Gilt für alle Touren, daß sie Länge > D haben?
Komplement von REACHABILITY: Fragestellung hier: Ist Knoten n von 1
nicht erreichbar?
Seien ein Problem PROB, ein Fall F kodiert als F ∈ Σ ∗ und eine Fragestellung
gegeben: LPROB = {F |Antwort von F : ” ja“}. Das Komplement ist:
¯LPROB = {w|w /∈ LPROB}. w ist dabei Beschreibung von Fällen mit Antwort
” nein“ und von Wörtern, die überhaupt keine Fälle beschreiben.
Streng gesehen gilt: LPROB = ¯ LPROB. Es gilt nur: LPROB ⊆ ¯ LPROB. Dies
wird aber keine Rolle spielen.
Definition 3.3 Sei C eine Komplexitätsklasse (Menge von Sprachen). Definiere
das Komplement dieser Komplexitätsklasse mit co-C = { ¯ L | L ∈ C
}.
Deterministischen Klassen sind unter dem Komplement abgeschlossen, d. h.
C = co-C. Sowohl bei Zeit- als auch bei Platzschranken können wir aus einer
deterministischen Turing-Maschine T eine Maschine ¯ T konstruieren, bei der
die Rollen von ” yes“ und ” no“ in T gerade vertauscht werden.
Der Komplementabschluß bei nichtdeterministischen Platz folgt demnächst,
bei nichtdeterministischer Zeit ist er ein offenes Problem.

3 BEZIEHUNGEN ZWISCHEN KOMPLEXITÄTSKLASSEN 29
3.2 Hierarchiesätze
Sie kennen unter Umständen die Chomsky-Hierarchie REG < KFR < KSS
< REKURSIVAUFZ. Hier geht es um quantitative Hierarchien f(n) ≥ n,
f(n) eigentliche Komplexitätsfunktion. Es werden nur eigentliche Komplexitätsfunktionen
f(n) mit f(n) ≥ n betrachtet (Ausnahme: Theorem 3.3)
Definition 3.4 (Haltesprache) Eine Haltesprache Hf ist wie folgt definiert:
Hf = {M; x|M ist Beschreibung einer deterministischen Turing-Maschine
M akzeptiert x in höchstens f(|x|) Schritten}
Das heißt, wir betrachten alle Beschreibungen von Turing-Maschinen. Dabei
nehmen wir an, unser Alphabet Σ sei groß genug: 0, 1, ” (“, ” ;“, usw. seien
Symbole aus Σ.
Wie kann man nun eine Turing-Maschine für Hf konstruieren?
Einschub: Eine angemessene einheitliche Kodierung der Beschreibung
von Turing-Maschinen ist: M = (K, Σ, δ, s) mit:
• Σ = {1, . . . , |Σ|} (Zahlen, alle binär)
• K = {|Σ| + 1,
|Σ| + 2, . . . , |Σ| + |k|}
≡s
• Zahlen |k| + |Σ| + 1, . . . , |k| + |Σ| + 6 für spezielle Symbole ←, →, –, h,
” yes“, ” no“
• alle verwendeten Zahlen werden dargestellt durch Strings der Länge
⌈log(|k| + |Σ| + 6)⌉ Bits mit führenden Nullen
• δ wird dargestellt als Sequenz von Paaren ((q, σ1, . . . , σk), (p, ρ1, D1,
ρ2, D2, . . . , ρk, Dk ))
• ” (“ und ” )“ sind als Symbole vorhanden
Das heißt also, daß ein String M = (|Σ|)(|K|)δ ∈ Σ eine Turing-Maschine
beschreibt.
Für die folgende Sätze und Lemmata benötigen wir noch eine universelle
Turing-Maschine U, die sämtliche Turing-Maschinen M simulieren kann.
Dabei wird die Beschreibung vom jeweiligen M mit einer Eingabe x kombiniert
(M; x) und als Eingabe von U verstanden: U(M; x) = M(x).
Simulation eines Schrittes von M ((q, w, u) M → (p, w ′ , u ′ )) auf U wie folgt:
U ∗
(sim, ⊲, M; x, ⊲w, q; u) → (sim, ⊲, M; x, ⊲w ′ , p; u ′ ). U kennt das letzte Symbol
von w und den Zustand q von M. U sucht in der Beschreibung von M den

3 BEZIEHUNGEN ZWISCHEN KOMPLEXITÄTSKLASSEN 30
Übergang δ(q, σ) = (p, ρ, D) und ändert den String auf dem zweiten Band
entsprechend.
Simulationsidee (1-Band-Turing-Maschine auf 2-Band-Turing-Maschine):
Lemma 3.1 Hf ∈ TIME (f(n) 3 )
Beschreibung von
M und Eingabe x
⊲ M; x
❨
δ
⊲ w ′ ❘
σ q u
enthält Beschreibung der errechneten
Konfiguration in M
Beweisskizze: Konstruktion einer Turing-Maschine Uf mit vier Bändern,
die Hf in Zeit (f(n) 3 ) entscheidet.
Uf basiert auf folgenden Maschinen:
• universelle Turing-Maschine U
• 1-Band-Turing-Maschine zur Simulation von Mehrband-Turing-
Maschine (Theorem 2.1)
• Maschine zum linearen Speed-up
• Mf , wobei Mf eine 4-Band-Turing-Maschine sei (Falls Mf mit k > 4
Bändern, dann auch Uf )
Arbeitsphasen von Uf :
1. Band 4: mit Mf mit ⊓ f(|x|) Pseudo-Blanks füllen.
2. Band 3: Kopie der Beschreibung von M; dabei Test, ob M tatsächlich
eine Turing-Maschine beschreibt.
Band 1: Wandle ⊲M; x zu ⊲M; ⊲x. Dadurch steht nur noch die Eingabe
⊲x zur Verfügung
Zeitaufwand: O(f(|x|) + n) = O(f(n))
3. Uf simuliert nun die Konfigurationen von M auf Band 2 ähnlich wie
eine universelle Turing-Maschine U.
Band 2:
(q, ⊲w ′ 1σ1, u1, ⊲w ′ 2, . . . , ⊲w ′ k σk, uk) M → (p, ⊲x1, y1, . . . , ⊲xk, yk)
gemäß δ(q, σ1, . . . , σk) = (p, ρ1, D1 . . . , ρk, Dk) alles auf einem Band
gemäß Theorem 2.1.
Band 3: Uf

3 BEZIEHUNGEN ZWISCHEN KOMPLEXITÄTSKLASSEN 31
• kopiert (q, σ1, . . . , σk) hinter Beschreibung von M (Scan auf Band
2)
• sucht in Beschreibung von M entsprechenden Übergang (p, ρ1,
D1, . . . , ρk, Dk) und kopiert ihn ans Ende (Scan Band 3)
• ändert Bandinhalt 2 entsprechend (Scan Band 2)
Band 4: Nach Simulation eines Schrittes von M wird die Uhr“ um
”
einen Schritt nach rechts versetzt.
Zeitaufwand: Für kM-Band-Maschine M O(lMk 2 Mf(|x|)), wobei lM
die maximale Länge der Beschreibung von Zuständen und Symbolen
von M und kM die Anzahl der Bänder von M ist. lMk 2 M ≤ f(n), da
≤ |M| ≤ n.
lM k 2 M
≤ lkM
M
Falls Uf feststellt, daß M den Input x in f(|x|) Schritten akzeptiert, dann
akzeptiert Uf auch M; x. Falls M x nicht akzeptiert oder die ” Uhr“ abgelaufen
ist, weist Uf den Input zurück.
Zeitaufwand: O(f(n) · f(n) 2 ) = O(f(n) 3 ).
Mit dem Theorem über linearen Speed-up (Theorem 2.2) kann Uf so modifiziert
werden, daß höchstens f(n) 3 Schritte benötigt werden.
Lemma 3.2 Hf /∈ TIME 1 n
2f(⌊ 2 ⌋) , f(n) ≥ 10n + 4
Beweis: (durch Widerspruch)
Angenommen, es gibt Turing-Maschine MHf , die Hf in f(⌊ n
2 ⌋) entscheidet.
Dann konstruiere folgende Maschine Df (Diagonalisierung):
Df (M) : if MHf (M; M) = ” yes“ then ” no“ else ” yes“
Falls MHf eine k-Band-Turing-Maschine ist, dann ist Df eine (k + 1)-Band-
Turing-Maschine mit:
1. Die Eingabe x von Band 1 wird als x; x in |x| + 1
1. Kopie
|x| = 3|x| + 1 Schritten auf Band 2 kopiert.
2. Kopie
2. Dann Rücklauf auf Band 2 in 2|x| + 1 Schritten.
+ |x|
zurücklaufen
Insgesamt werden also 5|x| + 2 Schritte benötigt.
Dann auf den Bändern 2 bis k + 1 Arbeit wie MHf . Bei Eingabe M (Maschinenbeschreibung)
mit |M| = n braucht Df also
n
5|M| + 2 + 1/2f ≤ 1/2f(n) + 1/2f(n) = f(n)
2
Schritte. Das obige ≤-Zeichen gilt, da f(n) ≥ 10n + 4 und f monoton steigende
Funktion (da eigentliche Komplexitätsfunktion).
Gilt: Df (Df)?
+

3 BEZIEHUNGEN ZWISCHEN KOMPLEXITÄTSKLASSEN 32
1. Df (Df) = ” yes“, d. h. Df akzeptiert die eigene Beschreibung ⇔
MHf (Df; Df) = ” no“. Daraus folgt, daß Df /∈ Hf .
Nach der Definition von Hf heißt das, daß Df die eigene Beschreibung
Df nicht in f(n), n = |Df|, Schritten akzeptiert.
Es folgt, daß das Ergebnis von Df(Df) = ” no“ ist, also ein Widerspruch
existiert.
2. Entsprechend ist Df (Df) = ” no“ ⇔ MHf (Df; Df ) = ” yes“.
Nach der Definition von Hf wird Df in f(n) Schritten akzeptiert, also
Df (Df) = ” yes“, was wiederum ein Widerspruch ist. q.e.d.
Aus Lemma 3.1 und 3.2 folgt
Theorem 3.1 (Zeithierachie) Sei f(n) ≥ 10n + 4 eigentliche Komplexitätsfunktion.
Dann gilt
TIME(f(n)) ⊂ TIME 8(f(2n + 1)) 3
Es gilt allerdings nicht die Gleichheit!
Korollar 3.1 P ⊂ EXP
Beweis: Jedes Polynom p(n) ist irgendwann ≤ 2 n , anders ausgedrückt gibt
es für alle Polynome p(n) ein n0, so daß für alle n ≥ n0 gilt: p(n) ≤ 2 n .
Also ist P ⊆ TIME (2 n ).
Von Theorem 3.1 wissen wird, daß
TIME(2 n ) ⊂ TIME 8(2 2n+1 ) 3 = TIME 2 6n+6 ⊆ TIME
d. h. P ⊂ EXP.
Für den Platzbedarf gilt ähnliches wie für den Zeitbedarf:
2 n2
⊆ EXP
Theorem 3.2 (Platzhierachie) Sei f(n) eigentliche Komplexitätsfunktion.
Dann gilt:
SPACE(f(n)) ⊂ SPACE(f(n) · log n)
Was kann passieren, wenn f(n) nicht eigentliche Komplexitätsfunktion ist?
Theorem 3.3 (Gap-Theorem) Es gibt eine rekursive Funktion f : N →
N mit
TIME(f(n)) = TIME 2 f(n)
Beweis: Idee ist hierbei die Definition einer Funktion f(n), so daß für jede
Eingabe der Länge n jede beliebige Turing-Maschine M entweder in weniger
als f(n) Schritten hält oder mehr als 2 f(n) Schritte benötigt.

3 BEZIEHUNGEN ZWISCHEN KOMPLEXITÄTSKLASSEN 33
Betrachte alle Turing-Maschinen M0, M1, M2, . . . in der lexikographischen
Ordnung ihrer Kodierungen.
Für beliebige i, k ≥ 0 sei folgende Eigenschaft definiert: P (i, k) heißt, daß
für alle Maschinen Mj, 0 ≤ j ≤ i, gilt: Mj hält in weniger als k Schritten
oder Mj hält nach mehr als 2k + 1 Schritten oder Mj hält überhaupt nicht.
P (i, k) kann folgendermaßen entschieden werden: Simuliere alle Maschinen
Mj, j ≤ i, auf allen Eingaben der Länge i bis zum Schritt 2k + 1.
Definiere dazu f(i) für irgendein i ≥ 0 und betrachte Folge von k’s: k1 =
2i, kj = 2kj−1 + 1 für j = 2, 3, . . . .
Sei nun N(i) = i j=0 |Σj| i mit Σj aus Mj. N(i) ist die Anzahl aller Inputs
der Länge i für die ersten i + 1 Maschinen. Jeder Input x der Länge i
kann höchstens ein P (i, kj) unwahr machen (M ∈ {M0, . . . , Mi} hält auf x
zwischen kj und 2kj Schritten).
(*) Dann gibt es aber ein l ≤ N(i)+1, so daß P (i, kl) wahr ist. Sei f(i) = kl,
d. h. P (i, f(i)) ist wahr (f(i) kann schnell wachsen!).
Sei nun L ∈ TIME(2f(n) ). Das heißt, daß L von einer Turing-Maschine Mj
in 2f(n) Schritten entschieden wird.
Für jeden Input x mit |x| ≥ j (das sind alle bis auf endlich viele) hält Mj
nicht zwischen f(|x|) und 2f(|x|) Schritten.
Nun war f(n) war für n ≥ j aber gerade so definiert, daß Mj berücksichtigt
wurde (siehe (*)).
Da Mj aber nach höchstens 2f(|x|) Schritten hält, muß Mj bei Eingabe von
|x| schon nach höchstens f(|x|) Schritten halten.
Was geschieht nun mit den Inputs der Länge < j?
Ändere Mj derart in M ′ j ab, daß alle Eingaben der Länge < j erkannt werden
(1 Scan) und dann rückwärts das Word einlesen sowie Zustände der Form
K × [Σl ], l < j, zufügen. Dies geht in 2|x| Schritten.
Da f(i) ≥ 2i gilt, gilt auch TIME(f(n)) = TIME 2f(n) . q.e.d.
Bemerkungen:
• Beachte das Größenwachstum von f(n) und die riesige Anzahl von
Zuständen von M ′ j !
• Konstruktion ginge auch mit 3 f(n) und anderen schnell genug wachsenden
Funktionen.
• Für den Platz kann man ähnliche Resultate erzielen.
3.3 Die Erreichbarkeitsmethode
Das Hierachie-Theorem über deterministischen Platz und deterministische
Zeit gehörten mit zu den ersten Resultaten, die in der Komplexitätstheorie
bewiesen wurden.

3 BEZIEHUNGEN ZWISCHEN KOMPLEXITÄTSKLASSEN 34
Die schwierigen und wichtigen Fragen betreffen aber den Bereich determi-
nistische versus nichtdeterministische Berechnung, speziell P ? = NP.
Theorem 3.4 Sei f(n) eigentliche Komplexitätsfunktion. Dann gilt:
1. SPACE(f(n)) ⊆ NSPACE(f(n)) und TIME(f(n)) ⊆ NTIME(f(n))
2. NTIME(f(n)) ⊆ SPACE(f(n))
3. ∃c > 0 NSPACE(f(n)) ⊆ TIME(c log n+f(n) )
Beweis:
1. Jede deterministische Turing-Maschine ist auch nichtdeterministisch
(mit nur einer Wahl pro Schritt).
2. Sei L ∈ NTIMEf(n). Dann gibt es (eine) nichtdeterministische Turing-
Maschine M = (K, Σ, ∆, s), die L in Zeit f(n) akzeptiert.
Sei d die maximale Anzahl von Übergangsmöglichkeiten (Choices) in
M (|∆(q, σ)| ≤ d, d ist eine Konstante). Die Übergangsmöglichkeiten
sind dann etwa: [(p1, ρ1, D1), 0], . . . [(pd, ρd, Dd), d − 1].
Die deterministische Maschine M ′ generiert jetzt eine Sequenz von
Choices, die f(n) lang ist, und schreibt sie auf ein zusätzliches Band:
d1, d2, . . . , d f(n), 0 ≤ di ≤ d − 1.
Dann arbeitet M ′ einen Input x mit |x| = n wie M gemäß der vorgegebenen
Sequenz von Choices ab.
Diese Simulation eines Berechnungspfades von M kann in Platz f(n)
stattfinden, da in jedem Schritt nur ein Platz beschrieben werden kann
und die Berechnungspfade von M höchstens f(n) lang sind.
Es gibt aber in der Regel exponentiell viele Berechnungspfade in M.
Mit Start der Auswahlsequenz 01, 02, . . . , 0 f(n) können aber auf dem
Band systematisch alle Sequenzen erzeugt werden, indem immer die
jeweils vorherige Sequenz gelöscht wird.
Betrachtet man Sequenz a1, . . . , a f(n) als Darstellung der Zahl
f(n)
i=1 aid i−1 , so entspricht das einer Addition mit 1. Dies geht in Platz
O(f(n)).
3. Sei M = (K, Σ, ∆, s) nichtdeterministische k-Band-Turing-Maschine
mit E/A-Bändern, die L in f(n) Platz akzeptiert.
Eine Konfiguration von M bei einer Eingabe x sieht folgendermaßen
aus: (q, w1, u1, . . . , wk, uk) mit w1u1 = ⊲x (wegen E/A). Die Ausgabe
wkuk ist uninteressant, da L entschieden wird.
Diese Konfiguration kann beschrieben werden durch (2k − 2)-Tupel
(q, i, w2, u2, . . . , wk−1, uk−1), wobei i die Position des ersten Kopfes
auf x angibt, 0 ≤ i ≤ n = |x|.
Es gibt |K| Möglichkeiten für q, n + 1 Möglichkeiten für i und

3 BEZIEHUNGEN ZWISCHEN KOMPLEXITÄTSKLASSEN 35
≤ |Σ| (2k−2)f(n) Möglichkeiten für den Rest. Das heißt, daß die Gesamtzahl
der Konfigurationen beschränkt ist durch n·c f(n) n+f(n)
1 = clog 1 für
eine Konstante c1, die nur von M abhängt.
Sei nun G(M, x) der Konfigurationsgraph von M bei Eingabe von x,
wobei die Knoten alle möglichen Konfigurationen {Ci} symbolisieren
und eine Kante (C1, C2) genau dann existiert, wenn gilt: C1 M → C2.
Offenbar gilt: x ∈ L ⇔ es existiert ein Weg von der Startkonfiguration
C0 = (s, 0, ⊲, ɛ, . . . , ⊲, ɛ) zu einer Konfiguration der Form
Ci = ( yes“, i, . . . ). Das heißt also, daß das Entscheidungsproblem,
”
ob x ∈ L ist, reduziert werden kann auf REACHABILITY im Gra-
log n+f(n)
phen G(M, x) mit c1 Knoten.
Dafür gibt es aber einen polynomiellen Algorithmus mit O(m2 log m),
d. h. ≤ c2m3 log n+f(n)
bei Eingabe von m Knoten. Hier ist m = c , und
1
3 log n+f(n))
≤ (c2c3 1 )(log n+f(n)) . Mit c = c2c3 1 ergibt
somit c2m3 = c2c1 sich eine Laufzeit von clog n+f(n) .
Jede Konfiguration von M (jeder Knoten von G(M, x)) hat die Länge
O(log |K| + log n + kf(n)). Für den Erreichbarkeitsalgorithmus muß
in der Kantenmenge des Graphen G(M, x) nachgesehen werden, ob
eine Kante existiert. Dieses kann durch das explizite Erstellen der Adjazenzmatrix
und den Zugriff auf das entsprechende Matrixelement
3(log n+f(n))
geschehen. Das Erstellen der Matrix benötigt O c1 Zeit.
Die Adjazenzmatrix kann aber auch implizit erstellt werden: Für je
zwei Konfigurationen C und C ′ wird mit Hilfe von ∆ überprüft, ob
C M → C ′ gilt. Dies dauert O(log |K| log n + kf(n)) Zeit.
Insgesamt erhält man somit einen Zeitaufwand von O c log n+f(n) mit
einem geeignetem c. q.e.d.
Korollar 3.2 L ⊆ NL ⊆ P ⊆ NP ⊆ PSPACE
Beweis: Mit Theorem 3.4: etwa NL = NSPACE (log n) ⊆ TIME (c 2 log n ) =
TIME (n 2 log c ) ⊆ P.
Bemerkung: Aus Theorem 3.2 folgt L = SPACE (log n) ⊂ PSPACE =
SPACE (n k ). Das heißt, daß irgendwo in der obigen Hierachie ein ” echtes“
Enthaltensein gilt. Wir wissen derzeit nicht wo, und vermuten, daß überall
eine echte Teilmenge vorliegt.
3.3.1 Nichtdeterministischer Platz
Aus Theorem 3.3 folgt sofort, daß
log
NSPACE(f(n)) ⊆ TIME c
n+f(n)
log
⊆ SPACE c
n+f(n)

3 BEZIEHUNGEN ZWISCHEN KOMPLEXITÄTSKLASSEN 36
Wir werden sehen, daß wir exponentiellen deterministischen Platz zur Simulation
nichtdeterministischen Platzes nicht benötigen.
Folgende Definition wird noch benötigt:
Definition 3.5 (PATH) Sei G = (V, E) ein Graph mit |V | = n Knoten.
Seien weiterhin x, y ∈ V und i ≥ 0. Die Aussage (Prädikat) PATH (x, y, i)
ist genau dann wahr, wenn ein Weg von x nach y mit einer Länge ≤ 2 i
existiert.
Theorem 3.5 (Savitch) REACHABILITY ∈ SPACE(log 2 n)
Beweis: Sei G = (V, E) ein Graph mit |V | = n Knoten, V = {1, . . . , n}.
Seien weiterhin x, y ∈ V und i ≥ 0.
Da der Weg von x nach y in G höchstens Länge n zu haben braucht, können
wir die Erreichbarkeit von x nach y mit PATH (x, y, ⌈log n⌉) entscheiden.
Sei M eine 4-Band-Turing-Maschine mit zwei Arbeitsbändern und E/A:
• Band 1 (Eingabe): Adjazenzmatrix von G
• Band 2: Tripel der Form (u, v, j), wobei (x, y, i) erstes (linkestes) Tripel
ist. Die Zahlen sind in Binärdarstellung.
Wie entscheidet M PATH (x, y, i)?
Falls i = 0 ist, ist die Länge des Weges ≤ 2 0 = 1, also ist x = y oder
(x, y) ∈ E.
Für i ≥ 1 gilt: Berechne PATH (x, y, i) folgendermaßen: Für alle Knoten
z teste, ob PATH (x, z, i − 1) und PATH (z, y, i − 1) gilt. Falls es ein z
gibt derart, daß ein Weg der Länge ≤ 2 i−1 von x nach z und von z nach y
existiert, dann gibt es einen Weg der Länge ≤ 2 i−1 + 2 i−1 = 2 i von x nach
y.
Dazu werden alle Knoten z ∈ V nacheinander generiert, um Platz zu sparen
(Band 3). Wenn ein neues z generiert ist, wird auf Band 2 (x, y, i), (x, z, i−1)
hinzugefügt.
Dann folgt wieder ein Test PATH (x, z, i − 1) (wieder rekursiv):
Falls PATH (x, z, i − 1) = false: Lösche (x, z, i − 1) und gehe zum nächsten
” z“.
Falls PATH (x, z, i − 1) = true: Lösche (x, z, i − 1) und schreibe (z, y, i − 1).
Teste dann PATH (z, y, i−1); falls PATH (z, y, i−1) = true: PATH (x, y, i) =
true, falls ” false“, lösche (z, y, i − 1) und gehe zum nächsten ” z“. Falls kein
erfolgreiches z existiert, dann PATH (x, y, i) = false, sonst PATH (x, y, i) =
true
Band 2 arbeitet wie ein Keller: (x0, y0, ⌈log n⌉), . . . , (xi, yi, ⌈log n⌉ − i − 1),
(xi, z, ⌈log n⌉ − i) und enthält nie mehr als ⌈log n⌉ + 1 Tripel, jedes mit der
Länge 3⌈log n⌉, d. h. O(log 2 n).
Band 3 enthält nur generierte z der Länge ⌈log n⌉.
Der Gesamtplatzbedarf ist also O(log 2 n). q.e.d.

3 BEZIEHUNGEN ZWISCHEN KOMPLEXITÄTSKLASSEN 37
Korollar 3.3 Sei f(n) eine eigentliche Komplexitätsfunktion mit f(n) ≥
log n. Dann gilt:
NSPACE(f(n)) ⊆ SPACE(f(n) 2 )
Beweis: Sei M eine nichtdeterministische Turing-Maschine mit Platzbedarf
f(n). Die Eingabe sei x mit |x| = n.
Die Simulation auf deterministischen Maschinen läuft mit Algorithmus aus
Theorem 3.5 auf dem Konfigurationsgraphen G(M, x).
Für geeignetes c gibt es höchstens c f(n) Knoten, d. h. die Darstellung einer
Konfiguration ist höchstens von der Länge log c f(n) = f(n) log c = O(f(n)).
Systematisches Erzeugen der Konfigurationen nacheinander auf Band 3 (mit
Wiedergebrauch des Platzes): Für PATH (C, C ′ , 0) wird getestet, ob C = C ′
oder C M → C ′ . Letzteres wird durch Nachsehen in der Übergangsrelation ∆
von M festgestellt.
Außer den oben erzeugten Konfigurationen stehen noch die Startkonfigu-
ration sowie sämtliche ” yes“-Konfigurationen (nacheinander) für den Test
M ∗
CStart → C yes“ auf Band 3.
”
Da die Darstellung eines Knotens höchstens von der Länge O(f(n)) ist und
höchstens ⌈log cf(n) ⌉ Tripel auf Band 2 geschrieben werden, folgt für den
Platzbedarf O(f(n) 2 ). q.e.d.
Aus obigem Korollar folgt sofort PSPACE = NSPACE. Das deutet darauf
hin, daß Nichtdeterminismus bezüglich Platz nicht so bedeutend ist wie
bezüglich Zeit.
Das soll noch an einer weiteren Fragestellung belegt werden, dem Komplement
von nichtdeterministischen Platzklassen. Dies betrifft Fragen, die bis
1987 im wesentlichen offen waren.
Definition 3.6 Für nichtdeterministische Turing-Maschinen sei bei Eingabe
x
S(h) = C
M t
C ist Konfiguration in G(M, x) und CStart → C mit t ≤ h
Behauptung: Falls M eine nichtdeterministische Turing-Maschine mit
Platzbedarf f(n) und f(n) ≥ log n eine eigentliche Komplexitätsfunktion
ist, dann kann |S(h)| in O(f(n)) nichtdeterministisch berechnet werden.
Beweis: später
Theorem 3.6 (Immerman, Szelepscényi; 87/88) Sei f(n) ≥ log n eine
eigentliche Komplexitätsfunktion. Dann gilt:
NSPACE(f(n)) = co-NSPACE(f(n))

3 BEZIEHUNGEN ZWISCHEN KOMPLEXITÄTSKLASSEN 38
Beweis: Sei L ∈ NSPACE(f(n)). Das heißt, daß eine nichtdeterministische
Turing-Maschine M mit E/A und Platzbedarf f(n) existiert. Konstruiere
eine nichtdeterministischen Turing-Maschine co − M, die ¯ L = Σ ∗ \L akzeptiert,
folgendermaßen:
z sei die Anzahl aller Konfigurationen von M mit z ≤ c f(n) , c > 0. Es folgt
dann:
1. Für alle h: |S(h)| ≤ c f(n) und log(|S(h)|) ≤ f(n) · log c ∈ O(f(n)).
2. Für alle C mit CStart
somit ist C ∈ S(z).
M ∗
→ C existiert ein t ≤ z mit CStart
M t
→ C und
3. Teste für alle C, ob C ∈ S(z) oder nicht. Existiert eine akzeptierende
Konfiguration C ” yes“ in S(z), dann akzeptiert co − M nicht. Existiert
keine akzeptierende Konfiguration in S(z), dann akzeptiert co − M.
(Nichtdeterministischer Test (|S(z)| sei bekannt, Ermittlung von |S(z)| siehe
Theorem 3.7):
1. m = 0
2. Erzeuge systematisch nacheinander alle Konfigurationen C von M auf
Arbeitsband 1. Bei ständigem Wiedergebrauch des Platzes ergibt sich
ein Platzbedarf von O(f(n)).
3. Teste, ob C ∈ S(z).
Rate nacheinander bei Benutzung desselben Platzes Konfigurationenfolge
C = Cz, Cz−1, Cz−2, . . . , C1 = CStart
Teste mit Hilfe von ∆ von M, ob Ci M → Ci+1 oder Ci = Ci−1
Falls ja für alle i: C ∈ S(z), m := m + 1. Falls C = C ” yes“ ist, dann ist
C ” yes“ in S(z) und co − M akzeptiert nicht (siehe oben bei Punkt 3).
Falls nein für ein i: C /∈ S(z). Dies kann falsch sein.
4. Falls alle C getestet wurden:
m < |S(z)|: Es wurde falsch geraten. Goto 1
m = |S(z)|: Richtig geraten.
Falls alle C ∈ S(z) nicht akzeptierend in M: Akzeptiere x. q.e.d.
Theorem 3.7 (Immerman, Szelepscényi) Sei G = (V, E) ein Graph
und x ∈ V, |V | = n. Die Anzahl der von x erreichbaren Knoten kann auf
einer nichtdeterministischen Turing-Maschine mit Platz O(log n) berechnet
werden.
Beweis: Sei S(h) = {y| es gibt einen Weg von x nach y mit Länge ≤ h}
|S(h)| ≤ n und kann in O(log n) Zeichen dargestellt werden.
S(0) = {x}, |S(0)| = 1. Sei |S(h − 1)| schon berechnet und auf einem Band
notiert (alle vorherigen Werte |S(i)|, i < h − 1 sind schon gelöscht).

3 BEZIEHUNGEN ZWISCHEN KOMPLEXITÄTSKLASSEN 39
Bei der folgenden Berechnung stehen immer nur höchstens zwei Knoten der
Länge O(log n) auf einem Band: Platzbedarf O(log n).
Die Zahlen |S(h − 1)|, m ≤ |S(h − 1)|, |S(h)|, l ≤ |S(h)| benötigen ebenfalls
Platz O(log n).
Nichtdeterministische Berechnung:
1. l = 0
2. Erzeuge systematisch nacheinander alle Knoten v ∈ V (Wiedergebrauch
des Platzes)
3. Teste nichtdeterministisch, ob v ∈ S(h).
(a) m = 0
(b) Erzeuge nacheinander alle Knoten u ∈ V
(c) Teste nichtdeterministisch, ob u ∈ S(h − 1):
i. Rate (bei Wiedergebrauch des Platzes) u =
uh−1, uh−2, . . . , u0 = x.
ii. Falls (ui, ui+1) ∈ E für alle i: u ∈ S(h − 1), m := m + 1.
Falls dann u = v oder (u, v) ∈ E, dann ist v ∈ S(h). Setze
l := l + 1 und Goto 2. Wenn nicht, goto 3(b).
Falls (ui, ui+1) /∈ E für ein i, ist u /∈ S(h − 1) (kann falsch
sein!) Goto 3(b) (Nächster Knoten)
4. Alle Knoten getestet:
m < |S(h − 1)|: Berechnung falsch, goto 3.
m = |S(h − 1)|: Berechnung richtig und v /∈ S(h − 1) und für alle
u ∈ S(h − 1) ist (u, v) /∈ E. Es folgt, daß v /∈ S(h). Goto 2 (nächster
Knoten)
5. Alle Knoten getestet: |S(h)| = l
Bemerkungen:
1. L sei kontextsensitive Sprache (Klasse CS), d. h. Produktionen sind
nicht verkürzend. Ist ¯ L = Σ ∗ \L kontextsensitiv?
Wegen CS = NSPACE(n) = co-NSPACE(n) = co-CS lautet die Antwort:
ja.
Diese Frage war sehr lange offen.
2. Noch einige verbesserte Resultate: Sei f(n) eigentliche Komplexitätsfunktion.
Mit dem Theorem 3.1 gilt: TIME(f(n)) ⊂
TIME(f(n) log 2 f(n)).
f(n)
3. Zeit versus Platz: TIME(f(n)) ⊆ SPACE
log f(n)

4 REDUKTIONEN UND VOLLSTÄNDIGKEIT 40
4 Reduktionen und Vollständigkeit
4.1 Reduktionen
Wir haben schon Reduktionen von einem Problem auf ein anderes kennengelernt,
etwa MATCHING auf MAXFLOW (D).
Reduktionen betreffen Aussagen wie: Problem A ist mindestens so schwer
(hard) wie B. Dies sagen wir, wenn B auf A reduziert werden kann.
Definition 4.1 (Reduktion) B wird reduziert auf A :⇔ es gibt eine
Transformation R derart, daß für jede Eingabe x für B R(x) eine äquivalente
Eingabe für A ist: x ∈ LB ⇔ R(x) ∈ LA.
x ✲
R
R(x)
✲ Algorithmus für A
Algorithmus für B
✲
” yes“ / ” no“
Das heißt, wir können mit Hilfe der Transformation R und einem Algorithmus
für Problem A das Problem B lösen.
Dabei darf der Aufwand für R allerdings nicht beliebig groß werden, wenn
wir noch sinnvoll reduzieren wollen. Zum Beispiel kann TSP (D) so leicht
auf REACHABILITY reduziert werden: Gegeben seien zwei Knoten a und
b sowie ein Fall F aus TSP (D). Die Transformation R(F ) ist dann: R(F ) =
({a, b}, E) mit (a, b) ∈ E ⇔ Antwort für F ist ” ja“.
Definition 4.2 Seien L1, L2 ⊆ Σ ∗ . L1 ist mit logarithmischem Platz reduzierbar
auf L2 :⇔ es existiert eine Funktion R : Σ ∗ → Σ ∗ , die von einer deterministischen
Turingmaschine mit Platz O(log n) berechnet werden kann,
und
∀x ∈ Σ ∗ x ∈ L1 ⇔ R(x) ∈ L2
R heißt Reduktion von L1 auf L2.
Schreibweise: L1 ≤log L2 oder nur L1 ≤ L2.
Am Anfang der Untersuchungen von Reduktionen konzentrierte man sich
auf solche, die in polynomieller Zeit berechnet werden konnten.
Satz 4.1 Sei R eine Reduktion, die von einer Turingmaschine M berechnet
wird. Dann hält M auf allen Eingaben x nach polynomiell vielen Schritten.
Beweis: Aus |x| = n folgt, daß es O(nc log n ) mögliche Konfigurationen von
M gibt.
Da M deterministisch ist, kann keine Konfiguration zweimal durchlaufen
werden, da M sonst nicht halten würde. Daher haben die Berechnungen
höchstens die Länge O(nc log n ) = O(nn log c ) = O(n k ) für ein k ≥ 1 + log c.
Folgerung: Für |x| = n ist |R(x)| ∈ O(n k ), also von polynomieller Länge.

4 REDUKTIONEN UND VOLLSTÄNDIGKEIT 41
Beispiel: HAMILTON PATH (Hamilton’scher Weg, HP): Sei G = (V, E)
ein Graph. Frage: Gibt es einen Weg in G, der jeden Knoten genau einmal
besucht?
✻
✛ ✲
✛
✸
❄
❄ ✰
✻
✲
Dies ist ein schweres Problem, aber SAT ist mindestens genauso schwer.
SAT: Gegeben sei ein Boole’scher Ausdruck Φ über X = {x1, . . . , xn}.
Frage: Gibt es eine Wahrheitsbelegung von X derart, daß Φ wahr wird? (Ist
Φ erfüllbar?).
Beispiel (für SAT): Sei Φ = ((x1 ∨ x2) ∧ x3), X = {x1, x1, x2, x2, x3, x3}.
Gesucht ist eine Wahrheitsbelegung T : X → {true, false} mit T (x) =
true ⇔ T (¯x) = false, d. h. ¯x = ¬x. x, ¯x heißen auch Literale.
Setze T1(x1) = T1(x3) = true und T1(x2) = false. Mit dieser Belegung folgt:
T1(Φ) = false. Mit T2(xi) = true für i = 1, 2, 3 ist T2(Φ) = true. Das heißt
die Antwort auf Φ ∈ SAT ist: ” ja“.
Beispiel 4.1 HP ≤ SAT
Beweis:
1. Sei G = (V, E) ein Fall von HP. Konstruiere einen Boole’schen Ausdruck
R(G) mit R(G) ist erfüllbar ⇔ G besitzt Hamilton’schen Weg
folgendermaßen: R(G) = X, Φ bzw. R(G) = Φ (da X eigentlich überflüssig
ist, da in Φ die Literale auftauchen).
2. Sei V = {1, . . . , n} und X = {xij|1 ≤ i, j ≤ n}, wobei xij für die
Aussage Knoten j ist i-ter Knoten in dem Hamilton’schen Weg“ steht.
”
Diese Aussage kann wahr oder falsch sein.
Schreibe Φ in konjunktiver Normalform: Φ = A1 ∧ A2 ∧ · · · ∧ An
(Φ =
i Ai, Ai =
yij j ). Es gelten für alle j = 1, . . . , n folgende Klauseln
(Disjunktionen):
(a) (x1j ∨ x2j ∨ · · · ∨ xnj): Knoten j muß in dem Pfad irgendwo auftauchen.
(b) Für i, j, k = 1, . . . , n, i = k ist (xij ∨ xkj): j kann im Pfad nicht
i-ter Knoten und k-ter Knoten sein.
(c) Für i = 1, . . . , n: (xi1 ∨ xi2 ∨ · · · ∨ xin): Ein Knoten muß der i-te
im Pfad sein.
(d) Für i, j, k = 1, . . . , n, j = k ist (xij ∨ xik): j und k können nicht
beide i-ter Knoten im Pfad sein.

4 REDUKTIONEN UND VOLLSTÄNDIGKEIT 42
(e) Für alle (i, j) mit (i, j) ∈ E und k = 1, . . . , n − 1 (xki ∨ xk+1,j):
Knoten j kann nicht unmittelbarer Nachfolger von Knoten i in
dem Pfad sein (an irgendeiner Stelle k).
R(G) = Φ sei Konjunktion aller dieser Klauseln.
3. Behauptung: R ist Reduktion von HP auf SAT.
Zu zeigen: Für jeden Graphen G gilt:
R(G) erfüllbar ⇔ G hat Hamilton’schen Pfad
und R kann mit Platz O(log n) berechnet werden.
4. Sei R(G) erfüllbar, d. h. es existiert eine Wahrheitsbelegung T , die
R(G) erfüllt: T (R(G)) = true. Dann erfüllt T alle Klauseln in R(G),
also gibt es für jedes j genau ein i mit T (xij) = true, denn sonst
könnten (x1j ∨ x2j ∨ · · · ∨ xnj) und (xij ∨ xkj) nicht alle erfüllt werden.
Analog gibt es für jedes i genau ein j mit T (xij) = true (Klauseln
(xi1 ∨ xi2 ∨ · · · ∨ xin) und (xij ∨ xik)).
Das heißt aber, daß T eine Permutation Π(1), . . . , Π(n) mit
Π(i) = j ⇔ T (xij) = true
der Knoten von G impliziert. Der i-te Knoten im Pfad ist Knoten j.
Dazu gilt die Aussage (*): Für alle k = 1, . . . , n−1 ist (Π(k), Π(k+1)) ∈
E. Begründung: Sei für k-ten Knoten im Pfad i Π(k) = i und für
(k + 1)-ten Knoten im Pfad j Π(k + 1) = j, so muß gelten: T (xki) =
true und T (xk+1,j) = true. Angenommen (i, j) ∈ E. Dann folgt (aus
Punkt 2(e) der Konstruktion und da T (Φ) nach Voraussetzung erfüllt):
true = T (xk,i ∨ xk+1,j) = T (false ∨ false) = false. Widerspruch.
Also gilt mit (*): Π(1), Π(2), . . . , Π(n) ist Hamilton’scher Weg.
5. Umgekehrt: Habe G einen Hamilton’schen Pfad Π(1), . . . , Π(n). Definiere
dann eine Wahrheitsbelegung T für Φ mit T (xij) = true ⇔
Π(i) = j und T (xij) = false ⇔ Π(i) = j.
Man sieht schnell ein, daß T (R(G)) = true gilt.
6. R kann mit Platz O(log n) berechnet werden: Eine Turingmaschine M
berechnet R(G) wie folgt:
Phase 1:
• Band 1: Eingabe von Graph G: Knoten- und Kantenliste.
• Band 2: Anzahl der Knoten n (binär), Platz: log n.
• Band 3: Zähler i, j, k, Platz: log n.
• Band 4: Systematische Ausgabe aller Klauseln der Konstruktion,
die unabhängig von G sind: Punkte 1 bis 4 der Konstruktion
(Ausgabe ist natürlich länger als log n).

4 REDUKTIONEN UND VOLLSTÄNDIGKEIT 43
Phase 2:
• Band 3: Zähler i, j, k, k + 1. Systematisches Erzeugen aller Klauseln
(xki∨xk+1,j) nacheinander. Nachdem eine Klausel erzeugt ist,
nachprüfen (auf Band 1), ob (i, j) ∈ E. Falls (i, j) ∈ E, Klausel
löschen; andernfalls Ausgabe der Klausel auf Band 4 und Klausel
auf Band 3 löschen. Platzbedarf hier: 8 log n + c ∈ O(log n). (c
sind Trennsymbole, Klammern)
SAT ist ein Problem aus der Logik. Wie kann man nun bei gegebenen Ausdruck
Φ und gegebener Wahrheitsbelegung T den Wert T (Φ) berechnen?
Eine Möglichkeit ist die Benutzung von logischen Schaltkreisen (Gates), etwa
für den Ausdruck Φ = ((x1 ∨ x2) ∧ x3) folgendermaßen:
❧
x1
x2 ❧ x3 ❧
❄
❥¬
❄
∨❥
❄
∧❥
Definition 4.3 (Boole’scher Schaltkreis) Ein Boole’scher Schaltkreis
(sogenannter Boolean Circuit) ist ein Graph C = (V, E) mit V = {1, . . . , n}.
Ein Knoten g aus V heißt auch Gate.
Jeder Knoten g ∈ V hat einen Eingangsgrad 0, 1, oder 2.
Die Sorte des Knotens s(g) ∈ {true, false, ∨, ∧, ¬}∪{x1, x2, . . . } . Die Sorten
Variablen
true, false, xi haben den Eingangsgrad 0, ¬ hat den Eingangsgrad 1 und ∨, ∧
haben den Eingangsgrad 2.
Der letzte Knoten n ist der Ausgabeknoten; dieser hat keine ausgehenden
Kanten (kann auf mehrere Knoten erweitert werden. Der Ausgangsgrad ist
für alle anderen Knoten beliebig.
Definition 4.4 (Wahrheitsbelegung) Eine Wahrheitsbelegung T zu einem
Boole’schen Schaltkreis C = (V, E) ist eine Abbildung von V in die
Menge {true, false}, für die folgendes gilt (g, g1, g2 ∈ V ):
1. T (g) = true, falls s(g) = true
2. T (g) = false, falls s(g) = false
3. T (g) ∈ {true, false}, falls g eine Variable ist (also s(g) ∈ {x1, x2, . . . })
4. T (g) = T (g1)XT (g2), falls s(g) = X ∈ {∨, ∧}, (g1, g) ∈ E und
(g2, g) ∈ E
5. T (g) = ¬T (g1), falls s(g) ∈ {¬} und (g1, g) ∈ E

4 REDUKTIONEN UND VOLLSTÄNDIGKEIT 44
Als Wahrheitsbelegung des Schaltkreises C wird die Belegung des Ausgangsknotens
definiert, also: T (C) := T (n).
Bemerkung: Um dies auch formal tun zu dürfen, muß der Definitionsbereich
von T erweitert werden.
CIRCUIT VALUE: Sei C = (V, E), V enthält die freien Variablen, und die
Eingabeknoten sind nur true und false. Frage: Ist T (C) = true?
CIRCUIT SAT: Sei C = (V, E). Frage: Gibt es eine Wahrheitsbelegung T
der Eingabeknoten (Variablen) derart, daß T (C) = true? (Ist C erfüllbar?)
Beispiel 4.2 C-VAL = CIRCUIT VALUE ≤ CIRCUIT SAT = C-SAT
Beweis: Die benötigte Reduktion ist R ≡ id.
Alle Schaltkreise, die variablenfrei sind, sind Fälle von CIRCUIT VALUE.
Die Antwort für diese Fälle ist gleich sowohl für C-VAL als auch für C-SAT.
CIRCUIT SAT ist also Verallgemeinerung von C-VAL.
Beispiel 4.3 CIRCUIT SAT ≤ SAT
Beweis: Sei C = (V, E) und g ein Gate in V . Die benötigte Reduktion ist
R(C) = Φ.
Es ergibt sich folgende Tabelle:
C Klauseln in Φ
Variable x (¬g ∨ x) ∧ (g ∨ ¬x)
true (g)
false (¬g)
NOT-Gate mit Vorgänger h (¬g ∨ ¬h) ∧ (g ∨ h) (= XOR (g, h))
OR-Gate (¬h ∨ g) ∧ (¬h ′ ∨ g) ∧ (h ∨ h ′ g❥ ∨ ¬g)
✠ ❘
h h ′
AND-Gate (¬g ∨ h) ∧ (¬g ∨ h ′ ) ∧ (¬h ∨ ¬h ′ ∨ g)
g❥ ✠ ❘
h h ′
Output Gate (g)
Es gilt: C erfüllbar ⇔ R(C) erfüllbar.
Seien A, B, C Probleme, für die gelte: A ≤ B: B ist mindestens genauso
schwer wie A; und B ≤ C: B ist mindestens genauso schwer wie C. Gilt
dann auch A ≤ C?
Ist unsere Sprechweise, die Transitivität beinhaltet, überhaupt gerechtfertigt?
Satz 4.2 Seien L1 ≤ L2 und L2 ≤ L3. Dann gilt auch L1 ≤ L3.

4 REDUKTIONEN UND VOLLSTÄNDIGKEIT 45
Beweis: Seien R eine Reduktion von L1 auf L2 und R ′ eine Reduktion von
L2 auf L3. Dann ist R ◦ R ′ eine Reduktion von L1 auf L3, weil: x ∈ L1 ⇔
R ′ (R(x)) ∈ L3.
Zu zeigen bleibt: R ◦ R ′ kann mit Platz O(log n) ausgeführt werden.
Seien MR und MR ′ die entsprechenden Turingmaschinen mit logarithmischen
Platz.
x
✻
MR
✸
❘
❄
R(x) ✛
✻
MR ′
✸
R ′ ❘
❄
(R(x))
.
.
u. U. |x| k dieser Bandinhalt wäre zu lang,
für ein k ≥ 1
Trick: Der Input R(x) für MR ′ wird simuliert. Zu jedem Zeitpunkt der Be-
rechnung merkt sich M auf einem Extraband die Position i des Lesekopfes
von MR ′ auf Eingabe R(x), wobei i binär dargestellt ist.
Anfangs ist i = 1, gelesen wird ⊲. Wann immer der Lesekopf von MR ′ um
eine Position nach rechts geht, wird i inkrementiert.
Die Berechnung von MR auf Eingabe x wird so lange fortgesetzt, bis der
Schreibkopf von MR auf dem Ausgabeband die neue Position i erreicht und
das nächste Ausgabesymbol produziert (und zwar das, welches endgültig
stehen bleibt). Dieses Symbol liest MR ′ und arbeitet damit weiter. Solange
auf Position i stehengeblieben wird, arbeitet MR ′ mit diesem Symbol.
Kritischer Fall: Lesekopf von MR ′ geht nach links, weil das Symbol schon
lange vergessen wurde. Dann wird i dekrementiert und MR wiederholt die
gesamte Berechnung von Anfang bis der Schreibkopf von MR wieder das
Symbol auf die neue Position geschrieben hat. Wenn dieses Symbol bekannt
ist, geht die Berechnung von MR ′ weiter.
Platzbedarf: O(log n), da log i ∈ O(log n) für alle i ≤ |k(x)| q.e.d.
4.2 Vollständigkeit
Die Relation ≤ ist transitiv. Welches sind die maximalen Elemente bezüglich
dieser Halbordnung?
Definition 4.5 (Vollständigkeit) Sei C eine Komplexitätsklasse und L
eine Sprache in C (L ∈ C). L heißt C-vollständig :⇔
∀L ′ ∈ C L ′ ≤ L

4 REDUKTIONEN UND VOLLSTÄNDIGKEIT 46
• vollständige Sprachen (Probleme) sind die schwierigsten ihrer Klasse.
• C ′ ⊆ C Komplexitätsklassen. C-vollständige Sprachen sind die Kandidaten,
die am ehesten nicht in C ′ liegen, wenn C ′ unter Reduktion
abgeschlossen ist.
• C ′ ist unter Reduktion abgeschlossen, wenn für alle L mit L ≤ L ′ ,
L ′ ∈ C ′ gilt: L ∈ C ′ .
Satz 4.3 P, NP, coNP, L, NL, PSPACE und EXP sind alle unter Reduktion
abgeschlossen.
Beweis: Übungsaufgabe
Satz 4.4 Seien C und C ′ Komplexitätsklassen, die unter Reduktion abgeschlossen
sind. Falls es eine Sprache L gibt, die vollständig für beide Klassen
ist, gilt C = C ′ .
Beweis: Sei L C-vollständig. Dann können alle Sprachen in C auf L reduziert
werden. Da L ∈ C ′ , folgt C ⊆ C ′ . Umgekehrt gilt analoges, da Abschluß
(L) = C. q.e.d.
Gibt es überhaupt ” natürliche“ vollständige Probleme?
Zur Einführung unserer ersten P-vollständigen und NP-vollständigen Probleme
benutzen wir die sogenannte Tafelmethode. Sei M = (K, Σ, δ, s) eine
in polynomieller Zeit arbeitende Turingmaschine, die L entscheidet.
Bei Eingabe von x kann die Berechnung als |x| k × |x| k Berechnungstafel
dargestellt werden, wobei |x| k die Zeitschranke ist.
Beispiel:
⊲ 0s 1 1 ⊔ ⊔ ⊔ ⊔
⊲ ⊔ 1q0 1 ⊔ ⊔ ⊔ ⊔
⊲ ⊔ 1 1q0 ⊔ ⊔ ⊔ ⊔
⊲ ⊔ 1 1 ⊔q0 ⊔ ⊔ ⊔
⊲ ⊔ 1 1 0 ⊔q1 ⊔ ⊔
⊲ ⊔ 1 1 0q2 ⊔ ⊔ ⊔
⊲ ⊔ 1 1q2 0 ⊔ ⊔ ⊔
⊲ ⊔ 1q2 1 0 ⊔ ⊔ ⊔
⊲ ⊔q2 1 1 0 ⊔ ⊔ ⊔
⊲ ⊔“yes“ 1 1 0 ⊔ ⊔ ⊔
Die Zeilen stehen für die Zeitschritte, die Spalten für die Positionen auf dem
Band der Turingmaschine. In den Spalten wird auch die Kopfposition mit
Zustand vermerkt. Ein Eintrag (i, j) enthält den Inhalt der j-ten Position
nach i Schritten.
Wir gehen von einer 1-Band-Turingmaschine mit folgenden Besonderheiten
aus:

4 REDUKTIONEN UND VOLLSTÄNDIGKEIT 47
• Start auf Position 1.
• Der Bandbegrenzer ⊲ wird nie erreicht, da Kopf auf ⊲ immer Bewegung
nach rechts impliziert und dieser Schritt dann übersprungen wird,
d. h., wir simulieren dann zwei Schritte durch einen.
• Falls Haltezustand ” yes“ oder ” no“ erreicht wird, wird immer an das
linke Ende des Bandes zurückgelaufen.
• Falls Zeit |x| k noch nicht erreicht ist, werden die Zeilen wiederholt.
Außerdem gilt für die Eingabe x: |x| ≥ 2. Eingaben der Länge |x| ≤ 1 werden
sofort entschieden.
Ein Halt erfolgt nach höchstens |x| k − 2 Schritten. Dies kann durch größeres
k immer erreicht werden.
Die zugehörige Tafel akzeptiert dann die Eingabe x genau dann, wenn
T |x| k −1,1 = ” yes“. Klar ist: M akzeptiert x ⇔ Tafel T akzeptiert x.
Theorem 4.1 CIRCUIT VALUE ist P-vollständig .
Beweis: CIRCUIT VALUE ist in P. Sei C = (V, E), V = {1, . . . , n}. Einfaches
Durchrechnen der Gates 1, . . . , n ergibt T (C) = T (n) in Zeit O(n+n 2 ).
Zu zeigen: Für jede Sprache L ∈P gibt es eine Reduktion R(x) von L auf
CIRCUIT VALUE mit ∀x ∈ X ∗ R(x) ist variablenfreier Schaltkreis und x ∈
L ⇔ R(x) hat Wert true.
Sei M eine 1-Band-Turingmaschine, die L in Zeit n k entscheidet. Für i = 0,
j = 0 oder j = |x| k −1 sind die Werte der Berechnungstafel a priori bekannt:
i = 0: Eingabe x und ⊔
j = 0: ⊲
j = |x| k − 1: ⊔
Sei nun i ≥ 1 und 1 ≤ j ≤ |x| k − 2. Der Wert von Tij hängt nur ab von den
Werten Ti−1,j−1, Ti−1,j sowie Ti−1,j+1.
i − 1, j − 1 i − 1, j
i, j
i − 1, j + 1
Falls keines der Vorgängerfelder mit einem Zustand markiertes Feld ist, so
ist Ti,j = Ti−1,j−1. Falls ein Vorgängerfeld mit einem Zustand markiert ist,
so ergibt sich der neue Wert aus der Übergangstafel aus M. Sei Γ = Σ × K
und m = ⌈log |Γ|⌉ + 1. Jedes γ ∈ Γ kann als m-Tupel (s1, . . . , sm), si ∈
{0, 1} dargestellt werden. Die Berechnungstafel wird nun als Tafel binärer
Eingänge Sijl gesehen (0 ≤ i ≤ |x| k − 1, 0 ≤ j ≤ |x| k − 1 und 1 ≤ l ≤ m).

4 REDUKTIONEN UND VOLLSTÄNDIGKEIT 48
Jedes dieser Sijl hängt nur ab von 3m binären Einträgen von Si−1,j−1,1,
Si−1,j−1,2, . . . , Si−1,j+1,m. Das heißt, es gibt Boole’sche Funktionen
F1, . . . Fm mit
Sijl = Fl(Si−1,j−1,1, . . . , Si−1,j+1,m), i, j > 0, 1 ≤ l ≤ m
Jedes dieser Fl kann als Boole’scher Schaltkreis dargestellt werden, es kann
also ein Boole’scher Schaltkreis C mit 3m Eingaben und m Ausgaben konstruiert
werden, der die binäre Kodierung von Tij aus den binären Kodierungen
von Ti−1,j−1, Ti−1,j sowie Ti−1,j+1 berechnet, und zwar für alle
i = 1, . . . , |x| k , j = 1, . . . , |x| k − 1.
C hängt nur von M ab, hat also eine konstante feste Größe unabhängig von
der Länge von x.
Konstruktion des Schaltkreises R(x):
Eingabegates S0,0,1, S0,0,2, . . . , S0,0,m, S0,1,1, . . . , S 0,|x| k −1,m gemäß der Kodierung
der Anfangskonfiguration bei Eingabe von x, wobei 0 für false und 1
für true steht, und die entsprechenden binären Kodierungen der ersten und
letzten Spalten (immer (⊲, ɛ), (⊔, ɛ), ɛ ist kein Zustand).
(|x| k − 1) · (|x| k − 2) Kopien des Schaltkreises C, genannt jeweils Cij.
si−1,j−1,1
sij1
. . . si−1,j+1,m
Cij
. . .
sijm
Die Ausgabegates von Ci−1,j−1, Ci−1,j, Ci−1,j+1 werden dabei als Eingabegates
von Cij identifiziert. Das Ausgabegate von R(x) soll das erste Ausgabegate
von C |x| k −1,1 sein.
Dabei gilt folgende Annahme: Die Berechnung von M endet immer mit ” yes“
oder ” no“. Das erste Bit von ” yes“ ist immer 1, das von ” no“ immer 0.
Durch Induktion über i ist nun leicht zu zeigen, daß die Ausgabegates von
Cij der binären Kodierung der i-ten Zeile in der Berechnungstafel entsprechen.
Falls der Wert von R(x) true wird, heißt das, daß in M der ” yes“
Zustand erreicht wurde, also x ∈ L. Falls x ∈ L, dann akzeptiert die Berechnungstafel,
und damit wird der zugehörige Schaltkreiswert true.
R(x) kann in O(log |x|) Platz erzeugt werden, Schaltkreis C in konstanter
Zeit: Für Cij jeweils Merken der Indizes und Eingabeknoten E(i, j, h), h =
1, . . . , 3m identifizieren mit Ausgabeknoten (Gates) von A(i − 1, j − 1, l),
A(i − 1, j, l), A(i − 1, j + 1, l) für l = 1, . . . , m.
Das heißt, es handelt sich nur um Berechnungen mit Zahlen mit maximaler
Länge log |x| k = O(k log |x|) = O(log |x|) (k ist konstant).
Es werden systematisch alle Indexpaare (i, j) unter Wiedergebrauch des
Platzes durchgegangen.

4 REDUKTIONEN UND VOLLSTÄNDIGKEIT 49
Die Generierung der numerierten Gates Cij benötigt jeweils O(1) Platz, also
insgesamt O(log |x|) Platz. q.e.d.
Theorem 4.2 (Cook, 1971) SAT ist NP-vollständig.
Beweis: Wir wissen schon, daß CIRCUIT SAT ≤ SAT. Wir zeigen:
∀L ∈ NP gilt: L ≤ LCIRCUIT SAT
woraus dann folgt: L ≤ LSAT (wegen Satz 4.2).
Sei L ∈NP. Wir konstruieren einen Schaltkreis R(x) mit Eingabegates (entweder
Konstanten oder Variablen) mit
x ∈ L ⇔ R(x) ist erfüllbar
(d. h. wird unter einer Belegung der Variablen true).
Sei M = (K, Σ, ∆, s) eine nichtdeterministische Turingmaschine, die L in
n k akzeptiert. M sei 1-Band-Turingmaschine, und für jeden Zustand q und
jedes Symbol σ ∈ Σ sei |∆(σ, q)| = 2. Dies ist immer zu erreichen:
• Sei die Anzahl der Auswahlmöglichkeiten etwa m > 2, dann nehmen
wir m − 2 Zustände dazu, um diese Wirkung zu erreichen.
• Falls m = 1, dann schreiben wir die Nachfolgetripel zweimal auf.
• Falls m = 0, werden Zustand, Symbol und Position nicht verändert
(zweimal hinschreiben)
Das heißt, wir können annnehmen, daß M bei jedem Übergang immer zwei
Auswahlmöglichkeiten hat: 0 und 1. Insgesamt ist dann bei einem Berechnungspfad
eine Folge von Auswahlen (c0, c1, . . . , c |x| k−1) ∈ {0, 1} |x|k entstanden.
Für eine feste Sequenz c = (c0, c1, . . . , c |x| k−1) ist dann die Berechnung
deterministisch. Für Schritt i wählen wir Auswahl ci für den Übergang.
Das heißt, wir können die Berechnungstafel T (M, x, c) aufstellen, die zu
Maschine M, Input x und Auswahlsequenz c gehört.
Alle inneren Tij hängen nur von Ti−1,j−1, Ti−1,jTi−1,j+1 und der Wahl ci−1
ab. Das heißt, der Schaltkreis Cij sieht wie folgt aus:
si−1,j−1,1
sij1
. . . si−1,j+1,m
Cij
. . .
sijm
ci−1

5 NP-VOLLSTÄNDIGE PROBLEME 50
Das heißt, C hat jetzt 3m + 1 Eingaben statt 3m.
R(x) kann wieder in Platz O(log |x|) erstellt werden, da nur Zahlen ≤ |x| k
in die Berechnung eingehen.
Es folgt sofort, R(x) ist erfüllbar, d. h., es gibt Sequenz von Eingaben
c0, . . . , c |x| k −1, so daß genau dann Wert (R(x)) = true ist, wenn x ∈ L
gilt. q.e.d.
Anmerkung: Wenn eine Belegung c0, . . . , c |x| k −1 erst einmal festgelegt ist,
dann haben wir nur noch ein CIRCUIT VALUE Problem zu lösen. (Es gibt
aber exponentiell viele Belegungen!)
Bemerkungen:
• Oft wird von den Transformationen nur verlangt, daß sie in polynomieller
Zeit ausführbar sind (Karp) (für Klassen P, NP und aufwärts)
bzw. in log n Platz für P und darunter.
• Auch nichtdeterministische Reduktionen sind untersucht worden.
5 NP-vollständige Probleme
Wir haben nun zwei NP-vollständige Probleme kennengelernt: SAT und
CIRCUIT SAT. Im folgenden werden weitere vorgestellt.
Worin liegt die Bedeutung der NP-vollständigen Probleme?
1. Sei L NP-vollständig. Falls L ∈ P gilt, würde P = NP folgen.
Ein Nachweis, daß auch nur ein NP-vollständiges Problem in P liegt,
ist bisher nicht erbracht und ist nach heutiger Kenntnis eher unwahrscheinlich.
2. NP-Vollständigkeit ist selbst eine Eigenschaft von Probleme und Sprachen,
die diese charakterisieren. Sie gelten als ” sehr schwer“ lösbar.
Wenn wir von einem NP-vollständigem Problem den bestmöglichen
Rechenaufwand auch nicht exakt kennen, so können wir doch sagen,
daß alle schwierigen Probleme in NP etwa gleich schwer sind (Relativ
zur Reduktion mit Platzaufwand O(log n)).
Sei L ∈ NP und M NP-vollständig. Falls M ≤ L gilt, dann ist L aufgrund
der Transitivität der Reduktion NP-vollständig.
Woher weiß man nun, daß ein Problem NP-vollständig ist?
• Nachsehen in Büchern
• Beweisen mit folgendem Beweismuster: PROB liege vor
1. PROB ∈ NP

5 NP-VOLLSTÄNDIGE PROBLEME 51
2. Suche geeignetes NP-vollständiges Problem VOLL
3. Konstruiere Reduktion R: VOLL → PROB
4. Zeige, daß R mit O(log n) Platz konstruiert werden kann
1 und 4 sind meist leicht zu zeigen, die Hauptarbeit liegt in 2 und 3.
1 und 4 werden im folgenden oft nicht extra gezeigt, da offensichtlich.
5.1 Varianten von SAT
Ein wichtiges Problem, das NP-vollständig ist, ist 3SAT .
kSAT ist das Problem SAT, wobei in jeder Klausel höchstens k Literale
vorkommen.
Satz 5.1 3SAT ist NP-vollständig.
Beweis: CIRCUIT SAT ≤ 3SAT (schon in Beispiel 4.3 gezeigt). In der Tat
haben in der Reduktion alle erzeugten Klauseln höchstens 3 Variablen.
Satz 5.2 3SAT bleibt NP-vollständig,
1. falls alle Klauseln genau drei Literale enthalten
2. falls jede Variable höchstens dreimal auftaucht und jedes Literal
höchstens zweimal
Beweis:
1. Klauseln mit ein oder zwei Literalen: Auffüllen mit Kopien eines schon
vorkommenden Literals, z. B. (x ∨ ¬y) ⇒ (x ∨ x ∨ ¬y)
2. Sei x Variable, die in einem Ausdruck aus 3SAT k-mal auftaucht. Ersetze
x beim ersten Auftauchen durch x1, beim zweiten Auftauchen
durch x2, usw.
Es entstehen neue Variablen x1, x2, . . . , xk, die bei Wahrheitsbelegung
den gleichen Wert annehmen müssen. Das geschieht durch (konjunktives)
Hinzufügen des Ausdrucks Φ = (¬x1 ∨ x2) ∧ (¬x2 ∨ x3) ∧ · · · ∧
(¬xk ∨ x1).
Für alle i = 1, . . . k gilt: T (Φ) = true ⇔ T (¬xi ∨ xi+1) = true
Bemerkung: Grenzlinie zwischen P und NP: 2SAT ist in P (sogar in NL).
Beweis wird weggelassen.
Was passiert, wenn ein Problem aus 2SAT nicht erfüllbar ist?
Sinnvolle Frage: Wie ist die maximale Anzahl von Klauseln, die erfüllt werden
können?

5 NP-VOLLSTÄNDIGE PROBLEME 52
MAX2SAT : Sei Φ Boole’scher Ausdruck, wobei alle Klauseln höchstens
zwei Literale enthalten, und k eine ganze Zahl. Gibt es eine Belegung T
derart, daß mindestens k Klauseln erfüllt werden?
Theorem 5.1 MAX2SAT ist NP-vollständig.
Beweis:
1. MAX2SAT ∈ NP: Rate Belegung und teste!
2. 3SAT ≤ MAX2SAT:
Betrachte zunächst für eine Klausel (x ∨ y ∨ z) folgendes Produkt von
zehn Klauseln ( ” ∧“ wird als Produkt interpretiert): (*)
(x)(y)(z)(w)
(¬x ∨ ¬y)(¬y ∨ ¬z)(¬z ∨ ¬x)
(x ∨ ¬w)(y ∨ ¬w)(z ∨ ¬w)
Wieviele Klauseln können in diesem Ausdruck erfüllt werden?
Beachte: (*) ist symmetrisch bezüglich x, y, z, aber nicht bezüglich w.
Somit müssen nur die Fälle
(a) 3 Variablen aus {x, y, z} sind true
(b) 2 Variablen aus {x, y, z} sind true
(c) 1 Variable aus {x, y, z} ist true
(d) Keine Variable aus {x, y, z} ist true
betrachtet werden.
(a) T (x) = T (y) = T (z) = true, T (w) = true oder = false. Dann
können maximal sieben Klauseln erfüllt werden.
T (w) = true: Zeile 1: 4, Zeile 2: 0, Zeile 3: 3
T (w) = false: Zeile 1: 3, Zeile 2: 0, Zeile 3: 3
(b) T (x) = false, T (y) = T (z) = true, T (w) = true oder = false. Es
können wiederum maximal sieben Klauseln erfüllt werden:
• T (w) = true: Zeile 1: 3, Zeile 2: 2, Zeile 3: 2
• T (w) = false: Zeile 1: 2, Zeile 2: 2, Zeile 3: 3
(c) Nur eines, etwa T (x) = true, T (y) = T (z) = false, T (w) = true
oder false: Sieben Klauseln erfüllbar.
(d) T (x) = T (y) = T (z) = false, T (w) = false oder = true ⇒ sechs
Klauseln erfüllbar.

5 NP-VOLLSTÄNDIGE PROBLEME 53
Das heißt: Falls wir eine Belegung T finden mit T (x ∨ y ∨ z) = true,
dann können wir mit Hilfe von w immer sieben Klauseln erfüllen, sonst
höchstens sechs.
Sei Φ irgendein Fall von 3SAT. R(Φ): Für jede Klausel Ci = (α∨β ∨γ)
konstruiere zehn Klauseln nach Methode (*) mit Zusatzvariable wi
(statt w). Zehn Klauseln entsprechen einer Gruppe. Falls Φ m Klauseln
hat, hat R(Φ) 10m Klauseln.
Die maximale Anzahl der erfüllbaren Klauseln ist also k = 7m.
Behauptung: R(Φ) hat Belegung, die mindestens 7m Klauseln erfüllt ⇔ Φ
ist erfüllbar.
Seien 7m Klauseln in R(Φ) unter T erfüllt. Jeder Gruppe kann höchstens
sieben erfüllte Klauseln haben. Also hat jede Gruppe genau sieben erfüllte
Klauseln, d. h. mindestens ein Literal in jeder Ausgangsklausel Ci muß mit
true belegt sein. Also ist Φ erfüllt.
Φ ist erfüllt unter T . Daraus folgt, daß in jeder Gruppe sieben Klauseln
erfüllbar sind und somit R(Φ) eine Schranke k = 7m erreicht.
Logarithmischer Platz: Die Gruppen werden systematisch nacheinander erzeugt.
Die Indices sind alle in O(log n) darstellbar. q.e.d.
Es gibt noch weitere Varianten von SAT, die NP-vollständig sind, z. B.
können wir verlangen, daß in 3SAT in jeder Klauseln, die Variablen weder
alle true noch alle false sein dürfen: NAESAT (not-all-equal SAT). Solche
Probleme sind aus beweistechnischen Gründen oft interessant.
5.2 Graphentheoretische Probleme
Hier werden im folgenden nur ungerichtete Graphen G = (V, E),
[i, j] ∈ E behandelt.
i
j
INDEPENDENT SET (INDSET): Sei G = (V, E) ein ungerichteter
Graph, k ∈ N. Frage: Gibt es eine unabhängige Menge I mit |I| = k? (I ist
eine unabhängige Menge von Knoten: ∀i, j ∈ I [i, j] ∈ E).
Theorem 5.2 INDEPENDENT SET (INDSET) ist NP-vollständig.
Beweis: 3SAT ≤ INDSET. In Theorem 5.1 haben wir Gruppen von zehn
Klauseln als Bausteine benutzt. Hier benutzen wir Dreiecke als Grundbausteine,
d. h., wir werden nur Graphen betrachten, die in Dreiecke partitioniert
werden können. Wir betrachten also nur eine Untermenge von Problemen
in INDSET und zeigen, daß diese schon NP-vollständig ist.
Konstruktionsbeispiel: Φ = (x1 ∨x2 ∨x3)∧(¬x1 ∨¬x2 ∨¬x3)∧(¬x1 ∨x2 ∨x3)

5 NP-VOLLSTÄNDIGE PROBLEME 54
x1
¬x1
¬x1
x2
x3
¬x2
¬x3 x2
x3
Allgemein: Φ = C1 ∧C2 ∧· · ·∧Cm mit Ci = (αi1 ∨α2i ∨α3i), αij sind Literale
der Form x oder ¬x.
R(Φ) = (G, K), K = m, wobei G = (V, E) ein Graph mit
und
V = {vij|i = 1, . . . , m; j = 1, 2, 3}
E = {[vij, vik]|i = 1, . . . , m; j = k; 1 ≤ j < k ≤ 3}∪{[vij, vlk]|i = l, αij = ¬αlk}
Das heißt, für jedes Auftreten eines Literals in Φ gibt es einen Knoten. Die
erste Menge von Kanten definiert Dreiecke den Klauseln entsprechend; die
zweite Menge von Kanten verbindet zueinander gehörige entgegengesetzte
Literale.
Behauptung: Es gibt eine unabhängige Menge I mit K Knoten in G genau
dann, wenn Φ erfüllbar ist.
Sei I unabhängig und |I| = K. Aus K = m folgt, daß I in jedem Dreieck
genau einen Knoten hat (niemals zwei, da sonst nicht unabhängig). Diese m
Knoten, die mit Literalen bezeichnet sind, haben keine Kanten zwischeneinander,
d. h. sie gehören nicht zu entgegengesetzten Literalen. Setze alle zu
den Knoten aus I gehörenden Literale auf true: Φ ist erfüllt.
Umgekehrt: Sei T Belegung für Φ mit T (Φ) = true. Wähle in jeder Klausel
Ci ein Literal mit Wert true aus. Jedes dieser m Literale gehört zu einem
Knoten in den entsprechenden Dreiecken. Da sie jeweils den Wert true haben,
können sie nicht zu Literalenpaaren der Form x und ¬x gehören (aus
verschiedenen Klauseldreiecken). Also gibt es zwischen Knoten keine Kanten,
woraus folgt, daß I unahängig ist. q.e.d.
Zu unabhängigen Mengen gibt es zwei weitere eng verwandte Probleme:
CLIQUE: Sei G = (V, E) ein Graph, k ∈ N. Eine Clique ist ein vollständiger
Untergraph, d. h., alle Knoten sind untereinander mit Kanten direkt
verbunden. Frage: Gibt es Cliquen der Größe k?

5 NP-VOLLSTÄNDIGE PROBLEME 55
NODE COVER: Sei G = (V, E) ein Graph, k ∈ N. Frage: Gibt es eine
Überdeckung der Größe ≤ k? Eine Knotenüberdeckung ist eine Teilmenge
U ⊆ V mit |U| ≤ k derart, daß für alle [u, v] ∈ E gilt: u ∈ U oder v ∈ U.
Theorem 5.3 CLIQUE und NODE COVER sind NP-vollständig.
Beweis:
1. INDSET ≤ CLIQUE: Sei G = (V, E) ein Graph und k ein Fall von
INDSET. Wähle die Relation R(G, k) = ¯ G mit k Fall von CLIQUE.
¯G = (V, Ē) ein Graph mit Ē = {[u, v]|[u, v] ∈ E} ist. I ist unbhängig
in G genau dann, wenn I einen vollständigen Untergraphen in ¯ G impliziert.
2. I ist unabhängig in G = (V, E), |I| = k genau dann, wenn V − I eine
Überdeckung der Größe |V | − k in G ist.
” ⇒“: Für alle [a, b] ∈ E gilt: a ∈ V − I oder b ∈ V − I (sonst a, b ∈ I,
was ein Widerspruch zur Unabhängigkeit wäre)
” ⇐“: V − I ist Überdeckung. Also gilt für alle a, b ∈ I: [a, b] ∈ E
(andernfalls wäre a ∈ V − I oder b ∈ V − I).
5.3 Mengen- und Zahlenprobleme
Bisher spielten Zahlen für uns fast nur als Indizes eine Rolle (Ausnahme ist
etwa TSP). Allerdings waren bei der Reduktion die Distanzen auch nur 1
oder 2. Es gibt aber eine Anzahl interessanter Probleme, bei denen (große)
Zahlen eine große Rolle spielen.
SUMME VON UNTERMENGEN (SUM): Sei A = {a1, . . . , an} eine
Teilmenge von N und M ∈ N. Frage: Existiert eine Menge B ⊆ A mit
ai∈B ai = M?
Theorem 5.4 SUM ist NP-vollständig.
Beweis:
1. SUM ∈ NP: Rate B und teste.
2. Wir zeigen NODE COVER ≤ SUM: Sei R(G, k) = A; M mit
G = (V, E), V = {v1, . . . , vn}, E = {e1, . . . , em}, A =
{a1, . . . , an, b1, . . . , bm}. Für alle j = 1, . . . , n gilt:
aj = 4 m +
m
ɛij · 4 i−1
1 vj ist Knoten von ei
mit ɛij =
0 sonst
i=1
Für alle i = 1, . . . , m gilt: bi = 4 i−1 und M = k · 4 m + 2 · m
i=1 4i−1 .
Behauptung: G hat Knotenüberdeckung S ⊆ V mit |S| ≤ k genau

5 NP-VOLLSTÄNDIGE PROBLEME 56
dann, wenn ein B ⊆ A mit
x∈B x = M existiert.
” ⇒“: o.B.d.A. sei |S| = k (Zunahme von Knoten). Für i = 1, . . . , m
sei φi =
vj∈S ɛij. 1 ≤ φi ≤ 2: Zu jeder Kante ei gehören mindestens
ein vj ∈ S (Überdeckung) und höchstens zwei Knoten aus S.
Sei B1 = {aj|vj ∈ S}, B2 = {bi|1 ≤ i ≤ m, φi = 1}, B = B1 ∪ B2
(Füllelemente, falls ei nur von einem v ∈ S getroffen). Es gilt:
x =
aj +
x∈B
vj∈S
φi=1
=
4 m +
vj∈S
= |S| · 4 m +
= k · 4 m +
bi
m
i=1
ɛij4 i−1
+
4 i−1
φi=1
⎜ ⎟
m ⎜ ⎟
⎜ ɛij⎟
4
⎜ ⎟
⎝vj∈S
⎠
i−1 +
4
φi=1
i−1
i=1
⎛
φi
⎞
m
φi4 i−1 +
4 i−1
i=1
= k4 m +
= k4 m + 2
= M
i,φi=2
φi=1
2 · 4 i−1 +
m
4 i−1
i=1
i,φi=1
4 i−1 +
i,φi=1
4 i−1
” ⇐“: Es existiere B ⊆ A mit
x∈B x = M. Sei B1 = B ∩ {a1 . . . , an}
und B2 = B ∩ {b1, . . . , bm}. Behauptung: S = {vj|aj ∈ B1} ist Kno-

5 NP-VOLLSTÄNDIGE PROBLEME 57
tenüberdeckung mit |S| = k.
M = k · 4 m + 2
=
aj∈B1
m
4 i−1
i=1
aj +
=
4 m +
vj∈S
= |S| · 4 m +
bi∈B2
m
i=1
bi
ɛij4 i−1
+
bi∈B2
⎜
m ⎜
⎜ ɛij 4
⎜
⎝vj∈S
i−1
⎟ +
⎟
⎠
i=1
⎛
⎞
≤2
≤ m i=1 3·4i−1 =4m−1 bi
m
|{bi} ∩ B2| ·4
≤1
i−1
Also gilt: |S| = k, da der Rest < 4m ist. Außerdem gibt es bei der
Summation keine Überträge, d. h. für alle i = 1, . . . , m gilt:
2 =
ɛij + |{bi} ∩ B2|
vj∈S
≤1
⇒ ∀i
ɛij ≥ 1
vj∈S
⇒ ∀i ∃vj ∈ S mit ɛij ≥ 1
i=1
⇒ ∀i ∃vj ∈ S mit vj ist Knoten von ei
⇒ S ist Überdeckung mit |S| = k
q.e.d.
Mit SUM kann man zeigen, daß eine Reihe von weiteren Zahlenproblemen
NP-vollständig sind.
PARTITION: Sei A = {a1, . . . , an} eine Teilmenge von N. Frage: Existiert
eine Menge D ⊆ A (Partitionsmenge) mit
ai∈D ai =
aj∈A\D aj =
1 n 2 i=1 ai?
Es gilt: SUM ≤ PARTITION, denn: Sei A wie oben, M ein Fall aus
SUM. Dann kann man folgende Relation R aufstellen: R(A, M) = A ′ =
A ∪ {an+1, an+2}, wobei an+1 = M + 1 und an+2 = n i=1 ai + 1 − M sind.
Man sieht sofort, daß n+2 i=1 ai = 2 n i=1 ai + 2.
Sei nun B ⊆ A mit
ai∈B ai = M (also Lösung von SUM). Setze D =
B ∪ {an+2} ⊆ A ′ .

5 NP-VOLLSTÄNDIGE PROBLEME 58
Dann gilt (*):
ai =
ai + an+2 = M +
ai∈D
ai∈B
n
ai + 1 − M =
i=1
n
ai + 1
also ist D Partitionsmenge.
Sei D Partitionsmenge von A ′ . O.b.d.A. ist an+2 ∈ D (sonst ∈ A ′ \D). Also
ist an+1 ∈ D, weil sonst
ai∈D ai ≥ an+1 + an+2 = n i=1 ai + 2 > ai + 1
(keine Partition).
Setze B = D\{an+2}. Mit (*) folgt sofort, daß
n
n
ai = ai + 1 − ai + 1 − M = M
ai∈B
i=1
a∈D a
Rucksackproblem (KNAPSACK): Sei X = {w1, . . . , wn} ⊆ N eine
Menge von Gewichten bzw. Größen von Stücken, Y = {v1, . . . , vn} ⊆ N
eine Menge, die den Wert (value) dieser Stücke angibt, und seien W eine
Gewichts- und K eine Kostenschranke. Frage: Existiert eine Menge
I ⊆ {1, . . . , n} mit
i∈I wi ≤ W und
i∈I vi ≥ K; anders ausgedrückt:
kann ich einen Rucksack so beladen, daß ich einen bestimmten Mindestwert
mitbekomme?
PARTITION ≤ KNAPSACK, denn:
Sei R({a1, . . . , an} ) = X, Y, W, K mit wi = vi = 2ai für i = 1, . . . , n und
A
W = K = n i=1 ai.
Ist n i=1 ai ungerade, so gibt es keine Lösung für beide Probleme.
Ist n i=1 ai gerade, so gilt:
ai∈D
ai = 1
2
i=1
n
ai ⇔
wi =
vi =
i=1
i∈I
i∈I
i=1
n
ai =
2ai
mit I = {i|ai ∈ D}.
Das Rucksackproblem und auch das Partitionsproblem haben auf den ersten
Blick verblüffend einfache Lösungen.
Satz 5.3 Jeder Fall von KNAPSACK mit n Stücken und Gewichtsschranke
W kann in O(nW ) Schritten gelöst werden.
Beweis: Sei V (W, i) maximaler Wert, der erreicht werden kann mit Stücken
aus den ersten i Stücken, die genau auf Gewicht W aufsummiert werden.
⎧
⎫
⎨
⎬
V (W, i) = max vj
⎩ J
⊆ {1, . . . , i}, wj = W
⎭
j∈J
i=1
j∈J
i∈I

5 NP-VOLLSTÄNDIGE PROBLEME 59
Für i = 0 gilt: V (W, 0) = 0, J = ∅. Offenbar gilt für i ≥ 0:
V (W, i + 1) = max{V (W, i), vi+1 + V (W − wi+1, i)}
(Falls W − Wi+1 < 0, dann V (W, i + 1) = V (W, i))
Berechnung von Wertematrix V (W × (n + 1)-Matrix) ist in O(nW ). Der
vorliegende Fall hat genau dann eine Lösung ( ” Ja“-Antwort), wenn es j, i
gibt mit V (j, i) ≥ k. q.e.d.
Das heißt aber nicht, P = NP! nW ist keine polynomielle Funktion der
Eingabe!
Im allgemeinen ist die Eingabe von Knapsack beschrieben durch 2n + 2
Zahlen (w1, . . . , wn, v1, . . . , vn, W, K). Nun kann beispielsweise W so groß
sein, daß W die Länge der Eingabe bestimmt. Nimmt man als Eingabelänge
n log W und W = 2 n an, dann ist nW = n2 log W = w 2 keine polynomielle
Funktion der Eingabelänge. Sind aber alle Gewichte und Werte von Stücken
durch ein Polynom p(n) beschränkt, dann ist die Lösung tatsächlich polynomiell.
Solche Algorithmen heißen pseudopolynomielle Algorithmen. Gibt
es solche Algorithmen immer?
Bei Problemen wie SAT, CLIQUE, NODE COVER traten bisher nur Zahlen
als Indizes auf, die polynomiell beschränkt waren; d. h., daß hier die Zahlen
von vornherein klein waren.
Es gibt aber auch Probleme wie etwa TSP(D), wo die Zahlen exponentiell
groß sein können (relativ zur Anzahl der Städte). Trotzdem finden wir dort
(derzeit) keine pseudopolynomiellen Lösungen. Den Grund werden wir etwas
später sehen.
Falls ein Problem PROB NP-vollständig bleibt, wenn es nur auf Fälle F
beschränkt wird, bei denen alle Zahlen ≤ p(n) für Eingabelänge n sind,
dann ist PROB NP-vollständig im strengen Sinne. (Manchmal auch stark
NP-vollständig)
Mengenprobleme: Jetzt noch zu einigen Mengenproblemen.
Ein wichtiges Basisproblem ist 3D-MATCHING (Tripartites Matching,
3DM): Seien B, G, H Mengen mit |B| = |G| = |H| = n und T eine Relation
mit T ⊆ B × G × H. Frage: Gibt es ein dreidimensionales Matching T ′ ⊆ T ,
d. h. ein T ′ mit |T ′ | = n und ∀(b1, g1, h1), (b2, g2, h2) ∈ T ′ b1 = b2, g1 = g2
und h1 = h2?
Man kann zeigen: 3SAT ≤ 3DM.
Folgende Probleme hängen mit 3DM eng zusammen:
SET COVERING: Sei F = {S1, S2, . . . , Sn}, Si ⊆ U und B ∈ N. Frage:
Gibt es eine Menge von höchstens B Mengen in F , deren Vereinigung gerade
U ist?

6 CONP 60
EXACT COVER BY 3-SETS: Seien F = {S1, . . . , Sn}, Si ∈ U, |Si| =
3, |U| = 3m. Frage: Gibt es m disjunkte Mengen in F , deren Vereinigung U
ist?
Sofort ist einsichtig, daß
3DM 1.
≤ EXACT COVER BY 3-SETS 2.
≤ SET COVERING
1. 3DM ist Spezialfall von EXACT COVER BY 3-SETS: U = B ∪ G ∪
H, (b, g, h) ∈ T entspricht {b, g, h} ∈ F und T ′ entspricht exakter
Überdeckung F ′ .
2. EXACT COVER BY 3-SETS ist Spezialfall von SET COVERING
(Schranke m).
5.4 Weitere NP-vollständige Probleme
1. HAMILTON PATH (HP): Sei G = (V, E) ein Graph. Frage: Gibt
es einen Weg c1, . . . , cn, cj ∈ V = {1, . . . , n} durch alle Knoten mit
[cj, cj+1] ∈ E, j = 1, . . . , n − 1?
2. TSP(D): HP ≤ TSP (D), denn:
Sei G = (V, E) ein
Fall aus HP. R(G) = C, (dij), B mit C = V, B =
1 falls [i, j] ∈ E
n + 1 und dij =
. G hat Hamilton’schen Weg
2 sonst
genau dann, wenn es eine Tour durch alle Städte mit Länge ≤ n + 1
gibt.
Alle Zahlen sind in der Reduktion polynomiell beschränkt, d. h., TSP
(D) ist stark NP-vollständig!
3. INTEGER PROGRAMMING: Sei A ganzzahlige m × n-Matrix, D
ein m-stelliger Vektor. Frage: Gibt es einen ganzzahligen n-stelligen
Vektor X mit AX ≤ D?
SET COVERING ≤ INTEGER PROGRAMMING
6 coNP
6.1 NP und coNP
Für die Frage, ob ein Problem (oder eine Sprache) in NP liegt, ist in dieser
Vorlesung oft so argumentiert worden:
Sei Φ ein Boole’scher Ausdruck und Fall von SAT. Rate Belegung und teste.
Gibt es ein Zertifikat oder Zeugen, daß Φ wahr werden kann? Falls Φ wahr
ist, gibt es immer einen derartigen Zeugen.
Dies gilt für Probleme in NP allgemein.

6 CONP 61
Definition 6.1 Sei R ⊆ Σ ∗ × Σ ∗ eine binäre Relation auf Wörtern.
R heißt polynomiell entscheidbar ⇔ ∃ deterministische Turing-Maschine,
die die Sprache {x; y|(x, y) ∈ R} in polynomieller Zeit entscheidet.
R heißt polynomiell balanciert ⇔ ∃k ∀(x, y) ∈ R gilt |y| ≤ |x| k .
Theorem 6.1 Sei L ⊆ Σ ∗ . L ∈ NP ⇔ Es gibt eine polynomiell entscheidbare
und polynomiell balancierte Relation R derart, daß
L = {x|∃y ∈ Σ ∗ mit (x, y) ∈ R}
Beweis:
” ⇐“: Falls R existiert, dann wird L von folgender nichtdeterministischer
Turing-Maschine M entschieden:
Für Eingabe x rät M ein y (erzeugt nichtdeterministisch ein y) mit |y| ≤ |x| k .
Für das Wort x; y wird dann die deterministische Turing-Maschine für R benutzt,
um zu testen, ob (x, y) ∈ R. M akzeptiert, falls (x, y) ∈ R, und weist
zurück, falls (x, y) ∈ R. Das heißt, M akzeptiert x in nichtdeterministisch
polynomieller Zeit genau dann, wenn x ∈ L.
” ⇒“: Sei L ∈ NP. Das heißt, es existiert eine nichtdeterministische Turing-
Maschine N, die L in Zeit |x| k für ein k entscheidet. Definiere R wie folgt:
(x, y) ∈ R ⇔ y ist eine Kodierung einer akzeptierenden Berechnung von N
bei Eingabe x. (Dies kann z. B. die Aneinanderreihung aller Konfigurationen
y = C0, C1, . . . , C” yes“
für ein i ≤ |x| k einer akzeptierenden Berechnung sein.
i
Jedes |Ci| ∈ O(|x| k ), also y ∈ O(|x| k · |x| k ) = O(|x| 2k )).
R ist polynomiell balanciert, da y ≤ c|x| 2k . R ist auch polynomiell entscheidbar,
da in linearer Zeit (in Bezug auf das Wort x; y) getestet werden kann,
ob y tatsächlich eine akzeptierende Berechnung von x beschreibt. Da N L
entscheidet, gilt L = {x|(x, y) ∈ R} q.e.d.
Bemerkung: y wird dabei auch Zertifikat, Zeuge oder auch Testwort genannt.
Es gibt immer einen derartigen Zeugen, falls x ∈ L, d. h., falls die
Antwort für unser Entscheidungsproblem ” yes“ lautet.
In coNP sind gerade die Probleme, für die es negative Zertifikate gibt, die
bezeugen, daß ein Fall nicht dazugehört bzw. die Antwort ” no“ hat. Das
heißt, im Fall der negativen Antwort gibt es immer ein kurzes (polynomielles)
Zertifikat.
Beispiele:
1. co-HAMILTON PATH (coHP): Sei G = (V, E) ein Graph. Frage: Hat
G keinen Hamilton’schen Weg?
Für G ∈ LcoHP ist es schwierig, ein Zertifikat zu finden. Aber für
G ∈ LcoHP (d. h. G ∈ LHP) hat man ein Zertifikat, das leicht zu testen
ist: rate Pfad v1, . . . , vn und teste.

6 CONP 62
2. VALIDITY (Allgemeingültigkeit): Sei Φ ein Boole’scher Ausdruck.
Frage: Ist Φ allgemeingültig, d. h., ist Φ wahr für alle Belegungen?
Antwort ” yes“. Welches Zertifikat soll man angeben?
Antwort ” no“: Rate Belegung T und teste, ob T (φ) = false.
VALIDITY und coSAT hängen eng zusammen:
Das heißt:
Φ ist allgemeingültig ⇔ ¬Φ ∈ LcoSAT
Φ ∈ LVALIDITY ⇔ Für alle Belegungen T gilt: T (¬Φ) = false
Zur Erinnerung: coNP = { ¯ L|L ∈ NP} und natürlich ¯ L = Σ ∗ \L, NP =
{L| ¯ L ∈ coNP}.
Satz 6.1 Eine Sprache L ist NP-vollständig ⇔ ¯ L = Σ ∗ \L ist coNPvollständig.
Beweis: Sei L NP-vollständig, d. h. ∀M ∈ NP gilt: ∃R Reduktion mit
∀x ∈ Σ ∗ : (x ∈ M ⇔ R(x) ∈ L)
∀x ∈ Σ ∗ : (x ∈ M ⇔ R(x) ∈ L)
∀x ∈ Σ ∗ : (x ∈ ¯ M ⇔ R(x) ∈ ¯ L)
Das heißt, ∀ ¯ M ∈ coNP gilt: ∃R mit ∀x ∈ Σ ∗ x ∈ ¯ M ⇔ R(x) ∈ ¯ L, d. h., ¯ L
ist coNP-vollständig. q.e.d.
Gilt nun NP = coNP? Diese Frage ist noch offen! Falls P = NP, gilt NP =
coNP. Falls NP = coNP, folgt für die P-NP-Frage ersteinmal nichts.
Satz 6.2 Falls L coNP-vollständig und L ∈ NP, gilt coNP = NP.
Beweis: Sei M ∈ coNP. Dann existiert eine Reduktion von M auf L. Wegen
L ∈ NP folgt: M ∈ NP, also coNP ⊆ NP. Entsprechend gilt wegen Satz 6.1
und ¯ L ∈ coNP für alle M ∈ NP: M ≤ ¯ L ∈ coNP, womit NP ⊆ coNP folgt.
q.e.d.
Wir wissen: P ⊆ NP ∩ coNP. Wir wissen nicht: NP = coNP?
6.2 Primzahlen
Problem PRIMES: Sei n ∈ N. Frage: Ist n Primzahl? PRIMES ist in coNP.
Man findet leicht ein negatives Zertifikat n ∈ LPRIMES: Rate Teiler und
teste.
Problem coPRIMES (Composite Numbers): Sei n ∈ N. Frage: Gibt es a, b ∈
N, 1 < a, b < n mit ab = n? coPRIMES ist in NP.

6 CONP 63
Satz 6.3 (Fermat) Sei p eine beliebige ungerade Zahl ∈ N.
p ist prim ⇔
∃r, 1 < r < p mit
1. r p−1 = 1 mod p
2. r p−1
q = 1 mod p für alle Primzahlen q, die p − 1 teilen
Theorem 6.2 (Pratt) PRIMES ∈ NP ∩ coNP.
Beweis: Zu zeigen bleibt: PRIMES ∈ NP.
Mit dem Satz von Fermat (Satz 6.3) können wir ein Zertifikat raten:
Schritt 1: Rate r und teste, ob r p−1 = 1 mod p.
Schritt 2: Rate q1, . . . , qk, Primfaktoren von p−1. Teste, ob q1q2 . . . qk = p−1.
Teste für alle i = 1, . . . , k, ob qi prim. Das heißt, das Zertifikat wird rekursiv
aufgebaut: C(p) = (r; q1, C(q1), q2, C(q2), . . . , qk, C(qk))
Beispiel:
Länge von C(p):
C(67) = (2; 2, C(2), 3, C(3), 11, C(11))
C(11) = (8; 2, C(2), 5, C(5))
|C(p)| ≤ |r| +
C(5) = (3; 2, C(2), 2, C(2))
C(3) = (2, C(2))
C(2) = (1)
k
i=1
(|qi + C(qi)|) + 2k + 2
Trennzeichen, Klammern
Behauptung: |C(p)| ≤ 5 log 2 p.
Für p = 2 bzw. p = 3 ist die Behauptung klar: |C(2)| = |(1)| = 3
Weiterhin ist |r| ≤ log p, und für die Anzahl k der Teiler von p − 1 gilt
k < log p. Außerdem ist q1 = 2 und qi ≥ 2. Damit ist Πqi ≥ 2 k und
somit k < log p. Da Π k i=1 qi = p − 1, q1 = 2 und |qi| ≤ log qi + 1 gilt, folgt
k
i=1 |qi| ≤ 2 log p und k
i=2 log qi ≤ log p−1
2 .

6 CONP 64
Induktionsvoraussetzung: |C(qi)| ≤ 5 log 2 qi (da qi < p)
⇒
|C(p)| ≤ 5 log p + 2 + |C(2)| + 5
k
log qi ≤ log
i=2
= 5 log p + 5 + 5
p − 1
2
k
log 2 qi < (log p − 1) 2
i=2
k
i=2
< log p − 1
log 2 qi
k
i=2
log 2 qi
Also ist |C(p)| ≤ 5 log 2 p − 10 log p + 5 + 5 + 5 log p = 5 log 2 p + 10 − 5 log p.
≤0 für p≥5
Behauptung: C(p) kann in polynomieller Zeit getestet werden.
Sei l = ⌈log p⌉. Berechne die Residuen r2 = rr, r4 = r2r2 , . . . , r2l =
r2l−1r2l−1 (alle modulo p, da sonst die Zahlen zu groß würden). Es werden
jeweils l Multiplikationen mit Zahlen der Länge ≤ l benötigt, Kosten
jeweils O(l2 ). Maximal l Multiplikationen und Residuenbildungen werden
für rx O(l
mod p, 1 ≤ x ≤ p − 1 und beliebiges x gebraucht. Insgesamt also
3 ).
Das heißt, für r p−1 mod p und r p−1
q i mod p wird insgesamt O(l 4 ) Zeit
benötigt, etwa c log 4 p.
Behauptung: T (C(p)) ≤ c log 5 p.
Beweis durch Induktion:
T (C(p)) ≤
Schritt 1
c log 4 Schritt 2
k
p + T (C(qi))
≤ c log 4 p + c
i=1
k
i=1
log 5 qi
≤ c log 4
k
p + c(log p − 1) log qi
Es ist log qi ≤ log p−1
2 < log p − 1 und log qi ≤ log(p − 1) ≤ log p.
Daher gilt:
i=1
T (C(p)) ≤ c log 4 p + c(log p − 1) log 4 p
= c log 5 p − c log 4 p + c log 4 p
= c log 5 p
4
q.e.d.

7 SCHLUSSBETRACHTUNGEN 65
Bemerkungen:
• Falls PRIMES NP-vollständig wäre, hätte man somit NP = coNP als
Ergebnis!
• Teststring, Zertifikat hier von polynomieller Länge (bisher meist linear,
hier quadratisch in Bezug auf den Input).
Was passiert, wenn man schon weiß, daß die zu testende Zahl von bestimmter
Form ist? Etwa eine Mersenne’sche Primzahl, also z = 2 p − 1 für eine
Primzahl p. Man weiß, daß z von dieser Form sehr oft keine Primzahl ergibt.
Wir können hier aber einen schnellen Test machen.
Satz 6.4 (Lucas) Sei p eine Primzahl. Es gilt:
Mp = 2 p − 1 ist prim ⇔ up = 0 mod Mp
Dabei ist u2 = 4 und ui+1 = u2 i − 2.
Lucas Test für Mersenne’sche Primzahlen:
begin u := 4
for i = 3 to p do
u := (u * u - 2) mod Mp
if u = 0 mod Mp then ’Mp ist prim’
else ’Mp ist nicht prim’
end
Komplexität: O(p 3 ).
Bemerkung: Berechnung von a mod Mp geht besonders leicht, da Mp =
p−1
i=0 2i .
7 Schlußbetrachtungen
7.1 P gegen NP
Wir haben gesehen, daß es nützlich ist, Probleme als NP-vollständig zu
klassifizieren. Die Aussage ist: Falls ein Problem NP-vollständig ist, dann
kennen wir keinen polynomiellen Lösungsalgorithmus (und wir wissen nicht,
ob überhaupt einer existieren kann!). Wie verläuft nun die Trennlinie in NP?
Theorem 7.1 Falls P = NP, dann gibt es eine Sprache L ∈ NP mit L ∈
P und L ist nicht NP-vollständig.
Beweis: Papadimitriou Seite 330-332.

7 SCHLUSSBETRACHTUNGEN 66
coNP NP
✬
✬
✩
coNPvollständig
• PRIMES
NPvollständig
✫
• Validity
P-vollständig
• CIRCUIT
VALUE
✫
✪
• SAT
• TSP (D)
• GRAPH
ISOMORPHIE
✩
✪
GRAPH ISOMORPHIE ist ein wichtiges Problem, das bisher nicht so
gut eingeordnet werden konnte (wichtig für Logik-Überprüfung beim Chip-
Entwurf): Gegeben seien zwei Graphen G1 = (V1, E1) und G2 = (V2, E2).
Frage: Sind G1 und G2 isomorph?
Anders formuliert: Existiert eine Funktion f : V1 1−1
→ V2, bei der für alle
v1, u1 ∈ V1 gilt:
[v1, u1] ∈ E1 ⇔ [f(v1), f(u1)] ∈ E2
7.2 Orakel
Gibt es Welten, in denen man die Frage P = NP leichter beantworten kann?
Vorstellung: Ein Algorithmus arbeitet an einem Problem, weiß an einer Stelle
nicht so recht weiter, der Fortgang hängt davon ab, ob ein boole’scher
Ausdruck erfüllbar ist oder nicht.
Die Antwort darauf wird unmittelbar gegeben. Ein ” freundliches“ Orakel
löst uns SAT sofort.
Definition 7.1 Eine Turing-Maschine M mit Orakelmenge A ist eine
Mehrband-Turing-Maschine mit einem speziellen Frageband und speziellen
Zuständen q? – Fragezustand, q ” yes“ und q ” no“ – Antwortzustände.
q? geht über entweder in q ” yes“, falls das Wort auf dem Frageband in A liegt,
oder in q ” no“, falls das Fragewort nicht in A liegt.
Turing-Maschine M A
⊲ x1 . . .
♦
✎
a1 . . .
ak
⊲
✲
⊲
. . .
. . .
⊲ . . .
Fragewort (∈ A → q ” yes“, ∈ A → q ” no“)

7 SCHLUSSBETRACHTUNGEN 67
Die Komplexität ist genauso definiert wie bei Klassen ohne Orakel (deterministisch
und nicht-deterministisch). Unrealistisch ist allerdings, daß jede
Frage aus dem Orakel als nur ein Schritt zählt.
Definition 7.2 Sei C eine deterministische oder nichtdeterministische
Komplexitätsklasse. Dann ist C A die Klasse von Sprachen, die durch Maschinen
desselben Typs wie für C akzeptiert wird, aber versehen mit einem
Orakel A.
Theorem 7.2 Es gibt Orakel A und B mit
1. P A = NP A
2. P B = NP B
Beweis:
1. Sei A eine PSPACE-vollständige Sprache. Dann gilt:
PSPACE a b c
A A
⊆ P ⊆ NP ⊆ NPSPACE d
⊆ PSPACE, also P A = NP A
(a) Sei L ∈ PSPACE. Man nehme eine deterministische Turing-Maschine,
die L auf A in polynomieller Zeit reduziert, und stelle
dann die Frage aus Orakel A genau einmal.
(b) Trivial (da jede deterministische Turing-Maschine auch nichtdeterministische
Turing-Maschine)
(c) Jede nichtdeterministische Turing-Maschine M mit Orakel A, die
in polynomieller Zeit arbeitet, kann durch eine nichtdeterministische
Turing-Maschine M ′ mit polynomiellem Platz, die auch A
selbst beantwort, simuliert werden.
(d) Satz von Savitch
2. Papadimitriou S. 340 bis 342
7.3 PSPACE
Wie sehen nun ” natürliche“ vollständige Probleme in PSPACE aus?
QBF (quantifizierte Boole’sche Formel): Sei E =
Q1x1Q2x2 . . . Qmxm eine Boole’sche Formel mit Φ(x1, . . . , xm) – Boole’scher
Ausdruck und Qi ∈ {∃, ∀}. Frage: Ist E wahr?
QBF (auch QSAT, quanitifisiertes SAT ) ist PSPACE-vollständig.
WORT-CS: Sei G eine kontextsensitive Grammatik und w ein Wort ∈ Σ ∗ .
Frage: Ist w ∈ L(G)?
WORT-CS ist PSPACE-vollständig.

7 SCHLUSSBETRACHTUNGEN 68
Kontextsensitive Sprachen: L(G) = L(M) mit M nichtdeterministische
Turing-Maschine mit Platz O(n) (linear beschränkte Turing-Maschine.
Sei L ∈ PSPACE, d. h. es existiert eine Turing-Maschine N, die L in p(n)
Platz akzeptiert, d. h. w ∈ L wird in p(|w|) Platz entschieden.
Trick: Padding. Jedes Wort w ∈ Σ ∗ wird mit Reduktion R (log space) zu
einem Wort R(w) = w# . . . # mit |R(w)| = p(|w|) aufgeblasen. # sind
hierbei Sondersymbole, Pseudoblanks. Das Wort R(w) wird nun in linearem
Platz entschieden.
Viele verallgemeinerte Spiele wie GO sind auch PSPACE schwer!
7.4 Parallele Komplexitätsklassen
Ein Modell für Parallelität, das schon in diesem Skript aufgetreten ist: Familie
von (Boole’schen) Schaltkreisen C = (C0, C1, . . . ), Ci mit i Inputgates.
Betrachtet werden nur uniforme Familien von Schaltkreisen: Es existiert
Turing-Maschine mit logarithmischen Platz, die für jede Eingabe 1 n die
Ausgabe Cn produziert. (Intuitiv: eine uniforme Familie von Schaltkreisen
entspricht der gleichen algorithmischen Idee). Sie dient dazu, unsinnige Konstruktionen
zu vermeiden (auch platzkonstruierbar).
Parallele Komplexität:
Definition 7.3 (Größe und Tiefe eines Schaltkreises) Sei C ein
Schaltkreis. Dann ist depth(C) die Länge des längsten Weges in C (genannt
Tiefe von C) und size(C) die Anzahl der Gatter von C (genannt Größe von
C).
Definition 7.4 Sei C = (C0, C1, . . . ) eine uniforme Familie von Schaltkreisen,
f, g : N → N Funktionen. Die parallele Zeit von C ist kleiner oder
gleich f(n), falls für alle n die Tiefe von Cn kleiner oder gleich f(n) ist,
falls also gilt:
∀n ∈ N depth(Cn) ≤ f(n).
Die Gesamtarbeit von C ist kleiner oder gleich g(n), falls für alle n die
Größe von Cn kleiner oder gleich groß ist, falls also gilt:
∀n ∈ N size(Cn) ≤ g(n).
Definition 7.5 Seien f, g : N → N Funktionen und L eine Sprache. Es
gilt:
L ∈ PT/WK(f(n), g(n)) ⇔
Es existiert eine uniforme Schaltkreisfamilie C, die L in paralleler Zeit
O(f(n)) und mit O(g(n)) Arbeit entscheidet.
Man kann zeigen: REACHABILITY ∈ PT/WK (log 2 n, n 3 log n).

7 SCHLUSSBETRACHTUNGEN 69
Weitere Klassen: NC (NICK’S CLASS), NCj = ∞ k=1 PT/WK
(log j n, nk ) (polynomielle Arbeit, parallele Zeit O(log 3 n)). NC = ∞ j=1 NCj.
NC sieht man heute vom komplexitätstheoretischen Ansatz her als die Klasse
an, in der Probleme stecken, die mit vernünftigem Hardwareaufwand schnell
zu lösen sind.
Theorem 7.3 NC1 ⊆ L ⊆ NL ⊆ NC2 ⊆ NC ⊆ P
Man weiß derzeit nicht, ob irgendein echtes Enthaltensein vorliegt!
P-vollständige Probleme, wie CIRCUIT VALUE, sind diejenigen Kandidaten,
die am ehesten nicht in NC liegen. Man spricht dann auch von inhärent
sequentiellen Problemen.
Was weiß man: REACHABILITY und 2SAT sind NL-vollständig.
RLP
✠
P-vollständig
P
NC
NC2
NL
L
NC1
P-vollständig: MAXFLOW(D), LINEAR PROGRAMMING (RLP)
Ellipsoidmethode (Khachiyan, 70): A ∈ Z m×n , B ∈ Z m ∃Y ∈ Q n mit AY ≤
B?
Literaturliste
Bücher zur Vorlesung Komplexitätstheorie:
• Papadimitriou, Christos H., Computational Complexity, Addison-
Wesley Publishing Company, 1994
• Garey, M. R., Johnson, D. S., Computers and Intractabilty, A Guide
to the Theory of NP-Completeness, Freeman and Company, 1979
• Hopcroft, Ullman, Einführung in die Automatentheorie, Formale Sprachen
und Komplexitätstheorie, 3. Auflage 1994
• Reischuk, Karl Rüdiger, Einführung in die Komplexitätstheorie, Teubner,
1990

Index
Übergangsfunktion, 11, 15
Adjazenzmatrix, 3
akzeptieren, 14, 24
Algorithmus, 2
pseudopolynomiell, 59
aufzählbar
rekursiv, 14
balanciert
polynomiell, 61
berechenbar
rekursiv, 14
berechnen, 14
Bipartites Matching, 9, 10
Boole’scher Schaltkreis, 43
Boolean Circuit, 43
Breitensuche (breadth-first), 3
CIRCUIT SAT, 44
CIRCUIT VALUE, 44, 47, 50, 69
CLIQUE, 54, 55
co-HAMILTON PATH, 61
coHP, 61
coNP, 60, 62
coPRIMES, 62
coSAT, 62
CS, 39
entscheidbar
polynomiell, 61
rekursiv, 14
entscheiden, 14, 24
Entscheidungsproblem, 2, 7, 14
EXACT COVER BY 3-SETS, 60
EXP, 28, 32
Fall, 1
Familie, 68
Fermat, Satz von, 63
Gesamtarbeit, 68
Graph, 1, 3
70
GRAPH ISOMORPHIE, 66
Haltesprache, 29–31
HAMILTON PATH, 41, 60
Heiratsproblem, 9
Hierachie-Theorem, 32, 33
HP, 41, 60
Immerman, Szelepscényi, Theorem
von, 37, 38
INDEPENDENT SET, 53
INDSET, 53
Instanz, 1
INTEGER PROGRAMMING, 60
KNAPSACK, 58
Kodierung, 15
Komplement, 28
Komplexitätsklasse, 16
Konfiguration, 13, 15
L, 28, 35
Lucas, Satz von, 65
MATCHING, 9
3D-MATCHING, 59
MAXFLOW, 7–10
Modell, 68
NC, 69
Netzwerk, 5
NICK’S CLASS, 69
NL, 28, 35
NODE COVER, 55
NP, 24, 27, 34, 35, 60, 62
NPSPACE, 28
NSPACE, 27, 37, 39
NTIME, 24, 25, 27
O-Notation, 3
Optimierungsproblem, 7
P, 20, 24, 27, 32, 34, 35, 62

INDEX 71
P-NP-Frage, 10, 62, 66
Padding, 68
PARTITION, 57
PATH, 36
Platz, 21, 26
Platzhierachie, 32
polynomiell verwandt, 15
Pratt, Theorem von, 63
PRIMES, 62
PSPACE, 28, 35, 37, 67
QBF, 67
QSAT, 67
RAM, 2, 22, 26
REACHABILITY, 2, 8, 9, 14, 21,
26, 28, 35, 36
Reduktion, 9, 10, 40
Rucksackproblem, 58
SAT, 41, 43, 49, 60
2SAT, 51
3SAT, 51
MAX2SAT, 52
NAESAT, 53
quantifisiertes, 67
Savitch, Theorem von, 36
SET COVERING, 59
SPACE, 21, 27, 36, 37
SUM, 55
SUMME VON UNTERMEN-
GEN, 55
Tafelmethode, 46
Testwort, 61
Tiefe, 68
Tiefensuche (depth-first), 3
TIME, 16, 27
Transitive Hülle, 13
Traveling Salesman Problem, 10
TSP, 28, 60
Turing-Maschine, 2, 11, 13–15, 21,
23, 26, 29
k-Band, 15, 16, 21
mit Ein- und Ausgabe, 21
mit Orakelmenge, 66
nichtdeterministisch, 23, 24,
26
universell, 29
VALIDITY, 62
Vollständigkeit, 45
coNP-vollständig, 62
NP-vollständig, 49, 59, 62, 65
P-vollständig, 47
Wachstum
nicht polynomielles, 4
polynomielles, 4
Wahrheitsbelegung, 43
Wert, 6
worst case, 5
WORT-CS, 67
Zeit, 16
parallel, 68
Zeithierachie, 32
Zertifikat, 61
Zeuge, 61