Skript zur Vorlesung KomplexitÂ¨at von Algorithmen

Skript zur Vorlesung 

Komplexität von Algorithmen 

Jan Dörntlein 

19. Juli 2012 

Dieses Skript wurde auf Basis der Tafelanschriften (und zwar ohne jegliche 

Ergänzungen) der Vorlesung Komplexität von Algorithmen von Prof. Schröder an 

der FAU Erlangen erstellt. Es erhebt keinerlei Anspruch auf Vollständigkeit oder 

Korrektheit und dient nur dem Übungszweck. 

Literatur: Computability and Complexity, From a Programming Perspective, Neil 

D. Jones 

Inhaltsverzeichnis 

1 Komplexität 2 

1.1 Berechnungsmodell WHILE . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 

1.2 GOTO - ähnliche Modelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 

1.3 Die Turingmaschine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 

1.4 Successor Random Access Machine . . . . . . . . . . . . . . . . . . . . . . . 13 

1.5 Komplexitätsklassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 

2 Ein Hierarchiesatz 20 

2.1 Berechnungsmodell I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 

2.2 Selbstinterpretation von I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 

2.3 Zeitbeschränkte Selbstinterpretation . . . . . . . . . . . . . . . . . . . . . . . 22 

2.4 Die lineare Hierarchie für I . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 

1


3 Speicherplatz als Ressource 23 

3.1 In logspace berechenbare Funktionen . . . . . . . . . . . . . . . . . . . . . . 26 

3.2 Platzhierarchien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 

4 Nichtdeterminismus 28 

5 Die Backbone - Hierarchie 30 

6 Vollständigkeit 36 

6.1 PTIME - Vollständigkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 

6.2 NPTIME - Vollständigkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 

6.3 PSPACE - vollständigkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 

6.4 Quantifizierte Boolesche Formeln . . . . . . . . . . . . . . . . . . . . . . . . 48 

7 Parallel computation models 53 

2


1 Komplexität 

Einteilung der Komplexitätsklassen: 

L 

NL 

P 

NP — coNP 

PH 

PSPACE 

EXPTIME 

NEXPTIME — CONEXPTIME 

logarithmisch 

nicht deterministisch 

polynomzeit 

polynomielle Hierarchie 

polynomieller Speicher 

Beispiele für Probleme und deren Einteilung in diese Klassen: 

Problem Komplexität Algos. / Tools 

SAT NP SAT-Solver 

OWL-DL NEXPTIME Fact++, Racer 

PRIMES P Zufallsalgorithmen (Rubin) 

Lineare Optimierung P Simplex (EXPTIME) 

FOL (Logik erster Stufe) unentscheidbar / r.e. SPASS, Vampire 

HOL (Logik hoeherer Ordnung) nicht r.e. / nicht co-r.e. Isabelle: Blast, Leo2 

Algorithmus als Berechnungsmodell, wie z.B. TM, sRAM, CM, WHILE, GOTO. 

Alle diese Modelle können sich gegenseitig in Polynomzeit simulieren. 

1.1 Berechnungsmodell WHILE 

Daten : D ist eine Menge von binäre Bäumen, d,e ∈ D. d,e := a | (d.e) (d und e sind hier der 

linke und rechte Teilbaum). A sind alle atomaren, endlichen Werte. Es gilt: a ∈ A, nil ∈ A 

(nil steht hier für das leere Element, der Platzhalter). 

• Bsp.: ((a.(b.c)).(a.c) 

• oder: (a.(b.(c.(d.(a.nil))))) := (abcda). ”Liste als Baum”. 

Allgemein gilt: (d 1 ,d 2 ,...,d n ) := (d 1 .(d 2 .(d 3 .(...(d n .nil)...))), nil stellt hierbei die leere 

Liste dar. 

3


Def.: Die Listendarstellung d von d ∈ D (d als Datenelement) ist definiert durch: 

Mit nil: 

(d 1 .(d 2 .(d 3 .(...(d n .nil)...)) = (d 1 ,...d n ) 

Ohne nil: 

Bsp.: 

(d 1 .(d 2 .(d 3 .(...(d n .a)...)) = (d 1 ,...d n ,a) 

((a.(b.c).((b.b).c)) = ((a.(b.c))(b.b)c) = ((abc)(bb)c) 

Einschub, Kodierung von Atomen nur durch nils: 

a i = (f alse i) 

(d.e) = (true,de) 

Natürliche Zahlen: 

Booleans: 

0 = () 

n + 1 = (nil.n) 

n = (nil...nil) 

}{{} 

n−mal 

true = 1 = (nil) 

f alse = 0 = () = nil 

Formal: D ist die kleinste Menge X mit 

(i) A ⊆ X 

(ii) d,e ∈ X ⇒ (d.e) ∈ X 

Größe: |d| ist definiert durch: 

(iii) |a| = 1 

(iii) |(d.e)| = |d| + |e| 

Rekursion: Die Menge X, der d ∈ D für die |d| eindeutig erfüllt ist, erfüllt (i) und (ii), 

also ist D ⊆ X (also gilt X = D): 

Programme : bestehen aus einer Menge von Variablen, Vars (wie X,Y ,Z) und d,e,f ∈ D. 

4


Ausdrücke: 

E,F ::== X|d| cons EF| hd E| tl E| =?EF 

}{{} }{{} }{{} }{{} 

P unkt 

head 

tail 

V ergleich 

Anweisungen: 

C,D ::== X := E 

}{{} 

Zuweisung 

| C;D 

}{{} 

SequentielleKomposition 

|while E do C (E wird auf nil geprüft) 

Programme: Sei X eine Eingabevariable und Y eine Ausgabevariable. 

p ::== read X; C; write Y 

Mehrere Ein- / Ausgaben bekommt man über Baumstrukturen, beispielsweise Eingabe 

von d,e als (d.e). 

read X; Y := hd X; Z = tl X; C; write Y 

Scoping: per {} oder Einrücken 

Beispielprogramm: 

reverse = 

read X; 

Y := nil; 

while X do 

Y := cons (hd X) Y; 

X := tl X; 

write Y; 

Makros: Z,W seien hier ’frische’ Variablen, also Variablen, die bisher noch nicht aufgetaucht 

sind. 

if E then C = 

Z := E; 

while Z do { Z := false; C; } 

if E then C else D = 

W := true; 

5


if E then { W := false; C } 

if W then D; 

list E1...En = 

cons E1 (cons E2 ... (cons En nil) ... ) 

cons* E1...En = 

cons E1 (cons E2 .. (cons En-1 En) ... ) 

Bsp.: 

list a b (d a) = (a b (d a) ) 

cons* a b (d a) = (a b d a) 

Inline-Prozeduren: Für 

p = read X; C; write Y: 

Z := pW (Z,W ∈ V ars) in Programm q. 

Es wird ¯C aus C durch Umbennenen konstruiert: 

X → X ′ , Y → Z, X ′ sei frisch. 

Es müssen auch andere Var in C umbennant werden, damit sie frisch in q sind. Dann gilt 

Z := pW → X ′ = W ; ¯C. 

Übung: Ähnlich für Verwendung von p in komplexen Ausdrücken. 

Bsp. für eine Inline-Prozedur: 

append = 

read X; 

A := hd X; Y := tl X; 

B := reverse A; 

while B do 

Y := cons (hd B) Y; 

B := tl B; 

write Y; 

Im Vergleich hierzu jetzt die umbenannte Prozedur reverse; nur der Körper wird umbenannt: 

Y → B, X → X ′ . 

6


B := nil; 

while X’ do 

B := cons (hd X’) B; 

X’ := tl X’; 

Vorsicht: C geht bei einer Umbenennung von Y nach Z davon aus, dass Y mit nil initialisiert 

wurde. Besser ist es, wenn alle Variablen auf jeden fall frisch sind. 

Zahloperationen: 

succ = cons nil 

prec = tl 

add = 

read XY; X:= hd XY; Y:= tl XY; 

while X do 

Y := succ Y 

X := prec X 

write Y 

Formale Semantik: Vars(p) ist die Menge der in p vorkommenden Variablen. Ein Speicher 

für p ist eine Abbildung σ : V ars(p) → D. Store p ist die Menge der Speicher für p. 

Notation: [X 1 → d 1 ,...,X n → d n ] = Funktion σ mit σ(X 1 ) = d 1 ,...,σ(X n ) = d n 

⎧ 

⎪⎨ d v = X 

σ[X → d](v) = ⎪⎩ σ(v) sonst 

Für Vars p = X,Z 1 ,...,Z n , mit X als Eingabevariable: 

Anfangsspeicher (Initialspeicher) σ p 0 (d) = [X → d,Z 1 → nil,...,Z n → nil] 

Ausdrücke: Eσ ∈ D : 

• Xσ = σ(X) 

• dσ = d 

• consEFσ = (Eσ.Fσ) 

⎧ 

⎪⎨ dE = (d.e) 

• hdEσ = ⎪⎩ nil 

• tlEσ analog 

7


⎧ 

⎪⎨ true Eσ = Fσ 

• =?EFσ = ⎪⎩ f alse sonst 

Anweisungen: Anweisung C wird ausgeführt auf Speicher σ und terminiert bei σ ′ . 

C ⊢ σ → σ ′ 

Bsp.: 

X := d ⊢ [X → e,Y → f ] → [X → d,Y → f ] 

Diese Relation ⊢ → wird induktiv definiert (d.h. als kleinste unter folgenden Regeln 

abgeschlossene Relation). Bei folgenden Regeln gilt: oberhalb des Strichs steht die 

Prämisse, unterhalb die Konklusion. 

• Regel (:=) 

X := E ⊢ σ → σ[X → Eσ] 

• Regel (;) 

• Regel (w ⊥) 

• Regel (w⊺) 

C ⊢ σ → σ ′ D ⊢ σ ′ → σ ′′ 

C;D ⊢ σ → σ ′′ 

Eσ = nil 

while E do C ⊢ σ → σ 

Eσ nil C ⊢ σ → σ ′ while E do C ⊢ σ ′ → σ ′′ 

while E do C ⊢ σ → σ ′′ 

D.h. C ⊢ σ → σ ′ gilt genau dann, wenn dies mit den Regeln in endlich vielen Schritten 

herleitbar ist. 

Herleitung kann als Datenstruktur (Baum) aufgefasst werden → Induktion über Herleitung. 

Zeige: wenn P (h) für alle Herleitungen h gilt, die einfacher als h 1 sind, so gilt P (h 1 ), dann 

gilt P für alle Herleitungen. 

Lemma: Determinismus von WHILE. 

C ⊢ σ → σ 1 und C ⊢ σ → σ 2 ⇒ σ 1 = σ 2 

8


Beweis: Induktion über die Herleitung von C ⊢ σ → σ 1 . Anwendung von (w ⊥) und (w⊺). 

Y σ ′ =nil 

whileY do...⊢σ ′ →σ ′ 

Y σ nil Y :=nil⊢σ→σ ′ 

while Y do Y := nil ⊢ [Y → d] → [Y → nil] mit d nil 

(:=) ist klar, (w ⊥) ist klar. (;) ist einfacher als (w⊺). 

(w⊺): 

Eσ nilD ⊢ σ → σ 3 while E do D ⊢ σ 3 → σ 1 

while E do D ⊢ σ → σ 1 

Notwendigerweise haben wir folgende Regelanwendungen: 

Eσ nilD ⊢ σ → σ 4 while E do D ⊢ σ 4 → σ 2 

while E do D ⊢ σ → σ 2 

Nach Induktionsvorraussetzung für D ⊢ σ → σ 3 : σ 3 = σ 4 , 

damit nach Induktionsvorraussetzung für while E do D ⊢ σ 2 → σ 1 : σ 1 = σ 2 . 

Beispiel zum Zeigen von Zustandsübergängen: 

(nil.nil) nil Y := Y ⊢ σ → σ w(nil.nil)do...⊢σ→σ ′ 

while(nil.nil)doY := Y ⊢ σ → σ ′ ? 

⇒ offensichtlich unendliche Herleitung (unter den Strichen steht dasselbe). 

Programme: p : D → D ⊥ = D ∪ {⊥} wobei ⊥= undefiniert 

⎧ 

⎪⎨ e falls C ⊢ σ0 P (d) → σ,σ(Y ) = e 

read X; C; write Y (d) = ⎪⎩ ⊥ sonst 

⇒ Wohldefniert nach obigem Lemma (Determinismus). 

Bemerkungen: =? ist programmierbar, wenn man in der Lage ist, Atome zu vergleichen (also 

mithilfe atomarer Gleichheit =? A ) und ohne atomare Gleichheit programmierbar, wenn 

A = {nil} (dann gibt es nichts zu vergleichen). 

Pattern: Term mit Variablen über die Sprache der Bäume: pat ::= X|a| (pat 1 .pat 2 ) 

Verwendung z.B. beim case: case E of pat 1 ⇒ C 1 |...|pat n ⇒ C n 

9


Beispiel: 

swap: 

read X; 

case X of nil => Z := nil; 

write Z; 

bzw. 

swap: 

read X; 

case X of (W.Y) => Z := (Y.W); 

write Z; 

Informell: Matchen von d ∈ D (mit d = Eσ) auf pat i bindet die Var in pat i auf die 

entsprechenden Teilbäume von d. 

case ist ein Makro für geschachtelte ifs; der Zugriff auf Var geschieht per hd oder tl. 

rewrite rules: rewrite [X 1 ,...,X n ] by rule 1 ,...,rule k mit 

rule ::= [pat 1 ,...,pat n ] ⇒ [E 1 ,...,E n ]| [pat 1 ,...,pat n ] ⇒ C 

entspricht case auf n-Tupeln, [E 1 ,...,E n ] → [X 1 ,...,X n ] := [E 1 ,...,E n ] 

Matching: 

Beispiel: 

Substitution = Abb. τ : V ars(E) → D 

patτ ∈ D 

d matcht pat ⇔ ∃τ,patτ = d 

pat = ((X.nil).Y ) 

d = (((a.b).nil).(a.(c.d))) matcht pat per Y → (a.(c.d)) und X → (a.b) 

d = (a.b) matcht nicht 

Beispiel: =? für A = nil 

(Vollständige Version des Programms findet sich im Buch). 

10


=?: 

read X; 

D := hd X; 

E := tl X; 

GO := true; 

Y := false; 

while GO do 

rewrite [D,E] by 

[((D1.D2).D3), ((E1.E2).E3)] => 

[(D1.(D2.D3)), (E1.(E2.(E3))] 

[(nil.D2), (nil.E2)] => 

[D2, E2] 

[nil, nil] => 

GO := false; Y := true; 

[((D1.D2).D3), (nil.E2)] => 

GO := false; 

... 

write Y; 

Programme als Daten: 

A = {:=,;,while,var,quote,cons,hd,tl,=?,nil,prog} 

· ∈ D def. für Programme / Anweisungen / Ausdrücke. 

readV i ;C;writeV j = (prog V i C V j) 

C;D = (;C D) while E do C = (while EC) 

V i := E = (:= V i E) V i = (var i) 

d = (quote d) cons EF = (cons EF)... 

1.2 GOTO - ähnliche Modelle 

L ∈ {GOT O,T M,RAM}: Gemeinsame Notation und Semantik. 

p ∈ L − P rog., p = I 1 ,...,I n oder 1 : I 1 ,...,m : I m , m + 1 

}{{} 

Ende des Programms 

: 

11


Zustände: s = ( 

l , σ ) 

}{{} }{{} 

Label l∈{1,...,m+1} Speicher σ∈L−Store p 

p ⊢ s → s ′ p geht in einem Schritt von s nach s’ . Einschritttransition. 

p ⊢ s → ∗ s ′ p geht in n ≥ 0 Schritten von s nach s’ . 

p(x) = y(x,y ∈ L − Data, p terminiert bei Eingabe x mit Ausgabe y.) 

Modellabhängig: 

• Readin: L − Data → L − Store p 

• Readout: L − Store p → L − Data 

Damit: p(x) = y ⇔ ∃σ ∈ L − Store p : p ⊢ (1,Readin(x)) → ∗ (m + 1,σ)&Readout(y) = y 

(⇒ d.h. p =⊥ , wenn p bei Eingabe x nicht terminiert) 

GOTO - Berechnungsmodell : 

Def. 1.1: GOTO - Syntax. 

• GOTO-Data = D mit A = nil 

• Instruktionen: I := X := nil|X := Y |X := hdY |X := tlY |X := consY Z 

• Kontrollstruktur: [if X] goto l 1 [else l 2 ] mit l 1 ,l 2 ∈ {1,...,m + 1} 

z.B. reverse: 

1. Y := nil; 

2. if X goto 3 else 7; 

3. Z := hd X; 

4. Y := cons ZY; 

5. X := tl X; 

6. goto 2; 

7. X := Y; 

Def. 1.2: GOTO - Semantik. 

12


• Sei p = I 1 ,...,I m ,V ars(p) = {X,Z 1 ,...,Z n } mit X als Ein-/Ausgabevariable. 

• GOTO-Store p = V ars(p) → D 

• Readin(d) = [X → d,Z 1 → nil,...,Z n → nil] 

• Readout(σ) = σ(X) 

Transitionen: 

1.3 Die Turingmaschine 

I l = (X := nil) : p ⊢ (l,σ) → (l + 1,σ[X → nil]) 

I l = (X := Y ) : p ⊢ (l,σ) → (l + 1,σ[X → Y ]) 

I l = (X := consY Z) : p ⊢ (l,σ) → (l + 1,σ[X → (σ(Y ).σ(Z))]) 

... 

⎧ 

⎪⎨ σ(X) nil : p ⊢ (l,σ) → (l 

I l = (if X goto l 1 else l 2 ) : 

1 ,σ) 

⎪⎩ σ(X) = nil : p ⊢ (l,σ) → (l 2 ,σ) 

Def. 1.3: k ist die Anzahl der Bänder. Σ = {0,1,B}, das gesamte Alphabet. 

T M K -Data = {0,1} ∗ 

T M K -Store = {(L 1 S 1 R 1 ,...,L k S k R k )} mit L i ,R i ∈ Σ ∗ ,S i ∈ Σ. 

L i S i R i repräsentiert das Band, S i ist die Position des Lese-/Schreibkopfes. 

Instruktionen : 

j ist die Bandnummer. Hier gibt es Labels anstatt von Zuständen. 

I ::== right j | lef t j | write j S | if j S goto l 1 else l 2 

Readin(x) = {Bx,B,...,B} 

Readout(L 1 S 1 R 1 ,...,L k S k R k ) = P f x(R 1 ) 

}{{} 

Symbole vor erstem B 

⎧ 

⎪⎨ S P f x(R ′ ) falls R = SR ′ ,S B 

d.h. P f x(R) = ⎪⎩ () sonst 

Transitionen (für k=1) : 

I l = right : p ⊢ (l,LSS ′ R) → (l + 1,LSS ′ R) 

I l = right : p ⊢ (l,LS) → (l + 1,LSB) 

I l = lef t : analog 

(später R k ) 

13


I l = write S : p ⊢ (l,LS ′ R) → 

⎧ 

(l + 1,LSR) 

⎪⎨ p ⊢ (l,LSR) → (l 

I l = (if S goto l 1 else l 2 ) : 

1 ,LSR) 

⎪⎩ p ⊢ (l,LS ′ R) → (l 2 ,LS ′ R) 

Bsp. 1.4: Band 1 nach Band 2 kopieren. 

0. write 1 

1. if1 0 goto 2 else 4 

2. write2 0 

3. goto 6 

4. if1 1 goto 5 else 9 

5. write2 1 

6. right2 

7. right1 

8. goto 1 

9. 

1.4 Successor Random Access Machine 

Successor: alle gegebenen Zahloperationen sind das Inkrement und das Dekrement. 

Instruktionen : 

I ::== X i := X i + 1 | X i := X i − 1 | if X i = 0 goto l 1 else l 2 | 

| X i := X j | X i := 〈X j 〉 | 〈X i 〉 := X j 

}{{} 

indirekte Zuweisung 

SRAM-Store: N → N 

Readin(x) = [0 ⊢ x,1 ⊢ 0,...] 

Readout(σ) = σ(0) 

Transitionen : 

I = (X i := 〈X j 〉) : p ⊢ (l,σ) → (l + 1,σ[i → σ(σ(j))]) 

I = (〈X i 〉 = X j ) : p ⊢ (l,σ) → (l + 1,σ[σ(i) → σ(j)]) 

14


1.5 Komplexitätsklassen 

Zeitkomplexität : 

Def. Zeitverbrauch/Laufzeit: GOTO - ähnliche Sprachen: p = I 1 ,...,I m . 

⎧ 

⎪⎨ t wenn p ⊢ (1,Readin(d)) = s 

time p (d) = 

1 → s 2 → ... → s t = (m + 1,σ) 

⎪⎩ ⊥ sonst 

⇒ ”Kleinschrittig” 

Einheitskostenmodell (unit cost model): Für jede Zuweisung wird eine Kosteneinheit 

fällig. 

• WHILE: T Eσ = Größe von E. 

C ⊢ time σ → t wird induktiv definiert durch 

Zeitklassen : 

X := E ⊢ time σ → T Eσ + 1 

C ⊢ time σ → t C ⊢ σ → σ ′ D ⊢ time σ ′ → t ′ 

C;D ⊢ time σ → t + t ′ 

Eσ = nil 

while E do C ⊢ time σ → T Eσ + 1 

Eσ nil C;while E do C ⊢ time σ → t 

while E do C ⊢ time σ → T Eσ + t 

Def. 1.6: Ein Problem ist eine Menge A ⊆ {0,1} ∗ → kodierbar in alle Datenmodelle. 

⎧ 

⎪⎨ true wenn d ∈ A (d ist ein Bitstring) 

p entscheidet A, falls p(d) = ⎪⎩ f alse sonst 

Bsp. 1.7: 

• SAT = {d aussagenlogische Formel|dist erfüllbar} 

• P RIMES = {n ∈ N|n prim} 

• HALT = {(p,d)| p(d) ⊥} 

Bei der Konversion in Bitstrings muss man beim Problem P RIMES aufpassen. 

Def. 1.8: Sei f : N → N L time(f (n)) = {p ∈ L − P rog| time p (d) ≤ f (|d|)∀d ∈ {0,1} ∗ } 

L ptime = ⋃ f P olynom Ltime(f (n)) 15


Def. 1.9: 

• T IME L (f (n)) = {A ⊆ {0,1} ∗ |A wird von einem p ∈ L time(f (n)) entschieden} 

• P T IME L = {A ⊆ {0,1} ∗ | A wird von einem p ∈ L ptime entschieden} 

Robustheit: zu Zeigen ist, dass alle Berechnungsmodelle in P T IME liegen. 

Def. 1.10: Für Berechnungsmodelle L,M L ≺ ptime M (L ptime-reduzierbar auf M) ⇔ 

∀p ∈ L − P rog ∃q ∈ M − P rog,f P olynom 

p = q ∧ ∀d ∈ {0,1} ∗ , time q (d) ≤ f (time p (d)) 

Lemma 1.11: 

(a) L ≺ ptime M ⇒ P T IME L ⊆ P T IME M 

(b) L ≼ ptime M ∧ M ≼ ptime ⇒ P T IME L = P T IME M (der Operator ≼ ptime ist transitiv!) 

DER PLAN: Zeige: T M ≼ GOT O ≼ SRAM ≼ T M und GOT O ≼ W HILE ≼ GOT O ⇒ 

Proposition 1.12: 

P T IME T M = P T IME GOT O = P T IME SRAM = P T IME W HILE 

• W HILE ≼ ptime GOT O, Beweis: 

(a) Ausdrücke E zerlegen in Sequenzen von Zuweisungen. 

(b) Ersetze while durch bedingte Sprünge. 

Der Blowup-Faktor ist vernachlässigbar. 


• GOT O ≼ ptime W HILE, Beweis mit Böhm-Jacopini-Konstruktion: 

Übersetze p = I 1 ,...,I m in 

read X; 

C := 1; 

while C do 

if =? C 1 then T( 1, I1 ) 

... 

if =? C m then T( m, Im ) 

write X 

mit T (l,I l ) = I l ;C := l + 1mod(m + 1)} wenn I l eine Zuweisung ist, sonst 

T (l,if X goto l 1 else l 2 ) = {if X then C := l 1 mod(m+1) else C := l 2 mod(m+1)} 

Der Blowup-Faktor ist hier m, also die Länge des Programms. 

16



• T M ≼ ptime GOT O: Kodierung von Symbolen/Bändern nach D. 

B + = 0,0 + = 1,1 + = 2 

c(S 1 ,...,S k ) = (S + 1 ,...,S+ k ) 

o.E.: k = 1 (ein Band). Repräsentation: LSR durch 

V ar 

C S + 

Rt C(R) 

Lt c(L ∇ ) = reverse (L) 

Übersetze p = I 1 ,...,I m in ¯p = Ī 1 ,...,Ī m gemäß 

I Ī 

right if (=? Rt nil) then Lt := cons C Lt; C := B + ; 

else Lt := cons C Lt; C := hd Rt, Rt := tl Rt; 

left analog 

write S C := S + 

if S goto l 1 else l 2 if (=?C S + ) then ¯l 1 else ¯l 2 

→ linearer Blowup. 


• SRAM ≼ ptime T M: 

Beweis durch RISC − SRAM: X 0 als Akkumulator. 

I ::= X 0 := X i | X i := X 0 | X 0 := X 0 + 1 | X 0 := 〈X i 〉 | 〈X 0 〉 := Xi | 

| if X 0 goto l 1 else l 2 

Zum Beispiel: X j := 〈X i 〉 → X k := X 0 ; X 0 := 〈X i 〉; X j := X 0 ;X 0 := X k 

→ nur lineare Verlangsamung. 

Simulation in T M 5 (k = 5): 

17


Band Inhalt, Grundposition 

1: Input ...BBa o ...a n BB... 

2: Addressen ...BBbin(b 1 )Bbin(b 2 )B...Bbin(b k )BB... 

3: Werte ...BBbin(c 1 )Bbin(c 2 )B...Bbin(c k )BB... 

4: Akku ...BBbin(σ(0))BB... 

5: Scratch ...BB...BB... 

Repräsentiert [σ ⊢ σ(0),b 1 ⊢ c 1 ,...,b k ⊢ c k ]. 

– Abschlusscode, der am Ende ausgeführt wird: Kopiere Band 4 nach Band 1, da 

die Ausgabe auf Band 1 abläuft. Zeit: O(log(σ(0))). 

– Simulation in TM q: z.B. X 0 := X 0 + 1. 

* Fahre ans Ende von Band 4. 

* Ersetze von rechts 1 durch 0 solange möglich. 

* Ersetze 0 oder B durch 1. 

* Fahre in Grundposition. 

Zeit: O(log(σ(0))). 

– X i := X 0 . 

* Durchsuche Band 2 und 3 parallel bis i als b j auf Band 2 gefunden ist. 

* Nicht gefunden: i an Band 2 hängen, Band 4 ans Ende von Band 3 anhängen, 

fahre zur Grundposition. 

* gefunden: kopiere c j+1 , b k auf Scratch, überschreibe c j mit Akku. Kopiere 

Scratch hinter neue c j , fahre zur Grundposition. 

Zeit: O(max. Bandlänge). 

– X 0 := 〈X i 〉. 

* Durchsuche Band 2 und 3 parallel bis i als b j auf Band 2 gefunden ist. 

* Nicht gefunden: fertig, fahre zur Grundposition. 

* gefunden: kopiere c j nach Scratch, Durchsuche parallel Band 2 und 3 bis 

c j auf Band 2 als b p gefunden wird, nicht gefunden: 0 auf Akku, sonst: 

kopiere c p auf Akku, fahre zur Grundposition. 

Zeit: O(max. Bandlänge). 

Abschätzung der Bandlänge bei t ≥ n. 

σ(j) ≤ n + t ≤ 2t 

18


Also ∃c,σ(j) 0 ⇒ j ≤ max(2t,c). 

⇒ Bandlänge = O(max(2t,c) · log(t)) = Zeit für Schritt t in q, also bei 

t = time p (d) ⇒ time q (d) = O(t · max(2t,c) · log(t)) ⇒ polynomiell. 

• DAG - Semantik für GOTO: 

Idee: spare Platz und Zeit durch Sharing. 

z.B.: X = cons Y Y ; X und Y sind hier Pointer auf Bäume. Jetzt wird der linke und 

rechte Teilbaumpointer von X jeweils auf Y umgebogen. 

Def. 1.16: DAG = directed acyclic graph. Der gewichtete Graph G: (V ,→) ist eine 

Menge von Knoten, → ist eine Menge von Kanten. Kanten sind unabhängig existierend 

von Knoten. 

→∈ e : d(e) ∈ V ,c(e) ∈ V . Lies: d(e) → e c(e) 

G ist azyklisch ⇔ n 0 → e 1 n 1 ... → e k n k = n 0 ⇒ k = 0, k ist die Anzahl der Schritte, 

man hat also keinen Schritt gemacht, denn sonst wäre der Graph zyklisch. 

DSG (data storage graph) ist eine Art DAG mit einem Knoten 0 ∈ V , der keine 

ausgehende Kante hat. Alle anderen Knoten haben zwei ausgehende Kanten, die die 

Labels l bzw. r haben. Optional gibt es eine Wurzel, die ein ausgewählter Knoten 

ist. 

Konversion: Zu einem Datenelement d ∈ D gibt es einen DSG dag(d) mit Wurzel. 

dag(nil) = 0, 0 ist hier die Wurzel. 

dag(d 1 .d 2 ) = (dag(d 1 ).dag(d 2 )), mit neuer gemeinsamer Wurzel. 

Konversion umgekehrt: δ ist ein DSG, n ist ein Knoten. unf = unfold. 

⎧ 

⎪⎨ nil n = 0 

unf (δ,n) = ⎪⎩ (d 1 .d 2 ) wenn unf (δ,n 1 ) = d 1 und unf (δ,n 2 ) 

[Bsp.: reverse als DAG mit Liste X = (a b)] 

Def. 1.17: DAG - Semantik für GOTO. 

Speicher für p : σ = (δ,ρ) mit δ als DSG ohne Wurzel mit der Knotenmenge V . 

ρ : V ars(p) → V . 

σ p,DAG 

0 

(d) = (δ,ρ) mit δ = dag(d),ρ(X) = Wurzel von δ und ρ(Y ) = 0 sonst. 

Readout(δ,ρ) = unf (δ,ρ(X)) ∈ D 

Instruktionen: Semantik von if X... ist wie bisher mit einer Abfrage auf ρ(X) 0. 

I e = (X := E): p ⊢ (l,(δ,ρ)) → (l + 1,(δ ′ ,ρ[X → n])), wenn s(δ,ρ,E) = (δ ′ ,n) mit 

19


s(δ,ρ,nil) = (δ,0) 

s(δ,ρ,Y ) = (δ,ρ(Y )) 

s(δ,ρ,cons Y Z) 

⎧ 

= (δ+ frischer Knoten n, der mit l auf δ(Y ) und mit r auf δ(Z) zeigt,n) 

⎪⎨ (δ,n) wenn ρ(Y ) → l n 

s(δ,ρ,hd Y ) = ⎪⎩ (δ,0) sonst 

s(δ,ρ,hd Y ) analog. 

Korrektheit der DAG - Semantik: 

Def. 1.18: (δ,ρ) ∼ p σ : V ars(p) → D :⇔ unf (δ,ρ(Y )) = σ(Y ) für alle Y ∈ V ars(p) 

Proposition 1.19: p DAG (d) = p GOT O ,timep 

DAG (d) = timep 

GOT O (d) 

Beweis: Zeige 

(a) σ p,DAG 

0 

(d) ∼ δ p,GOT O 

0 

(d) und 

(b) (δ,ρ) ∼ σ ⇒ (p ⊢ (l,σ) → (l ′ ,σ ′ ) ⇔ ∃(δ ′ ,ρ ′ )p ⊢ DAG (l,(δ,ρ)) → (l ′ ,(δ ′ ,ρ ′ )) ∧ 

(δ ′ ,ρ ′ ) ∼ σ ′ ) 

Implementierung der DAG - Semantik in Pascal-ähnlichem Pseudocode; zunächst ohne 

Input. V ars(p) = {X,Z 1 ,...,Z k } 

// Node i ist (Hd(i), Tl(i)) 

type Index = 0... inf, Node = 0 ... inf; 

vars X, Z1, ... Zk : Node; 

Hd, Tl : array Index of Node; 

Time: Index; 

Hd[0] := 0; Tl[0] := 0; X := 0; Z1 := 0; ... Zk := 0; 

Time := 1; // liefert frische Indizes 

1: I’1, ..., m: I’m, m + 1; writeout; 

I Ī, entspricht obigem I ′ 

Z := nil Z := 0, Time := Time + 1 

Z := V Z := V; Time := Time + 1 

Z := hd V Z := Hd[V]; Time := Time + 1 

Tl ... ... 

Z := cons V W Hd[Time] := V; Tl[Time] := W; Z := Time; Time = Time + 1 

if Z goto l 1 else l 2 if Z 0 goto l 1 else l 2 

Input: (p,d) ⊢ Initialisiere X auf d, p ⊢ Pascal, Blowup: lineare Verlangsamung. 

Proposition 1.19: GOT O ≼ ptime SRAM 

20


Beweis: Implementiere obigen Pseudocode in der SRAM. 

• zwei unendliche Arrays: interleaving mit geraden und ungeraden Adressen 

• Deswegen: Zähler wird in jedem Schritt um zwei erhöht 

2 Ein Hierarchiesatz 

2.1 Berechnungsmodell I 

I ist das Ein-Variablen-WHILE, siehe Buch. 

Die Variable heißt A. WHILE ist nach I kompilierbar. 

p ⊢ p, V ars(p) = {X 1 ,...,X n } (von WHILE nach I). A repräsentiert hier X 1 ,...,X n . 

X i → hd(tl i−1 (A)) ist jetzt := X i 

X i := E → 

A := cons ∗ X 1 ,...,X i−1 E tl i (A) 

Blowup: time p (d) ≤ k · n 2 time p (d) 

2.2 Selbstinterpretation von I 

Zunächst: 

I Interpretation in WHILE. 

Zustand: 

Vl 

Cd 

St 

Value (Speicher), d.h. σ(A) 

code stack 

value stack 

Hauptschleife: 

u1var => 

read PD; (* (p.d) *) 

P := hd PD; (* (var 1)C(var 1) *) 

C:= hd (tl P); 

Cd := cons C nil; St := nil; Vl := tl PD; 

while Cd do STEP; 

write Vl; 

STEP ist rewriting ”⇒”mit Invarianten: 

21


• ([(E.Cd),St,d] ⇒ ∗ [Cd,(e.St),d]) genau dann wenn E[A → d] = e 

• ([(C.Cd),St,d] ⇒ ∗ [Cd,St,e]) genau dann wenn C ⊢ [A → d] → [A → e] 

Cr steht hier für den Codrest. 

STEP => 

rewrite [Cd, St] by 

[((quote d).Cr), St] => [Cr, cons d St] 

[((var 1).Cr), St] => [Cr, cons Vl St] 

[((hd E).Cr), St] => [cons* E dohd Cr, St] 

[(dohd.Cr), (T.St)] => [Cr, cons (hd T) St] 

(* analog für tl, cons etc. *) 

Beispiel: 

[((; C1 C2).Cr), St] => [cons* C1 C2 Cr, St] 

[((:= (var 1) E).Cr), St] => [cons* E doasgn Cr, St] 

[(doasgn, Cr), (T.Sr)] => { Cd := Cr, St := Sr; Vl := T } 

[((while E C).Cr), St] => [cons* E dowhile (while E C) Cr, St] 

[((dowhile.(while E C).Cr), (nil.Sr)] => [Cr, Sr] 

[((dowhile.(while E C).Cr), (T.Sr)] => [cons* C (while E C) Cr, Sr] 

[((hd (var 1)).Cr), St] => [((var 1).(dohd.Cr)), St] => 

=> [(dohd.Cr), (Vl.St)] => [Cr, ((hd Vl).St)] 

Zeitanalyse: 

• STEP hat keine Schleifen, läuft daher in konstanter Zeit. 

• höchstens zwei Durchläufe pro Operator bzw. Schritt der op. Semantik 

⇒ lineare Verlangsamung, Faktor unabhängig von p! 

Selbstinterpretation in I. u1var ∈ I-Prog. 

Verlangsamung: O(|V ars(u1var)| 2 ), also linear und unabhängig von p. 

Theorem 2.1: 

I hat einen effizienten Selbstinterpreter i, d.h. 

• i(p.d) = pd, ∀p ∈ P rog,d ∈ D 

• ∃a ∈ R, ∀p,d : time(p.d) ≤ a · time p (d) 

22


Bemerkung 2.2: 

Es ist nicht klar, ob WHILE einen effizienten Selbstinterpreter hat: 

(p.d) ⊢ i(p.d) 

ist in WHILE interpretierbar und braucht polynomielle Zeit in (p.d). 

2.3 Zeitbeschränkte Selbstinterpretation 

Def. 2.3: tu (time universal program) ist ein zeitbeschränkter Selbstinterpreter, wenn für alle 

p ∈ I − P rog, d ∈ D, n ≥ 1 gilt, dass: 

⎧ 

⎪⎨ (pd.nil) time 

tu((p.d).n) = 

p (d) ≤ n 

⎪⎩ nil sonst 

tu ist effizient, wenn time tu ((p.d).n) ≤ k min(n,time p (d)) 

Satz 2.4: I hat einen effizienten zeitbeschränkten Selbstinterpreter. 

Beweis: tt. Erweiterung von u1var. Input n, Ctr := n, Ctr herunterzählen bei jedem push von 

{quote, var, dohd, dotl, cons, doasgn, dowhile}, Abbruch bei Ctr = 0. 

⇒ lineare Verlangsamung, unabhänig von p. Also time tt ((p.d).n) ≤ k 1 · time p (d), ferner 

time tt ((p.d).n) ≤ k 2 · n mit k ′ := max(k 1 ,k 2 ) und tu := tt. 

2.4 Die lineare Hierarchie für I 

Satz 2.4: 

Es existiert eine Zahl b ∈ N mit ∀a: T IME I (an) ⊂ T IME I (ban). 

Bemerkung: b = 248 

Beweis 

durch Diagonalisierung: 

diag = 

read A; 

A := tu( list A A (a * |A|) ); (* erstes A Daten, zweites A Programm *) 

if hd A then A := false else A := true; 

write A; 

B a := {p | diag a (p) = true} 

23


Behauptung: ∃b ∀a : B a ∈ T IME I (ban) − T IME I (an). 

Zeitanalyse für diag a (p): 

• Berechnung von a · |p|: c · a · |p|, 

• tu : k · min(a|p|,time p (p)) ≤ ka|p|. 

• Rest: in konstanter Zeit e. 

Also ist B a ∈ T IME I (ban) mit b = c + k + e (unabhängig von a). 

Noch zu Zeigen: B a T IME I (an). 

Annahme: p ∈ time I (an) entscheidet B a . 

Dann p ∈ B a ⇔ diag a (p) = true ⇔ p(p) = f alse, da time p (p) ≤ a|p| 

⇔ p entscheidet B a : p B a . 

3 Speicherplatz als Ressource 

Bestimme Komplexität als benötigten Speicherplatz abhängig vom Input. 

Offensichtliche Relationen zu den Zeitklassen: 

• Zeit O(f (n)) ⇒ Platz O(f (n)) 

• Platz O(f (n)) ⇒ Zeit O(|Σ| f (n) ) 

letzteres: Platz f (n) liefert O(|Σ| f (n) ) Zustände, von denen ein terminierendes Programm keinen 

wiederholen darf. 

Platzverbrauch messen: 

Generisch für GOTO - artige Sprachen: 

p = I 1 ,...I m ← L-Prog 

p ⊢ (1,Readin(d)) = (l 1 ,σ 1 ) → ... → s t = (m + 1,σ t ) 

⇒ spacep(d) L = max{|σ 1 |,...,|σ t |} 

Def.: |σ| abhängig von L. 

24


Beispiel TM: |(L 1 S 1 R 1 ,...L k S k R k )| = max( |L 1 S 1 R 1 | 

}{{} 

uneindeutig 

,|...|,|L k S k R k |) 

time = O(2 space ) motiviert Interesse an SP ACE(f (n)), f (n) = o(n) mit z.B. f = log. 

Aber nach obiger Definition gilt stets spacep 

T M (d) ≥ |d|. 

Lösung: Readonly - Band für Eingabe, später auch Writeonly - Band für die Ausgabe. 

Formal: Band 1 ist die Eingabe, write 1 verboten. 

|(L 1 S 1 R 1 ,...L k S k R k )| = max(|L 2 S 2 R 2 |,|...|,|L k S k R k |) 

⇒ T M ro 

Proposition 3.1: Sei p ∈ T M ro -Prog, spacep 

T M (d) ≥ |d|. ⇒ es existiert q ∈ T M-Prog mit 

q = p ∃a mit spaceq 

T M (d) ≤ a · space T M ro 

p (d). 

Definition 3.2 der Platzklassen: 

space L (f (n)) = {p ∈ L − P rog | space L p(d) ≤ f (|d|)} 

logspace L = 

∞⋃ 

space L (k · log(n)) 

k=0 

SP ACE L (f (n)) = {A | A wird durch ein p ∈ space L (f (n)) entschieden} 

Entsprechend LOGSP ACE L , P SP ACE L . 

Platzverbrauch RAM: 

Readonly - Eingabe zählt nicht mit. 

∑ 

|σ| = logσ(i),σ : N → N 

σ(i)0 

Robustheit: T M ro → SRAM: sogar CM = (Counter machine), entspricht SRAM mit Zuweisungen 

nur X i := X i + 1,X i := X i − 1. 

Band b 1 ,...,b i ,b i+1 ,...,b m wird repräsentiert durch zwei Zahlen der Basis drei, (B ̂= 0,0 ̂= 1,1 ̂= 

2). l = b 1 ,...,b i und r = b m ,...,b i+1 . Speicherverbrauch: logl,logr ≤ 2 (+Overhead). Obwohl 

die Basis drei ist, gilt das hier mit dem dualen Logarithmus. (⇒ linear erhöhter Platzbedarf). 

SRAM → T M: σ(i) > 0 nimmt Platz logσ(i) + 1 auf dem Band ein. Wenn σ(i) > 0 ⇒ i 

kommt im Programm p vor (konstanter Platzbedarf). 

25


Oder: i war einmal Inhalt eines Registers, also logi ≤ spacep 

SRAM (d). Quadratischer Blowup 

für die SRAM, bei der CM nur linear. 

Def. 3.3: Platzverbrauch für GOT O. Schreibe in DSG δ n → ∗ m für Knoten n,m in δ, wenn 

m von n aus in k ≥ 0 Schritten erreichbar ist. Sei (δ,ρ) ∈ ST ORE p (ρ : V ars(p) → V , V Menge 

der Knoten in δ). Dann |(δ,ρ)| = #{n | ∃X ∈ V ars(p),δ(X) → ∗ n}. 

TM → GOTO: Repräsentiere Bänder als Listen, d.h. die Anzahl der erreichbaren Knoten ist 

O(Bandlänge). 

right: Lt := cons(Hd Rt)Lt; Rt := tl Rt 

GOTO → SRAM: SRAM repräsentiert zunächst auch die unerreichbaren Knoten. Lösung: 

garbage collection, polynomielle Erhöhung des Platzverbrauchs. 

Theorem 3.4: 

(i) Sei f (n) ≥ max(1,log(n)). Dann 

⋃ 

⋃ 

SP ACE T M ro 

(cf ) = SP ACE CM (cf ) 

c 

Zum Bsp. ist LOGSP ACE T M = LOGSP ACE CM := LOGSP ACE. 

(ii) P SP ACE T M = P SP ACE SRAM = P SP ACE CM = P SP ACE GOT O := P SP ACE 

Inklusion zwischen Zeit- und Platzklassen 

Proposition 3.5: T IME T M (f ) ⊆ SP ACE T M (f ), ∀f . Insbesondere gilt P T IME ⊆ P SP ACE. 

Beweis: Pro Schritt wird höchstens eine Zelle beschrieben. 

Theorem 3.6: LOGSP ACE ⊆ P T IME 

Beweis: Sei A ∈ LOGSP ACE. Dann wird A entschieden durch p = I 1 ,...,I m ∈ space T M ro(k · 

logn),∀k. Keine Wiederholung von Zuständen ⇒ 

p ∈ time( 

da 3 k logn = n k log3 . 

m }{{} 

Prog.-Zähler 

· (n + 2) 

}{{} 

Pos. auf Eingabeband 

c 

· (k · logn) 

}{{} 

Pos. auf Band 2 

· 3 k logn 

}{{} 

Inhalt Band 2 

) ⊆ P T IME 

26


Theorem 3.7: Sei f (n) ≥ n ⇒ SP ACE T M ⊆ ⋃ c>0 T IMET M (c f ) 

Korollar: 

Beweis: 

m ≥ 1. 

P SP ACE ⊆ EXP SP ACE 

Abschätzung der Anzahl Zustände der 1 - Band TM, p = I 1 ,...,I m in space(f ) und 

3 f (|d|) · f (|d|) · (m + 1) ≤ 3 f (|d|) · 2 f (|d|) · (2m) f (|d|) = (12m) f (|d|) 

Bemerkung: 

LOGSP ACE ⊆ P T IME ⊆ P SP ACE ⊆ EXP T IME 

3.1 In logspace berechenbare Funktionen 

Wichtig: 

Ausgabe auf gesondertes writeonly Band. 

logspace = feste Anzahl Pointer in die Eingabe 


berechenbar. 

Die Funktionen −,+,≤,∗ und das Sortieren von n-Tupeln sind in logspace 

Beweis: 

z.B. ≤ mit zwei Pointern (Zahl1, Zahl2) mit Kopie. 

• führende 0en überlesen 

• Längen vergleichen 

• Bei gleicher Länge von vorne Ziffern vergleichen. 

Lemma 3.9: 

Sei |f (d)| ≤ p(|d|) für ein Polynom p, dann sind folgenden Aussagen äquivalent: 

(i) f ist in logspace berechenbar 

(ii) Die Funktion λ(i,d).(i-tes Bit von f (d)) ist in logspace berechenbar. 

Beweis: 

Modifikation für q: 

• Präfix C := 0 

(i) ⇒ (ii). Sei f berechenbar durch 1 - Band TM 

}{{} 

eig. 3 Band 

q in Platz k logn. Eingabe X i ,I. 

27


• Ersetze lef t 3 durch C := C − 1, right 3 durch C := C + 1 

• Ersetze write 3 Z durch if C = I then write 3 Z 

Bei anständiger Programmierung des ursprüngliches Programms q gilt stets 0 ≤ C ≤ p(|X|), 

also ist der Platzverbrauch O(log(n)). 

(ii) ⇒ (i). q berechnet λ(i,d).(i-tes Bit von f (d)) in logspace. 

r = 

for C = 1 to p(|X|) do 

{ 

B := q CX; if B = 0 or B = 1 then 

write3 B; right3; 

} 

C braucht Platz von O(logn). q umprogrammieren: Input X vom Eingabeband; Input I aus C. 

Platzverbrauch bleibt gleicht (bis auf C). 

Theorem 3.10: Seien f ,g logspace berechenbar, dann auch f ◦ g. 

Vorsicht: Zwischenergebnis g(x) kann nicht vollständig gespeichert werden. 

Beweis: TM p f berechne f , p g berechne λ(i,x).(i-tes Bit von g(x)) in logspace (nach Annahme 

und Lemma 3.9). Verwendung von 4-Bd. TM zur Berechnung von f ◦ g. 

Band Inhalt 

1(r/o) Eingabe 

2 Arbeitsband von p f 

3 i = Kopfposition auf Eing. g(x) von p f (binär) 

4 b = Symbol an i 

5 Arbeitsband von p g 

6(w/o) Ausgabe 

r arbeitet zunächst wie p f bis auf Ausgabe (jetzt auf Band 6) und Eingabe: 

• if 1 S... → if 4 S... 

• right 1 → i := i + 1;b := p g (x,i) 

}{{} 

auf TM 

28


Modifiziere p g : Band 5 als Arbeitsband. Band 4 als Ausgabeband. Eingabe X von Band 1 und i 

von Band 3. 

Platzanalyse: 

Band Inhalt 

2 O(log(n)) da p f ∈ logspace 

3 O(log|g(x)|) 

4 O(1) 

5 O(log(n)) da p g ∈ logspace 

logspace ⊆ ptime: also |g(x)| ≤ π(|X|) mit π polynom, also log|g(x)| = O(log(|X|)) mit |X| = n. 

3.2 Platzhierarchien 

Es gelten Hierarchiesätze im wesentlichen wie für Zeitklassen mit analogen Beweisen. Lineare 

Hierarchien für die 1 - Band TM und die allgemeine robuste Hierarchie für space ≥ n. Insbesondere 

gilt P SP ACE ⊆ EXP SP ACE aber P SP ACE EXP SP ACE. 

4 Nichtdeterminismus 

Determinismus: 

ist die Eindeutigkeit des Nachfolgezustands. 

Hier: angelischer Nichtdeterminismus, also die Fähigkeit zum richtigen Raten (Gegenteil: dämonisch). 

Logische/Spieltheoretische Analogie: Angelisch = ∃ = Player. Dämonisch = ∀ = Opponent. 

Syntax: GOTO-ähnliche Sprache: l : goto l 1 orl 2 

Dann p ⊢ (l,σ) → (l 1 ,σ) und p ⊢ (l,σ) → (l 2 ,σ) 

WHILE: C ::= ....| choose C 1 or C 2 mit 

C i ⊢ σ → σ ′ 

choose C 1 or C 2 ⊢ σ → σ ′ i = 1,2 

Definition 4.1: Eine Berechnung ist eine Sequenz von Zustandsübergängen durch ein Programm 

p ⊢ s 1 → s 2 → ... → s t . Diese heißt akzeptierend, wenn p = I 1 ,...,I m bei s t = (m + 1,σ) 

und Readout(σ) = true. p akzeptiert d, wenn eine akzeptierende Berechnung p ⊢ Readin(d) → 

... → s t existiert. Die Menge der akzeptierenden Zustände: Acc(p) = {d | p akzeptiert d} 

29


WHILE: p = read(X); C; write Y 

p(d) = {e ∈ D | ∃σ.C ⊢ [X → d] → σ,σ(Y ) = e} 

Acc(p) = {d | true ∈ p(d)} 

Beispiel 4.2: Pfadsuche. Problem: Gegeben ist ein gerichteter Graph G = (V ,E) und zwei 

Knoten s,t ∈ V . Entscheide, ob s → ∗ t gilt. 

Format: G = ( (u 1 .v 1 ) 

}{{} 

Kante u 1 →v 1 

...(u n .v n )) ∈ D 

read S, T, G; 

W := S; 

while W != T do 

Copy := G; 

while Copy do (* wähle irgendeine Kante Edge *) 

choose Copy := tl Copy; 

or { Edge := hd Copy; Copy := nil } 

if W = hd Edge then W := tl Edge; 

write true; 

Definition 4.3: 

GOTO - ähnlich: 

Zeit/Platzverbrauch bei Nichtdeterminismus. 

time p (d) = min{t | ∃p ⊢ Readin(d) → ... → s t akzeptierend} 

Für eine Berechnung C = p ⊢ (l 1 ,σ 1 ) → ... → (l t ,σ t ) gilt |C| = max{|σ 1 |,...,|σ t |}. Es gilt: 

WHILE: C ⊢ σ → t σ ′ mit 

space p (d) = min{|C| | C = p ⊢ Readin(d) → ... → s t akzeptierend} 

C i ⊢σ→ t σ ′ 

choose C 1 or C 2 ⊢σ→ t σ ′ i = 1,2 

time p (d) = min{t | ∃σ.C ⊢ [X → d] → t σ,σ(Y ) = true} (p = read X; C; write Y ) 

space ähnlich. 

30



Nichtdeterministische Klassen. 

NP T IME L = {Acc(p) | ∃ polynom f : ∀d.time p (d) ≤ f (d)} 

NP SP ACE L = {Acc(p) | ∃ polynom f : ∀d.space p (d) ≤ f (d) } 

NLOGSP ACE L = {Acc(p) | ∃k : ∀d.space p (d) ≤ k log|d| } 


(i) NP T IME ist robust (TM, SRAM, GOTO, WHILE) 

(ii) NP SP ACE T M = NP SP ACE SRAM = NP SP ACE GOT O = NP SP ACE CM 

(iii) NLOGSP ACE T M = NLOGSP ACE CM 

Der Beweis ist wie bisher. 


P T IME ⊆ NP T IME,P SP ACE ⊆ NP SP ACE,LOGSP ACE ⊆ NLOGSP ACE 

5 Die Backbone - Hierarchie 

Lemma 5.1: Normalisierung von Nichtdeterministischen TMs. 

TM q heißt Normalisierung, wenn 

(i) q akzeptiert d, gdw. q eine Berechnung der Form q ⊢ Readin(d) → ... → (m,σ) → 

(m,σ)... (q bleibt nicht stehen) mit Arbeitsband von σ = ...BB1BBB... 

(ii) p hat eine nicht-akzeptierende terminierende Berechnung für Eingabe d gdw. q eine Berechnung 

der Form q ⊢ Readin(d) → ... → (m−1,σ) → (m−1,σ)... mit σ = ..BB0BBB... 

(iii) Zeitverbrauch von q bei Erreichen von m bzw. m − 1 ist nur linear größer als der von p. 

Der Platzverbrauch bleibt gleich. 

Jedes p hat eine Normalisierung. 

Beweis 

(a) am Ende Band aufräumen 

(b) am Ende Instruktionen m − 1 : if 2 0 then GOT O m − 1 und m : (if 2 1 then) GOT O m 

Zu (a): Bandgröße mitprotokollieren → log. Overhead des Platzes. Zeit zum Löschen = O(P latz) = 

O(Zeit). 

31


zur Normalisierung: 

• Variante A: Σ ′ = Σ ∪ {X}. X ist die beiseitige Bandendemarkierung. → linearer Overhead 

bei Zeit. Σ ′ nach Σ kodieren: linearer Platzverbrauch. 

• Variante B: Bei bekannter Platzschranke f , f konstruierbar in Platz f (n) − 1. 

– f (|d|) hinter Ausgabe aufs Band als Cnt 

– Cnt nach rechts schieben; Cnt := Cnt − 1, dabei Band löschen 

– Ende bei Cnt = 0 

– 0 löschen 

– zum Bandanfang fahren 

– ohne Platzverbrauch 

Zustandsgraphen 

Definition 5.2: Gegeben TM p, Eingabe d: Eine Konfiguration (l,i,j,W ) besteht aus einem 

Label l, einem Arbeitsbandinhalt W ∈ Σ∗, einem i und j, die Kopfpositionen auf Eingabe- bzw. 

Arbeitsband. 

Zustandsgraph: G p (d) = gerichteter Graph (V ,E,v 0 ,v end ) mit V = V p (d) = Menge der Konfigurationen 

für p,d und E = E p (d) = {(C 1 ,C 2 ) | p ⊢ C 1 → C 2 } und v 0 = (1,0,0,())) und 

v end = (m,0,0,1) 

Observation: p akzeptiert d ⇔ v 0 → ∗ v end in G p (d). 

Definition 5.3: TM p ist f - beschränkt, wenn ∀d und für jede von v 0 erreichbare Konfiguration 

C = (l,i,j,W ) ∈ V p (d) gilt: |f | ≤ f (|d|) + 1 

→ Jedes erreichbare C ∈ V p (d) braucht Platz O(f (|d|)) 

Erreichbarkeint in Graphen: Problem GAP (graph accessability problem). 

Eingabe: gerichteter Graph G = (V ,E,v 0 ,v end ) (als Liste von Knoten + Liste gerichteter Kanten 

(= Paare von Knoten) + 2 Kanten). 

Ausgabe: true wenn v 0 → ∗ v end in G. 

32


Satz 5.4: 

GAP ∈ NLOGSP ACE. Algorithmus: 

w := v0 

while w != vend do 

choose w->x in E 

w := x 

write true 

Platz ≤ 2log(n). Gespeichert wird nur w und x. 

Komplemente: zu C von Problemen sind coC = {A | {0,1} ∗ − A ∈ C}. Wenn C deterministisch 

ist folgt C = coC (Antwort umdrehen). 

Satz 5.5: GAP ∈ NLOGSP ACE. 

Beweis: z.Z.: {0,1} ∗ − GAP ∈ NLOGSP ACE. Setze n i = #{u | v 0 → ≤i u} 

(v 0 → ≤i u ⇒ v 0 → ... → u) 

}{{} 

Nebenbemerkung: v 0 → ∗ v end ⇔ v 0 → ≤|V |−1 v end 

Algo 1: entscheide v 0 ↛ ∗ v end , wenn n |V |−1 = k 

≤i Knoten 

NoPath = true; Cnt := 0; 

for z = 1 to |V| do 

choose skip or (* z nicht erreichbar *) 

if v0 ->* z; (* NLOGSPACE *) 

then Cnt := Cnt - 1; 

if z = vend then NoPath := false; 

else abort; (* abort = while true do skip *) 

if Cnt != k then abort; 

write NoPath; 

Termination: genau die erreichbaren Knoten geraten. 

Platz: NoPath (O(1)), z(O(log(n))), Cnt(O(log(n))), v 0 → ∗ z (O(log(n))). Bleibt iterative Berechnung 

von n |V |−1 . 

n 0 = 1, dann n i = n aus n i−1 = k 

Nebenbemerkung: Für i ≥ 1, v 0 → ≤i z ⇔ ∃w : v 0 → ≤i−1 w,w → z 

33


n := 0 

for u := 1 to |V| do 

Cnt := 0; Foundu := false; 

for w := 1 to |V| do 

choose skip or 

if v0->w (u then Foundu = true 

else abort 

if Cnt != k then abort 

if Foundu = true then n := n + 1 

Platz: v 0 → ≤i−1 w, O(log(n)) (mit zusätzlichem Zähler). n,k,Cnt,w,n O(log(n)), Foundu: 

O(1). 

Band aufräumen: 

• ohne space overhead 

• bei unbekanntem Platzverbrauch 

• Nicht deterministisch löschen! 

• m − 2: choose {right 2 ; write 2 B; goto m − 2} or skip 

Definition 5.8: Für f : N → N ist der f-beschränkte Zustandsgraph Gp f (d) der vom Knoten 

C mit |C| ≤ f |d| aufgespannte Untergraph von G p (d). 

Erinnerung: GAP = {(N,E,v 0 ,v end ) | v 0 → ∗ v end }, GAP ∈ LOGSP ACE und 

GAP ∈ coNLOGSP ACE 

Satz 5.6: GAP ∈ P T IME 

Beweis, Tiefensuche: 

proc Main {read V ,E,v 0 ,v end 

for v ∈ V do Seen[v] := false; 

Probe(v 0 ); 

write Seen[v end ] 

} 

proc Probe(v) { 

34


if not Seen[v] then 

Seen[v] := true; 

for all v → v ′ ∈ E do Probe(v ′ ); 

} 

Zeit: ≤ |v| Aufrufe von Probe, jeweils in Zeit O(|E|). 

Overhead durch Rekursion: implementiere Stack auf TM, das gibt polynomiellen Overhead. 

Satz: GAP ∈ LOG 2 SP ACE = ⋃ h SP ACE(h(logn)2 ) 

Algorithmus: Divide-and-Conquer. 

Path(v 0 ,v end ,|V |) 

Path(v,w,l)= (* teste v → ≤l v end *) 

if l = 0 then return ’v = w’ 

if l = 1 then return ’v → w’ 

for u ∈ V do 

l ′ = l div 2 

if Path(v,u,l ′ ) & Path(u,w,l − l ′ ) 

then return true 

return false 

Platz: Stack mit Tiefe O(logn). Frame: v,w,l,u,Rücksprungadresse: O(logn) ⇒ O((logn) 2 ) 

Definition: 

f platzkonstruierbar ⇔ f berechenbar in Platz O(f (n)) 

Lemma 5.9: f ≥ log und platzkonstruierbar, p ein Programm. ⇒ Gp f (d) berechenbar in Zeit 

⋃ 

l cf |d| und Platz O(f |d|). 

Beweis: 

• Berechne f |d|, Platz O(f |d|), Zeit 2O(f |d|) 

• erzeuge Knoten mit for-Schleife, Platz O(f |d|), Zeit 2O(f |d|) 

• erzeuge Kanten mit for-Schleife durch alle Knotenpaare (C 1 ,C 2 ) (neu generieren). Schreibe 

(C 1 ,C 2 ) aufs Ausgabeband, wenn p ⊢ C 1 → C 2 . 

}{{} 

Gesamtzeit: (2 O(f |d|) ) 2 · O(|d| k ) = O(2 O(f |d|) ) 

Gesamtplatz: O(f |d|) 

poly. Zeit, Platz linear 

35


Satz 5.10: f ≥ log platzkonstruierbar. ⇒ NSP ACE(f (n)) ⊆ ⋃ c T IME(cf (n) ) 

Beweis: Sei p ∈ nspace(f (n)), Entscheide d ∈ Acc(p) in time(c f |d| ): 

• Berechne G f p (d) (Zeit 2 O(f |d|) ) 

• Entscheide G f p (d) ∈ GAP (Zeit ploynomiell in 2 O(f |d|) , also 2 O(f |d|) , nach Satz 5.6) 

Korollar: 

Beweis: 

NLOGSP ACE ⊆ P T IME 

NSP ACE(k logn) ⊆ T IME(c k logn ) = T IME(n k logn ) ⊆ P T IME 

Satz 5.12 (Savitch): f ≥ log platzkonstruierbar ⇒ NSP ACE(f (n)) ⊆ ⋃ c SP ACE(cf (n)2 ) 

Beweis: Sei p ∈ nspace(f (n)), entscheide d ∈ Acc(p) in SP ACE(cf (n) 2 ) 

• Berechne f , Gp f (d), Platz O(f |d|), Knoten r = 2O(f |d|) 

Konstruktion platzbeschränkter Funktionen wie für logspace. 

• Entscheide G f p (d) ∈ GAP in Platz O((logr) 2 ) = O((f |d|) 2 ) 

Korollar 5.13: P SP ACE = NSP ACE = coNP SP ACE 

}{{} 

(2) 

Beweis: 

von (2): coNP SP ACE = coP SP ACE = P SP ACE = NP SP ACE 

Satz 5.14 (Immerman): 

NP SP ACE(cf (n)) 

⋃ 

c 

f ≥ log platzkonstruierbar. ⇒ coNP SP ACE(f (n)) ⊆ 

Korollar 5.15: 

NLOGSP ACE = coNLOGSP ACE 

Beweis: 

Sei p ∈ nspace(f (n)), entscheide d Acc(p) in nspace(cf (n)). 

• Berechne f , Gp f (d), Platz O(f |d|), Knoten r = 2O(f |d|) 

• Entscheide G f p (d) GAP in Platz O(logr) = O(f |d|) 

36


Zusammenfassend: 

LOGSP ACE ⊆ NLOGSP ACE ⊆ P T IME ⊆ 

}{{} 

=coNLOGSP ACE 

⊆ NP T IME/coNP T IME ⊆ P SP ACE = NP SP ACE ⊆ EXP T IME 

}{{} 

6 Vollständigkeit 

LOGSP ACE P SP ACE 

=coNP SP ACE 

NLOGSP ACE P SP ACE 

P T IME EXP T IME 

Vollständiges Problem für C = ’schwieriges’ (engl. hard) Problem in C. D.h. für A ⊆ {0,1} ∗ 

C-vollständig ist zu Zeigen: 

(a) A ∈ C, ’obere Schranke’, A ist C-hart 

(b) B ∈ C, A ist ’härter’ als B, ’untere Schranke’ 

’härter als’ ist definiert per Reduktion (engl. reduction from ...). 

Beispiel: CLIQUE ≥ SAT mit CLIQUE = {(G,k) | G hat eine k-Clique}. G ist ungerichtet. 

K ⊆ V und (G = (V ,E)), k-Clique, falls #K = k und ∀u,v ∈ K,{u,v} ∈ E. 

SAT = {ϕ CNF | ϕ erfüllbar}, CNF endliche Konjugation von Klauseln. Klausel ist eine endliche 

Disjunktion von Literalen. Literal ist von der Form A | ¬A. 

Valuation: κ : V ars(ϕ) → {T ,F}, ϕ erfüllbar ⇔ ∃κ,κ(ϕ) = T 

Bekannt: SAT NP-Vollständig, klar: CLIQUE ∈ NP T IME. 

Reduktion: SAT → CLIQUE: Gegeben ϕ = (a 11 ∨ ... ∨ a 1n1 ) ∧ ... ∧ (a k1 ∨ ... ∨ a knk ) 

Konstruiere (G,k) mit V = Menge der Vorkommen von Literalen in ϕ = {(i,j) | i ∈ {1,...,k},j ∈ 

{1,...,n i }} 

{(i 1 ,j 1 ),(i 2 ,j 2 )} ∈ E ⇔ i 1 i 2 ∧ a i1 j 1 

¬a i2 j 2 

Beispiel: ϕ = (A ∨ ¬B) ∧ (B ∨ C) ∧ (¬A ∨ ¬C) 

3-Clique {A,B,¬C} ̂= [A → T ,B → T ,C → F] = κ, κ(ϕ) = T 

Formal: z. Z. ϕ erfüllbar, genau dann wenn G eine k-Clique hat. 

′ ⇒ ′ Sei κ(ϕ) = T , dann existiert ∀i ∈ {1,...,k}j i ∈ {1,...,n i } mit κ(a ij ) = T , dann ist {(i,j) | i = 

37


1,...,k} k-Clique. 

′ ⇐ ′ Sei k ∈ V eine k-Clique ⇒ k = {(1,j 1 ),...,(k,j k )}. Wähle κ mit κ(a iji ) = T für alle i. (geht, 

da nie a i1 j i1 

= ¬a i2 j i2 

), κ(ϕ) = T . 

Definition 6.1 (Reduktion): 

F = ptime), A,B ⊆ {0,1} ∗ . 

F Klasse von Funktionen {0,1} ∗ → {0,1} ∗ (z.B. F = logspace, 

A ≤ F B ⇔ ∃f ∈ F , A = f −1 [B] 

(d.h. d ∈ A ⇔ f (d) ∈ B ). 

C sei eine Klasse von Problemen, dann gilt B ist F -vollständig für C ⇔ 

(a) B ∈ C 

(b) B ist F -hart für C 

d.h. ∀A ∈ C gilt A ≤ F B. 

Kurznotation: C-vollst., C-hart. 

→ Sinnvoll, wenn C nach unten abgeschlossen unter ≤ F ist, d.h. B ∈ C ∧ A ≤ F B ⇒ A ∈ C 

z.B. C = P T IME, F = logspace oder C = NLOGSP ACE, F = logspace oder C = NP T IME, F = 

ptime. 

Lemma 6.2: Wenn C ⊆ D, C nach unten abgeschlossen unter ≤ F und A F - vollständig für 

D, dann gilt A ∈ C ⇔ C = D. 

Beweis: ′ ⇐ ′ trivial. 

′ ⇒ ′ : Sei B ∈ D, z.Z. B ∈ C. es reicht B ≤ F A √ 

Lemma 6.3: A F - hart für C, A ≤ F B ⇒ B F -hart für C. 

Lemma 6.4: Wenn C komplementabgeschlossen ist (A ∈ C ⇒ {0,1} ∗ − A ∈ C), dann folgt A 

F -vollständig für C ⇒ {0,1} ∗ − A F -vollständig für C. 

Beweis: Sei B ∈ C, z.Z. B ≤ F {0,1} ∗ − A. Es gilt: {0,1} ∗ − B ≤ F A, d.h. es existiert f ∈ F mit 

d ∈ {0,1} ∗ − B ⇔ f (d) ∈ A 

d.h. 

und damit B ≤ F {0,1} ∗ − A. 

d ∈ B ⇔ f (d) ∈ {0,1} ∗ − A 

38


Satz 6.5: GAP ist logspace-vollständig für NLOGSP ACE. 

Beweis: GAP ∈ NLOGSP ACE → siehe oben. 

Härte: Sei A ∈ NLOGSP ACE, z.Z. A ≤ logspace GAP . 

A = Acc(p) für ein p ∈ nspace(k logn). Setze f (d) = Gp 

k logn (d). f ist eine Reduktion von A 

nach GAP : d ∈ A ⇔ d ∈ Acc(p) ⇔ Gp 

k logn (d) ∈ GAP . 

}{{} 

Platz für f : O(logn) nach Lemma 5.9. 

=f (d) 

Korollar: GAP ∈ LOGSP ACE ⇔ LOGSP ACE = NLOGSP ACE. 

Beweis: LOGSP ACE nach unten abgeschlossen unter ≤ logspace wg. Abgeschlossenheit von 

logspace unter Komplement. 

Beweis: ≤ F ist transitiv, da F Konkatenationsabgeschlossen ist. 

Sei C ∈ C, dann zeige C ≤ F A. Weil B F -hart für C, gilt: C ≤ F B. 

Satz 6.6: REG ∅ = {G reguläre Grammatik | L(G) ∅} ist logspace-vollständig für NLOGSP ACE, 

wobei G = (N,T ,P ,S). 

Beweis: REG ∅ ∈ NLOGSP ACE für REG ∅ ≤ logspace GAP . 

Gegeben: G = (N,T ,P ,S), dazu ein definierter Graph f (G) = (V ,E,S,v end ) mit V = N ∪ T ∪ 

{ɛ} ∪ {v end } und 

E = {(N 1 ,N 2 ) | ∃a ∈ T ,N 1 ::= aN 2 ∈ P } ∪ {(N,a) | N ::= a ∈ P } ∪ {(N,ɛ) | N ::= ɛ ∈ P }... 

Es gilt: G ∈ REG ∅ ⇔ S → ∗ ɛ oder ∃a ∈ T S → ∗ a also f (G) ∈ GAP . 

f braucht nur Zähler, also f ∈ logspace ⇒ REG ∅ ≤ logspace GAP ⇒ REG ∅ ∈ NLOGSP ACE. 

Härte: GAP ≤ logspace REG ∅ . 

Gegeben: H = (V ,E,v 0 ,v end ). Definiere Grammatik G = f (H) durch N = V ,T = {a},P = 

{A ::= aB | A → B ∈ H} ∪ {v end ::= ɛ},S = v 0 . Das a ist hier nur ein Dummy und wird nicht 

benötigt (sonst wäre es keine reg. Grammatik). 

L(G) ∅ ⇔ v 0 → ∗ v end , d.h. f (G) ∈ GAP . f braucht nur Schleifenzähler, also f ∈ logspace. 

6.1 PTIME - Vollständigkeit 

Entspricht einem Mangel an effizienter Parallelisierbarkeit. 

39


Definition 6.7: Boolesche Programme. BOOLE: 

Programme q = I 1 ,...,I m . I ::= X := E | I 1 ;I 2 | goto l | if E then I 1 else I 2 

E := X | true | f alse | E 1 ∧,∨,⇒,⇐ E 2 | ¬E. Semantik wie erwartet, aber keine Eingabe. 

q ↓: q terminiert, q ↑: q terminiert nicht. 

q: Wert der letzten Zuweisung, falls q terminiert, ⊥ (undef.) sonst. 

Anfangszustand: alle Variablen sind am Anfang f alse. 

Untersprachen: SBOOLE, sequentielles BOOLE. Definiert durch Ausschluss von goto. 

Also nicht Turingvollständig. 

MCIRCUIT (monotones BOOLE, monotone Schaltkreise). I ::= X := Y | X := true | X := 

Y ∨,∧Z. 

q heißt einfach zuweisend, genau dann, wenn jede Variable X in höchstens einem X := E in 

q vorkommt. 

Größe: |q|: 1 für jedes Token (;, :=, if, 1). 1 + ⌈log(i + 1)⌉ für Var X i . 

Zentrales Problem: SBOOLE − COMP = {q ∈ SBOOLE | q = true}. 

Lemma 6.8: SBOOLE − COMP ∈ P T IME. 

Beweis: q ∈ SBOOLE hat zunächst polynomielle Laufzeit in |q|. Interpretation auf TM gibt 

polynomiellen Overhead. 

Lemma 6.9: Sei p ∈ ptime T M . Dann existiert f ∈ logspace mit ∀d : p(d) = true ⇔ 

f (d) ∈ SBOOLE − COMP . 

Satz 6.10: 

SBOOLE − COMP ist logspace-vollständig für P T IME. 

Beweis: Sei A ∈ P T IME. Zu zeigen: A ≤ logs SBOOLE − COMP . Es existiert p ∈ ptime, 

es gilt: p(d) = true ⇔ d ∈ A. Sei f wie in Lemma 6.9, dann gilt: d ∈ A ⇔ p(d) = true ⇔ 

f (d) ∈ SBOOLE − COMP . 

Beweis Lemma 6.9: 

Sei p ∈ I 1 ,...,I m ∈ time(π(n)), π Polynomiell. Konstruiere f (d) mit 

40


Variable Bedingung Indizes 

L l Prog.-Zähler = l 1 ≤ l ≤ m + 1 

Ti a Zelle i enthält a ∈ Σ a ∈ Σ,−π(n) ≤ i ≤ π(n) 

Anzahl Variablen gesamt: 6π(n) + 4. Und: i beginnt bei Kopfposition = 0. 

T i := a ≡ (Ti 0 := f alse,Ti 

1 := f alse,Ti 

B := f alse,Ti 

a := true) 

T i := T j ≡ (Ti 0 := Tj 0 ,T i 1 := Tj 1 ,T i 

B := Tj B ) 

Right(r) = (T −r := T −r+1 ,...,T r−1 := T r ,T r := B) 

Lef t(r) = (T r := T r−1 ,...,T −r+1 := T −r ,T −r := B) 

Dann f (a 1 ,...,a n ) = T 1 := a 1 ,...,T n = a n ,T n+1 = B,...,T π(n) = B,T 0 = B,...,T −π(n) = B 

L 1 = true; Makro: ST EP ,...,ST EP . T 1 

}{{} 

1 := T 1 1. 

π(n)−mal 

Zu Step: ST EP = if l 1 then I 1 else if l 2 then... if L m then I m 

Simulation von Instruktionen: 

I l 

I l 

right 

Right(π(n));L l := f alse;L l+1 := true 

left 

analog 

write a 

T 0 := a;L l := f alse;L l+1 := true 

if a goto l 1 else l 2 L l := f alse;L l1 := T0 a;L l 2 

:= ¬T0 

a 

Korrektheit der Bandrepräsentation: Beschriebene Zellen sind nie weiter als π(n) von der Kopfposition 

entfernt. 

Noch zu Zeigen: f ∈ logspace. 

Initialisierungscode per Schleife: Zähler läuft von −π(n) bis +π(n), Platz O(logn). ST EP : 

Zähler von 1,...,m in Platz O(1). I l hat Zähler von −π(n) bis +π(n) in Platz O(logn). π(n) - 

mal ST EP : Zähler, O(logn), insgesamt also f ∈ logspace. 

Monotone Schaltkreise 

Lemma 6.11: Es exisitiert f ∈ logspace,f : SBOOLE → MCURCUIT mit f (p) = p 

und f (p) ist einfach zuweisend. 

Satz 6.12: MCURCUIT − COMP := SBOOLE − COMP ∩ MCURCUIT ist P T IME - 

vollständig, sogar noch für MCURCUIT ≤a (MCURCUIT mit einfacher Zuweisung). 

41


Schrittweise Reduktion. p n → q 1 → q 2 → q 3 → q 4 Semanti- 

Beweis des Lemma 6.11: 

kerhaltend. 

(a) Z := E in q 1 ⇒ E ::= X | true | X∨,∧Y | ¬X 

if E... in q n ⇒ E ::= X 

Konstruktion: Ersetze f alse durch uninitialisierte Variablen. Ersetze komplexe Terme durch 

Folgen von Zuweisungen, wie z.B.: X := (Y ∧ Z) ∨ (W ∧ Z) wird zu U 1 = Y ∧ Z,U 2 = 

W ∧ Z,X = U 1 ∨ U 2 . 

⇔,⇒ ersetzen durch ∧,∨,¬, z.B.: X ⇒ Y ≡ ¬X ∨ Y . 

Die Reduktion in logspace: Vermeide echte Rekursion mit linear tiefem Stack. Schachtelungstiefe 

per Zähler verfolgen, in etwa: Gesamttiefe messen (2 Zähler), Tiefste Ebene 

übersetzen (zählen), zweittiefste Ebene übersetzen (zählen), usw. Konstant viele Zähler, jeweils 

O(logn). 

(b) Kein if (also auch kein ; mehr) in q 2 : q 1 = I 1 ,...,I m ⇒ q 2 = GO := true,I 1 ,...,I m 

• if U then I else J = V := U;S := GO;GO := S ∧ V ;I;GO := S ∧ ¬V ; J;GO := S 

mit S,V frisch. 

• I,J = I;J 

• X := E = X := (E ∧ G) ∨ (X ∧ ¬GO) 

in logspace: Vermeide echte Rekursion mit Stack aus lineare vielen S. Stattdessen durchnummerierung: 

S = S 1 ,S 2 ,S 3 ,... Schachtelungstiefe der if s mitzählen und der aktuellen 

Tiefe entsprechend S verwenden. 

(c) Idee: führe ¬X als Var X ′ mit q 2 = I 1 ,...,I m . V ars(q 2 ) = {X 1 ,...,X k }. 

Dann: q 3 = X ′ 1 := true,...,X′ k := true,I 1,...,I m mit 

• X := true := X := true,X ′ := S,S frisch. 

• X := Y := X := Y ,X ′ := Y ′ 

• X := Y ∧ Z := X := Y ∧ Z,X ′ := Y ′ ∨ Z ′ 

• X := Y ∨ Z := X := Y ∨ Z,X ′ := Y ′ ∧ Z ′ 

• X := ¬Y := T := Y ,X := Y ′ ,X ′ := T 

• X Y := X := Y ′ ,X ′ := Y 

Platz: Zähler 1,...,k für Präfix: O(logk), Übersetzung I → I in O(logk) (für V ar-Indices) 

und Programmzähler 1,...,n in O(logn) 

Verschärfung: q einfach zuweisend, wenn 

• jede Variable X taucht in q höchstens in einer Zuweisung X := E auf. 

42


• wenn in q eine Zuweisung X := E vorkommt und Y ∈ V ars(E), dann gilt: 

– q enthält Y := F vor X := E 

– q enthält keine Zuweisung an Y 

(d) Konstruiere q 4 einfach zuweisend (q 4 = q 3 ). Sei q 3 = I 1 ,...,I m , dann ist q 4 = I 1 ,...,I m 

mit 

• l : X := E = X l := E l mit X 1 ,...,X l (alle verschieden, l frisch) 

E l aus E durch Ersetzen der in E vorkommenden Variable Y . 

• suche in q 3 ab l rückwärts nach k : Y := D 

• ersetze Y durch X k , wenn gefunden 

Platz: Braucht nur Pointer (für das aktuelle l) und für die Rückwärtssuche und Variablenindizes 

⇒ O(logn) 

Horn - SAT 


Eine positive Hornklausel ist eine aussagenlogische Formel der Form 

C = A 1 ∧ ... ∧ A n → A 0 

mit A 0 ,...,A n ∈ V (Aussagenvariablen). Eine positive Hornform ist eine Konjunktion H von 

positiven Hornklauseln. 

H |= A ⇔ ∀κ : V → {T ,F} 

Wenn κ(H) = T gilt: κ(A) = T . 

Bsp.: (A ∧ B → C) ∧ (A ∧ C → D) ∧ (A → B) ∧ (A) ≡ H, ⇒ H |= D 

Wenn H |= A, dann gilt H ∧ ¬A ist unerfüllbar. 

Problem: pHorn = {(H,A) | H |= A} 

Satz 6.13: 

pHorn ist P T IME-vollständig. 

Bemerkung 6.14: Allgemeiner kann man Erfüllbarkeit von (nicht notwendigerweise positiven) 

Hornformen betrachten, d.h. Konjunktionen von Hornklauseln wie A 1 ∧...∧A n → A 0 oder 

A 1 ∧ ... ∧ A n → ⊥. 

43


Problem: HORN = {H Hornform | H erfüllbar } ist auch P T IME-vollständig. Obere Schranke 

wie in Satz 6.13, untere Schranke aus Satz 6.13. 

Beweis von Satz 6.13: Obere Schranke: Boolesches Array M[V ars(H,A)] von Markierungen 

wird auf f alse initialisiert. 

while applicable (* "solange wir können" *) 

pick A1 and ... and An -> A0 in H with 

M[A1] = true & ... & M[An] = true & M[A0] = false 

M[A0] = true 

return M[A] 

Schleifendurchläufe ≤ #Klauseln in H. Einzelner Schleifendurchlauf: lineare Suche durch H. 

Anwendungsbedingung: Schleife 1,...,n linear. 

Insgesamt also ptime. 

Zu zeigen: Algo antwortet true, gdw. H |= A. 

” ⇒ ” Invariante ∀V ∈ V ars(H,A),[B] = true ⇒ H |= B 

” ⇐ ” Algo antwortet f alse. Lies M als Valuation. Dann M(H) = true wenn 

C = A 1 ∧ ... ∧ A n → A 0 in H mit M(A 1 ) = true&...&M(A n ) = true, dann M(A 0 ) = true, weil 

die Schleife beendet wurde. 

Aber M(A) = f alse, folglich H ̸|= A 

Untere Schranke: Reduktion von MCURCUIT − COMP mit Einfachzuweisung. 

Sei q ∈ MCURCUIT , einfachzuweisend. q = 1 : X 1 := E 1 ,...,n : X n := E n wobei alle 

X 1 ,...,X n verschieden sind. Dann ist f (q) = (H,X m ) mit H ist eine Konjunktion von Hornklauseln 

• → X für X := true in q 

• Y → X für X := Y in q 

• Y ∧ Z → X für X := Y ∧ Z in q 

• Y → X,Z → X für X := Y ∨ Z in q 

Offenbar ist f ∈ logspace. 

44


Sei q ⊢ (1,σ 0 ) → ... → (m + 1,σ m ), dann ist zu zeigen, dass 

f (q) ∈ pHORN 

}{{} 

H|=X m 

⇔ q ∈ MCURCUIT − COMP 

}{{} 

σ m (X m )=T 

Zeige per Induktion: H |= X i ⇔ σ i (X i ) = T . 

Der Schritt geht von k 

zeigen es für i: Fallunterscheidung nach E i . 

• E i = true: Dann ist σ i (X i ) = T und H |= X i , da → X i in H 

• E i = Y ,Y {X 1 ,...,X m }: Dann ist σ i (X i ) = F und ... 

Beweis: Sei κ(V ) = F für alle Variablen V {X 1 ,...,X n },κ(X i ) = T mit (i = 

1,...,m). Insbesondere ist κ(Y ) = F. κ(H) = T . Also H ̸|= X i (per κ wie oben, 

Valuation κ(X i ) → F). 

... H ̸|= X i , Gegenbeispiel: κ(X j ) = T für j i,κ(V ) = F sonst. Dann κ(H) = T : klar für 

Klauseln ... → X j ,j i. Ferner auch okay für Y → X i wegen κ(Y ) = F. 

• E i = X j : Dann ist j < i. σ i (X i ) = T ⇔ σ i (X j ) = T und ⇔ j


Beweis: obere Schranke per CF ∅ ≤ logspace pHorn. 

Produktion N ::= A 1 ,...,A n wird in eine positive Hornklausel H übersetzt A 1 ∧ ... ∧ A n → N. 

A 0 ::= ɛ. Zusätzlich werden folgende Axiome hinzugefügt: → a für alle Terminalen a ∈ T . Teste 

ob H |= S. 

untere Schranke: per pHorn ≤ logspace CF ∅ . Übersetze positive Hornklausel A 1 ∧...∧A n → A 0 

in Produktion A 0 ::= A 1 ,...,A n mit n ≥ 0. Bei Test auf H |= A wird A das Startsymbol. Das ganze 

gibt jetzt die Grammatik G. L(G) ∅ (dann = {ɛ}) ⇔ H |= A. 

Spiele 

Ein zwei-Spieler Spiel G = (P 1 ,P 2 ,W 0 ,M) besteht aus folgenden Kompo- 


nenten: 

• endliche Mengen P 1 ,P 2 von Spielerpositionen für Spieler 1 bzw. Spieler 2. 

• eine Menge W 0 ⊆ P 1 von gewonnenen Positionen für Spieler 1 (das Spiel ist zu Ende und 

Spieler 1 gewinnt) 

• eine Menge von Zügen M ⊆ (P 1 × P 2 ) ∪ (P 2 × P 1 ) 

Die Menge der Gewinnpositionen für Spieler 1 ist die kleinste Menge W ⊆ P 1 mit W 0 ⊆ W und 

∀p 1 ∈ P 1 : (∃(p 1 ,p 2 ) ∈ M : ∀(p 2 ,p 3 ) ∈ M : p 3 ∈ W ) ⇒ p 1 ∈ W 

Def.: V 0 ⊆ V 1 ⊆ durch V 0 ∅, V i+1 = F(V i ), Behauptung: W = ⋃ ∞ 

i=0 V i 

Zu Zeigen: ∀i,V i ⊆ V i+1 Induktion: i = 0 trivial. 

i → i + 1: F monoton: ∀X,Y ,X ⊆ Y ⇒ F(X) ⊆ F(Y ) 

V i+1 = F(V i ) ⊆ F(V i+1 ) = V i+1 

√ 

Da P 1 endlich, exisitiert i ≤ |P 1 | mit V i = V i+1 = F(V i ) dann V j = V i ,∀j ≥ i, dann ⋃ ∞ 

j=0 V j = V i . 

Insbesondere F(V i ) ⊆ V i 

√ 

Noch zu Zeigen: kleinster Präfixpunkt. Sei P (Y ) ⊆ Y ⊆ P 1 , zeige V j ⊆ Y durch Induktion: 

Fall j = 0 trivial. Fall j → j + 1: V j+1 = F(V j ) ⊆ F(Y ) ⊆ Y √ 

Das alles braucht nur P 1 endlich, F monoton. 

Allgemein: P (W ) ⊆ W bedeutet, dass W Präfixpunkt von P ist. 

Problem: GAME = {(G = (P 1 ,P 2 ,W 0 ,M),p ∈ P 1 ) | ”p ∈ W ”, Gewinnpos. für Spieler 1 } 

Satz 6.16: 

GAME ist P T IME - vollständig. 

46


Beweis: 

Obere Schranke. 

V new = ∅ 

repeat: 

V = V new 

V new := F(V ) 

until V = V new 

return ”p ∈ V ” 

≤ |P 1 | Schleifendurchläufe, poly. Zeit pro Durchlauf, also ptime. Korrektheit nach obigem am 

Ende V = Menge der Gewinnpositionen. 

Untere Schranke: per pHORN ≤ logspace GAME. 

Gegeben: (H,A), konstruiere f (H,A) = (G,A) mit G = (V ar(H,A), 

H }{{} 

Menge von positiven Hornklauseln 

M = {(A 0 ,A 1 ∧...∧A n → A 0 ) | A 1 ∧...∧A n → A 0 ∈ H} ∪{(A 1 ∧...∧A n → A 0 ,A i ) | i ∈ {1,...,n}} 

Zu zeigen: (G,A) ∈ GAME ⇔ H |= A 

” ⇒ ” Zeige F(Y ) ⊆ Y für Y = {B|H |= B} 

” ⇐ ” Fasse Gewinnpositionen W ⊆ P 1 = V ar(H,A) als Valuation auf. Zeige W (H) = T 

→ offenbar f ∈ logspace. 

6.2 NPTIME - Vollständigkeit 

P T IME - Urproblem: P T IME − COMP = {(p,d,π) | π poly.,p ∈ ptime(π(n)),p(d) = T } 

P T IME - vollständig: obere Schranke. Interpretiere p(d) für π(|d|) Schritte. 

Zeit polynomiell in |p|,π(|d|). 

Untere Schranke. Sei A ∈ P T IME, dann existiert ein p ∈ ptime(π(n)), π polynomiell, d ∈ A ⇔ 

p(d) = T . Setze f (d) = (p,d,π), dann d ∈ A ⇔ f (d) ∈ P T IME − COMP . 

f ∈ logspace klar. 

Wiederholung: P T IME - vollständigkeit von pHORN, P T IME − COMP → SBOOLE − 

COMP → MCIRCUIT → pHORN 

Analoger Plan für NP T IME: NP T IME − COMP = {(p,d,π) | πpoly.p ∈ ntime(π(n)),d ∈ 

Acc(p)} → SBOOLE − NONT RIV → ... → 3SAT 

Triviale Probleme geben immer f alse aus, egal wie die Variablen initialisiert worden 

sind. Bei nicht - trivialen Programmen können wir die Variablen so initialisieren, 

dass auch true rauskommen kann. 

,∅,M) 

47


SBOOLE−NONT RIV = {q ∈ SBOOLE | ∃Init = (X 1 := b 1 ,...,X n = b n ),b 1 ,...,b n ∈ {true,f alse}, 

Init,q = T } 

Reduktion 1: Gegeben (p,d,π),p ∈ ntime(π(n)). Konstruiere q analog wie für ptime, mit 

letzter Instruktion L m+1 := L m+1 und dem nichtdeterministischen 

l : goto l 1 or l 2 

= L l := f alse;if O t then L l1 = true else L l2 = true 

O t ist das Orakel zum Zeitpunkt t, d.h. t − te Kopie von ST EP . 

V ar(q ′ ) = {X 1 ,...,X k ,O 1 ,...,O π(|d|) } 

q = X 1 := f alse,...,X k := f alse,q ′ 

Dann q ∈ SBOOLE − NONT RIV ⇔ d ∈ Acc(p), q konstruierbar in logspace. 

Reduktion 2: Wie bisher, nur ohne if, ←,→, kompl. Ausdrücke, einfache Zuweisungen. Wir 

können hier nicht davon ausgehen, dass alle Variablen standartmäßig auf f alse stehen. (f alse 

wird nicht eleminiert, also kein Bedarf an uninitialisierten Variablen). 

Reduktion 3: 3SAT . Wiederholung: 3CNF ist eine Konjugation von Klauseln aus je ≤ 3 

Literalen. 3SAT = {ϕ 3CNF | ϕ erfüllbar } ∈ P T IME. Obere Schranke trivial. 

Untere Schranke: Aus q = I 1 ,...,I m ∈ SBOOLE spezifiziert mit den bekannten Einschränkungen. 

Konstruiere 3CNF F mit Klauseln wie bisher, plus 

• ¬X für X := f alse in q 

• ¬Y → X ≡ Y ∨ X für X := ¬Y in q 

F ∈ 3SAT ⇔ q ∈ SBOOLE −COMP und κ(F ) = T ⇔ X 1 := κ(X 1 ),...,X k := κ(X k ),q = T 

(Induktion: q tut nichts) mit V ars(q) = {X 1 ,...,X k }, wie im Horn - Fall. 

Satz: 

3SAT ist logspace-vollständig für nptime. 

6.3 PSPACE - vollständigkeit 

BOOLE: BOOLE − COMP = {p ∈ BOOLE | p = T } 

Satz: 

BOOLE − COMP ist logspace - vollständig für P SP ACE. 

48


Beweis: Beachte: BOOLE − COMP ist nicht Turingmächtig, da man Variablen nur boolesche 

Werte und keine beliebigen Zahlen geben kann. Man kann keinen zusätzlichen Speicherplatz 

anfordern. Folglich ist klar, wie lang es dauert bis das Programm terminiert, wenn es denn 

terminiert. 

⇒ Wenn p = I 1 ,...,I m ∈ BOOL mit |V ars(p)| = k terminiert, dann in maximal 2 k · m Schritten. 

Interpretiere also p mit Timeout 2 k · m, gebe JA zurück, wenn Endzustand (m + 1,σ) und die 

letzte Zuweisung true war. 

Platz: Wert der letzten Zuweisung: O(1). Zustand: k Variablen + Label l: O(|p|+log|p|) = O(|p|). 

Zähler: O(log2 k · m) = O(k + logm) = O(|p|). 

Untere Schranke: Sei p ∈ space T M (π(n)), π polynomiell, dann {d | p(d) = T } ≤ logspace BOOLE− 

COMP . Zu d ∈ {0,1} ∗ konstruiere f (d) (BOOLE) mit p(d) = T ⇔ f (d) ∈ BOOLE − 

COMP . 

Analog wie für P T IME: 

f (d) = Init; (* d aus Bdg., Rest des Bands leer von −π(n) bis π(n) *) 

L 1 = true 

while ¬L m+1 do STEP 

T 1 1 := T 1 1 

Korrektheit, logspace wie bisher. 

Korollar: BOOLE − T ERM = {p ∈ BOOLE | p ↓} (p terminiert) ist logspace - vollständig 

für P SP ACE. 

Beweis: Obere Schranke: per BOOLE − T ERM ≤ logspace BOOLE − COMP . 

q ∈ BOOLE − T ERM ⇔ q;X := true ∈ BOOLE − COMP . 

Untere Schranke: BOOLE −COMP ′ = BOOLE −COMP , eingeschränkt auf letzte Zuweisung 

in letzter Zeile. Nach obigen Beweis ist BOOLE − COMP ′ P SP ACE - vollständig. 

BOOLE − COMP ′ ≤ logspace BOOLE − T ERM 

q;X := E ⇔ q;X := E,m + 1, if ¬X goto m + 1 (linke Seite BOOLE − COMP ′ , rechte Seite 

BOOLE − T ERM). 

6.4 Quantifizierte Boolesche Formeln 

QBF : E ::= X | true | f alse | E 1 ∧ ∨ → E 2 | ¬E, ∀X.E ∃X.E 

49


Valuation κ(∀X.E) = κ(E[X → true]) ∧ κ(E[X → f alse]) 

κ(∃X.E) = κ(E[X → true]) ∨ κ(E[X → f alse]) 

Freie Variablen: FV (X) = {X}, FV (true) = FV (f alse) = ∅,FV (E 1 ×E 2 ) = FV (E 1 )∪FV (E 2 ),FV (¬E) = 

FV (E) FV (∀X.E) = FV (∃X.E) = FV (E) − {X} 

E ist abgeschlossen ⇔ FV (E) = ∅ 

Def.: QBF − SAT = {E ∈ QBF | ∃κ.κ(E) = true} 

Def.: QBT = {E ∈ QBF | E abgeschlossen, E = T } (quantifying boolean truth) 

QBT ≼ logspace QBF − SAT ist klar. 

QBF−SAT ≼ logspace QBT : E ∈ QBF−SAT (P V (E) = {X 1 ,...,X k }) ⇔ ∃X 1 ,...,∃X k : E ∈ QBT 

QBF ist kodierbar in ’normale’ Aussagenlogik. Übersetzung: t. 

t(∀X.E) = E[X → true] ∧ E[X → f alse] 

t(∃X.E) = E[X → true] ∨ E[X → f alse] 

⇒ exponentieller Blowup. 

Satz 6.18: QBT ist logspace-vollständig für P SP ACE. 

Beweis obere Schranke: 

(a) Eleminiere →,∧,∨,↔ 

• FALSCH: ( E 1 ↔ E 2 durch ∃X.(E 1 → X ∧ X → E 2 ) ), wird so gelassen wie es ist 

(b) Eleminiere ∀X.E per ¬∃X.¬E 

(c) Rekursive Funktion T rue(E) für E abgeschlossen 

• T rue(E) = case E of E 1 ∧ E 2 → T rue(E 1 ) ∧ T rue(E 2 ) 

• ¬E → ¬T rue(E) 

• true → T 

• ∃X.E → T rue(E[X → true]) ∨ T rue(E[X → f alse]) 

Implementierung: linear tiefer Stack für Rekursion, lineare große Stack Frames (Ausdruck, 

Rücksprung). 

Untere Schranke: Per Reduktion von BOOLE − T ERM. Reduktion zunächst auf BOOLE − − 

T ERM, d.h. also BOOLE − T ERM eingeschränkt auf 

50


p = I 1 ,...,I m mit I ::= X := true | X := f alse | if X goto l 1 else l 2 

Dazu: Eliminiere komplexe Ausdrücke wie gehabt. Eliminiere komplexe if s durch if /goto. 

Emulation einfacher Ausdrücke: z.B. X := Y ∧ Z → 

X := false 

if Y goto l1 else l2 

l1: if Z goto l2 else l3 

l2: X := true 

l3: ... 

⇒ ’offensichtlich’ in logspace. 

Codierung eines Schritts von p := I 1 ,...,I m mit V ars(p) = {X 1 ,...,X k } in QBF mit Variablen 

X 1 ,...,X k ,L 1 ,...,L m (Labels). 

}{{} }{{} 

⃗X 

⃗L 

Definition: N×(⃗X,⃗L, ⃗X ′ ,⃗L ′ ), so dass p ⊢ (l,o) → (l ′ ,o ′ ) ⇒ N×(σ(X 1 ),....,σ(X n ),F,...,F, 

σ ′ (X 1 ),...,σ ′ (X k ),F,...,F, 

T 

}{{} 

l ′ -te Stelle 

Schreibweise: für ⃗U = (u 1 ,...,u s ), ⃗V = (v 1 ,...,v s ) wobei 

• ⃗U ↔ ⃗V ≡ ∧ s 

i=1 (u i ↔ v i ) für I ⊆ {1,...,s} 

• ⃗U ↔ I 

⃗V ≡ ∧ i=I (u i ↔ v i ) 

• [r,w) = {r,...,w − 1} etc. 

• Lab(l) = L l ∧ ∧ i l ¬L i entsprechend Lab ′ (l) 

,F,....,F) (unterstelle p ⊢ (m + 1,σ) → (m + 1,σ)) 

T 

}{{} 

l-te Stelle 

Damit N ×(⃗X,⃗L, ⃗X ′ ,⃗L ′ ) = (Lab(1)∧E 1 )∨...∨(Lab(m)∧E m )∨(Lab(m+1)∧Lab ′ (m+1)∧ ⃗X ↔ ⃗X ′ ) 

mit 

,F,...,F, 

I l 

E l 

X i := true Lab ′ (l + 1) ∧ ⃗X ↔ [1,i)∪(i,k] X ′ ∧ X 

i 

′ 

X i := f alse ... ∧ ¬X 

i 

′ 

if X i goto l 1 else l 2 ((X i ∧ Lab ′ (l 1 )) ∨ (¬X i ∧ Lab ′ (l 2 ))) ∧ (⃗X ↔ ⃗X ′ ) 

51


Codierung der Ausführung von p: 

Wiederholung: wenn p terminiert, dann time(p) ≤ 2 r mit r = k⌈log(m + 1)⌉. N× ist ein binäres 

Prädikat N × (s,s ′ ),s,s ′ Zustände. 

Notation: N × n (s,s ′ ) ⇔ ∃s = s 0 ,s 1 ,...,s n = s ′ . N × (s 0 ,s 1 ) ∧ ... ∧ N × (s n−1 ,s n ). 

p ↓↔ ∃⃗X ′ ,⃗L ′ .N × 2r (s 0 , ⃗X ′ ,⃗L ′ ) ∧ L ′ m+1 ,s 0 = ( f alse,true, ⃗ f alse) ⃗ 

Trick 1: Divide-and-conquer. N × 20 (s,s ′ ) = N × (s,s ′ ),N × 2r+1 (s,s ′ ) = ∃s ′′ .N × 2r (s,s ′′ ) ∧ N × 2r 

(s ′′ ,s ′ ) → immer noch exponentiell. 

Trick 2: Unformulieren in Tailrekursion. N × 2r+1 (s,s ′ ) = ∃s ′′ .∀t,w.((t = s ∧ w = s ′′ ) ∨ (t = 

s ′′ ∧ w = s ′ )) → N × 2r (t,w), linear groß. 

ALC 

ALC ist eine Teilsprache der Web ontology language OW L. 

Formeln aus dieser Sprache heißen Konzepte C. 

C ::= A | T | ¬C | C 

}{{} }{{} 1 ⊓ C 2 | ∀R.C 

}{{} 

atomare Konzepte A ∈ A 

Interpretation: 

True 

I besteht aus 

• Bereich ∆ I (Menge) 

• A I ⊆ ∆ I ,∀A ∈ A 

• R I ⊆ ∆ I × ∆ I ,∀R ∈ R 

Rollen R ∈ R 

Semantik: C I ⊆ ∆ I def. durch T I = ∆ I , (¬C) I = ∆ I − C I mit (C I 1 ⊓ CI 2 ) = CI 1 ∩ CI 2 

(∀R.C) I = {d ∈ ∆ I | ∀e ∈ ∆ I .(d,e) ∈ R I ⇒ e ∈ C I } 

Beispiel: ChessFanatic = ChessP layer ⊓ ∀hasFriend.ChessFanatic 

C erfüllbar ⇔ ∃I.C I ∅, zum Beispiel: ∀R.C ⊓ ∀R.D ⊓ ∀R.(C ⊓ D) ist unerfüllbar. 

∀R.C ⊓ ∀R.(¬C) ist erfüllbar. 

52


Satz 6.19: ALC − SAT = {C | C erfüllbar} ist P SP ACE vollständig (Ladner 1977). 

Beweis: Obere Schranke ist ein Tableaux - System: 

C 1 ⊓ C 2 ,Γ 

C 1 ,C 2 ,Γ 

T ,Γ 

Γ 

¬¬C,Γ 

C,Γ 

¬(C 1 ⊓ C 2 ),Γ 

¬C 1 ,Γ | ¬C 2 ,Γ 

Γ erfolgreich, wenn keine Regel anwendbar auf Γ ist. 

A,¬A,Γ 

⊥ 

∀R.C 1 ,...,∀R.C n ,¬∀R.D,Γ 

C 1 ,...,C n ,¬D 

Beispiel: 

(∀R.C ⊔ D) ⊓ ¬∀R.D 

∀R.C⊔D,¬∀R.D 

C⊔D,¬D 

= mit der letzten Zeile folgt... 

= 

¬(¬(¬C ⊓ ¬D)) 

¬¬C,¬D 

C,¬D √ 

| ¬¬D,¬D 

D,¬D 

⊥ 

Algorithmus in npspace: Prüfe per Tiefensuche, dass alle Zweige erfolgreich enden. Rate bei 

¬(C ⊓ D). Lineare Tiefe ⇒ polynomieller Platz. 

Untere Schranke: Zeige QBT ≼ logspace ALC −SAT . QBF ohne Einschränkung in Normalform: 

Q 1 .x 1 .Q 2 .x 2 .....Q n .x n .ϕ mit Q i ∈ {∃,∀}, ϕ ist quantorenfrei. 

(z.B. (∃X.ϕ) ∧ π = ∃X.(ϕ ∧ π), wenn X ∈ FV (π)) 

Idee: zu prüfende Valuation der Variablen X 1 ,...,X n haben eine Baumstruktur: z.B. ∀X 1 .∃X 1 .∀X 3 .ϕ → 

(Bild eines Baums an der Tafel). 

Beschreibe das durch ALC−Konzept. Ebenen 0,...,n markiert durch atomare Konzepte Y 0 ,...,Y n . 

(∀R) m .C = ∀R....∀R.C 

}{{} 

m− mal 

| (∀R) ≤m .C = 

m∧ 

(∀R) m .C | ∃R.C = ¬∀R.¬C 

i=0 

Damit: 

∧ 

(∀R) i .(Y i ∧ ¬Y j ), (i = 0,m) 

j¬=i 

(∀R) i .(Y i → ∃R.Y i+1 ), (Q i = ∃) 

(∀R) i .(Y i → (∃R.(Y i+1 ∧ X i )) ∧ (∃R.(Y i+1 ∧ ¬X i ))) 

(∀R) i .((X i → (∀R) ≥m−i X i ) ∧ (¬X i → (∀R) ≤m−i ¬X i )) 

(∀R) m .ϕ 

53


7 Parallel computation models 

Definition 7.1: A P RAM is a sequence P = (π 1 ,...,π q ) of standard RAM programs (we have 

+ but no ·). q := q(m,n) is a function where m is the amount of registers used for the input and 

n is the total size of the input in bits. For a given problem we actually have a family of P RAM 

programs. We insist that the family needs to be uniform. That is, there is a TM that on input 

1 n 01 m can construct the P RAM program P m,n = (π m,n,0 ,π m,n,1 ,...,π m,n,q(m,n) ) in logarithmic 

space. 

Definition 7.2: Semantics of P RAM. A configuration of the P RAM m,n is a tuple 

(pc 0 ,pc 2 ,...,pc q(m,n) ) where pc i is the program counter of Π and σ : N → N is the value of 

the registers. The semantics of RAM π ⊢ (pc,σ) → (pc ′ ,σ ′ ) this is trivially extended to the 

(π 0 ,...,π q(m,n) ) ⊢ (pc 0 ,...,pc q(m,n) ) → (pc 0 ,...,pc q(m,n) ). With one catch if two or more programs 

(π i,1 ,...,π i,j ) want to write on step k to the same end of the store, the one with the smallest index 

wins. 

Definition 7.3: Time consumption of P RAMs. Let P = (P m,n ) be a unique family of P RAMs 

and let f ,g : N → N. We say that P runs in parralel time f with g processors if 

(i) q(m,n) < g(n) 

(ii) after f (n) steps we are in a configuration (pc 1 ,...,pc q(m,n) ,σ) where each pc i is the final 

state of π i . 

Example 7.4: Matrix multiplication. We are given square matrices A,B (m×m). The product 

C = AB is C i,j = ∑ n 

k=1 

A ik B kj . 

Parallelization: 

• create n 3 processors 

• in the first step we compute a matrix D (n × n × n) such that D i,j,k = A i,k · B k,j 

• We use n 2 of these processors to compute in steps 2ton C i,j (each processor one of the 

cells of C) 

Analysis: it runs in parallel time n with n 3 processors. The total number of operations is O(n 3 ). 

54


Example 7.5: 

We have a list L of n numbers. We want to sum them. 

• create n 2 processors 

• on step 1 we compute L 1 such that L 1 [i] = L[2i] + L[2i + 1] (|L| = ⌈ n 2 ⌉) 

• on step 2 we compute L 2 such that L 2 [i] = L 1 [2i] + L 1 [2i + 1] ... on step logn L logn has 

the size 1 

Analysis: it runs in parallel time logn with n 2 processors. 

Matrix multiplication can be done in logn parallels steps with n 3 proces- 

Observation 7.6: 

sors. 

Observation 7.7: The algorithm for summing numbers works for any associative operator 

⊙ (e.g. (X ⊙ Y ) ⊙ Z = X ⊙ (Y ⊙ Z)). This is the idea behind Map Reduce. We have a ’list A’ we 

first apply a function A → B to have ’list B’ (map step). We transform the ’list B’ into a B using 

a function ⊙ : B × B → B (associative), the reduce step. Finally, we need a function B → C to 

get the result. 

Example: get the longest words from a list of words. A = words, B =(set of words, N) and 

C =set word. f : WORD → (set of words, ). f (x) = ({x},|x|). 

⎧ 

(xs,lx) if lx > ly 

⎪⎨ 

(xs,lx) ⊙ (ys,lx) = (ys,ly) if ly > lx 

⎪⎩ (xs ∪ ys,lx) if lx == ly 

(associative) g : (set of words, N) → set word g(x,y) = x 

Look again at matrix multiplication: c · n 3 (total number of multiplications) ≤ d logn (parallel 

time) ·#processors ⇒ c d · n 3 

logn ≤ #processors 

Can we have matrix multiplication with parallel time O(logn) and O( n3 

logn ) processors? 

Lemma 7.8 Brent’s principle. If a algorithm runs in parallel time t on a P RAM with k processors 

executing a total number of X of operations, then it runs in parallel time c(t + X p ) on a 

P RAM with R processors (P ≤ R). 

Proof: Let X i be the number of operations being performed at step i, of course X = ∑ t 

i=1 x i . 

The i-th step can be simulated using only p processors. 

55


This requires time c( x i 

p 

+ 1). The total running time of the simulation is 

t∑ 

i=1 

c( x i 

p + 1) = ct + c p 

t∑ 

x i = ct + cX p = c(t + X p ) 

For the case of multiplication we have t = logn,X = n 3 ,k = n 3 ,p = n3 

logn : 

i=1 

c(logn + n3 

) = c(logn + logn) 

n 3 

logn 

Parallel time f total number of g operations it can be done with f g processors. 

Definition 7.9: Bool circiuts. A boolean curcuit is a DAG where each node is a ∧− gate or 

a ∨− gate (in-degree 2), or a ¬− gate (with in-degree 1) or a leaf (input nodes). The size of 

a BC is the number of nodes and the depth is the length of the longest path. A circuit family 

is a sequence C = (c 0 ,c 1 ,...) where each c i is a boolean circuit with i input nodes. A familiy is 

uniform if there is a TM that on input 1 n outputs c n in logarithmic space. We say that the parallel 

time of a family c is f if the depth of c n is at most f (n), the total work is g if the size of c n is at 

most g(n),∀n. 

Definition 7.10: Nick’s Class - NC. We define NC i as the problems that can be solved by a 

uniform circuit family of polynomiell size (small) and O(log i n) parallel time (fast). 

⋃ 

NC = NC i 

Theroem 7.11: A problem is in NC if it can be solved by a uniform P RAM family in 

polylogarithmic parallel time with polynomial many processors. 

Proof: ” ⇒ ” Let be c n with size n k and depth log i n. We create p p n = (π 1 ,...,π n k). Let g i be 

a gate c n , let d be the depth of this gate. We program π i as follows (assume g i is ∧-gate, g j and 

g k are the inputs of g i ). 

1: NOP 

2: NOP 

... 

3d+1: if Xj = 0 then goto end 

i 

56


3d+2: if Xk = 0 then goto end 

3d+3: Xi = 1 

An induction shows that the algorithm is correct. d can be computed in logarithmic space, so all 

p can be computed in logspace. 

” ⇐ ” Let m be the number of bits in the input. After t steps the size of the largest register is n+ 

b + t (b is the largest constant in a program). This can be proofed by induction on t. The number 

of registers that can be written in t steps is t · #processors. A configuration (pc 1 ,...,pc k ,σ) can 

be encoded with polynomially bits. 

One-Step-Parallel-Curcuit 

Input: pc 1 ,...pc k and σ 11 ,σ 12 ,.... 

Output: pc ′ 1 ,...,pc′ k and σ ′ . 

Corollar 7.12: 

NC ⊆ P T IME. Open question: NC = P T IME? 

Theorem 7.13: NL ⊆ NC 2 (nondeterministic logarithmic space) 

Proof: We know that GAP is NL− complete. We first show that GAP is in NC 2 . Let A be the 

adjacency matrix and Â be the addition all self-loops (Âij = 1). Consider the boolean product 

Â 2 = ÂÂ and Â2 ij = ∨ n 

k=1 

(Âik ∧ Âkj). 

Be aware: Â 2 ij 

= 1 if there is a path of length at most 2 between i and j. 

Doing Â4 = Â2 Â 2 we get Â 4 ij 

= 1 if there is a path of length at most 4. Â2⌈logn⌉ = Ân the 

adjacency matrix of the transitive closure of A. We stack logarithmically many BC of O(n 3 ) size 

and O(logn) depth that solve boolean matrix multiplication and get a BC with size O(logn 3 ) 

and depth O(log 2 n) ∈ NC 2 . 

Let R be the logspace reduction function. We are trying to show that x is in NC 2 . BIT (a,i) = 

bit i of a is in logspace. BIT − of − R(x,i) = bit(R(x),i) is in logspace. The state graph of the 

TM for bit − of − R can be generated in logspace. The size of this graph grows polynomially 

with |x|. 

57

Skript zur Vorlesung KomplexitÂ¨at von Algorithmen

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?