Berechenbarkeit und Komplexitätstheorie

Kapitel 1.5: Äquivalenz von RAM und TM
Berechenbarkeit und
Komplexitätstheorie
5. Vorlesung
Jede RAM-berechenbare Funktion kann auch
”
von einer Turingmaschine berechnet werden
und umgekehrt.“
D.h.:
Martin Dietzfelbinger
Die beiden Modelle haben die gleiche Berechnungskraft“.
”
Beweismethode: Wechselseitige Simulation.
13. November 2009
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
FG Komplexitätstheorie und Effiziente Algorithmen
TM auf RAM: Satz 1.5.1
BuK – 13.11.2009
1
Zeitbedarf
Zu jeder TM M = (Q, Σ, . . . ) können wir (konstruktiv/algorithmisch!) eine RAM M finden,
Erweiterung von Satz 1.5.1:
die dasselbe Ein-/Ausgabeverhalten wie M hat,
Zahl der Schritte von M auf x ist O(|x| + tM (x)), falls M
auf x hält.
d.h.: für jedes x = a1 · · · an ∈ Σ∗ gilt:
Überlege dazu:
• M hält auf Eingabe x = a1 . . . an
⇒
M hält auf Eingabe x = (a1, . . . , an)
und die Ausgabe von M auf x ist fM (x).
• Initialisierung: O(|Γ|), also konstant
• Jeder Schritt: O(|Γ|), also konstant
• Nachbearbeitung: O(|fM (x)| + 1), also O(|x| + tM (x))
• M hält nicht auf x ⇒ M hält nicht auf x.
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
2
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
3
(Logarithmische) Kosten der Simulation
Bemerkung:
Die Kosten der Berechnung von M auf x im logarithmischen
Kostenmaß sind O(tM (x) · log(tM (x))).
Erinnerung: Logarithmische Kosten veranschlagen
s = |bin(s)| für jede in einem Schritt gelesene Zahl s.
Alle verwendeten Zahlen sind konstant (durch |Γ| beschränkt),
außer: Rhead ≤ 2tM (x) + 1.
Kosten eines Schritts im logarithmischen Kostenmaß:
O(log(Rhead)), also O(log(tM (x))).
Gesamtkosten:
tM (x) · O(log(tM (x))), also O(tM (x) log(tM (x))).
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
4
Simulation von RAM auf TM (1.5.2)
• Kann entlang derselben Ideen auch Turingmaschinen in
C-/Java-/Pascal/. . . -Programmen simulieren.
Idealisierung:
Speicher.
Unbegrenzte
Rechenzeit,
FG Komplexitätstheorie und Effiziente Algorithmen
unbegrenzter
BuK – 13.11.2009
5
Definition (1.5.2): Zahlfunktionen auf TM
TM M = (Q, {0, 1, #}, Γ, B, q0, F, δ)
Jede RAM-berechenbare Funktion kann auch
”
von einer Turingmaschine berechnet werden.“
Typischer Input: 100#1101#1#0#11
Entspricht Zahlentupel (4, 13, 1, 0, 3)
Achtung!
Für (a1, . . . , an) ∈ Seq(N) ist
RAMs arbeiten mit Zahlen, TMn mit Zeichenreihen.
f˜M (a1, . . . , an) = (b1, . . . , bm),
Wie können Turingmaschinen Zahlfunktionen berechnen?
Lösung:
wenn fM (bin(a1)# · · · #bin(an)) = bin(b1)# · · · #bin(bm).
Wenn z.B. M auf Eingabe 100#1101#1#0#11
(Binär-)Kodierung
die Ausgabe 10101#110100 erzeugt,
ist f˜M (4, 13, 1, 0, 3) = (21, 52).
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
6
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
7
Definitionsbereich DM von f˜M :
Definition (1.5.2)
Die Menge der Tupel (a1, . . . , an) ∈ Seq(N), für die
fM (bin(a1)# · · · #bin(an)) die Form bin(b1)# · · · #bin(bm)
hat.
Bemerkung ( Syntaxcheck“):
”
Es ist sehr einfach (DFA!), zu testen, ob eine Eingabe x das
Format bin(a1)# · · · #bin(an) hat, ebenso für die Ausgabe.
Konsequenz: Wir nehmen an, dass M fehlerhafte Eingaben
und Ausgaben erkennt und geeignet behandelt.
. . . und ignorieren ab hier Syntaxfehler in Ein-/Ausgabe von M .
BuK – 13.11.2009
(a) Eine Zahlfunktion f : D → Seq(N) mit D ⊆ Seq(N) heißt
partiell rekursiv, wenn es eine TM M mit f = f˜M gibt.
(b) Eine Menge A ⊆ Seq(N) heißt rekursiv aufzählbar,
wenn es eine TM M = (Q, {0, 1, #}, . . .) gibt mit
LM = {bin(a1)# · · · #bin(an) | (a1, . . . , an) ∈ A}.
(b’) Eine Menge A ⊆ N heißt rekursiv aufzählbar, wenn es eine
TM M = (Q, {0, 1}, . . .) gibt mit LM = {bin(a) | a ∈ A}.
(c) Eine Menge A ⊆ Seq(N) heißt rekursiv, wenn es eine TM M gibt, die auf allen Eingaben hält, mit
LM = {bin(a1)# · · · #bin(an) | (a1, . . . , an) ∈ A}.
Mögliche Reaktion, je nach Bedarf:
Anhalten mit vorgeschriebener Ausgabe 0, ε, usw.
– Verwerfen – Endlosschleife – . . .
FG Komplexitätstheorie und Effiziente Algorithmen
Änderung im Vergleich zum Skript!
8
Beispiele
. . . usw.
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
9
Satz 1.5.5
Rekursive Zahlenmenge: {p ∈ N | p ist Primzahl}
Rekursive Menge von Paaren: {(a, b) ∈ N2 | a, b teilerfremd}
Rekursive Menge von Tupeln:
{(a1, . . . , an) ∈ Seq(N) | a1 ≤ . . . ≤ an}
Es sei D ⊆ Seq(N) und f : D → Seq(N) eine Funktion.
M sei eine RAM, die f berechnet. Dann gilt:
Es existiert eine Turingmaschine M mit f = f˜M .
Rekursive Funktion: N2 (a, b) → (a div b, a mod b)
Insbesondere: Wenn für A ⊆ Seq(N) eine RAM M existiert,
die die charakteristische Funktion cA von A berechnet, dann
ist A rekursiv
(d.h. cA kann von einer TM M berechnet werden).
Für jedes Beispiel: Überlege, wie eine TM für die Sprache/Funktion jeweils vorgehen könnte!
Beweis: Wir beschreiben, wie eine Mehrband-TM M arbeitet,
die dies leistet.
Rekursive Funktion: N2 (a, b) → a + b
Wieder: M kann mechanisch“ (algorithmisch) aus dem Pro”
gramm von M erzeugt werden.
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
10
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
11
Idee: Halte die Registerinhalte von M in Binärdarstellung auf
einem Band von M , zusammen mit den Registernummern.
···
Befehlszählerstand:
Wert in {0, 1, . . . , l − 1}.
Wird in der Steuereinheit von M gespeichert.
BB ##bin(i1)#bin(b1)##bin(i2)#bin(b2)## · · ·
· · · ##bin(im)#bin(bm)## BB · · ·
Programm von M hat drei Teile:
stellt Registerinhalte Ri1 = b1, . . . , Rim = bm dar.
(Alle anderen Registerinhalte sind 0.)
1. Initialisierung : Umbau der Eingabe auf das für die Simulation benötigte Format;
Beispiel: R0 = 5, R3 = 0, R4 = 12, R7 = 3.
Darstellung auf dem Band:
2. Schritt-für-Schritt-Simulation;
· · · B ##100#1100##11#0##0#101##111#11## B · · ·
3. Nachbearbeitung : Umbau der Ausgabe auf das für Turingmaschinen geforderte Format.
Register mit Inhalt 0 dürfen, müssen aber nicht
explizit dargestellt sein.
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
12
FG Komplexitätstheorie und Effiziente Algorithmen
Initialisierung:
Schritt-für-Schritt-Simulation:
Input für RAM M : (a1, . . . , an).
Für jede Zeile
Eingabeformat für TM M : bin(a1)# · · · #bin(an)
0 ≤ z < l, des Programms von M
hat das Programm der TM M ein
BB ##bin(1)#bin(a1)##bin(3)#bin(a2)## · · ·
##bin(2n − 1)#bin(an)##bin(0)#bin(n)##
Leicht zu konstruieren!
Zähle mit Binärzähler die Eingabezahlen nacheinander ab,
nach Lesen von aj schreibe: . . . ##bin(2j−1)#bin(aj )## . . ..
(Details: Skript.)
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
13
z : Bz ,
Benötigtes Format:
···
BuK – 13.11.2009
14
Teilprogramm“ TPz ,
”
(Block von Zeilen in der Turingtafel/Übergangsfunktionstabelle).
Zweck des Teilprogramms TPz :
Simuliere den Schritt zu Befehlszeile z.
Struktur von TPz hängt vom Maschinenbefehl in Zeile z ab.
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
15
Beispiel: 10: Ri ← Rj · Rk
Beispiel: 10: Ri ← Rj · Rk
Teilprogramm TP10 tut folgendes:
4. (Finde Position von Register Ri)
1. (Finde Inhalt von Register Rj )
Suche auf Band 1 das Teilwort ui = ##bin(i)#.
Suche auf Band 1 das Teilwort uj = ##bin(j)#.
Kontext: ##bin(i)#e1 · · · em##
Kontext: ##bin(j)#b1 · · · br ##
Übertrage alles rechts hiervon auf Band 3.
Kopiere b1 · · · br auf Band 2.
Falls ##bin(j)# nicht auf Band 1: Schreibe 0 auf Band 2.
Übertrage Restinschrift zurück von Band 3.
2. Analog: schreibe Inhalt von Rk auf Band 3.
Falls ui auf Band 1 nicht gefunden: hänge neuen Eintrag
bin(i)#d1 · · · ds## rechts an Band 1 an.
3. Unterprogramm: Multipliziere Zahlen auf Band 2, 3.
– Resultat: d1 · · · ds auf Band 2
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
Überschreibe #e1 · · · em## mit #d1 · · · ds## von Band 2.
16
5. Lösche Bänder 2 und 3; fahre Kopf auf Band 1 auf
Ausgangsposition
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
17
Andere Befehle: Analog (auch Übung).
Wenige, einfache Maschinenbefehle → wenige, einfache Fälle!
6. (Falls l ≥ 12:) Springe zum Teilprogramm TP11.
(Falls l = 11, springe zur Nachbearbeitung.)
Wenn M auf Input a hält:
Befehlszähler erhält schließlich einen Wert ≥ l.
In den Teilprogrammen
Nachbearbeitung.
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
18
TPz
erfolgt
FG Komplexitätstheorie und Effiziente Algorithmen
Sprung
BuK – 13.11.2009
zur
19
Nachbearbeitung:
Erreicht:
Beispiel: Aus der Bandinschrift
Ein-/Ausgabeverhalten der TM M bildet das der RAM M exakt nach.
Anzahl der Schritte der TM?
##11#101##10#1111##1001#11
Satz 1.5.5, Fortsetzung:
##110#11101##0#100##101#10##,
– entspricht Registerinhalten R3 = 5, R2 = 15, R9 = 3,
R6 = 29, R0 = 4, R5 = 2
erzeugt die Nachbearbeitung die Ausgabe-Bandinschrift
Wenn cM,logar(a) die Kosten der Rechnung von M auf a =
(a1, . . . , an) ∈ D im logarithmischen Kostenmaß bezeichnet
dann macht die simulierende TM M auf Input a
O((cM,logar(a) + a + b)3) Schritte, wenn b = f˜M (a) ist.
TM-Laufzeit beschränkt durch Polynom in logarithmischen
Kosten auf der RAM.
0#101#10#0,
entsprechend der RAM-Ausgabe (0, 5, 2, 0).
Mechanismen: Binäres Zählen, Textsuche, Umkopieren.
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
20
Beweisskizze:
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
21
• s := max. Länge der Inschrift von Band 1
Bemerkung: Polynomielle Beschränkung funktioniert nicht
mit dem uniformen Kostenmaß auf der RAM.
• t := max. Bitlänge eines Registerinhaltes
Beispiel: Starte mit Konstante 3, Input r.
• 1 RAM-Schritt kostet O(s + t ) TM-Schritte
In O(r) Schritten erzeuge Zahl 32 mit ≈ 2r · log 3 Bits.
• es gibt ≤ ca := cM,logar(a) RAM-Schritte
TM braucht zur Bearbeitung so langer Zahlen Zeit Ω(2r ):
exponentiell in der Schrittzahl der RAM.
r
2
• Phase 2 macht O(ca(s + t2)) Schritte
• s = O(a log(a) + ca).
• t = O(a + ca).
Alternative: Wenn die RAM die Multiplikations-Operation
nicht benutzt, kann man auch mit dem uniformen Kostenmaß
vorgehen (s. Übung).
• Also: Phase 2 macht O((a + ca) ) Schritte.
3
• Vorbearbeitung: O(a log(a)) Schritte.
• Nachbearbeitung: O((s + b)2) Schritte.
• Zusammen: O((a + b + ca)3).
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
22
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
23
Kapitel 1.3: Nichtdeterministische
Turingmaschinen
Nichtdeterministische Turingmaschinen
• kein Modell für realistischen Rechner
. . . und Chomsky-0-Grammatiken (1.3.2): später
• wie weiß die Maschine, was sie als nächstes tun soll?“:
”
kein echtes Problem, denn eine nichtdeterministische TM
rechnet nicht einfach Schritt für Schritt
1.3.1 Nichtdeterministische TM
• deterministisch“: in jeder Konfiguration genau eine
”
Nachfolgekonfiguration
. . . oder keine → Haltekonfiguration
• nichtdeterministisch“: es ist erlaubt, dass in man”
chen Konfigurationen mehr als eine Nachfolgekonfiguration
existiert
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
24
Definition (1.3.1)
Eine nichtdeterministische Turingmaschine (NTM) M besteht aus 7 Komponenten:
Q, Σ, Γ, B, q0, F : wie bei gewöhnlichen TM
• abstraktes Modell
• erleichtert (manchmal) Programmierung (in diesem Kapitel)
• hilft bei der Definition interessanter Sprachklassen
(Theorie der NP-Vollständigkeit)
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
25
Beispiel 1.3.2: Exaktes Rucksackproblem
Problem RUCKSACK∗
(auch: SUBSET SUM):
Input: n Objekte mit Volumina a1, . . . , an ∈ N, Rucksack mit
Kapazität b ∈ N.
δ : Q × Γ → P(Q × Γ × {L, R, N })
In einer Situation (q, a) (Zustand, gelesener Buchstabe) gibt
es keinen, einen, oder mehr als einen möglichen
Zug (q , a, D) .
Frage: Kann man aus den Objekten einige auswählen, so dass
sie den Rucksack exakt füllen, d.h. dass ihr Gesamtvolumen
genau b ist?
Gibt es eine Teilmenge I ⊆ {1, . . . , n} mit i∈I ai = b?
Die möglichen Züge sind die Elemente von δ(q, a).
Wenn |δ(q, a)| ≥ 2, dann existiert eine Auswahl oder
Verzweigungsmöglichkeit.
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
26
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
27
NTM für RUCKSACK∗
Formalisierung durch Sprache
3 Phasen: auf Input w passiert folgendes:
L:=
RUCKSACK∗
{bin(a1)# · · · #bin(an)#bin(b) | n ∈ N, a1, . . . , an, b ≥ 1 ,
ai = b}.
∃I ⊆ {1, . . . , n} :
i∈I
Das Entscheidungsproblem RUCKSACK∗ ist genau das Wortproblem für LRUCKSACK∗ .
Beispiel:
1. Syntaxcheck: Hat w das richtige Format?
Ist w ∈ L(1(0 + 1)∗(#1(0 + 1)∗)+)?
Bei Erfolg: Erreiche Zustand q2, Kopf auf erstem
Inputzeichen. Sonst: Halte verwerfend.
2. Wähle nichtdeterministisch“ einige der Zahlen aus.
”
Formal: Ersetze einige der #-Zeichen durch ∗.
3. Streiche die per bin(ai)∗ markierten Zahlen.
1010#101#1000#11#1101 ∈ LRUCKSACK∗ ;
110#10#1010#110#1111 ∈
/ L
RUCKSACK∗
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
4. Addiere (Übung!) die restlichen Zahlen und prüfe, ob die
Summe b ist.
.
28
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
29
NTM für RUCKSACK∗: technisch
NTM für RUCKSACK∗: Eigenschaften
1. Syntaxcheck: wie ein DFA
Bei Erfolg: Erreiche Zustand q2, Kopf auf erstem
Inputzeichen; sonst: Halte verwerfend.
Eingabe (a1, . . . , an, b) bestehe aus n + 1 Zahlen, syntaktisch
korrekt.
2. δ(q2, a) = {(q2, a, R)}, für a ∈ Σ.
Entspricht: 2n Teilmengen I ⊆ {1, . . . , n}
Falls i∈I ai = b, wird akzeptiert, sonst verworfen.
δ(q2, #) = {(q2, ∗, R), (q2, #, R)}, für a ∈ Σ.
δ(q2, B) = {(q3, B, L)}.
Manche Berechnungen akzeptieren, manche verwerfen.
3. Überschreibe bin(ai)∗ mit Nullen: 00 · · · 0#
(Skript: Deterministische TM für diese Aufgabe.)
4. Addiere die verbleibenden Zahlen und prüfe, ob die Summe
b ist. Falls ja, akzeptiere, falls nein, verwerfe.
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
Nach Phase 2 sind genau 2n viele verschiedene Situationen
möglich.
30
(Willkürliche) Festlegung: NTM M akzeptiert w, falls
mindestens eine der möglichen Berechnungen akzeptiert.
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
31
• Schreibe k M k.
Semantik von NTM
Definition (1.3.3)
• Iteration k ∗M k wird definiert wie bei TM.
NTM M = (Q, Σ, Γ, B, q0, F, δ) sei gegeben.
• Menge KM der Konfigurationen: wie bei TM
Startkonfiguration initM (x): wie bei TM
• Sei k = α1(q, a)α2 Konfiguration.
Für jedes Tripel (q , a, D) ∈ δ(q, a) gibt es eine Nachfolgekonfiguration k von k, und zwar:
k wird aus k gebildet wie bei (deterministischen) TM, unter
Benutzung des Zuges“ (q , a, D).
”
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
32
Definition (1.3.3)
BuK – 13.11.2009
33
• initM (x) = k0 k1 k2 · · ·
NTM M = (Q, Σ, Γ, B, q0, F, δ) sei gegeben.
• k = α1(q, a)α2 ∈ KM heißt Haltekonfiguration, wenn
δ(q, a) = ∅ ist.
Akzeptierend: q ∈ F
Verwerfend: q ∈ Q − F
• Folge
FG Komplexitätstheorie und Effiziente Algorithmen
(ohne Ende) heißt nicht-haltende Berechnung von M auf
x.
• akzeptierende Berechnung“: endet in akzeptierender
”
Haltekonfiguration
• verwerfende Berechnung“:
”
Haltekonfiguration
endet
in
verwerfender
initM (x) = k0 k1 · · · kt
heißt eine haltende Berechnung von M auf x falls kt
Haltekonfiguration.
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
34
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
35
Definition (1.3.4)
Wir definieren für NTM M nicht:
NTM M = (Q, Σ, Γ, B, q0, F, δ) sei gegeben.
HM und fM .
∗
• M akzeptiert x ∈ Σ , wenn M mindestens eine akzeptierende Berechnung für x hat, d.h.
(3 Zeilen im Skript S. 62 streichen.)
wenn es eine Berechnung
initM (x) = k0 k1 · · · kt
gibt, so dass kt akzeptierende Haltekonfiguration ist.
Achtung: Es ist dann unwichtig, ob es auch verwerfende oder
nicht haltende Berechnungen gibt.
• LM := {x ∈ Σ∗ | M akzeptiert x}.
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
36
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
Zeitschritte
Wurzel
Berechnungsbaum
In einem Berechnungsbaum sind alle möglichen Berechnungen
einer NTM M auf einem Input x zusammengefasst.
k’1
.
.
.
Jede Berechnung ist ein Weg aus Konfigurationen, alle Wege
haben einen gemeinsamen Startpunkt, die Startkonfiguration.
k0
init M(x)
0
k’’1
k’’’
1
1
k’2
k’’2
.
.
.
2
.
.
.
t
k
k
1
k
k
2
37
3
k
4
Nachfolge−
konfigurationen
von k
t+1
"verwirf"
"akzeptiere"
.
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
38
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
39
• jeder Berechnung initM (x) = k0 k1 · · · kt · · ·
(endlich oder unendlich) entspricht ein Pfad im Baum;
Berechnungsbaum – Definition (1.3.7)
CT(M, x) ( computation tree“) ist ein endlicher
”
oder unendlicher gerichteter Baum, folgendermaßen gebaut:
(i) Wurzel, mit initM (x) markiert.
(ii) Hat ein Knoten v im Baum Markierung k = α1(q, a)α2
und ist δ(q, a) = {(q1, a1, D1), . . . , (qs, as, Ds)}, und sind
k1, . . . , ks die Nachfolgekonfigurationen von k zu den s
Zügen in δ(q, a), so hat v Nachfolger v1, . . . , vs, die mit
k1, . . . , ks markiert sind.
• ein Knoten mit Markierung k ist Blatt
⇔ k Haltekonfiguration;
• M akzeptiert x
⇔ CT(M, x) hat mindestens ein akzeptierendes Blatt“.
”
CT(M, x) enthält alle Berechnungen von M auf x als Pfade!
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
40
Endlichkeit des Berechnungsbaums
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
41
Modellvarianten, Programmiertricks
. . . genau wie bei den (deterministischen) TMs.
Bemerkung (1.3.8)
Besonders wichtig: Nichtdeterministische Turingmaschinen mit
k Bändern: definiert genau wie bei deterministischen TMn.
CT(M, x) hat endlich viele Knoten
⇔ jede Berechnung von M auf x
Satz (1.3.5)
M sei NTM mit k Bändern. Dann gilt:
(a) Es gibt eine 1-Band-NTM M mit LM = LM endet nach endlich vielen Schritten.
Beweis: ⇒“: trivial.
”
⇐“: Wenn CT(M, x) unendlich ist, kann man per Induktion
”
einen unendlichen Weg in CT(M, x) konstruieren; dies ist eine
nicht abbrechende Berechnung; Details siehe Skript.
(b) Wenn jede Berechnung von M auf Inputs x ∈ Σn nach
höchstens t(n) Schritten anhält, so kann die NTM M in
(a) so konstruiert werden, dass jede Berechnung von M auf
Inputs x ∈ Σn nach höchstens O(t(n)2) Schritten anhält.
Fazit: Benutze k Bänder, wenn bequem.
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
42
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
43
Beispiel 1.3.6: Oberfolgenproblem
Beispiel: Oberfolgenproblem
Teilfolge“: 1000 ist Teilfolge von 001011001
”
Def.: u = b1 · · · bm heißt Teilfolge von x = a1 · · · an, wenn
es 1 ≤ i1 < · · · < im ≤ n gibt, so dass b1 · · · bm = ai1 · · · aim .
Gegeben: Beliebige r.a. Sprache L = LM , M TM.
Oberfolge“:
”
Def.: x heißt Oberfolge von u, wenn u Teilfolge von x ist.
L ist die Menge der Oberfolgen von Wörtern in L.
L := {x ∈ Σ∗ | ∃w ∈ L : w ist Teilfolge von x}.
Wir entwerfen eine 2-Band-NTM für L.
Beispiel: 001011001 ist Oberfolge von 1000, aber 001011101
ist nicht Oberfolge von 1000.
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
44
Beispiel: Oberfolgenproblem
Input: x = a1 . . . an
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
45
Beispiel: Oberfolgenproblem
2 Phasen:
1: Lese x von links nach rechts, wähle nichtdeterministisch“
”
Zeichen aus, die auf Band 2 kopiert werden.
Fahre Kopf auf Band 2 zum Ausgangspunkt zurück.
δ(q0, a, B) = {(q0, a, a, R, R), (q0, a, B, R, N )}, für a ∈ Σ;
In Phase 1 gibt es genau 2n verschiedene Abläufe.
Auf Input x = abac
steht auf Band 2 nach Phase 1 eines der folgenden Wörter:
abac, aba, abc, ab, aac, aa, ac, a, bac, ba, bc, b, ac, a, c, ε.
δ(q0, B, B) = {(q1, B, B, N, L)};
(16 Abläufe, 14 verschiedene Wörter als Resultat möglich.)
δ(q1, B, a) = {(q1, B, a, N, L)}, für a ∈ Σ;
Es gilt: M akzeptiert x genau dann wenn x eine Teilfolge
y ∈ LM hat, d.h. wenn x ∈ L ist.
δ(q1, B, B) = {(q0M , B, B, N, R)}.
2: Lasse M auf der Inschrift von Band 2 ablaufen.
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
46
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
47
Gewöhnliche TM ist praktisch“ ein Spezialfall von NTM:
”
Sei M = (Q, Σ, Γ, B, q0, F, δ) eine deterministische TM.
Technik: Aufzähler für Δ∗
Z.B.: Δ = {a, b, c}
Betrachte δ̂ : Q × Γ → P(Q × Γ × {L, R, N }) mit
δ̂(q, a) :=
{(q , a , D)},
∅,
Erzeuge nacheinander: ε, a, b, c, aa, ab, ac, ba, bb, bc, ca,
cb, cc, aaa, aab, aac, . . .
falls δ(q, a) = (q , a , D);
falls δ(q, a) = − (undefiniert).
Dasselbe Verhalten, Sprachen gleich: LM = LM̂ .
Berechnungen in M (eindeutig!) entsprechen
nungsbäumen in M , die zu Wegen entartet sind.
Lemma (1.3.10)
Berech-
Frage: Kann man mit NTM mehr berechnen“ als mit TM?
”
Nein!
Sei Δ Alphabet. Dann existiert eine deterministische 1-BandTM, die auf Eingabe ε unendlich lange läuft und dabei nacheinander die Konfiguration (qfertig , B) und dann die Konfigurationen
(qfertig , a1)a2 · · · an
erreicht, für alle a1 · · · an ∈ Δ+.
Idee: Zähle im d-ären System. (Details: Skript, Übung).
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
48
Satz (1.3.11)
Ist L = LM für eine nichtdeterministische TM M , dann ist
L rekursiv aufzählbar.
Beweis: Gegeben sei NTM M = (Q, Σ, Γ, B, q0, F, δ).
Simulation“: Beschreibe Arbeitsweise einer TM M .
”
Menge der Einzelzüge“ von M :
”
Z := Q × Γ × {L, R, N }
(Endliche Menge!)
Jede Berechnung k0 k1 k2 . . . entspricht einer
(eindeutigen) Zugfolge (z1, z2, . . .) in Z.
Aber: Nicht jede Zugfolge liefert eine Berechnung!
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
50
FG Komplexitätstheorie und Effiziente Algorithmen
Beispiel Rucksack-NTM:
Konfiguration
(q0, 1)1#11#1#100
...
(q2, 1)1#11#1#100
1(q2, 1)#11#1#100
11(q2, #)11#1#100
11 ∗ (q2, 1)1#1#10
11 ∗ 1(q2, 1)#1#10
11 ∗ 11(q2, #)1#10
11 ∗ 11#(q2, 1)#10
...
(q4, 0)0#11#1#100
...
BuK – 13.11.2009
49
Zug
(q0, 1, R)
...
(q2, 1, R)
(q2, 1, R)
(q2, ∗, R)
(q2, 1, R)
(q2, 1, R)
(q2, #, R)
(q2, 1, R)
...
...
...
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
51
M erzeugt auf Band 3 nacheinander jede mögliche endliche
Folge z1z2 . . . zr ∈ Z ∗.
TM M hat drei Bänder.
Band 1: Eingabe x, nie verändert.
Für jede dieser Folgen z1z2 . . . zr wird folgendes getan:
Band 2: Arbeitsband von M .
(∗) Kopiere x von Band 1 auf Band 2.
Band 3: Zugfolgen (z1, z2, . . .).
Rechne auf Band 2 wie M , führe dabei im i-ten Schritt Zug
zi aus, falls dies mit δ konsistent ist.
Wie hat man sich Band 3 vorzustellen?
Alphabet Z = Q × Γ × {L, R, N } Endliche Menge!!
Falls nach r Schritten eine akzeptierende Haltekonfiguration von M erreicht wird: halte, akzeptiere.
Sonst (d.h.: Zug nicht möglich, Rechnung stoppt verwerfend
oder nach r Schritten keine akzeptierende Haltekonfiguration
erreicht):
Lösche Band 2, erzeuge auf Band 1 nächste Zugfolge, gehe
zu (∗) .
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
52
Beobachtung:
Wenn x ∈ LM , es also mindestens eine akzeptierende Berechnung k0 k1 k2 . . . von M gibt, dann wird irgendwann
eine Zugfolge erzeugt, die einer akzeptierenden Berechnung
von M entspricht
⇒ M hält akzeptierend.
Wenn M akzeptierend hält, dann hat M soeben eine akzeptierende Berechnung von M durchgeführt.
⇒ x ∈ LM
BuK – 13.11.2009
53
Ergänzung
(1.3.12) Leichte Modifikation von M kann beobachten, ob
CT(M, x) endlich ist und x nicht akzeptiert wird.
(⇔ Für ein r führen alle mit δ konsistenten Zugfolgen
der Länge r in eine verwerfende Haltekonfiguration.)
Dann: Lasse die simulierende TM M verwerfend halten.
Fazit: Wenn alle nicht akzeptierenden Berechnungsbäume von
M endlich sind, dann ist LM rekursiv und M (modifiziert)
hält auf allen Eingaben.
Beachte: HM ist die Menge aller x mit: x ∈ LM oder CTM (x)
ist endlich. (Für diese x endet die beschriebene Prozedur
nach endlich vielen Schritten.)
Also: M akzeptiert x ⇔ x ∈ LM .
D.h.: LM = LM .
FG Komplexitätstheorie und Effiziente Algorithmen
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
54
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
55
Zeitaufwand der Simulation:
1.4 Struktur- und Abschlusseigenschaften
|Z|r · O(|x| + r) = O(|Z|t · (|x| + t)) = O(|Z|t · t).
Satz (1.4.1)
Wenn L, L1, L2 ⊆ Σ∗ Sprachen sind, dann gilt:
0≤r≤t
Konsequenz: Wenn t : N → R+ so ist, dass für jedes x ∈ Σ∗
jede Berechnung von M auf x höchstens t(|x|) Schritte macht,
dann ist die simulierende Turingmaschine M O(2c·t(n))zeitbeschränkt, für c = 1 + log |Z|.
(Exponentieller Blow-up)
Benutze NTM als bequeme Programmiertechnik!
Hilfreich z.B. für den Nachweis von Abschlusseigenschaften.
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
(a) L ist rekursiv ⇒ L ist rekursiv.
(b) L1, L2 sind rekursiv ⇒ L1 ∩ L2 und L1 ∪ L2 sind rekursiv.
(c) L ist rekursiv ⇔ cL ist rekursiv, wo
1, falls x ∈ L
cL(x) =
0, sonst
die charakteristische Funktion von L bedeutet.
(d) L1, L2 sind rekursiv ⇒ L1L2 ist rekursiv.
56
(e) L ist rekursiv ⇒ L∗ ist rekursiv.
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
57
1.4 Struktur- und Abschlusseigenschaften
Beweis: Jeweils Konstruktion einer neuen TM aus gegebenen
TMn.
(Details: Tafel, Skript, Übung.)
Beweisideen:
(c) Sei L = LM mit M = (Q, Σ, Γ, B, q0, F, δ).
Modifiziere M so, zu neuer TM M : Lasse M laufen. Wenn
M in Zustand q ∈ F [q ∈
/ F ] hält, schreibe 1B [0B] aufs
Band und halte mit dem Kopf unter der 1 [0].
Einer der beiden Fälle tritt immer ein, also hält M auf allen
Inputs.
Umkehrung: ähnlich (Übung.)
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
58
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
59
1.4 Struktur- und Abschlusseigenschaften
1.4 Struktur- und Abschlusseigenschaften
Beweisideen:
Beweisideen:
(d) Sei L1 = LM1 und L2 = LM2 ; beide TM halten auf allen
Inputs. – M ist neue 2-Band-TM.
Auf Eingabe x erzeugt M nacheinander jede Aufteilung
x = x1x2 (genau |x| + 1 Möglichkeiten) und lässt für jeden
dieser Fälle auf Band 2 TM M1 auf x1 und danach TM M2
auf x2 ablaufen.
Sobald einmal beide Berechnungen akzeptiert haben, akzeptiert M . Wenn M für keine der |x| + 1 Aufteilungen
akzeptiert hat, dann verwirft M .
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
(e) Sei L = LM für eine TM M , die auf jeder Eingabe hält.
M ist 2-Band-TM, die folgendes tut:
x steht auf Band 1.
Erzeuge auf einer zweiten Spur unter x systematisch jede
der 2|x| 0-1-Folgen der Länge |x|.
Man benutzt die 1-en als Trennsymbole und erhält so eine
Einteilung von x in Teilworte:
x = x1 . . . xk .
60
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
61
Struktur- und Abschlusseigenschaften
Für jede Einteilung lasse M auf jedem der Teilworte
ablaufen.
Satz (1.4.2)
Sobald einmal alle diese Berechnungen akzeptiert haben,
akzeptiert M .
Wenn L, L1, L2 ⊆ Σ∗ rekursiv aufzählbare Sprachen sind,
dann gilt:
Wenn M für keine der 2|x| Aufteilungen akzeptiert hat,
dann verwirft M .
(a) L1 ∩ L2 ist rekursiv aufzählbar.
(b) L1 ∪ L2 ist rekursiv aufzählbar.
(c) L1L2 ist rekursiv aufzählbar.
(d) L∗ ist rekursiv aufzählbar.
Beweis: Jeweils Konstruktion einer neuen TM oder NTM
aus gegebenen TMn.
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
62
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
63
Zu (b): Paralleles Laufenlassen zweier Turingmaschinen
Struktur- und Abschlusseigenschaften
(hier: auf demselben Input)
...
Satz (1.4.4)
B B B e i n g a b e B B B
Für jede Sprache L ⊆ Σ∗ gilt:
...
L ist rekursiv ⇔ L und L sind rekursiv aufzählbar.
...
B e i n g a b e B B B B B
M1
AKZ
Beweis: ⇒“: leicht.
”
⇐“: Gegeben: TM M1 für L und M2 für L.
”
Neue 2-Band-TM M : Tut auf Eingabe x folgendes:
...
M2
Lasse M1 und M2
Flagregister
parallel
Zu (c) und (d): Benutze NTM. (Auch für (b) verwendbar.)
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
auf Eingabe x laufen.
64
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
65
Bezeichnung rekursiv aufzählbar“
”
Definition 1.4.5
Sobald M1 hält und akzeptiert, hält und akzeptiert M .
Sobald M2 hält und akzeptiert, hält und verwirft M .
Eine Mehrband-TM N heißt ein Aufzähler für L ⊆ Σ∗,
falls N auf Eingabe ε auf einem besonderen Ausgabeband
(Kopf kann sich nur nach rechts bewegen, jede Zelle nur 1×
beschreiben) eine Zeichenfolge
Genau eines der beiden Ereignisse tritt ein!
Und: x ∈ L ⇔ M akzeptiert x.
#x1#x2#x3# · · · ,
x1, x2, x3 . . . ∈ Σ∗, # ∈ Σ,
schreibt, wobei L = {x1, x2, x3, . . .} ist.
Achtung: Wiederholungen sind nicht verboten.
Wenn |L| = ∞, hält N nicht an.
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
66
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
67
Bezeichnung rekursiv aufzählbar“
”
Beweis des Satzes: 2 Konstruktionen.
⇐“: Gegeben: Aufzähler N für L.
”
Wir bauen eine 3-Band-TM M für L.
Satz 1.4.6
L ist rekursiv aufzählbar ⇔ es gibt einen Aufzähler für L.
M tut folgendes, auf Eingabe x (Band 1, nie verändert):
.
B B B a 1 a 2 a 3 ...
M:
an B B B
...
Eingabe x für M :
N
# x # x # x #
1
2
3
Bänder von
N
a r b e i t s b a n d + v o n + N
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
68
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
69
⇒“: (Achtung: Abweichung vom Skript)
”
Gegeben: TM M = (Q, Σ, Γ, B, q0, F, δ) mit L = LM .
Wiederhole:
1. Lasse N (weiter)laufen, bis ein # geschrieben wurde.
Z = Q × Γ × {L, R, N }: Menge aller Züge von M .
2. Unterbreche N .
Aufzähler N hat 3 Arbeitsbänder und ein Ausgabeband.
3. Das letzte Wort links vom # wird mit x verglichen.
N arbeitet wie folgt, auf leerem Input.
4. Bei Übereinstimmung: halte und akzeptiere.
5. Sonst: Gehe zu 1.
Klar:
x ∈ L ⇔ x wird von N geschrieben ⇔ TM M akzeptiert x.
D.h.: L = LM .
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
70
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
71
N erzeugt auf Band 3 nacheinander
jedes Wort x#z1 . . . zr in Σ∗{#}Z ∗.
(Benutze Lemma 1.3.10.)
Man kontrolliert leicht nach:
Jede akzeptierende Berechnung von M auf einem x wird
unendlich oft erzeugt.
Wiederhole folgendes:
Jedes x ∈ LM = L wird unendlich oft auf das Ausgabeband
geschrieben.
(∗) Erzeuge auf Band 3 das nächste Wort x#z1 . . . zr .
Kopiere x# von Band 3 auf Band 1 und x auf Band 2.
Rechne auf Band 2 wie M , führe dabei im i-ten Schritt Zug
zi aus, falls dies mit δ konsistent ist.
Falls diese Rechnung nach ≤ r Schritten zu einer akzeptierenden Haltekonfiguration von M führt:
Kopiere x# von Band 1 auf das Ausgabeband.
Modifikation: Man schreibt nur dann x#, wenn die Zugfolge
z1 . . . zr von M nach genau r Schritten akzeptierend hält.
Dadurch wird erreicht, dass jedes Wort von L nur ein einziges
Mal ausgegeben wird.
Gehe zu (∗).
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
72
Kanonische Aufzählung
FG Komplexitätstheorie und Effiziente Algorithmen
L ⊆ Σ∗ ist rekursiv
ε,
0, 1, 2,
00, 01, 02, 10, 11, 12, 20, 21, 22,
000, 001, 002, 010, 011, 012, 020, 021, 022, 100, 101, . . .
⇔
es gibt einen Aufzähler N für L, der die Elemente von L in
kanonischer Reihenfolge ausgibt.
∗
Kanonische Anordnung“ von Σ , für Σ = {0, 1, . . . , b − 1}:
”
x <kan y :⇔ |x| < |y| oder (|x| = |y| ∧ (x)b < (y)b)
sortieren,
bei
FG Komplexitätstheorie und Effiziente Algorithmen
Längengleichheit
BuK – 13.11.2009
73
Satz (Skript: nach Bem. 1.4.8)
Beispiel: Σ = {0, 1, 2}
(erst nach Länge
lexikographisch)
BuK – 13.11.2009
74
Beweis: 1. Fall: L ist endlich.
Dann ist L rekursiv und eine TM kann die Elemente von L in
kanonischer Reihenfolge aufschreiben.
(Speichere alle x ∈ L in der Steuereinheit.)
2. Fall: L ist unendlich. Übung!
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
75
Bis nächste Woche
• Folien nacharbeiten!
• Skript S. 85–90: Simulation RAM auf TM.
• Skript S. 55–66: NTMn.
• Skript S. 74–79, 82: Abschlusseigenschaften,
Bezeichnung rekursiv aufzählbar“.
”
• Übungsaufgaben drucken und vorbereiten.
FG Komplexitätstheorie und Effiziente Algorithmen
BuK – 13.11.2009
76