Skript in PDF - Theoretische Informatik - Technische Universität ...
Skript in PDF - Theoretische Informatik - Technische Universität ... Skript in PDF - Theoretische Informatik - Technische Universität ...
THEORETISCHE INFORMATIK Vorlesungsskript Jiˇrí Adámek Institut für Theoretische Informatik Technische Universität Braunschweig April 2006
- Seite 3 und 4: Inhaltsverzeichnis 1 Endliche Autom
- Seite 5 und 6: INHALTSVERZEICHNIS iii 7.3 Komplexi
- Seite 7 und 8: Kapitel 3 Turingmaschinen Weder end
- Seite 9 und 10: 3.1. DEFINITION EINER TURINGMASCHIN
- Seite 11 und 12: 3.1. DEFINITION EINER TURINGMASCHIN
- Seite 13 und 14: 3.2. MODIFIKATIONEN VON TURINGMASCH
- Seite 15 und 16: 3.2. MODIFIKATIONEN VON TURINGMASCH
- Seite 17 und 18: 3.2. MODIFIKATIONEN VON TURINGMASCH
- Seite 19 und 20: 3.3. ENTSCHEIDBARE PROBLEME UND REK
- Seite 21 und 22: 3.3. ENTSCHEIDBARE PROBLEME UND REK
- Seite 23 und 24: 3.3. ENTSCHEIDBARE PROBLEME UND REK
- Seite 25 und 26: 3.4. NICHTDETERMINISTISCHE TURINGMA
- Seite 27 und 28: 3.5. BERECHENBARE FUNKTIONEN 93 ges
- Seite 29 und 30: 3.5. BERECHENBARE FUNKTIONEN 95 (q0
- Seite 31 und 32: Kapitel 4 Churchsche These Die Chur
- Seite 33 und 34: 4.1. RAM 99 Hier ist die Liste alle
- Seite 35 und 36: 4.1. RAM 101 2. READ 3. STORE ∗2
- Seite 37 und 38: 4.3. GRAMMATIKEN UND TURINGMASCHINE
- Seite 39 und 40: 4.3. GRAMMATIKEN UND TURINGMASCHINE
- Seite 41 und 42: 4.3. GRAMMATIKEN UND TURINGMASCHINE
- Seite 43 und 44: 4.4. CHOMSKY-HIERARCHIE 109 Beispie
- Seite 45 und 46: 4.5. REKURSIVE FUNKTIONEN 111 π k
- Seite 47 und 48: 4.5. REKURSIVE FUNKTIONEN 113 Beisp
- Seite 49 und 50: 4.5. REKURSIVE FUNKTIONEN 115 wir j
- Seite 51 und 52: Kapitel 5 Unentscheidbare Probleme
THEORETISCHE INFORMATIK<br />
Vorlesungsskript<br />
Jiˇrí Adámek<br />
Institut für <strong>Theoretische</strong> <strong>Informatik</strong><br />
<strong>Technische</strong> <strong>Universität</strong> Braunschweig<br />
April 2006
Inhaltsverzeichnis<br />
1 Endliche Automaten 1<br />
1.1 Mathematische Grundbegriffe . . . . . . . . . . . . . . . . . . . . . . 2<br />
1.2 Def<strong>in</strong>ition der endlichen Automaten . . . . . . . . . . . . . . . . . . 6<br />
1.3 Nichtdeterm<strong>in</strong>istische Automaten . . . . . . . . . . . . . . . . . . . . 10<br />
1.4 Reguläre Sprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16<br />
1.5 M<strong>in</strong>imierung von Automaten . . . . . . . . . . . . . . . . . . . . . . 21<br />
1.6 Nerode-Äquivalenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24<br />
1.7 Beweise der Regularität . . . . . . . . . . . . . . . . . . . . . . . . . 27<br />
1.8 Moore- und Mealy-Automaten . . . . . . . . . . . . . . . . . . . . . 30<br />
2 Kontextfreie Sprachen und Kellerautomaten 33<br />
2.1 Die Idee e<strong>in</strong>er formalen Grammatik . . . . . . . . . . . . . . . . . . . 33<br />
2.2 Kontextfreie Grammatik . . . . . . . . . . . . . . . . . . . . . . . . . 34<br />
2.3 Ableitungsbäume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37<br />
2.4 Kontextfreie und reguläre Sprachen . . . . . . . . . . . . . . . . . . . 43<br />
2.5 Eigenschaften kontextfreier Sprachen . . . . . . . . . . . . . . . . . . 48<br />
2.6 Nullierbare Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . 54<br />
2.7 Chomsky-Normalform . . . . . . . . . . . . . . . . . . . . . . . . . . 56<br />
2.8 Algorithmen für formale Sprachen . . . . . . . . . . . . . . . . . . . 61<br />
2.9 Kellerautomaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63<br />
2.10 Kellerautomaten und kontextfreie Sprachen . . . . . . . . . . . . . . 68<br />
3 Tur<strong>in</strong>gmasch<strong>in</strong>en 73<br />
3.1 Def<strong>in</strong>ition e<strong>in</strong>er Tur<strong>in</strong>gmasch<strong>in</strong>e . . . . . . . . . . . . . . . . . . . . . 73<br />
3.2 Modifikationen von Tur<strong>in</strong>gmasch<strong>in</strong>en . . . . . . . . . . . . . . . . . . 79<br />
3.2.1 TM mit mehreren f<strong>in</strong>alen Zuständen . . . . . . . . . . . . . . 79<br />
3.2.2 TM mit zusätzlichem Gedächtnis . . . . . . . . . . . . . . . . 79<br />
3.2.3 TM mit erweitertem Bandalphabet . . . . . . . . . . . . . . . 80<br />
3.2.4 TM mit mehrspurigem Band . . . . . . . . . . . . . . . . . . 80<br />
3.2.5 TM mit mehreren Bändern . . . . . . . . . . . . . . . . . . . 82<br />
3.3 Entscheidbare Probleme und rekursive Sprachen . . . . . . . . . . . 85<br />
i
ii INHALTSVERZEICHNIS<br />
3.4 Nichtdeterm<strong>in</strong>istische Tur<strong>in</strong>gmasch<strong>in</strong>en . . . . . . . . . . . . . . . . . 90<br />
3.5 Berechenbare Funktionen . . . . . . . . . . . . . . . . . . . . . . . . 93<br />
4 Churchsche These 97<br />
4.1 RAM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97<br />
4.2 RAM-Berechenbarkeit . . . . . . . . . . . . . . . . . . . . . . . . . . 102<br />
4.3 Grammatiken und Tur<strong>in</strong>gmasch<strong>in</strong>en . . . . . . . . . . . . . . . . . . 103<br />
4.4 Chomsky-Hierarchie . . . . . . . . . . . . . . . . . . . . . . . . . . . 108<br />
4.5 Rekursive Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . 110<br />
5 Unentscheidbare Probleme 117<br />
5.1 Universelle Tur<strong>in</strong>gmasch<strong>in</strong>e . . . . . . . . . . . . . . . . . . . . . . . 117<br />
5.2 Das Halteproblem . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122<br />
5.3 Weitere unentscheidbare Probleme . . . . . . . . . . . . . . . . . . . 124<br />
5.3.1 Das Akzeptanzproblem . . . . . . . . . . . . . . . . . . . . . 124<br />
5.3.2 Akzeptanz des leeren Wortes . . . . . . . . . . . . . . . . . . 125<br />
5.3.3 Ist e<strong>in</strong>e TM e<strong>in</strong> Algorithmus? . . . . . . . . . . . . . . . . . . 126<br />
5.3.4 Satz von Rice . . . . . . . . . . . . . . . . . . . . . . . . . . . 127<br />
5.3.5 M<strong>in</strong>imierung von Tur<strong>in</strong>gmasch<strong>in</strong>en . . . . . . . . . . . . . . . 129<br />
6 Komplexität von Algorithmen 131<br />
6.1 Beispiele effizienter Algorithmen . . . . . . . . . . . . . . . . . . . . 132<br />
6.2 Komplexitätsklasse P . . . . . . . . . . . . . . . . . . . . . . . . . . 138<br />
6.3 Berechnungsprobleme und Reduzierbarkeit . . . . . . . . . . . . . . . 142<br />
6.4 Robustheit der Klasse P . . . . . . . . . . . . . . . . . . . . . . . . . 147<br />
6.4.1 TM mit zusätzlichem Gedächtnis . . . . . . . . . . . . . . . . 148<br />
6.4.2 TM mit mehrspurigem Band . . . . . . . . . . . . . . . . . . 148<br />
6.4.3 Mehr-Band TM . . . . . . . . . . . . . . . . . . . . . . . . . . 148<br />
6.4.4 RAM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148<br />
6.5 Geometrische Algorithmen und reelle RAM . . . . . . . . . . . . . . 150<br />
6.6 Komplexitätsklasse N P . . . . . . . . . . . . . . . . . . . . . . . . . 161<br />
6.7 N P-Vollständigkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163<br />
6.8 Weitere N P-vollständige Probleme . . . . . . . . . . . . . . . . . . . 168<br />
6.9 Komplexitätsklasse coN P . . . . . . . . . . . . . . . . . . . . . . . . 172<br />
6.10 Komplexität von Optimierungsproblemen . . . . . . . . . . . . . . . 174<br />
6.11 Approximation von Optimierungsproblemen . . . . . . . . . . . . . . 180<br />
6.12 Raumkomplexität . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185<br />
7 Parallele Algorithmen 191<br />
7.1 Algorithmen für e<strong>in</strong>e PRAM . . . . . . . . . . . . . . . . . . . . . . 191<br />
7.2 Simulationen von PRAM Modellen . . . . . . . . . . . . . . . . . . . 198
INHALTSVERZEICHNIS iii<br />
7.3 Komplexitätsklasse N C . . . . . . . . . . . . . . . . . . . . . . . . . 199<br />
7.4 Boolesche Schaltkreise und PRAMs . . . . . . . . . . . . . . . . . . . 202<br />
7.5 Netzwerk-Modelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212<br />
7.5.1 R<strong>in</strong>g . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212<br />
7.5.2 Zweidimensionales Gitter . . . . . . . . . . . . . . . . . . . . 213<br />
7.5.3 Hypercube . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
iv INHALTSVERZEICHNIS
Kapitel 3<br />
Tur<strong>in</strong>gmasch<strong>in</strong>en<br />
Weder endliche Automaten noch Kellerautomaten s<strong>in</strong>d genügend starke Berechnungsmodelle,<br />
denn sie s<strong>in</strong>d nicht fähig, selbst so e<strong>in</strong>fache Sprachen wie z. B.<br />
{a n b n c n ; n ≥ 1} zu akzeptieren. Wir führen jetzt e<strong>in</strong> Modell e<strong>in</strong>er Masch<strong>in</strong>e e<strong>in</strong>,<br />
die e<strong>in</strong>e sehr starke Leistung hat, obwohl die Def<strong>in</strong>ition nicht komplizierter als die<br />
der Kellerautomaten ist: die Tur<strong>in</strong>gmasch<strong>in</strong>en. Diese Masch<strong>in</strong>en wurden von Alan<br />
Tur<strong>in</strong>g <strong>in</strong> den dreißiger Jahren als Formalisierung des <strong>in</strong>tuitiven Begriffs des Algorithmus<br />
e<strong>in</strong>geführt. Tur<strong>in</strong>g versuchte zu zeigen, dass jeder Rechenprozess, den e<strong>in</strong><br />
Mensch aufgrund e<strong>in</strong>er (endlichen, e<strong>in</strong>deutigen) Anweisung durchführen kann, auch<br />
automatisch von e<strong>in</strong>er Masch<strong>in</strong>e durchgeführt werden kann. Was e<strong>in</strong>em menschlichen<br />
Rechner zur Verfügung steht, ist e<strong>in</strong>e endliche Liste von Instruktionen, die<br />
zusammen mit den Daten <strong>in</strong> se<strong>in</strong>em Gedächtnis e<strong>in</strong>e endliche Menge von (<strong>in</strong>neren)<br />
Zuständen formt. Außerdem hat er e<strong>in</strong>en unbeschränkten Raum, <strong>in</strong> dem er lesen,<br />
schreiben und überschreiben darf. Das kann (zweidimensional) durch e<strong>in</strong>en beliebig<br />
erweiterbaren Papierstoß realisiert werden, oder äquivalent, falls alle Zeilen als<br />
Erweiterungen der ersten angesehen werden, als e<strong>in</strong> (e<strong>in</strong>dimensionales) unendliches<br />
Band. Das formale Modell ist dann dem e<strong>in</strong>es Kellerautomaten ähnlich: anstelle des<br />
Kellers gibt es hier e<strong>in</strong> Band, auf dem sich e<strong>in</strong> read-and-write-Kopf unbeschränkt<br />
bewegt.<br />
Die Leistungsfähigkeit von Tur<strong>in</strong>gmasch<strong>in</strong>en ist trotzdem unvergleichlich größer als<br />
die der Kellerautomaten. Es zeigt sich, dass die Klasse aller Probleme, die mit Tur<strong>in</strong>gmasch<strong>in</strong>en<br />
gelöst werden können, dieselbe ist wie die Klasse aller Probleme, die<br />
moderne Rechner mit modernen Programmiersprachen lösen können. Die Churchsche<br />
These, die wir später genauer erläutern, behauptet, dass die Tur<strong>in</strong>gmasch<strong>in</strong>e<br />
sogar e<strong>in</strong> ganz allgeme<strong>in</strong>es Modell des Begriffs des Algorithmus ist. Also kann e<strong>in</strong><br />
Problem genau dann mit e<strong>in</strong>em Algorithmus gelöst werden, wenn e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e<br />
es lösen kann. Diese These kann nicht bewiesen werden (der Begriff des Algorithmus<br />
ist eben doch nur <strong>in</strong>tuitiv), aber sie wurde mehrmals überzeugend dadurch<br />
untermauert, dass andere – oft grundsätzlich verschiedene – Berechnungsmodelle<br />
dieselbe Klasse lösbarer Probleme ergeben.<br />
3.1 Def<strong>in</strong>ition e<strong>in</strong>er Tur<strong>in</strong>gmasch<strong>in</strong>e<br />
E<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e besteht – analog zum Kellerautomaten – aus <strong>in</strong>neren Zuständen,<br />
externem Speicher und e<strong>in</strong>er Betriebse<strong>in</strong>heit, die aufgrund des momentanen<br />
Zustandes und des gerade gelesenen Symbols entscheidet, welcher der nächste Zustand<br />
ist und wie der Speicher geändert wird. Im Vergleich zu Kellerautomaten<br />
73
74 KAPITEL 3. TURINGMASCHINEN<br />
hat hier der Speicher den Typ e<strong>in</strong>es (unbeschränkten) Bandes, auf dem sich e<strong>in</strong><br />
Lese-/Schreibkopf frei bewegt:<br />
. . . a b b a . . .<br />
•<br />
q3<br />
<br />
•q0<br />
•<br />
<br />
•q2<br />
•q1<br />
⇑<br />
Kopf<br />
Band<br />
Betriebse<strong>in</strong>heit<br />
(Obwohl das Band unbeschränkt ist, ist zu jedem Zeitpunkt nur e<strong>in</strong> endlicher Teil<br />
beschrieben; der Rest ist leer.) Noch e<strong>in</strong> Unterschied im Vergleich zu den Kellerautomaten:<br />
wir arbeiten zuerst nur mit determ<strong>in</strong>istischen Tur<strong>in</strong>gmasch<strong>in</strong>en, denn sie<br />
s<strong>in</strong>d (wie im Fall der endlichen Automaten) genauso leistungsfähig wie die nichtdeterm<strong>in</strong>istischen.<br />
Das beweisen wir später. Die Übergangsfunktion δ e<strong>in</strong>er Tur<strong>in</strong>gmasch<strong>in</strong>e<br />
entscheidet aufgrund des momentanen Zustandes q und des gerade gelesenen<br />
Bandsymbols s, ob<br />
1. sich der Zustand zu q ′ ändert und sich der Kopf nach l<strong>in</strong>ks (L) oder rechts<br />
(R) bewegt oder<br />
2. sich der Zustand zu q ′ ändert und der Kopf das momentane Bandsymbol mit<br />
e<strong>in</strong>em neuen Symbol s ′ überschreibt.<br />
Das beschreiben wir als Funktion<br />
δ(q, s) = (q ′ , s ′ ), wobei s ′ = L, R oder s ′ ∈ Σ ist.<br />
(Σ ist das gegebene E<strong>in</strong>gabealphabet). Wir müssen aber auch Bandfelder, die nicht<br />
beschriftet s<strong>in</strong>d, behandeln. Dazu führen wir e<strong>in</strong> Spezialsymbol<br />
# (Blank)<br />
e<strong>in</strong>, das unbeschriftete Felder bezeichnet. In der Formel δ(q, s) = (q ′ , s ′ ) s<strong>in</strong>d q und<br />
q ′ also Zustände, s e<strong>in</strong> Symbol aus Σ ∪ {#} und s ′ e<strong>in</strong> Symbol aus Σ ∪ {#,L,R}.<br />
Obwohl die Tur<strong>in</strong>gmasch<strong>in</strong>e, wie wir sie jetzt def<strong>in</strong>ieren, determ<strong>in</strong>istisch ist, gibt es<br />
neben 1. und 2. noch e<strong>in</strong>e weitere Möglichkeit für ihr Verhalten, nämlich dass<br />
3. die Masch<strong>in</strong>e im Zustand q auf dem Bandsymbol s hält und die Berechnung<br />
endet.<br />
Formal wird dies dadurch beschrieben, dass δ(q, s) nicht def<strong>in</strong>iert ist.<br />
Hier ist δ also e<strong>in</strong>e partielle Funktion. Es gibt e<strong>in</strong>en wichtigen Grund für diesen<br />
dritten Fall: der Kopf der Tur<strong>in</strong>gmasch<strong>in</strong>e ist ke<strong>in</strong> read-only-Kopf (wie im Fall<br />
der endlichen Automaten und Kellerautomaten). Der Impuls, e<strong>in</strong>e Berechnung zu<br />
beenden, erfolgt hier also nicht durch das Ende der E<strong>in</strong>gabe.<br />
Im Vergleich mit den DEA oder Kellerautomaten ergibt sich e<strong>in</strong>e kle<strong>in</strong>e Vere<strong>in</strong>fachung:<br />
es genügt e<strong>in</strong> f<strong>in</strong>aler Zustand, wir brauchen ke<strong>in</strong>e Menge F ⊆ Q (vergleiche<br />
3.2 unten).<br />
Def<strong>in</strong>ition. E<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e (TM) ist e<strong>in</strong> Fünftupel<br />
M = (Q, Σ, δ, q0, qF)<br />
wobei
3.1. DEFINITION EINER TURINGMASCHINE 75<br />
Q e<strong>in</strong>e endliche Menge (aller Zustände),<br />
Σ e<strong>in</strong>e endliche Menge (das E<strong>in</strong>gabealphabet), die die Symbole L, R und<br />
# nicht enthält,<br />
δ e<strong>in</strong>e partielle Funktion (die Übergangsfunktion) mit Def<strong>in</strong>itionsbereich<br />
Q × (Σ ∪ {#}) und Wertebereich Q × (Σ ∪ {#,L,R}),<br />
q0 ∈ Q der Initialzustand und<br />
qF ∈ Q der F<strong>in</strong>alzustand ist.<br />
Notation. Wir schreiben statt δ(q, s) = (q ′ , s ′ ) oft nur<br />
(q, s) → (q ′ , s ′ )<br />
und sprechen von Übergangsregeln. Wir bezeichnen durch Σ die Menge Σ =<br />
Σ ∪ {#}.<br />
Beispiel 1. Teilbarkeit durch 5. Der Algorithmus, der für e<strong>in</strong>e Zahl entscheidet, ob<br />
sie durch 5 teilbar ist, ist e<strong>in</strong>fach: akzeptiert werden Zahlen mit der letzten Ziffer 0<br />
oder 5. Wir lesen also die E<strong>in</strong>gabe s1 . . .sn bis wir das letzte beschriebene Feld sn<br />
erreichen (also: bis # ersche<strong>in</strong>t und dann e<strong>in</strong>en Schritt zurück). Falls sn = 0 oder<br />
5, gehen wir <strong>in</strong> den F<strong>in</strong>alzustand qF über:<br />
(q0, i) → (q0, R) für i = 0, 1, . . .,9 (wir lesen weiter)<br />
(q0, #) → (q1, L) e<strong>in</strong>en Schritt zurück und <strong>in</strong> den neuen Zustand q1<br />
<br />
(q1, 0) → (qF , 0)<br />
falls sn = 0 oder 5, ist der letzte Zustand qF<br />
(q1, 5) → (qF , 5)<br />
Genauer: die folgende TM<br />
M = ({q0, q1, qF }, {0, 1, . . ., 9}, δ, q0, qF),<br />
deren Übergangsregeln oben aufgelistet s<strong>in</strong>d, akzeptiert die Sprache aller Wörter<br />
über Σ = {0, 1, . . ., 9}, die mit 0 oder 5 enden. Beispiel e<strong>in</strong>er Berechnung: für die<br />
E<strong>in</strong>gabe 132 wird die TM die folgenden Schritte machen:<br />
. . . # # 1 3 2 # # # # . . .<br />
⇑<br />
q0<br />
. . . # # 1 3 2 # # # # . . .<br />
⇑<br />
q0<br />
. . . # # 1 3 2 # # # # . . .<br />
⇑<br />
q0<br />
. . . # # 1 3 2 # # # # . . .<br />
. . . # # 1 3 2 # # # # . . .<br />
⇑<br />
q1<br />
⇑<br />
q0<br />
Initialkonfiguration<br />
Haltekonfiguration<br />
Da ke<strong>in</strong> Übergang (q1, 2) → def<strong>in</strong>iert ist, hält hier die Tur<strong>in</strong>gmasch<strong>in</strong>e. Die E<strong>in</strong>gabe<br />
132 wird nicht akzeptiert, da q1 nicht der F<strong>in</strong>alzustand ist.
76 KAPITEL 3. TURINGMASCHINEN<br />
Die Berechnung von E<strong>in</strong>gaben formalisieren wir jetzt.<br />
Konfigurationen: E<strong>in</strong>e Konfiguration e<strong>in</strong>er Tur<strong>in</strong>gmasch<strong>in</strong>e ist die vollständige<br />
Information über die TM zu e<strong>in</strong>em Zeitpunkt der Berechnung; sie wird durch (1)<br />
den momentanen Zustand q, (2) den Inhalt des Bandes und (3) die Position des<br />
Kopfes bestimmt. Also ist (1) e<strong>in</strong> Element der Menge Q. Wir können (2) und (3)<br />
zusammenfassen, <strong>in</strong>dem wir sagen, welches Wort u l<strong>in</strong>ks vom Kopf steht, welches<br />
Wort v rechts steht und welches Symbol a aus Σ = Σ ∪ {#} der Kopf liest. Dabei<br />
ist u entweder leer, oder hat das erste Symbol aus Σ und die weiteren aus Σ:<br />
u ∈ Σ × Σ ∗ ∪ {ε}.<br />
Analog v ∈ Σ ∗ × Σ ∪ {ε}. E<strong>in</strong>e Konfiguration ist also e<strong>in</strong> Quadrupel<br />
(q, u, a, v), wobei q ∈ Q, u ∈ Σ × Σ ∗ ∪ {ε}, a ∈ Σ und v ∈ Σ ∗ × Σ ∪ {ε}.<br />
Die Menge<br />
K = Q × (Σ × Σ ∗ ∪ {ε}) × Σ × (Σ ∗ × Σ ∪ {ε})<br />
heißt Konfigurationsmenge.<br />
Die üblichere (und übersichtlichere) Schreibweise ist, u, a, v zu konkatenieren und a<br />
zu unterstreichen:<br />
(q, uav).<br />
In Beispiel 1 <strong>in</strong> Abschnitt 3.1 hat die Berechnung also die Konfigurationen<br />
(q0, 132)<br />
(q0, 132)<br />
(q0, 132)<br />
(q0, 132#) und<br />
(q1, 132)<br />
Berechnung: Die E<strong>in</strong>gabe<br />
s1s2 . . . sn ∈ Σ ∗<br />
wird immer so auf das Band geschrieben, dass die Buchstaben ohne Leerzeichen<br />
h<strong>in</strong>tere<strong>in</strong>ander stehen. Der Kopf wird auf den ersten Buchstaben gestellt und der<br />
Zustand ist <strong>in</strong>itial. Mit anderen Worten heißt das: wir erwarten am Anfang, dass<br />
die Konfiguration die folgende Form hat:<br />
(∗) (q0, s1s2 . . .sn), wobei s1 . . . sn ∈ Σ ∗ .<br />
Der Fall der leeren E<strong>in</strong>gabe ε ∈ Σ ∗ (also n = 0) entspricht der Konfiguration<br />
(q0, #).<br />
Konfigurationen der Form (∗) heißen Initialkonfigurationen.<br />
Falls die Tur<strong>in</strong>gmasch<strong>in</strong>e e<strong>in</strong>e Konfiguration<br />
(q, s1s2 . . .si−1sisi+1 . . . sn)<br />
erreicht hat, gibt es zwei Möglichkeiten: entweder ist δ(q, si) nicht def<strong>in</strong>iert, dann<br />
heißt die Konfiguration Haltekonfiguration, oder es gilt<br />
δ(q, si) = (q ′ , s ′ ) mit s ′ ∈ {L,R} ∪ Σ,<br />
dann def<strong>in</strong>ieren wir die Folgekonfiguration wie folgt:<br />
1. falls s ′ =L, dann ist die Folgekonfiguration<br />
(q ′ , s1s2 . . . si−1sisi+1 . . . sn)<br />
2. falls s ′ =R, dann ist die Folgekonfiguration<br />
(q ′ , s1s2 . . . si−1sisi+1 . . . sn)<br />
3. falls s ′ ∈ Σ, dann ist die Folgekonfiguration<br />
(q ′ , s1s2 . . . si−1s ′ si+1 . . . sn).<br />
Diese Def<strong>in</strong>ition ist <strong>in</strong> Tabelle 3.1 zusammengefasst.
3.1. DEFINITION EINER TURINGMASCHINE 77<br />
Konfiguration δ(q, si) Folgekonfiguration<br />
(q, s1s2 . . . si−1sisi+1 . . . sn) (q ′ , L) (q ′ , s1s2 . . .si−1sisi+1 . . .sn)<br />
(q, s1s2 . . . si−1sisi+1 . . . sn) (q ′ , R) (q ′ , s1s2 . . .si−1sisi+1 . . .sn)<br />
(q, s1s2 . . . si−1sisi+1 . . . sn) (q ′ , s ′ ) (q ′ , s1s2 . . .si−1s ′ si+1 . . .sn)<br />
(q, s1s2 . . . si−1sisi+1 . . . sn) nicht def<strong>in</strong>iert ke<strong>in</strong>e (Haltekonfiguration)<br />
Tabelle 3.1: Def<strong>in</strong>ition der Folgekonfiguration der TM<br />
Bemerkung 1. Wie ist der Fall 1 zu verstehen, falls i = 1 gilt? Die Folgekonfiguration<br />
zu (q0, s1 . . . sn) ist natürlich (q ′ , #s1 . . .sn). Analog folgt im Fall 2 aus i = n,<br />
dass die Folgekonfiguration (q ′ , s1 . . . sn#) ist.<br />
Notation. Die Relation ” Folgekonfiguration“ auf der Menge K aller Konfigurationen<br />
bezeichnen wir mit dem Symbol ⊢. Also ergibt der 1. Fall<br />
(q, s1s2 . . .si−1sisi+1 . . . sn) ⊢ (q ′ , s1s2 . . . si−1sisi+1 . . .sn)<br />
usw. Die reflexive und transitive Hülle dieser Relation wird mit ⊢ ∗ bezeichnet; d.h.,<br />
K ⊢ ∗ K ′ bedeutet, dass K und K ′ zwei Konfigurationen s<strong>in</strong>d, die entweder gleich<br />
s<strong>in</strong>d oder dass es Konfigurationen<br />
K = K0, K1, . . .,Kn = K ′<br />
mit Ki−1 ⊢ Ki für i = 1, . . .,n gibt. Wir sagen, dass die Konfiguration K ′ von K<br />
berechenbar ist.<br />
In Beispiel 1 <strong>in</strong> Abschnitt 3.1 gilt<br />
(q0, 132) ⊢ (q0, 132) ⊢ . . . ⊢ (q1, 132)<br />
und, die letzte Konfiguration hat ke<strong>in</strong>e Folgekonfiguration, da sie e<strong>in</strong>e Haltekonfiguration<br />
ist.<br />
Def<strong>in</strong>ition. Für jede Tur<strong>in</strong>gmasch<strong>in</strong>e ist die Berechnung e<strong>in</strong>er E<strong>in</strong>gabe s1s2 . . . sn<br />
∈ Σ ∗ e<strong>in</strong>e endliche oder unendliche Liste von Konfigurationen:<br />
K0 ⊢ K1 ⊢ K2 ⊢ . . .<br />
wobei<br />
1. K0 die Initialkonfiguration mit K0 = (q0, s1s2 . . .sn) ist, und<br />
2. falls die Liste endlich ist, ist die letzte Konfiguration e<strong>in</strong>e Haltekonfiguration.<br />
Wir sagen, dass die Tur<strong>in</strong>gmasch<strong>in</strong>e die E<strong>in</strong>gabe genau dann akzeptiert, wenn ihre<br />
Berechnung endlich ist und der Zustand der letzten Konfiguration f<strong>in</strong>al ist.<br />
Bemerkung 2. Die Berechnung e<strong>in</strong>er E<strong>in</strong>gabe w hat also drei mögliche Ergebnisse:<br />
1. die TM hält und akzeptiert w,<br />
2. die TM hält und akzeptiert w nicht,<br />
3. die TM hält nicht (und akzeptiert w deshalb nicht).<br />
Am Anfang ist die E<strong>in</strong>gabe ” kompakt“, also ohne Unterbrechung (durch #) auf dem<br />
Band geschrieben. Im Verlauf der Berechnung kann # an jeder Stelle ersche<strong>in</strong>en.<br />
Beispiel 2. In Beispiel 1 <strong>in</strong> Abschnitt 3.1 haben wir die Berechnung der E<strong>in</strong>gabe<br />
132 beschrieben. Die letzte Konfiguration ist (q1, 132). Da q1 nicht f<strong>in</strong>al ist, wird<br />
132 nicht akzeptiert.<br />
Auch das leere Wort wird nicht akzeptiert: hier haben wir e<strong>in</strong>e 1-Schritt-Berechnung,<br />
denn (q0, #) ist e<strong>in</strong>e Haltekonfiguration, und q0 ist nicht f<strong>in</strong>al.
78 KAPITEL 3. TURINGMASCHINEN<br />
Diese Tur<strong>in</strong>gmasch<strong>in</strong>e hält auf jede E<strong>in</strong>gabe (e<strong>in</strong>e wichtige Eigenschaft, wie wir<br />
später erfahren werden) und akzeptiert genau die E<strong>in</strong>gaben, deren letztes Symbol<br />
0 oder 5 ist.<br />
Def<strong>in</strong>ition. Für jede Tur<strong>in</strong>gmasch<strong>in</strong>e M = (Q, Σ, δ, q0, F) bezeichnen wir mit<br />
L(M)<br />
die Sprache aller Wörter über Σ, die M akzeptiert.<br />
Beispiel 3. E<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e, die die Sprache aller Wörter<br />
[a n b n c n ] für n ≥ 1<br />
über Σ = {a, b, c, [, ]} akzeptiert. (Diese Sprache ist nicht kontextfrei – beweisen sie<br />
es!)<br />
Wir simulieren den folgenden primitiven Algorithmus:<br />
(i) lösche e<strong>in</strong> a und gehe nach rechts, solange e<strong>in</strong> a gelesen wird,<br />
(ii) lösche e<strong>in</strong> b und gehe nach rechts, solange e<strong>in</strong> b gelesen wird,<br />
(iii) lösche e<strong>in</strong> c und gehe nach l<strong>in</strong>ks; am Ende:<br />
(iv) akzeptiere genau dann, wenn alle Felder zwischen [ und ] leer s<strong>in</strong>d.<br />
Schritt (i) wird wie folgt implementiert:<br />
1. (q0, [ ) → (q1,R)<br />
2. (q1, a) → (q2, #)<br />
3. (q2, #) → (q2,R)<br />
4. (q2, a) → (q2,R)<br />
Schritt (ii) analog:<br />
5. (q2, b) → (q3, #)<br />
6. (q3, #) → (q3,R)<br />
7. (q3, b) → (q3,R)<br />
und Schritt (iii) wie folgt:<br />
8. (q3, c) → (q4, #)<br />
9. (q4, x) → (q4,L) für x = #, a, b<br />
10. (q4, [ ) → (q1,R)<br />
11. (q1, #) → (q1,R)<br />
Schritt (iv) entspricht der Situation, <strong>in</strong> der im Zustand q1 am Ende das Symbol ]<br />
gelesen wird:<br />
12. (q1, ] ) → (qF , ] )<br />
Das heißt, dass die folgende TM:<br />
M = ({q0, q1, q2, q3, q4, qF }, {a, b, c, [, ]}, δ, q0, qF),<br />
mit δ durch 1. bis 12. gegeben, die Sprache {[a n b n c n ] ; n ≥ 1} akzeptiert.<br />
Beispiel e<strong>in</strong>er Berechnung: das Wort [aac] wird wie folgt berechnet:<br />
(q0, [aac] ) ⊢ (q0, [aac] ) ⊢ (q1, [#ac] ) ⊢ (q1, [#ac] ) ⊢ (q1, [#ac] )<br />
und die TM hält, denn es ist ke<strong>in</strong> Übergang (q1, c) →? def<strong>in</strong>iert. Das Wort [aac]<br />
wird also nicht akzeptiert.
3.2. MODIFIKATIONEN VON TURINGMASCHINEN 79<br />
3.2 Modifikationen von Tur<strong>in</strong>gmasch<strong>in</strong>en<br />
Wir behaupteten <strong>in</strong> der E<strong>in</strong>leitung zu diesem Kapitel, dass Tur<strong>in</strong>gmasch<strong>in</strong>en zu<br />
e<strong>in</strong>er starken Leistung fähig s<strong>in</strong>d. Das ist auf den ersten Blick nicht leicht zu erkennen.<br />
Aber wir führen jetzt kompliziertere Masch<strong>in</strong>en e<strong>in</strong>, mit deren Hilfe schon recht<br />
komplizierte Sprachen akzeptiert werden können. Anschließend zeigen wir, dass sich<br />
alle diese neuen Masch<strong>in</strong>en auf den e<strong>in</strong>fachen Fall reduzieren lassen. (Das ist ke<strong>in</strong>e<br />
Überraschung: er<strong>in</strong>nern wir uns an die Churchsche These, die behauptet, dass sich<br />
alle Berechnungsmodelle auf TM reduzieren lassen!)<br />
3.2.1 TM mit mehreren f<strong>in</strong>alen Zuständen<br />
Wir können das Konzept der Tur<strong>in</strong>gmasch<strong>in</strong>en zu e<strong>in</strong>er Masch<strong>in</strong>e M = (Q, Σ, δ, q0,<br />
F) verallgeme<strong>in</strong>ern, die der obigen entspricht, nur ist F ⊆ Q e<strong>in</strong>e Menge f<strong>in</strong>aler<br />
Zustände. Jede solche Masch<strong>in</strong>e kann durch die folgende TM<br />
M ′ = (Q ∪ {qF }, Σ, δ ′ , q0, qF)<br />
simuliert werden: qF ist e<strong>in</strong> neuer Zustand, und δ ′ besteht aus allen Übergangsregeln,<br />
die <strong>in</strong> δ enthalten s<strong>in</strong>d, und zusätzlich werden <strong>in</strong> δ ′ noch die folgenden Regeln<br />
(q, s) → (qF,s)<br />
aufgenommen, wobei q ∈ F e<strong>in</strong> Zustand ist, für den δ(q, s) undef<strong>in</strong>iert ist. (Also<br />
führen Haltekonfigurationen (q, s) von M, bei denen q f<strong>in</strong>al ist, zu Haltekonfigurationen<br />
(qF,s) von M ′ .)<br />
3.2.2 TM mit zusätzlichem Gedächtnis<br />
Wir können die Def<strong>in</strong>ition e<strong>in</strong>er TM so modifizieren, dass die Masch<strong>in</strong>e <strong>in</strong> jedem<br />
Schritt zusätzlich e<strong>in</strong>en Zugriff auf e<strong>in</strong> Gedächtnis hat, wobei Symbole e<strong>in</strong>es endlichen<br />
Alphabets A = {a1, . . . , am} gespeichert werden. Die Übergangsfunktion δ<br />
entscheidet jetzt aufgrund (1) des Zustandes, (2) des gelesenen Symbols aus Σ∪{#}<br />
und (3) des gespeicherten Symbols aus A. Für Initialkonfigurationen nehmen wir<br />
an, dass e<strong>in</strong> ausgewähltes Symbol a0 ∈ A gemerkt wird.<br />
Beispiel 1. Die Sprache aller Wörter, deren erstes Symbol nie wieder vorkommt,<br />
also<br />
L = {s1 . . . sn ∈ Σ ∗ ; s1 = si für i = 2, . . .,n},<br />
kann durch e<strong>in</strong>e TM mit zusätzlichem Gedächtnis wir folgt akzeptiert werden: die<br />
TM liest das erste Symbol und speichert es im Gedächtnis (also A = Σ, d.h., das<br />
zusätzliche Gedächtnis kann e<strong>in</strong> Symbol aus Σ speichern). Dann vergleicht die TM<br />
die anschließend gelesenen Symbole mit dem gespeicherten und hält und akzeptiert<br />
nicht, falls sie e<strong>in</strong>e Übere<strong>in</strong>stimmung feststellt. Sobald die TM das Blanksymbol<br />
liest, hält sie und akzeptiert. Diese TM braucht nur zwei Zustände: q0, <strong>in</strong>itial und<br />
f<strong>in</strong>al, <strong>in</strong> dem s1 gespeichert wird, und q1, <strong>in</strong> dem nach rechts gegangen und mit dem<br />
Speicher verglichen wird.<br />
Bemerkung 1. E<strong>in</strong>e TM mit zusätzlichem Gedächtnis ist eigentlich e<strong>in</strong>e TM <strong>in</strong><br />
dem vorher def<strong>in</strong>ierten S<strong>in</strong>ne, deren Zustandsmenge das kartesische Produkt<br />
Q × A<br />
ist (d. h. die Menge aller Paare (q, a), wobei q e<strong>in</strong> Zustand und a ∈ A ist). Die<br />
Übergänge der Masch<strong>in</strong>e s<strong>in</strong>d also von (q, a) ∈ Q × A und s ∈ S abhängig. Der<br />
Initialzustand ist (q0, a0), und alle Zustände (qF , a), a ∈ A, s<strong>in</strong>d f<strong>in</strong>al.<br />
Zum Beispiel gilt für die Masch<strong>in</strong>e aus Beispiel 1 <strong>in</strong> Abschnitt 3.1, dass A = Σ (mit<br />
s0 ∈ Σ beliebig gewählt) und die Zustandsmenge<br />
Q = {q0, q1} × Σ = {(qi, s); i = 0, 1 und s ∈ Σ}
80 KAPITEL 3. TURINGMASCHINEN<br />
ist. Wir können sie wie folgt als ” normale“ TM beschreiben, wobei der Initialzustand<br />
(q0, s0) auch f<strong>in</strong>al ist:<br />
M = (Q, Σ, δ, (q0, s0), (q0, s0))<br />
mit den folgenden Übergangsregeln:<br />
((q0, s0), s) → ((q1, s), R) für alle s ∈ Σ<br />
((q1, s), s ′ ) → ((q1, s), R) für alle s ′ ∈ Σ, s ′ = s<br />
((q1, s), #) → ((q0, s0), #).<br />
Zum Beispiel wird die E<strong>in</strong>gabe stt(t = s) wie folgt berechnet:<br />
((q0, s0), stt) ⊢ ((q1, s), stt) ⊢ ((q1, s), stt) ⊢ ((q1, s), stt#) ⊢ ((q0, s0), stt#).<br />
Hier hält die TM und akzeptiert.<br />
3.2.3 TM mit erweitertem Bandalphabet<br />
Manchmal ist es geschickt, zusätzliche (Hilfs-)Symbole auf das Band schreiben zu<br />
dürfen, die nicht zum E<strong>in</strong>gabealphabet gehören. Das bedeutet, dass außer dem<br />
E<strong>in</strong>gabealphabet Σ noch e<strong>in</strong> Bandalphabet Γ mit Σ ⊆ Γ gegeben wird und die<br />
Übergangsfunktion δ mit allen Symbolen aus Γ arbeitet, d.h., δ ist e<strong>in</strong>e partielle<br />
Funktion mit Def<strong>in</strong>itionsbereich Q×(Γ∪{#}) und Wertebereich Q×(Γ∪{#, L, R}).<br />
E<strong>in</strong>e TM mit erweitertem Bandalphabet ist also e<strong>in</strong> 6-Tupel<br />
M = (Q, Σ, Γ, δ, q0, qF)<br />
wobei Σ ⊆ Γ das E<strong>in</strong>gabealphabet und<br />
δ : Q × (Γ ∪ {#}) → Q × (Γ ∪ {#, L, R})<br />
e<strong>in</strong>e partielle Funktion ist. Die Sprache, die M akzeptiert, ist die Sprache<br />
L(M) ⊆ Σ ∗<br />
aller Wörter über dem (kle<strong>in</strong>eren) E<strong>in</strong>gabealphabet Σ, für die M im F<strong>in</strong>alzustand<br />
hält.<br />
Beispiel 2. E<strong>in</strong>e 1-Band TM, die die Sprache {a n b n c n ; n ≥ 1} akzeptiert. Hier<br />
haben wir Σ = {a, b, c}, und wir benutzen Γ = {a, b, c, [, ]}. Die TM wird erst die<br />
E<strong>in</strong>gabe mit [ und ] umklammern:<br />
(q0, a) → (q0, L)<br />
(q0, #) → (q0, [ )<br />
(q0, [ ) → (q1, R)<br />
(q1, x) → (q1, R) füR x = a, b, c<br />
(q1, #) → (q1, ] ).<br />
Jetzt kann sie die TM von Beispiel 3 <strong>in</strong> Abschnitt 3.1 simulieren.<br />
Bemerkung 2. Für jede TM mit erweitertem Bandalphabet M gibt es e<strong>in</strong>e ( ” normale“)<br />
TM, die M simuliert. Das E<strong>in</strong>gabealphabet der neuen TM ist das Bandalphabet<br />
Γ von M. Wir überprüfen zuerst (unter Verwendung e<strong>in</strong>es zusätzlichen<br />
Gedächtnisses, das Σ be<strong>in</strong>haltet), ob jedes Symbol der E<strong>in</strong>gabe <strong>in</strong> Σ liegt. Falls<br />
ne<strong>in</strong>, hält die TM und akzeptiert nicht. Falls ja, wird weiter wie bei M berechnet.<br />
3.2.4 TM mit mehrspurigem Band<br />
Wir arbeiten hier mit e<strong>in</strong>er Modifikation von TM, die dar<strong>in</strong> besteht, dass das Band<br />
<strong>in</strong> k Spuren unterteilt wird, die alle gleichzeitig gelesen werden. Stellen wir uns erst<br />
vor, dass k = 2 ist. Wir schreiben Symbole aus dem E<strong>in</strong>gabealphabet Σ = Σ1 auf<br />
Spur 1 und Symbole e<strong>in</strong>es Hilfsalphabetes Σ2 auf Spur 2:<br />
. . . # 0 1 0 0 1 # # # . . .<br />
. . . # # a # b # # a #<br />
⇑<br />
. . .
3.2. MODIFIKATIONEN VON TURINGMASCHINEN 81<br />
Die Masch<strong>in</strong>e entscheidet <strong>in</strong> jedem Schritt abhängig vom Zustand und dem Inhalt<br />
beider Spuren (1) was der nächste Zustand wird und (2) ob sich der Kopf bewegt<br />
oder beide Spuren gleichzeitig überschrieben werden.<br />
E<strong>in</strong>e 2-Spur-TM ist eigentlich e<strong>in</strong>e TM im vorher def<strong>in</strong>ierten S<strong>in</strong>ne, deren Bandalphabet<br />
aus Paaren (s1, s2), mit s1 ∈ Σ1 und s2 ∈ Σ2, geformt wird. Die e<strong>in</strong>zige<br />
Ausnahme ist das Paar (#, #), das jetzt als Blank-Symbol dient. Also ist e<strong>in</strong>e 2-<br />
Spur-TM e<strong>in</strong>fach e<strong>in</strong>e TM mit dem E<strong>in</strong>gabealphabet<br />
Σ = Σ1 × Σ2 − {(#, #)}.<br />
Analoges gilt für k-spurige Masch<strong>in</strong>en, die auf der i-ten Spur Symbole aus Σi tragen<br />
(i = 1, . . .,k): das s<strong>in</strong>d also die ” normalen“ TM mit E<strong>in</strong>gabealphabet<br />
Σ = Σ1 × Σ2 × · · · × Σk − {(#, #, . . .,#)}<br />
und mit dem Blanksymbol (#, #, . . . , #).<br />
Beispiel 3. Primzahltest<br />
Wir zeigen, wie man e<strong>in</strong>e 3-spurige TM konstruiert, die die Sprache L aller Primzahlen<br />
(<strong>in</strong> b<strong>in</strong>ärer Darstellung) akzeptiert. Hiermit kann man auch gut die Idee<br />
von Tur<strong>in</strong>g illustrieren, dass jeder Algorithmus mit e<strong>in</strong>er TM automatisiert werden<br />
kann. Wir verwenden hier den primitiven Algorithmus, der jede Zahl n durch<br />
alle Testzahlen 2, 3, 4, . . ., n − 1 teilt und n akzeptiert, falls alle Divisionen e<strong>in</strong>en<br />
positiven Rest ergeben.<br />
EINGABESPUR<br />
TESTZAHLSPUR<br />
HILFSSPUR<br />
. . . 1 0 1 1 1<br />
. . .<br />
. . . 1 0 1<br />
. . .<br />
. . . 1 0 1 1 1<br />
⇑<br />
. . .<br />
q0<br />
Die Spuren der TM s<strong>in</strong>d (1) E<strong>in</strong>gabespur, die während der Berechnung unverändert<br />
bleibt, (2) Testzahlspur, die am Anfang mit 1 beschriftet wird und <strong>in</strong> jedem Berechnungsdurchgang<br />
um e<strong>in</strong>s vergrößert wird (sodass <strong>in</strong> dem ersten Berechnungsdurchgang<br />
durch 2 dividiert wird, im zweiten mit 3, usw.) und (3) e<strong>in</strong>e Hilfsspur. Wir<br />
schreiben am Anfang also die gegebene Zahl n = 1, 2, 3, . . . auf Spur 1, die Zahl 1<br />
auf Spur 2 und nichts auf Spur 3. Der Initialzustand q0 überprüft (durch Vergleich<br />
mit Spur 2), ob auf Spur 1 e<strong>in</strong>e Zahl n ≥ 2 steht. Im Fall von n = 0 oder n = 1,<br />
wird der Zustand q0 zu<br />
q−, e<strong>in</strong>em nicht-f<strong>in</strong>alen Haltezustand<br />
verändert. (Also werden 0 und 1 nicht akzeptiert.) Falls n ≥ 2 ist, werden Berechnungsdurchgänge<br />
rekursiv durchgeführt, die man wie folgt beschreiben kann:<br />
Anfang e<strong>in</strong>es Berechnungsdurchganges: Spur 1 wird auf Spur 3 kopiert. Die Zahl<br />
auf Spur 2 wird um 1 vergrößert. Die Spuren 1 und 2 werden verglichen und falls<br />
die Zahlen gleich s<strong>in</strong>d, wird der Zustand zu<br />
q+, e<strong>in</strong>em f<strong>in</strong>alen Haltezustand<br />
geändert (die E<strong>in</strong>gabe wird also akzeptiert, denn ke<strong>in</strong>e Zahl kle<strong>in</strong>er n, die n teilt,<br />
wurde gefunden).<br />
Rumpf e<strong>in</strong>es Berechnungsdurchganges: Die Zahl von Spur 3 wird durch die auf Spur<br />
2 dividiert (z.B. durch wiederholte Subtraktion).<br />
Ende e<strong>in</strong>es Berechnungsdurchganges: Jetzt steht auf Spur 3 der Rest der E<strong>in</strong>gabe<br />
modulo der Testzahl. Falls der Rest 0 ist, wird der Zustand zu q− verändert. Falls<br />
der Rest positiv ist, wird der Kopf nach l<strong>in</strong>ks zum ersten Symbol 1 von Spur 1<br />
geschoben und e<strong>in</strong> neuer Berechnungsdurchgang beg<strong>in</strong>nt.<br />
Es ist leicht e<strong>in</strong>zusehen, dass sich diese <strong>in</strong>formale Beschreibung der Tur<strong>in</strong>gmasch<strong>in</strong>e<br />
relativ e<strong>in</strong>fach durch e<strong>in</strong>e formal def<strong>in</strong>ierte TM realisieren lässt.
82 KAPITEL 3. TURINGMASCHINEN<br />
3.2.5 TM mit mehreren Bändern<br />
Die nächste Modifikation von TM ist e<strong>in</strong>e Masch<strong>in</strong>e, die mehrere Bänder hat und<br />
bei der auf jedem Band e<strong>in</strong> Lese-/Schreibkopf steht. Die k Köpfe bewegen sich<br />
unabhängig vone<strong>in</strong>ander und schreiben auch unabhängig vone<strong>in</strong>ander auf ihren <strong>in</strong>dividuellen<br />
Bändern. Die Kontrolle ist aber zentral (durch den gegebenen Zustand):<br />
Band 1<br />
Band 2<br />
. . . . . .<br />
⇑<br />
<br />
Kopf 1<br />
. . . . . .<br />
⇑<br />
<br />
Kopf 2<br />
SCHEMA EINER 2-BAND TM<br />
q4 •<br />
•q0<br />
<br />
<br />
Das bedeutet, dass der Übergangsfunktion δ hier der Zustand q und die k gelesenen<br />
Symbole<br />
(s1, s2, . . .,sk) ∈ Σ k<br />
zur Verfügung stehen. (Wir bezeichnen mit A k = A × A × · · · × A die Menge<br />
aller k-Tupel von Elementen aus A). Hier ist Σ die Menge aller Bandsymbole von<br />
allen k Bändern. Als Ergebnis haben wir e<strong>in</strong>en neuen Zustand q ′ und e<strong>in</strong> k-Tupel<br />
von Symbolen aus {L,R} ∪ Σ ∪ {#}. Das heißt, dass δ e<strong>in</strong>e partielle Funktion mit<br />
Urbildbereich Q × (Σ ∪ {#}) k und Wertebereich Q × (Σ ∪ {#,L,R}) k ist.<br />
Def<strong>in</strong>ition. E<strong>in</strong>e k-Band-Tur<strong>in</strong>gmasch<strong>in</strong>e ist e<strong>in</strong> Fünftupel M = (Q, Σ, δ, q0, qF ),<br />
die wie e<strong>in</strong>e TM def<strong>in</strong>iert wird, nur ist δ jetzt e<strong>in</strong>e partielle Funktion mit Urbildbereich<br />
Q × (Σ) k und Wertebereich Q × (Σ ∪ {L,R}) k .<br />
Die Berechnung durch e<strong>in</strong>e k-Band TM ist analog zum Fall e<strong>in</strong>er 1-Band TM def<strong>in</strong>iert.<br />
E<strong>in</strong>e Konfiguration hat die Form<br />
(q, u1a1v1, u2a2v2, . . . , ukakvk),<br />
wobei q der Zustand und uiaivi der Inhalt des i-ten Bandes bezeichnet. Falls<br />
δ(q, a1 . . . ak) def<strong>in</strong>iert ist, wird die Folgekonfiguration <strong>in</strong>dividuell auf jedem Band<br />
berechnet. Falls δ(q, a1 . . .ak) undef<strong>in</strong>iert ist, heißt die Konfiguration Haltekonfiguration.<br />
Band 1 dient als E<strong>in</strong>gabeband, das heißt, die Initialkonfiguration für e<strong>in</strong>e<br />
E<strong>in</strong>gabe s1 . . .sn ist<br />
(q0, s1 . . .sn, #, #, . . .,# )<br />
<br />
(k−1)−mal<br />
Die E<strong>in</strong>gabe wird akzeptiert, falls die Masch<strong>in</strong>e e<strong>in</strong>e Haltekonfiguration mit dem<br />
f<strong>in</strong>alen Zustand erreicht.<br />
Beispiel 4. E<strong>in</strong>e 2-Band TM, die die Sprache<br />
{a n b n c n ; n ≥ 1}<br />
akzeptiert.<br />
Die TM hat e<strong>in</strong> E<strong>in</strong>gabeband (Band 1) und e<strong>in</strong> Hilfsband (Band 2). Band 1 bleibt<br />
unverändert, Band 2 ist am Anfang leer.<br />
•<br />
•<br />
q3<br />
•q1<br />
•<br />
q2
3.2. MODIFIKATIONEN VON TURINGMASCHINEN 83<br />
Band 1<br />
Band 2<br />
a a . . . a b b . . . b c c . . . c # #<br />
⇑<br />
# # # . . .<br />
⇑<br />
Initialkonfiguration<br />
Erste Etappe der Berechnung: Solange der Kopf 1 a liest, schreibt Kopf 2 a, und<br />
beide Köpfe bewegen sich e<strong>in</strong> Feld nach rechts. Nur am Anfang schreibt Kopf 2 e<strong>in</strong><br />
x anstelle von a.<br />
Band 1<br />
Band 2<br />
a a . . . a b b . . . b c c . . . c # #<br />
⇑<br />
x a . . . a # # # . . .<br />
⇑<br />
Zweite Etappe: Hier bewegen sich Kopf 1 und Kopf 2 gleichzeitig <strong>in</strong> entgegengesetzte<br />
Richtungen: Kopf 1 nach rechts und Kopf 2 nach l<strong>in</strong>ks, bis Kopf 1 c und Kopf 2<br />
x liest. Falls Kopf 1 während dieser Bewegung immer b und Kopf 2 immer a liest,<br />
gehen wir zur dritten Etappe über; falls nicht, hält die TM <strong>in</strong> e<strong>in</strong>em nicht-f<strong>in</strong>alen<br />
Zustand (E<strong>in</strong>gabe nicht akzeptiert).<br />
Band 1<br />
Band 2<br />
. . . ## a a . . . a b b . . . b c c . . .<br />
. . . # x a . . . a # # # . . .<br />
⇑<br />
Dritte Etappe: Beide Köpfe bewegen sich gleichzeitig nach rechts, bis Kopf 1 # liest.<br />
Falls <strong>in</strong> jedem dieser Schritte außer dem letzten Kopf 1 c und Kopf 2 a liest und<br />
falls beide Köpfe im letzten Schritt # lesen, dann hält die TM im f<strong>in</strong>alen Zustand<br />
qF (E<strong>in</strong>gabe akzeptiert). Falls nicht, hält die TM und akzeptiert nicht.<br />
Formal können wir die Übergänge wie folgt beschreiben:<br />
Erste Etappe: (q0, a, #) → (q1, a, x)<br />
(q1, a, x) → (q1, R, R)<br />
(q1, a, #) → (q1, a, a)<br />
(q1, a, a) → (q1, R, R)<br />
Zweite Etappe: (q1, b, #) → (q2, R, L)<br />
(q2, b, a) → (q2, R, L)<br />
(q2, c, x) → (q2, R, R)<br />
Dritte Etappe: (q2, c, a) → (q2, R, R)<br />
(q2, #, #) → (qF,#, #).<br />
Das s<strong>in</strong>d alle Übergänge für die 2-Band TM mit Bandalphabet ˆ Σ = {a, b, c, x}<br />
und E<strong>in</strong>gabealphabet Σ = {a, b, c}, die die Sprache aller a n b n c n (n ≥ 1) akzeptiert.<br />
(Vergleichen Sie das mit Beispiel 3 <strong>in</strong> Abschnitt 3.1).<br />
Beispiele von Berechnungen: Die E<strong>in</strong>gabe aabbcc wird wie folgt berechnet:<br />
⇑
84 KAPITEL 3. TURINGMASCHINEN<br />
(q0, aabbcc, #) ⊢ (q0, aabbcc, x)<br />
⊢ (q0, aabbcc, x#)<br />
⊢ (q0, aabbcc, xx)<br />
⊢ (q0, aabbcc, xx#)<br />
⊢ (q0, aabbcc, xx#)<br />
⊢ (q0, aabbcc, xx#)<br />
⊢ (q0, aabbcc, xx#)<br />
⊢ (q0, aabbcc#, xx#)<br />
⊢ (qF , aabbcc#, xx#)<br />
und wird akzeptiert. Die E<strong>in</strong>gabe aabcc wird wie folgt berechnet:<br />
(q0, aabcc, #) ⊢ (q0, aabcc, x)<br />
⊢ (q0, aabcc, x#)<br />
⊢ (q0, aabcc, xx)<br />
⊢ (q0, aabcc, xx#)<br />
⊢ (q0, aabcc, xx)<br />
⊢ (q0, aabcc, xx#)<br />
und wird nicht akzeptiert.<br />
Bemerkung 3. Simulation e<strong>in</strong>er 2-Band-TM durch e<strong>in</strong>e 1-Band-TM<br />
Sei M = (Q, Σ, δ, q0, F) e<strong>in</strong>e 2-Band-TM. Wir konstruieren e<strong>in</strong>e 1-Band-TM mit<br />
zusätzlichem Gedächtnis, M, die die Masch<strong>in</strong>e M Schritt für Schritt simuliert. Das<br />
Band von M ist 4-spurig:<br />
Band 1<br />
Band 2<br />
a a b a a<br />
0 1 0<br />
⇑<br />
⇑<br />
Masch<strong>in</strong>e M<br />
. . . a a b a a # # # # . . .<br />
. . . # # # ⇑ # # # # # . . .<br />
. . . 0 1 0 # # # # # # . . .<br />
. . . ⇑ # # # # # # # # . . .<br />
Masch<strong>in</strong>e M<br />
Band 1 der Masch<strong>in</strong>e M wird auf die Spur 1 von M kopiert, die Kopfposition des<br />
Kopfes von Band 1 steht auf der Spur 2. Analog wird Band 2 auf Spur 3 von M<br />
kopiert und die Kopfposition des Bandes auf Spur 4. Das E<strong>in</strong>gabealphabet von M<br />
ist also<br />
Σ = (Σ ∪ {#}) × {⇑, #} × (Σ ∪ {#}) × {⇑, #} − {(#, #, #, #)},<br />
wobei (#, #, #, #) das Blank-Symbol ist.<br />
Die Zustände von M und M s<strong>in</strong>d dieselben. Die Masch<strong>in</strong>e M muss sich die letzten<br />
von Kopf 1 und Kopf 2 gelesenen Symbole merken, also hat sie e<strong>in</strong> zusätzliches<br />
Gedächtnis der Form (s1, s2, x), wobei si ∈ Σi ∪ {#} das aktuelle Symbol von Band<br />
i (= 1, 2) der Tur<strong>in</strong>gmasch<strong>in</strong>e M ist und x ∈ {l, r} aussagt, ob Kopf 2 (also das<br />
Symbol ⇑ auf Spur 4)l<strong>in</strong>ks oder rechts von Kopf 1 (dem Symbol ⇑ auf Spur 2)<br />
steht.<br />
1. Anfang der Simulation: Auf Spur 1 steht die E<strong>in</strong>gabe v1v2 . . . vn von M, die<br />
Spuren 2 - 4 s<strong>in</strong>d leer. Wir schreiben je e<strong>in</strong> ⇑ auf die Spuren 2 und 4 unter v1<br />
von Spur 1.<br />
SPUR 1<br />
SPUR 2<br />
SPUR 3<br />
SPUR 4<br />
. . . # v1 v2 . . . vn # . . .<br />
. . . # ⇑ # . . .<br />
. . .<br />
. . . # # # . . .<br />
. . .<br />
. . . # ⇑ # . . .<br />
. . .
3.3. ENTSCHEIDBARE PROBLEME UND REKURSIVE SPRACHEN 85<br />
2. Berechnungsschritt: Am Anfang der Simulation e<strong>in</strong>ers Schrittes von M steht<br />
der Kopf von M unter dem Symbol ⇑ auf Spur 2. Das gerade gelesene Symbol<br />
von Spur 1 wird als s1 im zusätzlichen Gedächtnis gespeichert. Danach sucht<br />
der Kopf von M das Symbol ⇑ auf Spur 4: entweder stehen die beiden Symbole<br />
⇑ untere<strong>in</strong>ander, sonst suchen wir l<strong>in</strong>ks bzw. rechts, falls im zusätzlichen<br />
Gedächtnis x = l bzw. x = r steht. Sobald ⇑ gefunden ist, wird das gerade<br />
gelesene Symbol von Spur 3 als s2 gespeichert. Aufgrund des Zustandes q von<br />
M und des Paares (s1, s2) im zusätzlichen Gedächtnis werden jetzt die Kopfpositionssymbole<br />
auf den Spuren 3 und 4 so bewegt, wie die Masch<strong>in</strong>e M die<br />
Köpfe bewegt, und die Symbole auf den Spuren 1 und 3 werden so überschrieben,<br />
wie M die Symbole auf beiden Bändern überschreibt. (Das geschieht <strong>in</strong><br />
endlich vielen Schritten der Kopfbewegung von M.) Die E<strong>in</strong>gabe x ∈ {l, r}<br />
im Gedächtnis wir aktualisiert und der Kopf wird nach ⇑ auf Spur 2 bewegt.<br />
3. Ende der Simulation: Die Masch<strong>in</strong>e M hält genau dann, wenn e<strong>in</strong>e Haltekonfiguration<br />
von M erreicht wird. Und M akzeptiert genau dann, wenn M<br />
akzeptiert.<br />
Satz 1. Für jede k-Band-TM gibt es e<strong>in</strong>e (1-Band-) TM, die dieselbe Sprache<br />
akzeptiert.<br />
Beweis. Für k = 2 folgt der Beweis aus der gerade beschriebenen Simulation und<br />
dem Fakt, dass e<strong>in</strong>e 4-spurige TM mit zusätzlichem Gedächtnis durch e<strong>in</strong>e TM<br />
simuliert werden kann (siehe Kapitel 3.2.2). Für k > 2 ist der Beweis analog und<br />
wird dem Leser überlassen.<br />
3.3 Entscheidbare Probleme und rekursive Sprachen<br />
Wie oben erwähnt, repräsentiert e<strong>in</strong>e TM e<strong>in</strong>e formale Darstellung des Begriffs e<strong>in</strong>es<br />
Algorithmus, <strong>in</strong>dem sie e<strong>in</strong>e beliebige E<strong>in</strong>gabe berechnet (und entweder akzeptiert<br />
oder nicht). Die Frage ist, ob wir nur term<strong>in</strong>ierende Algorithmen betrachten dürfen,<br />
oder ob wir auch Algorithmen erlauben, die unendlich lange berechnen. Im Berechnungsmodell<br />
der TM entsprechen den term<strong>in</strong>ierenden Algorithmen die TM, die auf<br />
jede E<strong>in</strong>gabe halten. Das bedeutet, dass das Nichtakzeptieren immer dadurch erfolgt,<br />
dass die TM <strong>in</strong> e<strong>in</strong>em nichtf<strong>in</strong>alen Zustand hält. Die allgeme<strong>in</strong>eren, nicht<br />
term<strong>in</strong>ierenden Algorithmen werden von allgeme<strong>in</strong>en TM repräsentiert.<br />
Probleme, die e<strong>in</strong> term<strong>in</strong>ierender Algorithmus löst, heißen entscheidbar. Die entsprechenden<br />
formalen Sprachen werden entweder entscheidbar oder rekursiv genannt.<br />
Die allgeme<strong>in</strong>eren Sprachen heißen semientscheidbar oder (aus Gründen, die<br />
wir später erklären) rekursiv aufzählbar:<br />
Def<strong>in</strong>ition. E<strong>in</strong>e Sprache L heißt rekursiv oder entscheidbar, falls es e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e<br />
M gibt, die L akzeptiert und auf jede E<strong>in</strong>gabe hält. E<strong>in</strong>e Sprache L<br />
heißt rekursiv aufzählbar oder semientscheidbar, falls es e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e<br />
M gibt, die L akzeptiert.<br />
Beispiel 1. Die folgenden Sprachen s<strong>in</strong>d rekursiv, denn die oben konstruierten TM<br />
halten auf jede E<strong>in</strong>gabe:<br />
1. Die Sprache aller durch 5 teilbaren Zahlen (siehe Beispiel 1 <strong>in</strong> Abschnitt 3.1).<br />
2. Die Sprache aller Primzahlen (siehe Beispiel 3 <strong>in</strong> Abschnitt 3.2.4).
86 KAPITEL 3. TURINGMASCHINEN<br />
3. Die Sprache {a n b n c n ; n ≥ 1} (siehe Beispiel 4 <strong>in</strong> Abschnitt 3.2.5 und Satz 1<br />
<strong>in</strong> Abschnitt 3.2.5).<br />
Beispiel 2. E<strong>in</strong>e Sprache Lcode, die nicht rekursiv aufzählbar ist.<br />
Es ist nicht möglich, e<strong>in</strong> ” natürliches“ Beispiel e<strong>in</strong>er nicht rekursiv aufzählbaren<br />
Sprache zu f<strong>in</strong>den, da alle ” natürlichen“ Beispiele durch irgende<strong>in</strong>en Algorithmus<br />
beschrieben werden. Aber vorausgesetzt, dass wir e<strong>in</strong>e Codierung für alle TM mit<br />
dem Bandalphabet {0, 1} haben (e<strong>in</strong>e solche Codierung wird <strong>in</strong> Kapitel 5.1 ausführlich<br />
beschrieben), können wir e<strong>in</strong>e konkrete Sprache, die nicht rekursiv aufzählbar<br />
ist, konstruieren. Wir nehmen also an, dass es für jede Tur<strong>in</strong>gmasch<strong>in</strong>e M mit Bandalphabet<br />
{0, 1} e<strong>in</strong> Wort c(M) über {0, 1} gibt, sodass der Code c(M) die Sprache<br />
der Tur<strong>in</strong>gmasch<strong>in</strong>e M vollständig beschreibt. Das heißt, dass für alle Tur<strong>in</strong>gmasch<strong>in</strong>en<br />
M und M ′ gilt:<br />
c(M) = c(M ′ ) ⇒ L(M) = L(M ′ ).<br />
Mit Lcode bezeichnen wir die Sprache aller Codewörter w = c(M) solcher Tur<strong>in</strong>gmasch<strong>in</strong>en<br />
M, die ihr eigenes Codewort nicht akzeptieren:<br />
Lcode = {w; w = c(M) für e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e M mit w /∈ L(M)}.<br />
Diese Sprache ist nicht rekursiv aufzählbar.<br />
Beweis. Die Annahme, dass es e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e ˆ M mit L( ˆ M) = Lcode gibt,<br />
führt zu e<strong>in</strong>em Widerspruch. Für das Codewort ˆw = c( ˆ M) dieser Masch<strong>in</strong>e ˆ M<br />
zeigen wir nämlich, dass (a) aus ˆw /∈ Lcode folgt ˆw ∈ Lcode und (b) aus ˆw ∈ Lcode<br />
folgt ˆw /∈ Lcode. Dann ist weder ˆw ∈ Lcode noch ˆw /∈ Lcode wahr.<br />
Zu (a): Da ˆw /∈ L( ˆ M) und ˆw = c( ˆ M), folgt aus der Def<strong>in</strong>ition von Lcode, dass<br />
ˆw ∈ Lcode.<br />
Zu (b): Da ˆw ∈ Lcode, gibt es M mit ˆw = c(M) und ˆw /∈ L(M). Aus c(M) = c( ˆ M)<br />
folgt aber L(M) = L( ˆ M); es gilt also ˆw /∈ L( ˆ M) = Lcode.<br />
Bemerkung 1. Jede rekursive Sprache ist selbstverständlich rekursiv aufzählbar,<br />
und jede kontextfreie Sprache ist rekursiv, wie sofort bewiesen wird.<br />
REGULÄR<br />
KONTEXTFREI<br />
REKURSIV<br />
REKURSIV AUFZÄHLBAR<br />
ALLE SPRACHEN<br />
Beispiel 4 <strong>in</strong> Abschnitt 3.2.5 zeigt, dass die Sprache L = {a n b n c n ; n ≥ 1} rekursiv<br />
(aber nicht kontextfrei) ist. E<strong>in</strong> Beispiel e<strong>in</strong>er Sprache, die rekursiv aufzählbar aber<br />
nicht rekursiv ist, wird <strong>in</strong> Kapitel 5 vorgeführt. Dort zeigen wir, dass e<strong>in</strong> solches<br />
Beispiel die Sprache<br />
Lhalt<br />
aller Wörter c(M)w ist, wobei M e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e und w e<strong>in</strong> E<strong>in</strong>gabewort ist,
3.3. ENTSCHEIDBARE PROBLEME UND REKURSIVE SPRACHEN 87<br />
auf das die Tur<strong>in</strong>gmasch<strong>in</strong>e M hält. (Das bedeutet, dass das ” Halteproblem“ nicht<br />
entscheidbar ist.)<br />
Beispiel 3. Jede kontextfreie Sprache ist rekursiv. Wir können nämlich den CYK-<br />
Algorithmus (Kapitel 2.7) durch e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e, die auf jede E<strong>in</strong>gabe hält, wie<br />
folgt implementieren. Die TM hat zwei Bänder : Band 1 ist das E<strong>in</strong>gabeband und<br />
auf Band 2 werden die Mengen Vi,j berechnet. Die TM hat e<strong>in</strong> zusätzliches Gedächtnis,<br />
<strong>in</strong> dem die Regeln der Grammatik gespeichert werden. Das Bandalphabet von<br />
Band 1 ist also Σ, und Kopf 1 ist e<strong>in</strong> Lesekopf. Band 2 hat als Bandalphabet die<br />
Potenzmenge 2 V aller Mengen von Variablen. Die Felder von Band 2 s<strong>in</strong>d mit zwei<br />
Indizes nummeriert, wir nehmen also an, dass es für jedes Paar i, j = 1, 2, 3, . . .<br />
genau e<strong>in</strong> Feld xij auf Band 2 gibt.<br />
Band 1<br />
(E<strong>in</strong>gabeband)<br />
Band 2<br />
(Hilfsband für Vi,j)<br />
. . . . . . . . .<br />
s1 s2 s3 s4 sn<br />
. . . . . .<br />
x11 x12 x22 x13 x23 x33 x14 . . . xnn<br />
Im ersten Schritt werden die Felder xi1, i = 1, . . .,n (wobei n die Länge der E<strong>in</strong>gabe<br />
ist) mit Vi,1 = {A ∈ V ; A → si ist e<strong>in</strong>e Regel} und die Felder xij, 1 < j ≤ n − i + 1<br />
mit ∅ beschriftet. Der rekursive Schritt wird wie im CYK-Algorithmus durchgeführt:<br />
nachdem alle Felder xi,1, . . . , xi,j−1 (i ≤ n) beschriftet wurden, wird xi,j mit Vi,j =<br />
{A ∈ V ; A → BC für B ∈ Vi,k und C ∈ Vi+k,j−k, wobei k < j} beschriftet. Am<br />
Ende überprüft die TM, ob im Feld x1n e<strong>in</strong>e Menge, die S enthält, steht oder nicht.<br />
Bemerkung 2. E<strong>in</strong> direkter Weg wäre, jeden Kellerautomaten durch e<strong>in</strong>e TM zu<br />
simulieren. Das stieße aber auf die Schwierigkeit, dass Kellerautomaten nichtdeterm<strong>in</strong>istisch<br />
s<strong>in</strong>d. Wir führen den entsprechenden Begriff für TM <strong>in</strong> Abschnitt 3.4<br />
e<strong>in</strong>.<br />
Satz 1. Falls L und L ′ rekursive Sprachen s<strong>in</strong>d, s<strong>in</strong>d auch die Sprachen<br />
L + L ′ , L ∩ L ′ , LL ′ und L ∗<br />
rekursiv.<br />
Beweis. Sei M e<strong>in</strong>e TM, die L akzeptiert, und M ′ e<strong>in</strong>e TM, die L ′ akzeptiert. Wir<br />
nehmen an, dass M und M ′ auf jede E<strong>in</strong>gabe halten.<br />
1. L + L ′ . Diese Sprache wird von e<strong>in</strong>er 2-Band TM akzeptiert, die auf Band 1<br />
die Masch<strong>in</strong>e M und gleichzeitig auf Band 2 die Masch<strong>in</strong>e M ′ simuliert. Falls<br />
beide Masch<strong>in</strong>en halten, ist der Zustand der neuen Masch<strong>in</strong>e genau dann f<strong>in</strong>al,<br />
wenn e<strong>in</strong>er der entsprechenden Zustände (von M oder M ′ ) f<strong>in</strong>al ist.<br />
2. L∩L ′ . Der Beweis ist analog zu 1., nur ist e<strong>in</strong> Zustand genau dann f<strong>in</strong>al, wenn<br />
beide Zustände (von M sowie von M ′ ) f<strong>in</strong>al s<strong>in</strong>d.<br />
3. LL ′ . Hier benutzen wir e<strong>in</strong>e 4-Band-Tur<strong>in</strong>gmasch<strong>in</strong>e M. Band 1 ist e<strong>in</strong> E<strong>in</strong>gabeband<br />
mit e<strong>in</strong>em read-only-Kopf. Auf Band 2 steht die Zahl i der Etappe<br />
(am Anfang i = 0). Auf Band 3 wird M simuliert, und auf Band 4 wird M ′<br />
simuliert. Jede E<strong>in</strong>gabe s1 . . . sn der Länge n wird <strong>in</strong> n + 1 Etappen berechnet.<br />
Die i-te Etappe besteht daraus, dass das Wort s1 . . .si auf Band 3 und<br />
das Wort si+1 . . .sn auf Band 4 kopiert werden, und dann simuliert unsere<br />
TM die Masch<strong>in</strong>e M auf Band 2 und die Masch<strong>in</strong>e M ′ auf Band 3, bis beide<br />
Masch<strong>in</strong>en M und M ′ halten. Falls sie beide akzeptieren, hält auch M und<br />
akzeptiert. Falls M oder M ′ nicht akzeptiert und i < n, wird die nächste<br />
Etappe mit i := i + 1 durchgeführt. Falls M oder M ′ nicht akzeptiert und<br />
i = n, hält M und akzeptiert nicht.
88 KAPITEL 3. TURINGMASCHINEN<br />
4. L ∗ . Dieser Beweis ist analog zu 3. Zunächst prüft M, ob das E<strong>in</strong>gabeband leer<br />
ist und akzeptiert gegebenenfalls. Ansonsten erzeugen wir auf Band 2, statt<br />
nur e<strong>in</strong>er Zahl i alle<strong>in</strong>, alle möglichen aufsteigenden Listen (i0, i1, . . . , ir) von<br />
Zahlen mit<br />
0 = i0 < i1 < i2 < · · · < ir = n wobei r = 1, . . .,n.<br />
Band 3 simuliert M: wir kopieren erst s1s2 . . .si1 auf Band 3 und, falls die<br />
Simulation <strong>in</strong> e<strong>in</strong>em f<strong>in</strong>alen Zustand von M hält, si1+1si1+2 . . . si2 auf Band 3<br />
und, falls die Simulation wieder <strong>in</strong> e<strong>in</strong>em f<strong>in</strong>alen Zustand hält, si2+1 . . . si3 auf<br />
Band 3 usw. Falls alle Simulationen <strong>in</strong> f<strong>in</strong>alen Zuständen von M halten, wird<br />
die E<strong>in</strong>gabe von M akzeptiert. Falls irgende<strong>in</strong>e der Simulationen <strong>in</strong> e<strong>in</strong>em<br />
nichtf<strong>in</strong>alen Zustand hält, beg<strong>in</strong>nt e<strong>in</strong>e neue Etappe (mit der nächsten Liste<br />
auf Band 2). Wenn alle Listen auf Band 2 durchgegangen worden s<strong>in</strong>d, ohne<br />
dass bis dah<strong>in</strong> M akzeptiert hat, hält M <strong>in</strong> e<strong>in</strong>em nichtf<strong>in</strong>alen Zustand.<br />
Bemerkung 3. Die Bezeichnung ” rekursiv aufzählbar“ für die von TM akzeptierten<br />
Sprachen stammt von e<strong>in</strong>er anderen Weise, wie TM angewendet werden können:<br />
zur Erzeugung von Sprachen. Wir beg<strong>in</strong>nen mit dem leeren Band, also mit der Konfiguration<br />
(q0, ###)<br />
und lassen die TM berechnen (bis sie hält, oder unendlich lange, falls sie nie hält).<br />
Alle Konfigurationen, die den f<strong>in</strong>alen Zustand qF haben, werden durchsucht und<br />
das Wort w rechts vom Lesekopf wird notiert; die Konfiguration hat also die Form<br />
(qF , vsw) (v ∈ Σ ∗ , s ∈ Σ), und wir notieren w. Die Sprache aller Wörter w, die so<br />
auf dem Band erzeugt werden, wird mit G(M) bezeichnet. Formale Def<strong>in</strong>ition:<br />
G(M) = {w; w ∈ Σ ∗ und es existieren v ∈ Σ ∗ und s ∈ Σ<br />
mit (q0, ###) ⊢ ∗ (qF , vsw)}<br />
Wir nennen G(M) die von M aufgezählte Sprache.<br />
Beispiel 4. Die TM<br />
M = ({q0, q1, qF }, {|}, δ, q0, qF)<br />
mit den Übergangsregeln<br />
(q0, |) → (q1, L)<br />
(q0, #) → (q0, |)<br />
(q1, |) → (qF,L)<br />
(q1, #) → (q1, |)<br />
(qF,#) → (q0, |)<br />
berechnet die leere E<strong>in</strong>gabe wie folgt:<br />
(q0, ###) ⊢ (q0, #|#)<br />
⊢ (q1, #|#)<br />
⊢ (q1, #||#)<br />
⊢ (qF,#||#) also || ∈ G(M)<br />
⊢ (q0, #|||#)<br />
⊢ (q1, #|||#)<br />
⊢ (q1, #||||#)<br />
⊢ (qF,#||||#) also |||| ∈ G(M)<br />
⊢ (q0, #|||||#)<br />
.<br />
.<br />
Wir sehen, dass M die Sprache aller positiven geraden Zahlen aufzählt.<br />
Satz 2. Jede Sprache G(M), die von e<strong>in</strong>er Tur<strong>in</strong>gmasch<strong>in</strong>e M aufgezählt wird, ist<br />
rekursiv aufzählbar.<br />
Beweis. Wir konstruieren e<strong>in</strong>e 2-Band Tur<strong>in</strong>gmasch<strong>in</strong>e M ′ , die die Sprache G(M)<br />
akzeptiert. Band 1 ist e<strong>in</strong> read-only-E<strong>in</strong>gabeband. Auf Band 2 wird die Masch<strong>in</strong>e
3.3. ENTSCHEIDBARE PROBLEME UND REKURSIVE SPRACHEN 89<br />
M simuliert (mit e<strong>in</strong>em zu Beg<strong>in</strong>n leeren Band 2). Jedesmal, wenn M ihren f<strong>in</strong>alen<br />
Zustand erreicht, überprüft die Masch<strong>in</strong>e M ′ , ob das Wort rechts des Kopfes auf<br />
Band 2 mit der E<strong>in</strong>gabe auf Band 1 übere<strong>in</strong>stimmt. Falls ja, hält M ′ und akzeptiert.<br />
Falls ne<strong>in</strong>, geht die Simulation auf Band 2 weiter. Dann gilt L(M ′ ) = G(M).<br />
Satz 3. Jede rekursiv aufzählbare Sprache L kann durch e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e aufgezählt<br />
werden, d.h. hat die Form L = G(M) für e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e M.<br />
Beweis. 1. Für jede rekursive Sprache L zeigen wir, dass L von e<strong>in</strong>er TM aufgezählt<br />
werden kann. Wir haben also e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e M0 mit<br />
L = L(M0),<br />
die auf jede E<strong>in</strong>gabe hält. Wir konstruieren e<strong>in</strong>e 4-Band-TM M, die die Sprache<br />
L aufzählt (und dann simulieren wir M mit e<strong>in</strong>er 1-Band-TM).<br />
. . .<br />
. . .<br />
<br />
k−mal<br />
<br />
. . .<br />
. . .<br />
Band 1: L(M0) wird aufgezählt<br />
Band 2: Schrittzähler<br />
Band 3: Alle Wörter der Länge ≤ k über Σ<br />
werden erzeugt<br />
Band 4: Simuliert M0 mit E<strong>in</strong>gabe aus Band 3<br />
Am Anfang s<strong>in</strong>d alle Bänder leer. Die Masch<strong>in</strong>e M schreibt <strong>in</strong> Etappe Nummer<br />
k die Zahl k auf Band 2 (am Anfang ist k = 0) und erzeugt auf Band 3<br />
systematisch alle Wörter s1 . . . sn über Σ mit n ≤ k.<br />
Jedes Wort s1 . . . sn auf Band 3 wird von M auf Band 4 kopiert, und anschließend<br />
simuliert M auf Band 4 die Masch<strong>in</strong>e M0 mit dieser E<strong>in</strong>gabe. Falls<br />
s1 . . .sn von M0 akzeptiert wird, wird das Wort auf Band 1 kopiert, der Kopf<br />
wird e<strong>in</strong> Feld l<strong>in</strong>ks von s1 gestellt und der Zustand zu qF geändert. Danach<br />
wird Band 1 wieder gelöscht. Falls s1 . . . sn nicht akzeptiert wird, wird das<br />
nächste Wort auf Band 3 erzeugt, oder, falls schon alle geprüft wurden, die<br />
nächste Etappe (k := k + 1 auf Band 2) wird begonnen.<br />
Es ist klar, dass die Masch<strong>in</strong>e M auf Band 1 die Sprache L(M0) aufzählt.<br />
2. Für jede rekursiv aufzählbare (aber nicht notwendigerweise rekursive) Sprache<br />
zeigen wir, dass L von e<strong>in</strong>er TM aufgezählt werden kann. Der Unterschied zum<br />
Fall 1. ist der, dass M0 hier nicht immer halten muss. Wir lösen dieses Problem,<br />
<strong>in</strong>dem wir die Simulation von M0 immer nur für höchstens k Schritte (wobei<br />
k der Inhalt des Bandes 2 ist) erlauben. Das heißt: falls M0 auf die E<strong>in</strong>gabe<br />
aus Band 3 <strong>in</strong> höchstens k Schritten hält und akzeptiert, aktivieren wir den<br />
Kopf auf Band 1 wie oben. Falls M0 entweder <strong>in</strong> höchstens k Schritten hält<br />
und nicht akzeptiert, oder nach k Schritten noch nicht gehalten hat, gehen<br />
wir zum nächsten Wort auf Band 3 (oder zur nächsten Etappe) über.
90 KAPITEL 3. TURINGMASCHINEN<br />
3.4 Nichtdeterm<strong>in</strong>istische Tur<strong>in</strong>gmasch<strong>in</strong>en<br />
Analog zum Fall nichtdeterm<strong>in</strong>istischer Automaten führen wir hier nichtdeterm<strong>in</strong>istische<br />
TM e<strong>in</strong>. Statt e<strong>in</strong>er partiellen Funktion δ : Q × Σ → Q ×Σ∪{L,R} haben<br />
wir hier e<strong>in</strong>e Relation δ:<br />
Def<strong>in</strong>ition. E<strong>in</strong>e nichtdeterm<strong>in</strong>istische Tur<strong>in</strong>gmasch<strong>in</strong>e M (NTM) ist e<strong>in</strong><br />
Fünftupel M = (Q, Σ, δ, q0, qF), das wie e<strong>in</strong>e TM def<strong>in</strong>iert wird, außer dass hier δ<br />
e<strong>in</strong>e Relation<br />
δ ⊆ [Q × Σ] × [Q × (Σ ∪ {L,R})]<br />
ist.<br />
Wir schreiben, wie oben,<br />
(q, s) → (q ′ , s ′ )<br />
falls die Relation δ das Quadrupel (q, s, q ′ , s ′ ) enthält. Der ganze Unterschied bezüglich<br />
der Notation zwischen e<strong>in</strong>er TM und e<strong>in</strong>er nichtdeterm<strong>in</strong>istischen TM ist,<br />
dass für e<strong>in</strong>e determ<strong>in</strong>istische TM für zwei beliebige Übergangsregeln<br />
(q, s) → (q ′ , s ′ ) und (q, s) → (q ′ , s ′ )<br />
gilt, dass, falls die l<strong>in</strong>ken Seiten gleich s<strong>in</strong>d (q = q und s = s), auch die rechten<br />
Seiten gleich se<strong>in</strong> müssen (q ′ = s ′ und s ′ = s ′ ). Für nichtdeterm<strong>in</strong>istische TM gilt<br />
ke<strong>in</strong>e solche E<strong>in</strong>schränkung.<br />
Beispiel 1. stochastischer Zahlengenerator.<br />
Wir beschreiben e<strong>in</strong>e nichtdeterm<strong>in</strong>istische Tur<strong>in</strong>gmasch<strong>in</strong>e M, die auf ihr Band<br />
entweder e<strong>in</strong>e beliebige Zahl n ≥ 1 (<strong>in</strong> b<strong>in</strong>ärer Form) schreibt und hält oder nie<br />
hält. Im Initialzustand q0 schreibt M e<strong>in</strong>e 1 und geht zum Zustand q1, <strong>in</strong> dem die<br />
folgende Wahl getroffen wird: entweder wird der Haltezustand qF erreicht, oder es<br />
wird e<strong>in</strong> neues Symbol 0, 1 geschrieben und (unter Verwendung e<strong>in</strong>es Hilfezustandes<br />
q2) der Kopf nach rechts bewegt.<br />
Formal:<br />
M = ({q0, q1, q2, qF }, {0, 1}, δ, q0, qF)<br />
wobei δ durch die folgenden Übergangsregeln beschrieben wird:<br />
(q0, #) → (q0, 1)<br />
(q0, 1) → (q1, R)<br />
(q1, #) → (q2, 0)<br />
(q1, #) → (q2, 1)<br />
(q1, #) → (qF,#)<br />
(q2, i) → (q1, R) für i = 0, 1.<br />
Beispiel:
3.4. NICHTDETERMINISTISCHE TURINGMASCHINEN 91<br />
. . . . . .<br />
⇑<br />
q0<br />
. . . 1<br />
⇑<br />
q0<br />
. . .<br />
. . . 1<br />
. . .<br />
⇑<br />
q1<br />
. . . 1 0<br />
⇑<br />
q2<br />
. . .<br />
. . . 1 0<br />
. . .<br />
⇑<br />
q1<br />
. . . 1 0 1<br />
⇑<br />
q2<br />
. . .<br />
. . . 1 0 1<br />
. . .<br />
⇑<br />
q1<br />
. . . 1 0 1<br />
. . .<br />
⇑<br />
qF<br />
Konfigurationen und die Berechnung von E<strong>in</strong>gaben s<strong>in</strong>d genauso def<strong>in</strong>iert wie für<br />
die (determ<strong>in</strong>istischen) TM. Hier hat e<strong>in</strong>e E<strong>in</strong>gabe natürlich nicht nur e<strong>in</strong>e, sondern<br />
mehrere Berechnungen.<br />
Def<strong>in</strong>ition. E<strong>in</strong>e nichtdeterm<strong>in</strong>istische Tur<strong>in</strong>gmasch<strong>in</strong>e M akzeptiert die E<strong>in</strong>gabe<br />
w ∈ Σ ∗ , falls es für w m<strong>in</strong>destens e<strong>in</strong>e Berechnung gibt, so dass M nach endlich vielen<br />
Schritten e<strong>in</strong>e Haltekonfiguration mit dem f<strong>in</strong>alen Zustand erreicht. Die Sprache<br />
aller E<strong>in</strong>gaben, die M akzeptiert, wird mit L(M) bezeichnet.<br />
Bemerkung 1. Die k-Band-TM lassen sich analog zu den nichtdeterm<strong>in</strong>istischen<br />
k-Band-TM verallgeme<strong>in</strong>ern: hier ist δ e<strong>in</strong>e Relation<br />
δ ⊆ [Q × Σ k ] × [Q × (Σ ∪ {L,R}) k ].<br />
Beispiel 2. Test der Zerlegbarkeit.<br />
Wir zeigen e<strong>in</strong>e nichtdeterm<strong>in</strong>istische 3-Band-TM, die die Sprache L ⊆ {|} ∗ aller<br />
zerlegbarer Zahlen, also Zahlen der Form<br />
n = pq mit p > 1 und q > 1<br />
akzeptiert.<br />
Wie <strong>in</strong> Beispiel 3 <strong>in</strong> Abschnitt 3.2.4 hat M e<strong>in</strong> E<strong>in</strong>gabeband, e<strong>in</strong> Testzahlband und<br />
e<strong>in</strong> Hilfsband. Im Initialzustand schreibt M die Zahl zwei (||) auf Band 2 (jede<br />
Testzahl ist größer oder gleich ||) und verändert den Zustand zu q1. In q1, dem<br />
e<strong>in</strong>zigen nichtdeterm<strong>in</strong>istischen Zustand, gibt es zwei Möglichkeiten: entweder wird<br />
e<strong>in</strong> neuer Strich auf Band 2 geschrieben, und der Zustand q1 bleibt, oder der Zustand<br />
verändert sich zu q2.<br />
Im Zustand q2 wird wie folgt determ<strong>in</strong>istisch berechnet:
92 KAPITEL 3. TURINGMASCHINEN<br />
1. Die Zahl n auf Band 1 wird mit der Zahl m auf Band 2 verglichen. Falls n ≤ m<br />
ist, hält die Masch<strong>in</strong>e, ohne zu akzeptieren.<br />
2. Falls n > m, wird n auf Band 3 kopiert.<br />
3. Band 2 wird von Band 3 abgezogen, bis auf Band 3 der Rest der Division von<br />
n durch die Testzahl steht. Dann hält die Masch<strong>in</strong>e.<br />
4. Falls Band 3 leer ist, wird die E<strong>in</strong>gabe akzeptiert, falls Band 3 nicht leer ist,<br />
wird sie nicht akzeptiert.<br />
Wir sehen, dass die Testzahl m e<strong>in</strong>e beliebige Zahl m = 2, 3, 4, . . . se<strong>in</strong> kann. Die<br />
E<strong>in</strong>gabe n wird genau dann akzeptiert, wenn es e<strong>in</strong> m < n gibt, das n teilt.<br />
Beispiel 3. Simulation e<strong>in</strong>es Kellerautomaten<br />
Wir können e<strong>in</strong>fach jeden Kellerautomaten durch e<strong>in</strong>e nichtdeterm<strong>in</strong>istische 2-<br />
Band-Tur<strong>in</strong>gmasch<strong>in</strong>e M simulieren, bei der auf Band 1 die E<strong>in</strong>gabe des Kellerautomaten<br />
und auf Band 2 der Keller<strong>in</strong>halt steht. M hat e<strong>in</strong> zusätzliches Gedächtnis, <strong>in</strong><br />
dem die Übergangsregeln des Kellerautomaten notiert werden. Am Anfang schreibt<br />
die NTM das Symbol k0 auf Band 2. Jede Übergangsregel<br />
(q, s, k) → (q ′ , k1 . . . kn), s ∈ Σ,<br />
des Kellerautomaten wird wie folgt simuliert:<br />
Band 1<br />
Band 2<br />
s ′ . . . s ′′ s . . .<br />
⇑<br />
k ′ . . . k ′′ k . . .<br />
⇑<br />
Übergang<br />
s ′ . . . s ′′ s . . .<br />
⇑<br />
. . .<br />
k1 kn k ′ k<br />
⇑<br />
′′ . . .<br />
Falls die Masch<strong>in</strong>e M im Zustand q die Symbole s (Band 1) und k (Band 2) liest,<br />
ändert sie ihren Zustand zu q ′ , bewegt den Kopf 1 e<strong>in</strong>en Schritt nach rechts und<br />
macht folgendes auf Band 2:<br />
1. Falls n = 0 (also k1 . . . kn = ε), wird k von kn überschrieben, und der Kopf 2<br />
schreibt, sich nach l<strong>in</strong>ks bewegend, die Symbole kn−1, . . . , k1.<br />
2. Falls n = 0, löscht Kopf 2 das Symbol k und bewegt sich e<strong>in</strong>en Schritt nach<br />
rechts.<br />
Analog wird jede spontane Übergangsregel<br />
(q, #, k) → (q ′ , k1 . . .kn)<br />
simuliert: der e<strong>in</strong>zige Unterschied ist, dass hierbei Kopf 1 stehenbleibt.<br />
Satz 1. Jede NTM kann durch e<strong>in</strong>e (determ<strong>in</strong>istische) TM simuliert werden.<br />
Beweis. Sei M e<strong>in</strong>e NTM, und sei r e<strong>in</strong>e Zahl, so dass es für jedes Paar (q, s) aus<br />
Q × (Σ ∪ {#}) höchstens r Übergänge (q, s) → (q ′ , s ′ ) gibt. Dann können wir die<br />
Übergänge durchnummerieren:<br />
(q, s) → (q ′ i, s ′ i) für i = 1, 2, . . .,r<br />
(Wiederholungen s<strong>in</strong>d erlaubt). Die e<strong>in</strong>zige Ausnahme ist δ(q, s) = ∅ (Haltekonfiguration).<br />
Wir simulieren M mit e<strong>in</strong>er 4-Band-TM wie folgt: Band 1 ist das E<strong>in</strong>gabeband mit<br />
e<strong>in</strong>em read-only Kopf. Auf Band 2 werden systematisch alle Zahlen k = 0, 1, 2, 3, . . .
3.5. BERECHENBARE FUNKTIONEN 93<br />
geschrieben, sie geben die Länge der Berechnung vor. Auf Band 3 werden systematisch<br />
alle k-Tupel aus Zahlen 1, . . .,r erzeugt (k = 1, 2, 3, . . .). Auf Band 4 werden<br />
für jeden E<strong>in</strong>trag<br />
i1i2 . . .ik<br />
von Band 3 die ersten k Takte der Masch<strong>in</strong>e M simuliert, aber <strong>in</strong> jedem Takt<br />
wählen wir den Übergang, dessen Index auf Band 2 steht. Also wird im Takt n der<br />
Übergang (q, s) → (q ′ <strong>in</strong> , s′ <strong>in</strong>) gewählt, wobei q der momentane Zustand ist und s<br />
das gerade gelesene Symbol. In e<strong>in</strong>er Haltekonfiguration von M mit q = qF hält<br />
M und akzeptiert die E<strong>in</strong>gabe, andernfalls, also auch bei Haltekonfigurationen mit<br />
q = qF wird k erhöht und die Simulation fortgesetzt. Es gibt also die folgenden<br />
Möglichkeiten für die Berechnung e<strong>in</strong>er E<strong>in</strong>gabe w:<br />
1. M hält auf w nach k Schritten für irgende<strong>in</strong>e Zahl k und akzeptiert w, d.h.,<br />
es gibt e<strong>in</strong>e akzeptierende Berechnung der Länge k von w. Dann hält auch M<br />
auf w und akzeptiert w (mit e<strong>in</strong>em der r k möglichen Inhalte von Band 3);<br />
2. M akzeptiert w nicht, d.h., alle von M bei E<strong>in</strong>gabe w erreichbaren Haltekonfigurationen<br />
haben e<strong>in</strong>en von qF verschienedenen Zustand. Dann hält M nie,<br />
denn M schreibt immer länger werdende k-Tupel (k = 1, 2, 3, . . .) auf Band<br />
2. Damit gehört w weder zu L(M) noch zu L(M).<br />
Es folgt, dass L(M) = L(M).<br />
Korollar 1. Jede von e<strong>in</strong>er nichtdeterm<strong>in</strong>istischen TM akzeptierte Sprache ist rekursiv<br />
aufzählbar.<br />
Satz 2. Falls L und L ′ rekursiv aufzählbare Sprachen s<strong>in</strong>d, s<strong>in</strong>d auch die Sprachen<br />
L + L ′ , L ∩ L ′ , LL ′ und L ∗<br />
rekursiv aufzählbar.<br />
Beweis. Für L + L ′ und L ∩ L ′ ist der Beweis gleich dem für rekursive Sprachen<br />
(siehe Satz 1 <strong>in</strong> Abschnitt 3.3).<br />
LL ′ : sei M e<strong>in</strong>e TM, die L akzeptiert, und M ′ e<strong>in</strong>e TM, die L ′ akzeptiert. Wir<br />
def<strong>in</strong>ieren e<strong>in</strong>e nichtdeterm<strong>in</strong>istische 4-Band-TM M, die LL ′ akzeptiert. Band 1 ist<br />
das E<strong>in</strong>gabeband mit der E<strong>in</strong>gabe s1s2 . . .sn, auf Band 2 schreibt M nichtdeterm<strong>in</strong>istisch<br />
e<strong>in</strong>e Zahl i = 0, 1, 2, . . ., auf Band 3 wird M mit E<strong>in</strong>gabe<br />
s1s2 . . . si<br />
simuliert, und auf Band 4 wird M ′ mit E<strong>in</strong>gabe<br />
si+1 . . .sn<br />
simuliert. Die Masch<strong>in</strong>e M akzeptiert genau dann, wenn sowohl M als auch M ′<br />
halten und akzeptieren.<br />
L ∗ : Dieser Beweis ist analog zu LL ′ , nur werden auf Band 2 statt nur e<strong>in</strong>er Zahl<br />
i nichtdeterm<strong>in</strong>istisch Listen (i0, i1, . . . , ir) von Zahlen mit 0 ≤ i0 < i1 < · · · <<br />
ir ≤ n geschrieben, und auf Band 3 wird M mit E<strong>in</strong>gabe s1 . . . si, si1+1 . . . si2,<br />
. . . , sir−1+1 . . . sir simuliert. Falls M alle diese E<strong>in</strong>gaben akzeptiert, hält M und<br />
akzeptiert.<br />
3.5 Berechenbare Funktionen<br />
Wie im Fall endlicher Automaten, können auch Tur<strong>in</strong>gmasch<strong>in</strong>en nicht nur als Akzeptoren<br />
von Sprachen, sondern als Masch<strong>in</strong>en für die Berechnung von Funktionen<br />
betrachtet werden. Hier benötigen wir sogar ke<strong>in</strong>e Modifikation der Masch<strong>in</strong>e, denn
94 KAPITEL 3. TURINGMASCHINEN<br />
sie kann das Ergebnis e<strong>in</strong>fach auf das Band schreiben. Allgeme<strong>in</strong> können wir Berechnungen<br />
von Funktionen von Σ ∗ nach Γ ∗ formalisieren, wobei Σ das Alphabet<br />
ist, <strong>in</strong> dem die E<strong>in</strong>gaben codiert werden, und Γ das Alphabet der Ausgaben.<br />
Def<strong>in</strong>ition. Wir sagen, e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e M berechnet die Funktion<br />
f : Σ ∗ → Γ ∗<br />
falls das E<strong>in</strong>gabealphabet von M die Menge Σ∪Γ enthält, die Masch<strong>in</strong>e M auf jede<br />
E<strong>in</strong>gabe w aus Σ ∗ hält und der Band<strong>in</strong>halt dann gleich f(w) ist.<br />
Beispiel 1. Die Funktion<br />
f(n) = 2n,<br />
wobei n unär (über Σ = {|}) dargestellt ist, wird von der folgenden TM berechnet:<br />
falls das erste Symbol # ist (also n = 0), hält die TM. Falls das erste Symbol | ist,<br />
löscht die Masch<strong>in</strong>e dieses Symbol, geht nach l<strong>in</strong>ks, schreibt | vor das letzte Symbol<br />
| am l<strong>in</strong>ken Wortrand, geht nach rechts und schreibt das gelöschte Symbol | wieder<br />
(q0, |) → (q1, #)<br />
(q1, #) → (q2, L)<br />
(q2, |) → (q2, L)<br />
h<strong>in</strong> usw.: (q2, #) → (q3, |)<br />
(q3, |) → (q3, R)<br />
(q3, #) → (q4, |)<br />
(q4, |) → (q0, R)<br />
Genauer, die TM<br />
M = ({q0, q1, q2, q3, q4, qF }, {0, 1}, δ, q0, qF ),<br />
deren Übergangsfunktion δ oben gegeben ist, berechnet die Funktion f(n) = 2n.<br />
Beispiel 2. Die Funktion<br />
f : Σ ∗ → {|} ∗<br />
der Länge der Worte<br />
f(s1s2 . . . sn) = n (unär dargestellt)<br />
wird von der folgenden TM berechnet:<br />
M = ({q0}, Σ ∪ {|}, δ, q0, q0),<br />
wobei δ wie folgt def<strong>in</strong>iert wird<br />
(q0, x) → (q0, |) für alle x ∈ Σ<br />
(q0, |) → (q0, R)<br />
Bemerkung. 1. Wie im Fall von Sprachenakzeptanz können wir auch für Funktionen<br />
den Begriff der TM modifizieren und zum Beispiel e<strong>in</strong>e Mehrband-TM<br />
benutzen. Es ist dann üblich, Band 1 als E<strong>in</strong>gabeband und Band 2 als Ausgabeband<br />
(mit Inhalt f(w), nachdem die TM hält) zu verwenden.<br />
2. Der F<strong>in</strong>alzustand spielt bei Berechnungen ke<strong>in</strong>e Rolle (und könnte, für diese<br />
Anwendung der TM, aus der Def<strong>in</strong>ition entfernt werden).<br />
3. Für Funktionen zweier (oder mehrerer) Variablen werden die verschiedenen<br />
Variablen vone<strong>in</strong>ander durch e<strong>in</strong>e leere Zelle getrennt. Also zum Beispiel e<strong>in</strong>e<br />
Funktion f(w1, w2) zweier Variabler aus Σ ∗ mit Werten <strong>in</strong> Γ ∗ wird von e<strong>in</strong>er<br />
TM berechnet, falls die TM auf jede E<strong>in</strong>gabe w1#w2 mit Band<strong>in</strong>halt f(w1, w2)<br />
hält.<br />
Beispiel 3. Addition. Wir wollen die Funktion<br />
f(n, m) = n + m (unär dargestellt)<br />
durch e<strong>in</strong>e TM berechnen: es genügt, das erste Symbol ” |“ zu streichen und die<br />
Lücke, die die zwei Variablen vone<strong>in</strong>ander trennt, durch ” |“ zu ersetzen:
3.5. BERECHENBARE FUNKTIONEN 95<br />
(q0, |) → (q1, #)<br />
(q0, #) → (qF,R)<br />
(q1, #) → (q2, R)<br />
(q2, |) → (q2, R)<br />
(q2, #) → (qF,|)<br />
Genauer, die TM<br />
M = ({q0, q1, q2, qF }, {|}, δ, q0, qF)<br />
mit der oben def<strong>in</strong>ierten Übergangsfunktion δ berechnet die Addition <strong>in</strong> unärer<br />
Darstellung.<br />
Beispiel 4. Multiplikation. Die Funktion<br />
f(n, m) = n ∗ m (unär dargestellt)<br />
kann von der folgenden 2-Band-TM berechnet werden:<br />
Band 1 ist das E<strong>in</strong>gabeband, aus Band 2 schreibt die Masch<strong>in</strong>e n-mal h<strong>in</strong>tere<strong>in</strong>ander<br />
die Zahl m, das heißt, m Symbole ” |“. Dann hält sie und hat auf Band 2<br />
(Ausgabeband) die Zahl n ∗ m.<br />
Def<strong>in</strong>ition. E<strong>in</strong>e Funktion (e<strong>in</strong>er oder mehrerer Variablen) von Σ ∗ nach Γ ∗ heißt<br />
berechenbar oder Tur<strong>in</strong>g-berechenbar, falls sie durch e<strong>in</strong>e TM berechnet werden<br />
kann.<br />
Beispiele 1. f(n) = 2n, f(n, m) = n + m, f(n, m) = n ∗ m und die Funktion<br />
f : Σ ∗ → N, die die Länge berechnet, s<strong>in</strong>d berechenbar.<br />
Bemerkung. 4. Wer der Churchschen These glaubt, erwartet, dass jede durch<br />
e<strong>in</strong>en (term<strong>in</strong>ierenden) Algorithmus gegebene, voll-def<strong>in</strong>ierte Funktion durch<br />
e<strong>in</strong>e TM berechenbar se<strong>in</strong> muss: man implementiert e<strong>in</strong>fach den Algorithmus<br />
auf e<strong>in</strong>er TM.<br />
5. Für partiell def<strong>in</strong>ierte Funktionen f : Σ ∗ → Γ ∗ können wir auch den Begriff<br />
von Berechnung durch e<strong>in</strong>e TM e<strong>in</strong>führen: die Situation, bei der f(w) nicht<br />
def<strong>in</strong>iert ist, entspricht der Berechnung der E<strong>in</strong>gabe w, wobei die TM nicht<br />
hält:<br />
Def<strong>in</strong>ition. E<strong>in</strong>e TM berechnet die partielle Funktion f : Σ ∗ → Γ ∗ , falls ihr E<strong>in</strong>gabealphabet<br />
Σ ∪ Γ enthält und die TM auf jede E<strong>in</strong>gabe w aus Σ ∗ genau dann hält,<br />
wenn f(w) def<strong>in</strong>iert ist, und sie dann den Band<strong>in</strong>halt f(w) hat. Solche Funktionen<br />
heißen partiell-berechenbar.<br />
Beispiel 5. Division. Die Funktion<br />
n : m (ganzzahlig) falls m = 0<br />
f(n, m) =<br />
undef<strong>in</strong>iert falls m = 0<br />
kann von der folgenden 2-Band-TM berechnet werden: Band 1 ist das E<strong>in</strong>gabeband,<br />
auf Band 2 schreibt die TM erst n und dann versucht sie, m Striche auf Band 2<br />
” wegzuwischen“. Falls dies nicht möglich ist, hält sie. Falls es jedoch möglich ist,<br />
versucht die Masch<strong>in</strong>e erneut, m Striche auf Band 2 zu löschen und so weiter.<br />
Beispiel 6. E<strong>in</strong>e unberechenbare Funktion β : →<br />
Diese Funktion, die als ” busy beaver“ (fleißiger Biber) bekannt ist, ist wie folgt<br />
def<strong>in</strong>iert:<br />
β(0) = 0<br />
und für jedes n > 0 ist<br />
β(n) = k,<br />
.
96 KAPITEL 3. TURINGMASCHINEN<br />
falls k die größte Zahl ist, die e<strong>in</strong>e TM mit n Zuständen auf die leere E<strong>in</strong>gabe<br />
schreiben kann. D.h., die TM hält auf der leeren E<strong>in</strong>gabe mit | k auf dem Band. Wir<br />
können β(n) e<strong>in</strong>fach bestimmen, wenn wir alle TM mit n Zuständen durchgehen<br />
(und die, die auf die leere E<strong>in</strong>gabe nicht halten, ausschließen). Die TM mit der<br />
e<strong>in</strong>zigen Übergangsregel (q0, #) → (q0, |) schreibt | auf die leere E<strong>in</strong>gabe. Daraus<br />
folgt<br />
β(1) ≥ 1.<br />
Aber jede Masch<strong>in</strong>e mit nur e<strong>in</strong>em Zustand, die mehr als e<strong>in</strong>en Strich auf die leere<br />
E<strong>in</strong>gabe schreibt, hält nie. Also gilt β(1) = 1. Bei zwei Zuständen darf δ nur auf<br />
drei Elementen der vierelementigen Menge Q×Σ def<strong>in</strong>iert se<strong>in</strong>, damit die Masch<strong>in</strong>e<br />
hält. Daraus folgt sofort<br />
β(2) = 2.<br />
Im allgeme<strong>in</strong>en gilt<br />
(∗) β(n + 2) > β(n) für jedes n.<br />
In der Tat, falls β(n) = k, d.h., falls e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e M mit n Zuständen | k<br />
schreibt, konstruieren wir e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e, M ′ , die n + 2 Zustände hat und<br />
| k+1 schreibt – woraus β(n+2) ≥ k +1 > β(n) folgt. Wir fügen zwei neue Zustände<br />
q ′ und q ′′ zu den Zuständen von M h<strong>in</strong>zu. Hält M im Zustand q auf e<strong>in</strong>em Feld |,<br />
so ergänzen wir M um drei neue Übergangsregeln:<br />
(q, |) → (q ′ , L)<br />
(q ′ , |) → (q ′ , L)<br />
(q ′ , #) → (q ′′ , |).<br />
Hält dagegen M im Zustand q auf e<strong>in</strong>em Feld #, so kann sich dieses Feld wegen<br />
der Maximalität von β(n) nur direkt neben dem Ergebnis | k von M bef<strong>in</strong>den. Wir<br />
können M nun um die Übergangsregel (q, #) → (q ′′ , |) ergänzen. In jedem Fall hält<br />
die Masch<strong>in</strong>e M ′ im Zustand q ′′ , nachdem sie | k+1 geschrieben hat.<br />
Satz 1. Für jede berechenbare Funktion f(n) gibt es e<strong>in</strong>e Konstante r mit der<br />
Eigenschaft, dass<br />
β(n + r) ≥ f(n) für alle n.<br />
Beweis. f(n) wird von e<strong>in</strong>er Tur<strong>in</strong>gmasch<strong>in</strong>e M berechnet. Sei r die Zahl aller<br />
Zustände von M. Wir konstruieren für jede Zahl n e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e Mn, die<br />
n + r Zustände hat und f(n) Striche auf die leere E<strong>in</strong>gabe schreibt – damit ist<br />
β(n + r) ≥ f(n) bewiesen. Zu den Zuständen von M werden n neue Zustände q 0<br />
(<strong>in</strong>itial), q 1, . . . , q n−1 h<strong>in</strong>zugefügt, sodass Mn auf die leere E<strong>in</strong>gabe n-mal e<strong>in</strong>en |<br />
schreibt und sich dabei nach l<strong>in</strong>ks bewegt:<br />
(q i, #) → (q i, |) für i = 0, . . .,n − 1<br />
(q i, |) → (q i+1, L) für i = 0, . . .,n − 2<br />
(q n−1 , |) → (q0, |)<br />
Der letzte Übergang bedeutet, dass von jetzt an die Masch<strong>in</strong>e M (mit der E<strong>in</strong>gabe<br />
| n ) simuliert wird – sie schreibt also | f(n) und hält.<br />
Korollar 1. Die busy-beaver-Funktion β(n) ist nicht Tur<strong>in</strong>g-berechenbar.<br />
Falls nämlich β(n) berechenbar wäre, müsste auch β(2n) berechenbar se<strong>in</strong> (wir<br />
hätten e<strong>in</strong>e TM, die erst die Zahl aller | ′ e der E<strong>in</strong>gabe verdoppelt, siehe Beispiel 1<br />
und dann die TM für β(n) simuliert). Dann würde es e<strong>in</strong>e Konstante r geben mit<br />
β(n + r) ≥ β(2n) für alle n.<br />
Speziell ergibt n = r + 2<br />
β(2r + 2) ≥ β(2r + 4),<br />
e<strong>in</strong> Widerspruch zu (∗).<br />
Bemerkung 1. Obwohl β(1) = 1, β(2) = 2 und β(3) = 3, gilt β(10) > 4000 (es<br />
existiert e<strong>in</strong>e DTM mit 10 Zuständen, die 4098 schreibt und hält. Dazu benötigt<br />
die TM über 200 Mio. Berechnungsschritte).
Kapitel 4<br />
Churchsche These<br />
Die Churchsche These behauptet, dass die <strong>in</strong>tuitive Klasse aller ” berechenbaren<br />
Funktionen“ mit den formal def<strong>in</strong>ierten Tur<strong>in</strong>g-berechenbaren Funktionen übere<strong>in</strong>stimmt.<br />
Diese These kann zwar nicht bewiesen werden, aber sie lässt sich untermauern,<br />
<strong>in</strong>dem man beweist, dass andere natürliche formale Darstellungen des<br />
Algorithmenbegriffs dasselbe Ergebnis liefern. Z. B. kann e<strong>in</strong>e Funktion mit Hilfe<br />
von PASCAL genau dann auf e<strong>in</strong>em modernen Rechner implementiert werden,<br />
wenn sie Tur<strong>in</strong>g-berechenbar ist. In diesem Kapitel zeigen wir verschiedene Modelle<br />
des Algorithmenbegriffs und beweisen, dass alle diese Modelle äquivalent zu Tur<strong>in</strong>gmasch<strong>in</strong>en<br />
s<strong>in</strong>d. Es ist trotzdem möglich, dass irgendwann e<strong>in</strong> neues, generell<br />
akzeptables Modell für Algorithmen gefunden wird, das allgeme<strong>in</strong>er als Tur<strong>in</strong>gmasch<strong>in</strong>en<br />
ist – aber niemand hält so etwas heute für wahrsche<strong>in</strong>lich.<br />
Die Tatsache, dass moderne Rechner und Tur<strong>in</strong>gmasch<strong>in</strong>en dieselbe Mächtigkeit besitzen,<br />
illustrieren wir an RAMs (oder Registermasch<strong>in</strong>en), die realen Rechnern viel<br />
näher als Tur<strong>in</strong>gmasch<strong>in</strong>en stehen. Wir beweisen exakt, dass Tur<strong>in</strong>g-berechenbare<br />
und RAM-berechenbare Funktionen dieselben Klassen formen.<br />
E<strong>in</strong> Modell ganz anderen Stils ist die formale Grammatik, e<strong>in</strong>e Verallgeme<strong>in</strong>erung<br />
kontextfreier Grammatiken. Wir beweisen, dass e<strong>in</strong>e Sprache genau dann von e<strong>in</strong>er<br />
solchen Grammatik erzeugt werden kann, wenn sie von e<strong>in</strong>er Tur<strong>in</strong>gmasch<strong>in</strong>e akzeptiert<br />
werden kann. Schließlich widmen wir uns den rekursiven Funktionen und<br />
zeigen auch hier, dass diese genau die Tur<strong>in</strong>g-berechenbaren Funktionen s<strong>in</strong>d.<br />
4.1 RAM<br />
E<strong>in</strong>e RAM, d.h. Random-Access-Masch<strong>in</strong>e (oder Registermasch<strong>in</strong>e) ist e<strong>in</strong> Modell<br />
e<strong>in</strong>er Berechnung, die realen Rechnern dadurch näher steht als TM, dass sie Programm<br />
und Datei separat behandelt. Geme<strong>in</strong>sam mit TM hat dieses Modell aber die<br />
präzise mathematische Def<strong>in</strong>ition und die Annahme, dass e<strong>in</strong>e unbegrenzte Speicherkapazität<br />
zur Verfügung steht. Die e<strong>in</strong>zelnen Register haben die Fähigkeit, beliebig<br />
große Zahlen zu enthalten.<br />
97
98 KAPITEL 4. CHURCHSCHE THESE<br />
Zeile:<br />
0<br />
1<br />
2<br />
READ 0<br />
LOAD 3<br />
k STOP<br />
<br />
Programm<br />
<br />
<br />
BZ<br />
STEUER-<br />
EINHEIT<br />
E<strong>in</strong>gabeband<br />
13 0 1 0 . . .<br />
⇑<br />
<br />
<br />
⇓<br />
2 0 14<br />
Ausgabeband<br />
SCHEMA EINER RAM<br />
E<strong>in</strong>e RAM besteht aus den folgenden Komponenten:<br />
SPEICHER<br />
<br />
R0<br />
R1 R2 . . .<br />
↑<br />
Akkumulator<br />
1. E<strong>in</strong>e Steuere<strong>in</strong>heit, die über e<strong>in</strong> Programm verfügt. E<strong>in</strong> Programm ist e<strong>in</strong>e<br />
durchnummerierte Liste von Befehlen, die weiter unten aufgeführt s<strong>in</strong>d. Die<br />
Steuere<strong>in</strong>heit enthält e<strong>in</strong> Register, das Befehlszähler (BZ) heißt und dessen<br />
Inhalt = i e<strong>in</strong>e natürliche Zahl ist. Das bedeutet, dass der Befehl Nr. i<br />
auszuführen ist.<br />
2. E<strong>in</strong>en Speicher, der aus durchnummerierten Registern R0, R1, R2, . . . besteht.<br />
Jedes Register Ri enthält e<strong>in</strong>e natürliche Zahl . Das Register R0<br />
heißt Akkumulator.<br />
3. E<strong>in</strong>em E<strong>in</strong>gabeband, das aus Feldern besteht. Jedes Feld enthält e<strong>in</strong>e natürliche<br />
Zahl. (E<strong>in</strong> Feld, das 0 enthält, wird als leer angenommen – das entspricht<br />
unserer Darstellung N = {|} ∗ .) Auf dem E<strong>in</strong>gabeband steht e<strong>in</strong> read-only<br />
Kopf, der nur lesen und sich dann sofort e<strong>in</strong> Feld nach rechts bewegen kann.<br />
Die gelesene Zahl wird mit bezeichnet.<br />
4. E<strong>in</strong>em Ausgabeband, das aus Feldern besteht und auf dem e<strong>in</strong> write-only Kopf<br />
steht, der nur e<strong>in</strong> Feld beschriften und sich anschließend sofort e<strong>in</strong> Feld nach<br />
rechts bewegen kann.<br />
Die RAM arbeitet taktweise: <strong>in</strong> jedem Takt wird der Befehl aus der Zeile <br />
durchgeführt.<br />
Anfang der Berechnung: Die E<strong>in</strong>gabe steht auf dem E<strong>in</strong>gabeband, das Ausgabeband<br />
ist leer, und alle Register (e<strong>in</strong>schließlich des Befehlszählers und des Akkumulators)<br />
s<strong>in</strong>d leer (Zahl 0).<br />
Ende der Berechnung: Die Berechnung endet, falls<br />
1. die Instruktion STOP durchgeführt wird oder<br />
2. e<strong>in</strong>e GOTO m Instruktion durchgeführt wird, obwohl ke<strong>in</strong> Befehl die Nummer<br />
m hat.
4.1. RAM 99<br />
Hier ist die Liste aller Befehle:<br />
Befehl Wirkung<br />
READ :=, := + 1, der Lesekopf bewegt<br />
sich nach rechts<br />
WRITE Der Schreibkopf schreibt und bewegt sich nach<br />
rechts, := + 1.<br />
LOAD i := und := + 1<br />
STORE i := und := + 1<br />
ADD i := + und := + 1<br />
PRED :=pred und := + 1. Hier gilt:<br />
pred (n + 1) = n und pred 0 = 0.<br />
GOTO m<br />
IF Ri = 0 GOTO m<br />
:= m<br />
<br />
m falls Ri = 0<br />
:=<br />
+ 1 sonst<br />
m falls > 0<br />
IF Ri > 0 GOTO m :=<br />
+ 1 sonst<br />
STOP Masch<strong>in</strong>e hält.<br />
Bemerkung 1. Für <strong>in</strong>direkte Adressierung dürfen wir ∗i (statt i) benutzen,<br />
z.B. hat LOAD ∗i die Wirkung := (also wird im Akkumulator der<br />
Inhalt des Registers, dessen Adresse <strong>in</strong> Ri steht, gespeichert). Analog für STORE ∗i<br />
und ADD ∗i. Außerdem benutzen wir !i statt i für Konstanten: z.B. hat STORE !i<br />
die Wirkung := i und := + 1.<br />
Die obige Liste von Befehlen ist kurz, um das Modell übersichtlich zu gestalten,<br />
aber weitere Befehle lassen sich leicht programmieren:<br />
Beispiel 1. SUCC i. Wir wollen den Befehl benutzen, der den Inhalt des Registers<br />
Ri um e<strong>in</strong>s erhöht. SUCC i ist dann dieses Unterprogramm:<br />
LOAD !1 [1 <strong>in</strong> den Akkumulator]<br />
ADD i<br />
STORE i<br />
<br />
[:= +1]<br />
Beispiel 2. PRED i. Der Befehl, der die Wirkung := −1, falls <br />
> 0 ist, hat, lässt sich analog programmieren.<br />
Beispiel 3. SUB i. Der Befehl, der die folgende Wirkung − , falls<br />
≥ und R0 := 0 ansonsten hat, hat das folgende Programm:<br />
0. IF R0 = 0 GOTO 4<br />
1. PRED<br />
2. PRED i<br />
3. GOTO 0<br />
4. LOAD i<br />
Beispiel 4. IF Ri = k GOTO m. Für jede Konstante k können wir diesen Sprungbefehl<br />
durch das folgende Unterprogramm ersetzen:<br />
LOAD !k<br />
SUB i<br />
STORE i<br />
IF Ri = 0 GOTO m<br />
Beispiel 5. Multiplikation. Die Funktion f(n, m) = n ∗ m kann wie folgt programmiert<br />
werden: wir speichern erst die E<strong>in</strong>gabe n <strong>in</strong> R1 und m <strong>in</strong> R2:
100 KAPITEL 4. CHURCHSCHE THESE<br />
0. READ<br />
1. STORE 1<br />
2. READ<br />
3. STORE 2<br />
Jetzt wird R1 solange zu R3 (= Speicher des Ergebnisses) addiert, bis = 0 ist,<br />
wobei bei jedem Schritt := − 1 gesetzt wird. Falls = 0, spr<strong>in</strong>gen<br />
wir zur Zeile a, die den WRITE-Befehl ausführt:<br />
4. IF R2 = 0 GOTO a<br />
5. LOAD 1<br />
6. ADD 3<br />
7. STORE 3<br />
8. PRED R2<br />
9. GOTO 4<br />
a = 10. LOAD 3<br />
11. WRITE<br />
Beispiel 6. Simulation e<strong>in</strong>er Tur<strong>in</strong>gmasch<strong>in</strong>e.<br />
Für jede TM können wir e<strong>in</strong> Programm für RAM schreiben, das die Arbeit der TM<br />
Schritt für Schritt simuliert. Wir nehmen an, dass die Zustände der TM durchnummeriert<br />
s<strong>in</strong>d:<br />
Q = {q0, q1, . . .,qn}, wobei q0 der Initialzustand ist,<br />
sowie auch die Symbole des Bandalphabetes:<br />
def.<br />
Σ = {s1, s2, . . .,sm} und s0 = #.<br />
Schließlich werden auch die Felder des Bandes durchnummeriert: 0 für das erste<br />
Feld der E<strong>in</strong>gabe und 1, 2, 3, . . . für die weiter rechts stehenden Felder. Um die<br />
Notation zu vere<strong>in</strong>fachen, nehmen wir an, dass die TM die Felder l<strong>in</strong>ks von 0 nie<br />
besucht. (Sonst könnten wir z.B. die Felder rechts von 0 nur mit geraden Zahlen<br />
nummerieren und die l<strong>in</strong>ks von 0 stehenden mit ungeraden Zahlen.)<br />
Um die Simulation zu vere<strong>in</strong>fachen, nehmen wir weiter an, dass die TM e<strong>in</strong> Spezialsymbol<br />
@ benutzt, das immer als letztes Symbol auf dem Band steht. Die E<strong>in</strong>gabe<br />
si0 . . .sik hat also die Form<br />
si0<br />
si1<br />
si2 . . . sik @ # # . . .<br />
0 1 2 k k+1k+2<br />
Bei der obigen Nummerierung von Σ sei @ = sm. Die E<strong>in</strong>gabe wird im E<strong>in</strong>gabeband<br />
der RAM entsprechend codiert:<br />
i0 i1 i2 . . . ik m 0 0 . . .<br />
Die Register der RAM spielen die folgende Rolle:<br />
R0 (Akkumulator)<br />
R1 (Zustand) enthält i, falls die TM im Zustand qi ist<br />
R2 (Kopfposition) enthält k + 2, falls der Kopf am Feld k steht<br />
R(3 + i) (Band<strong>in</strong>halt) enthält t, falls im Feld i das Symbol st steht.<br />
Das Programm der RAM, das die TM simuliert, besteht aus drei Teilen:<br />
Teil 1 sorgt dafür, dass die E<strong>in</strong>gabe<br />
si0<br />
si1<br />
si2 . . . s<strong>in</strong> @ = sm<br />
<strong>in</strong> die Register R3, R4, . . . , R(3 + n) und R(3 + n + 1) gelesen wird. Wir lesen also<br />
(mit READ) die E<strong>in</strong>gaben so lange, bis m (der Index von @ = sm) gelesen wird. Dabei<br />
lassen wir die Register R1 und R2 zunächst leer. Es ist e<strong>in</strong>fach, so e<strong>in</strong> Programm<br />
mit Hilfe der obigen Beispiele 1 bis 3 <strong>in</strong> Abschnitt 4.1 zu schreiben:<br />
0. LOAD !3<br />
1. STORE 2<br />
. . .
4.1. RAM 101<br />
2. READ<br />
3. STORE ∗2<br />
4. IF R0 = m GOTO 7<br />
5. SUCC 2<br />
6. GOTO 2<br />
Teil 2 (<strong>in</strong> den gesprungen wird, falls die E<strong>in</strong>gabe m ist) beg<strong>in</strong>nt damit, das der Kopf<br />
nach l<strong>in</strong>ks gestellt wird (:= 4) und der Zustand q0 (:= 0) ist.<br />
Dann werden die e<strong>in</strong>zelnen Zeilen der Übergangstabelle programmiert. In dem Fall,<br />
dass ke<strong>in</strong> Übergang existiert, wird zu Teil 3 (Ausgabe) gesprungen.<br />
Teil 3 des Programms schreibt , , . . ., bis es auf die Zahl := m<br />
(d.h. auf das Endsymbol @) stößt. Dann hält es:<br />
Zeile Befehl<br />
k LOAD !3<br />
k + 1 STORE 4 [Am Anfang: = 3]<br />
k + 2 LOAD 2<br />
k + 3 WRITE<br />
k + 4 SUCC 2<br />
k + 5 IF R0 = m GOTO (k + 7)<br />
k + 6 GOTO (k + 2)<br />
k + 7 STOP<br />
Beispiel 7. RAM-Simulation e<strong>in</strong>er e<strong>in</strong>fachen TM.<br />
Die folgende TM realisiert die Funktion SUCC:<br />
M = ({q0, q1}, {|, @}, δ, q0, q1)<br />
mit den folgenden Übergängen<br />
(1) (q0, |) → (q0, R)<br />
(2) (q0, @) → (q1, |)<br />
(3) (q1, |) → (q1, R)<br />
(4) (q1, #) → (q1, @)<br />
Die Simulation hat die drei oberen Teile, wobei Teil 2 wie folgt die vier Übergänge<br />
simuliert:<br />
Zeile Befehl Kommentar<br />
7. LOAD !3<br />
8. STORE 2 Initialposition des Kopfes (+ 3)<br />
9. LOAD ∗2 n R0 steht das momentan gelesene Symbol<br />
10. IF R1 = 0 GOTO a a-Übergänge (1), (2) (Zustand q0)<br />
11. IF R0 = 1 GOTO b Hier Zustand q1, b-Übergang (3)<br />
12. IF R0 = 0 GOTO c Hier Zustand q1, c-Übergang (4)<br />
13. GOTO k Zustand q1, Symbol @-Sprung <strong>in</strong> den Teil 3<br />
a = 14. IF R0 = 1 GOTO d d-Übergang (1)<br />
15. IF R0 = 2 GOTO e e-Übergang (2)<br />
d = 16. SUCC 2 Kopf nach rechts<br />
GOTO 9<br />
e = 17. LOAD !1 Statt @ = 2 wird | = 1 geschrieben<br />
18. STORE ∗2<br />
19. STORE 1 Zustand q1<br />
20. GOTO 9.<br />
b = 21. SUCC 2 Kopf nach rechts<br />
22. GOTO 9.<br />
c = 23. LOAD !2<br />
24. STORE ∗2<br />
25. GOTO k Also ist Zeile k = 26 der Anfang von Teil 3
102 KAPITEL 4. CHURCHSCHE THESE<br />
4.2 RAM-Berechenbarkeit<br />
Def<strong>in</strong>ition. E<strong>in</strong>e RAM berechnet e<strong>in</strong>e Funktion f(n1, n2, . . . , nk), deren Variablen<br />
und Werte <strong>in</strong> liegen, falls die RAM auf die E<strong>in</strong>gabe n1, n2, . . . , nk hält und auf dem<br />
Ausgabeband m (nur e<strong>in</strong>e Zahl) steht, wobei f(n1, . . .,nk) = m. E<strong>in</strong>e Funktion, die<br />
von e<strong>in</strong>er (geeignet programmierten) RAM berechnet werden kann, heißt RAMberechenbar.<br />
Beispiel 1. Die Funktionen<br />
f(n, m) = n + m und f(n, m) = n ∗ m<br />
s<strong>in</strong>d RAM-berechenbar.<br />
Das Programmieren von RAMs ist zwar im Vergleich zu modernen Programmiersprachen<br />
aufwendig und kompliziert, trotzdem ist es nicht schwer zu zeigen, dass<br />
jede Funktion, die sich mit e<strong>in</strong>em PASCAL-Programm berechnen lässt, auch <strong>in</strong> e<strong>in</strong>er<br />
RAM programmiert werden kann.<br />
Obwohl Tur<strong>in</strong>gmasch<strong>in</strong>en weniger realistisch als RAMs s<strong>in</strong>d (und viel e<strong>in</strong>facher),<br />
s<strong>in</strong>d sie ke<strong>in</strong>eswegs schwächer:<br />
Satz 1. Jede RAM-berechenbare Funktion ist Tur<strong>in</strong>g-berechenbar.<br />
Beweis. Wir haben e<strong>in</strong> RAM-Programm für die Funktion f(a1, . . .,ak), und wir<br />
simulieren es mit e<strong>in</strong>er 6-Band TM mit zusätzlichem Gedächtnis wir folgt:<br />
Band 1 (E<strong>in</strong>gabeband)<br />
Band 2 (Speicher)<br />
Band 3 (Akkumulator)<br />
Band 4 (Befehlszähler)<br />
Band 5 (Hilfsband)<br />
Band 6 (Ausgabeband)<br />
$ a1 $ a2 $ . . . ak $<br />
$ $ 1 $ $$ 2 $ $ $<br />
<br />
<br />
f(a1, . . . , ak)<br />
Die TM hat also das Bandalphabet Σ = {|, $}, und die E<strong>in</strong>gabe der RAM wird<br />
mit Trennungssymbolen $ auf Band 1 geschrieben. Band 2 enthält den Speicher<br />
der RAM: falls Register Ri benutzt wurde und momentan n enthält, f<strong>in</strong>den wir auf<br />
Band 2 die Komb<strong>in</strong>ation<br />
$ $ i $ n $$, was = n bedeutet.<br />
(Wir können aber mehrere solcher Komb<strong>in</strong>ationen mit demselben i auf Band 2<br />
f<strong>in</strong>den. In diesem Fall nehmen wir nur die, die am weitesten rechts steht). Band<br />
3 enthält den Inhalt des Akkumulators und Band 4 den des Befehlszählers. Band<br />
6 ist das Ausgabeband. Das (endliche) Programm der RAM ist im zusätzlichen<br />
Gedächtnis der TM gespeichert.<br />
Anfang der Simulation: Alle Bänder außer Band 1 s<strong>in</strong>d leer. Speziell wird Befehl<br />
Nr. 0 (= 0) simuliert.<br />
Simulation der Befehle: Es wird immer der Befehl, dessen Zeilennummer auf Band<br />
4 steht, simuliert. Wir zeigen e<strong>in</strong>ige Beispiele:<br />
READ Auf Band 1 steht der Kopf unter $, jetzt bewegt er sich, bis er auf dem<br />
nächsten $ stehen bleibt, wobei die Zahl ai auf Band 3 geschrieben<br />
wird. Danach wird der Befehlszähler (Band 4) um 1 erhöht.<br />
STORE i Auf Band 2 wird nach dem letzten Symbol $ die Komb<strong>in</strong>ation i $ n $<br />
$ geschrieben, wobei n der Inhalt des Akkumulators (Band 3) ist.<br />
. . .
4.3. GRAMMATIKEN UND TURINGMASCHINEN 103<br />
STORE ∗i Auf Band 3 steht e<strong>in</strong>e Zahl n. Diese soll <strong>in</strong> das Register Rj, wobei<br />
j der Inhalt von Ri ist, gespeichert werden. Also sucht der Kopf auf<br />
Band 2 die (am weitesten rechts stehende) Konfiguration<br />
$ $ i $ j $ $,<br />
und wenn er sie gefunden hat, schreibt er j auf das Hilfsband 5. Jetzt<br />
schreibt die TM auf Band 2 h<strong>in</strong>ter das letzte Symbol $ die Komb<strong>in</strong>ation<br />
j $ n $ $.<br />
Der Leser sollte jetzt ke<strong>in</strong>e Schwierigkeiten haben, jeden Befehl der RAM entsprechend<br />
zu simulieren. Wenn die RAM hält, hält auch die TM (nachdem sie die<br />
Instruktion WRITE simuliert hat). Sie hat dann f(a1, . . . , ak) auf dem Ausgabeband.<br />
Korollar 1. RAM-berechenbare und Tur<strong>in</strong>g-berechenbare Funktionen s<strong>in</strong>d dieselben.<br />
In der Tat ist jede Tur<strong>in</strong>g-berechenbare Funktion RAM-berechenbar: siehe Beispiel<br />
6 <strong>in</strong> Abschnitt 4.1.<br />
4.3 Grammatiken und Tur<strong>in</strong>gmasch<strong>in</strong>en<br />
In Kapitel 2 sprachen wir von kontextfreien Grammatiken, die es erlauben, e<strong>in</strong>e Variable<br />
durch e<strong>in</strong> Wort zu ersetzen. Das ist e<strong>in</strong> Spezialfall e<strong>in</strong>er Grammatik (auch<br />
unbeschränkte Grammatik oder Grammatik des Typs 0 genannt), die es allgeme<strong>in</strong><br />
erlaubt, e<strong>in</strong> Wort durch e<strong>in</strong> anderes zu ersetzen. Es zeigt sich, dass diese Grammatiken<br />
genau die rekursiv aufzählbaren Sprachen def<strong>in</strong>ieren. In diesem S<strong>in</strong>n erhalten<br />
wir also e<strong>in</strong> vollkommen neues Modell von Sprachen, die Tur<strong>in</strong>g-akzeptierbar s<strong>in</strong>d.<br />
Def<strong>in</strong>ition. E<strong>in</strong>e Grammatik G ist e<strong>in</strong> Quadrupel G = (Σ, V, S, R), wobei Σ das<br />
Alphabet aller Term<strong>in</strong>alsymbole, V das Alphabet aller Variablen (zu Σ disjunkt),<br />
S ∈ V das Startsymbol und R e<strong>in</strong>e endliche Menge an Paaren (α, β) von Wörtern<br />
über Σ ∪ V mit α = ε ist.<br />
Bemerkung 1. Elemente (α, β) aus R werden mit<br />
α → β<br />
bezeichnet und werden Produktionen oder Ersetzungsregeln genannt. Die Anwendung<br />
e<strong>in</strong>er Regel α → β auf e<strong>in</strong> Wort w ist genau dann möglich, wenn w die<br />
Form<br />
w = w ′ αw ′′ (w ′ , w ′′ Wörter über Σ ∪ V )<br />
hat. Das Ergebnis der Anwendung ist das Wort<br />
w ′ βw ′′ .<br />
Notation. 1. Mit ⇒ bezeichnen wir die Anwendung e<strong>in</strong>er e<strong>in</strong>zigen Regel; also<br />
schreiben wir für zwei Wörter u, w <strong>in</strong> (Σ ∪ V ) ∗<br />
u ⇒ v,<br />
falls es e<strong>in</strong>e Regel α → β <strong>in</strong> R und Wörter u1, u2 <strong>in</strong> (Σ ∪ V ) ∗ gibt, so dass<br />
u = u1αu2 und v = u1βu2.<br />
2. Mit ⇒ ∗ bezeichnen wir die reflexive und transitive Hülle der Relation ⇒.<br />
Def<strong>in</strong>ition. Für jede Grammatik G heißt die Menge aller Wörter über Σ, die vom<br />
Startsymbol ableitbar s<strong>in</strong>d, die Sprache L(G) erzeugt durch G. Kürzer:<br />
L(G) = {w ∈ Σ ∗ ; S ⇒ ∗ w}.<br />
Alle oben def<strong>in</strong>ierten Begriffe verallgeme<strong>in</strong>ern die <strong>in</strong> Kapitel 2 e<strong>in</strong>geführten Begriffe<br />
für kontextfreie Sprachen. Aber die allgeme<strong>in</strong>en Grammatiken erzeugen Sprachen,<br />
die nicht kontextfrei se<strong>in</strong> müssen:
104 KAPITEL 4. CHURCHSCHE THESE<br />
Beispiel 1. E<strong>in</strong>e Grammatik für die Sprache<br />
{|, ||, ||||, . . . } = {2n ; n ∈ }<br />
(die nicht kontextfrei ist! ). Die Idee ist, dass wir mit dem Wort [A] anfangen und<br />
die Zahl von A’s verdoppelt werden kann. Dafür verwenden wir e<strong>in</strong>e Variable D, die<br />
l<strong>in</strong>ks auftauchen kann (also [ → [D) und rechts verschw<strong>in</strong>den kann (also D] → ]),<br />
und die auf ihrem Weg nach rechts A verdoppelt: DA → AAD. Am Ende bekommen<br />
wir [AA · · · A], wobei die Anzahl der A’s gleich 2n ist. Jetzt brauchen wir nur die<br />
Klammern zu entfernen und A <strong>in</strong> | umwandeln. Formal:<br />
G = ({|}, {S, A, D, [, ]}, S, R),<br />
wobei R die folgenden Produktionen s<strong>in</strong>d:<br />
(1) S → [A]<br />
(2) [ → [D<br />
(3) D] → ]<br />
(4) DA → AAD<br />
(5) [ → ε<br />
(6) ] → ε<br />
(7) A → |<br />
Es gilt:<br />
L(G) = {2n ; n ∈ }.<br />
Beweis. Erst zeigen wir, wie 2 n abgeleitet wird, also {2 n ; n ∈ } ⊆ L(G):<br />
S ⇒ [A] Regel (1)<br />
⇒ ∗ [D n A] Regel (2) n-mal<br />
⇒ [D n−1 AAD] Regel (4) 1-mal<br />
⇒ ∗ [D n−2 AAAAD 2 ] Regel (4) 2-mal<br />
.<br />
⇒∗ [A2nDn ] Regel (4) n-mal<br />
⇒∗ [A2n] Regel (3) n-mal<br />
⇒ A2n] Regel (5)<br />
⇒ A2n Regel (6)<br />
⇒ 2n Regel (7)<br />
Ist umgekehrt w e<strong>in</strong>e Zahl ist, also e<strong>in</strong> Wort über {|} mit S ⇒ ∗ w, beweisen wir<br />
w = 2 n , das heißt L(G) ⊆ {2 n ; n ∈ }. Sei<br />
S ⇒ w1 ⇒ w2 ⇒ · · · ⇒ wk ⇒ w<br />
e<strong>in</strong>e Ableitung von w. Bezeichnen wir durch m die Anzahl von Indizes i, für welche<br />
die Regel (2) die Basis für wi ⇒ wi+1 ist. Da wk ke<strong>in</strong> D enthält, musste die Regel<br />
(3) genau m-mal angewandt werden. Dabei wurde die Anzahl der A’s bei jedem<br />
” Durchgang“ e<strong>in</strong>es D’s (von l<strong>in</strong>ks also [D, nach rechts, d. h. D]) immer verdoppelt,<br />
da dieser Durchgang nur auf Grund der Regel (4) möglich ist. Am Anfang gibt es<br />
genau e<strong>in</strong> A: aus S ⇒ w1 folgt w1 = [A]. Also entstehen im Laufe der Ableitung<br />
genau 2m Symbole A. Da das term<strong>in</strong>ale Symbol | nur durch die Regel (7) ersche<strong>in</strong>en<br />
kann und wk = w ke<strong>in</strong>e Variablen enthält, beweist dies, dass<br />
w = | 2m.<br />
Beispiel 2. E<strong>in</strong>e Grammatik für die (nicht kontextfreie) Sprache L = {a n b n c n ;<br />
n ≥ 1}. Sei<br />
G = ({a, b, c}, {B, C, S}, S, R)<br />
die Grammatik mit den Regeln<br />
(1) S → aBC | aSBC<br />
(2) CB → BC<br />
(3) aB → ab<br />
(4) bB → bb<br />
(5) bC → bc<br />
(6) cC → cc
4.3. GRAMMATIKEN UND TURINGMASCHINEN 105<br />
Das Wort a n b n c n , n ≥ 1, liegt <strong>in</strong> L(G), da es sich wie folgt ableiten lässt:<br />
S ⇒ ∗ a n−1 S(BC) n−1 [Regel S → aSBC, (n − 1)-mal angewendet]<br />
⇒ a n (BC) n [Regel S → aBC]<br />
⇒ ∗ a n B n C n [Regel BC → CB, (n − 1)-mal angewendet]<br />
⇒ a n bB n−1 C n [Regel aB → ab]<br />
⇒ ∗ a n b n C n [Regel bB → bb, (n − 1)-mal angewendet]<br />
⇒ a n b n cC n−1 [Regel bC → bc]<br />
⇒ ∗ a n b n c n [Regel cC → cc, (n − 1)-mal angewendet]<br />
Umgekehrt beweisen wir, dass nur Wörter der Form a n b n c n ableitbar s<strong>in</strong>d. In der<br />
Tat: falls w e<strong>in</strong> Wort ist, das von S ableitbar ist und ke<strong>in</strong>e Variable enthält, beweisen<br />
wir das folgende:<br />
1. Die Anzahl von a’s im Wort w ist dieselbe wie die von b’s und dieselbe wie die<br />
von c’s . In der Tat, die Regeln (2) - (6) ändern die Anzahl der Buchstaben a,<br />
b/B oder c/C nicht, und Regel (1) erhöht alle drei dieser Zahlen gleichzeitig<br />
um 1.<br />
2. Alle a’s stehen l<strong>in</strong>ks im Wort w, das heißt, w hat die Form w = a n v (und v<br />
besteht aus n b’s und n c’s ). Ke<strong>in</strong>e der Regeln (1) - (6) ändert nämlich die<br />
l<strong>in</strong>ke Position von a.<br />
3. Das Wort w enthält nicht die Komb<strong>in</strong>ation cb (das heißt, w hat nicht die Form<br />
w = ucbv). Um das zu beweisen, betrachten wir die Regeln (3) - (6): diese<br />
ändern weder Anzahl noch Position der Buchstaben a, b/B oder c/C im Wort,<br />
sie wandeln nur B → b oder C → c um. Wir können daher annehmen, dass<br />
<strong>in</strong> der Ableitung S ⇒ ∗ w zuerst nur die Regeln (1) und (2) benutzt werden,<br />
und dann erst werden die Regeln (3) - (6) angewendet. Genauer: es gibt e<strong>in</strong>e<br />
Ableitung:<br />
S ⇒ w1 ⇒ w2 ⇒ · · · ⇒ wi ⇒ · · · ⇒ wk = w,<br />
wobei für S ⇒ · · · ⇒ wi nur die Regeln (1) und (2) angewendet werden und<br />
für wi ⇒ · · · ⇒ wk nur die Regeln (3) - (6). Dann unterscheiden sich die<br />
Wörter wi und wk nur dadurch, dass an der Stelle im Wort, an der b steht,<br />
wi den Buchstaben B hat und dasselbe gilt analog für c/C. Das Wort wi<br />
enthält die Komb<strong>in</strong>ation CB nicht, denn ke<strong>in</strong>e der Regeln (3) - (6) kann B <strong>in</strong><br />
b umwandeln, falls vor diesem B entweder C oder c steht. Es folgt, dass das<br />
Wort w = wk die Komb<strong>in</strong>ation cb nicht enthält.<br />
4. w = a n b n c n , denn <strong>in</strong> 2. haben wir e<strong>in</strong> Wort v mit n b’s, n c’s und ohne die<br />
Komb<strong>in</strong>ation cb – das e<strong>in</strong>zige Wort ist v = b n c n .<br />
Beispiel 3. Simulation e<strong>in</strong>er TM.<br />
Wir zeigen jetzt, wie die Arbeit e<strong>in</strong>er TM vollständig von e<strong>in</strong>er Grammatik simuliert<br />
werden kann. Er<strong>in</strong>nern wir uns an das Konzept von Konfigurationen (q, u, a, v) aus<br />
Kapitel 3.1:<br />
. . . a<br />
. . .<br />
<br />
u<br />
⇑<br />
q<br />
<br />
v<br />
Die Konfigurationen werden jetzt statt (q, uav) durch das Wort [uqav] über Σ∪Q∪<br />
{[, ], #} bezeichnet. Also ist die Initialkonfiguration mit E<strong>in</strong>gabe s1 . . . sn das Wort<br />
[q0s1 . . . sn].<br />
Die Arbeit der TM wird durch die Relation ⊢ ( ” Folgekonfiguration“) beschrieben.<br />
Wir konstruieren jetzt e<strong>in</strong>e Grammatik G, <strong>in</strong> der für zwei Konfigurationen gilt:
106 KAPITEL 4. CHURCHSCHE THESE<br />
[uqav] ⊢ [u ′ q ′ a ′ v ′ ] genau dann, wenn [u ′ q ′ a ′ v ′ ] ⇒ [uqav].<br />
(Also beschreibt die Ableitung <strong>in</strong> der Grammatik G die Berechnung rückwärts.)<br />
Wir benutzen die Bandsymbole Σ der TM als term<strong>in</strong>ale Symbole und die folgenden<br />
Variablen:<br />
V = Q ∪ {S, #, [, ]};<br />
wir setzen V ∩ Σ = ∅ wie üblich voraus. Also<br />
G = (Σ, V, S, R),<br />
und die Produktionen R entsprechen den Möglichkeiten von ⊢ (siehe Tabelle 3.1 <strong>in</strong><br />
Abschnitt 3.1):<br />
1. Für jede Übergangsregel (q, s) → (q ′ , s ′ ) der TM mit s ′ <strong>in</strong> Σ ∪ {#} haben<br />
wir die Folgekonfigurationen [uqsv] ⊢ [uq ′ s ′ v], und wir benötigen also die<br />
Produktion (<strong>in</strong> der Gegenrichtung)<br />
(1) q ′ s ′ → qs.<br />
2. Für jede Übergangsregel (q, s) → (q ′ , R) der TM haben wir die Folgekonfigurationen<br />
[uqsv] ⊢ [usq ′ v] falls v = ε<br />
und<br />
[uqs] ⊢ [usq ′ #] falls v = ε.<br />
Wir benötigen dafür die Produktionen<br />
(2) sq ′ → qs<br />
(3) sq ′ #] → qs]<br />
3. Für jede Übergangsregel (q, s) → (q ′ , L) brauchen wir die Produktionen<br />
(4) q ′ s ′ s → s ′ qs ∀s ′ ∈ Σ ∪ {#}<br />
(5) [q ′ #s → [qs<br />
Nehmen wir jetzt an, dass die TM e<strong>in</strong> Wort s1 . . .sn über Σ akzeptiert, und<br />
dass sie ihr E<strong>in</strong>gabeband löscht, bevor sie hält. Dann haben wir e<strong>in</strong>e Berechnung,<br />
die mit der Initialkonfiguration [q0s1 . . . sn] beg<strong>in</strong>nt und mit der<br />
F<strong>in</strong>alkonfiguration [qF#] endet. Das heißt, aufgrund der Produktionen (1) -<br />
(5) gibt es e<strong>in</strong>e Ableitung (<strong>in</strong> der Gegenrichtung!)<br />
[qF#] ⇒ . . . ⇒ [q0s1 . . . sn].<br />
Wir fügen jetzt drei Produktionen h<strong>in</strong>zu, so dass wir dann vom Startsymbol<br />
S das Wort s1 . . . sn ableiten:<br />
(6) S → [qF#]<br />
(7) [q0 → ε<br />
(8) ] → ε<br />
Wir haben also die Grammatik<br />
GM = (Σ, V ∪ {#, [, ], S}, S, R)<br />
mit den Produktionen (1) - (8). Wir beweisen jetzt, dass sie die Sprache L(M)<br />
erzeugt.<br />
Satz 1. Falls M e<strong>in</strong>e TM ist, die ihr Band immer löscht, bevor sie hält, dann gilt<br />
für die obige Grammatik GM, dass L(M) = L(GM).<br />
Beweis. 1. Jedes Wort w = s1 . . .sn, das M akzeptiert, ist aus GM ableitbar,<br />
das heißt, L(M) ⊆ L(GM). In der Tat, für e<strong>in</strong>e gegebene Berechnung,<br />
die <strong>in</strong> der Konfiguration [q0s1 . . . sn] beg<strong>in</strong>nt und <strong>in</strong> [qF#] endet, seien k0 =<br />
[q0s1 . . . sn] ⊢ k1 ⊢ . . . ⊢ kM = [qF#] die Konfigurationen der Berechnung.<br />
Dann gilt<br />
S ⇒ [qF#] ⇒ kM−1 ⇒ kM−2 ⇒ · · · ⇒ k1 ⇒ [q0s1 . . . sn] ⇒ ∗ s1 . . .sn,<br />
wobei am Anfang die Produktion (6) und am Ende die Produktionen (7) und<br />
(8) verwendet wurden. Also gehört s1 . . . sn zu L(GM).
4.3. GRAMMATIKEN UND TURINGMASCHINEN 107<br />
2. Sei w = s1 . . . sn e<strong>in</strong> Wort, das von S ableitbar ist. Wir haben e<strong>in</strong>e Ableitung<br />
der Form<br />
S ⇒ [qF#] ⇒ w1 ⇒ w2 ⇒ . . . ⇒ wM = s1 . . . sn.<br />
Wir dürfen annehmen, dass die Regeln (7) und (8) (die bestimmt angewendet<br />
wurden, da w1 die beiden Klammern enthält, aber wM nicht) erst am Ende<br />
der Ableitung angewendet wurden, also wM−2 = [q0s1 . . .sn]. Für die Ableitung<br />
w1 ⇒ ∗ wM−2 wurden nur die Regeln (1) - (6) angewendet. Es ist also<br />
h<strong>in</strong>reichend, zu zeigen, dass, falls für zwei Konfigurationen w und w ′ , w ′ ⊢ w<br />
aufgrund von (1) - (6) gilt, dann folgt daraus w ⊢ w ′ .<br />
(a) Falls die Produktion (1) angewendet wurde, gilt w ′ = [uq ′ s ′ v] und w =<br />
[uqsv], wobei qs → q ′ s ′ e<strong>in</strong>e Übergangsregel ist. Dann ist w ′ e<strong>in</strong>e<br />
Folgekonfiguration von w.<br />
(b) Falls die Produktion (2) angewendet wurde, gilt w ′ = [usq ′ v] und w =<br />
[uqsv]. Wieder ist w ′ e<strong>in</strong>e Folgekonfiguration von w.<br />
(c) Falls die Produktion (3) angewendet wurde, gilt w ′ = [usq ′ #] und w =<br />
[uqs], und auch diesmal ist w ′ e<strong>in</strong>e Folgekonfiguration von w. Analog mit<br />
den Produktionen (4) und (5).<br />
Also für w1 = [qF#] und wM−2 = [q0s1 . . . sn] folgt aus w1 ⇒ ∗ wM−2, dass<br />
wM−2 ⊢ ∗ w1. Das bedeutet, dass die TM auf die E<strong>in</strong>gabe s1 . . . sn hält und<br />
akzeptiert. Also gehört s1 . . . sn zu L(M).<br />
Korollar 1. Für jede rekursiv-aufzählbare Sprache L gibt es e<strong>in</strong>e Grammatik, die<br />
L erzeugt.<br />
Beweis. Es gibt e<strong>in</strong>e TM, die L akzeptiert. Sei M e<strong>in</strong>e Modifikation dieser TM,<br />
die sich nur dadurch unterscheidet, dass M ihr Band löscht, bevor sie hält. Dann<br />
gilt<br />
L = L(M) = L(GM).<br />
Beispiel 4. Die folgende TM akzeptiert die Sprache aller ungeraden Zahlen (über<br />
Σ = {|}):<br />
M = ({q0, q1, q2}, {|}, δ, q0, qF)<br />
mit Übergängen<br />
(q0, |) → (q1, #)<br />
(q1, #) → (qF,R)<br />
(qF,|) → (q2, #)<br />
(q2, #) → (q0, R)<br />
Dieser TM entspricht die folgende Grammatik<br />
GM = ({|}, {q0, q1, q2, #, [, ], S}, S, R)<br />
mit den Produktionen<br />
S → [qF#]<br />
q1# → q0|<br />
#qF → q1#<br />
#qF#] → q1#]<br />
q2# → qF |<br />
#q0 → q2#<br />
#q2#] → q2#]<br />
[q0 → ε<br />
] → ε<br />
Satz 2. Jede von e<strong>in</strong>er Grammatik erzeugte Sprache ist rekursiv-aufzählbar.
108 KAPITEL 4. CHURCHSCHE THESE<br />
Beweis. Wir wollen zeigen, dass für jede Grammatik G die Sprache L(G) von e<strong>in</strong>er<br />
TM akzeptiert werden kann. Wir benutzen e<strong>in</strong>e nichtdeterm<strong>in</strong>istische 2-Band-TM,<br />
die alle Produktionen von G <strong>in</strong> e<strong>in</strong>em zusätzlichen Gedächtnis hat. Band 1 ist e<strong>in</strong><br />
read-only E<strong>in</strong>gabeband. Auf Band 2 schreibt die TM zu Beg<strong>in</strong>n das Startsymbol S.<br />
In jedem Berechnungsschritt zerlegt die TM nichtdeterm<strong>in</strong>istisch das Wort w auf<br />
Band 2 <strong>in</strong> drei Wörter:<br />
w = upv u, p, v ∈ (Σ ∪ V ) ∗ mit p = ε.<br />
Zum Beispiel ist am Anfang die e<strong>in</strong>zige mögliche Zerlegung u = ε, p = S und<br />
v = ε. Jetzt wählt die TM nichtdeterm<strong>in</strong>istisch e<strong>in</strong>e Produktion von G von der Form<br />
p → q (falls ke<strong>in</strong>e solche Produktion existiert, hält die TM <strong>in</strong> e<strong>in</strong>em nichtf<strong>in</strong>alen<br />
Zustand). Dann schreibt die TM das Wort w ′ = uqv auf Band 2 und vergleicht<br />
Band 1 mit Band 2. Falls die Inhalte gleich s<strong>in</strong>d, hält die TM und akzeptiert. Falls<br />
sie nicht gleich s<strong>in</strong>d, wird der neue Berechnungsschritt (Zerlegung des Wortes w ′ <strong>in</strong><br />
drei Wörter usw.) gestartet.<br />
Es ist klar, dass die E<strong>in</strong>gabe auf Band 1, falls sie von S ableitbar ist, nach endlich<br />
vielen Berechnungsschritten (die der Ableitung der E<strong>in</strong>gabe aus S entsprechen)<br />
akzeptiert wird. Falls umgekehrt die E<strong>in</strong>gabe nicht zu L(G) gehört, ist jede mögliche<br />
Berechnung entweder unendlich oder hält und akzeptiert nicht.<br />
4.4 Chomsky-Hierarchie<br />
In den 50er Jahren hat der berühmte L<strong>in</strong>guist Noah Chomsky formale Grammatiken<br />
e<strong>in</strong>geführt und spezielle Typen untersucht, von denen wir <strong>in</strong> diesem <strong>Skript</strong> schon<br />
e<strong>in</strong>ige kennengelernt haben:<br />
Grammatiken vom Typ 3 s<strong>in</strong>d genau die regulären Grammatiken, die wir <strong>in</strong> Kapitel<br />
2.4 e<strong>in</strong>geführt haben. Also die, die nur Produktionen der Form<br />
A → b1 . . . bn oder A → b1 . . .bnB<br />
(A, B s<strong>in</strong>d Variablen und b1, . . .,bn term<strong>in</strong>ale Symbole) haben dürfen. Wie wir aus<br />
2.4 wissen, erzeugen die regulären Grammatiken genau die regulären Sprachen.<br />
Grammatiken vom Typ 2 s<strong>in</strong>d genau die kontextfreien Grammatiken aus Kapitel 2.<br />
Hier haben die Produktionen die Form<br />
A → a1 . . .an<br />
(A ist e<strong>in</strong>e Variable, a1, . . . , an s<strong>in</strong>d term<strong>in</strong>ale Symbole oder Variablen). Die entsprechenden<br />
Sprachen s<strong>in</strong>d die kontextfreien Sprachen.<br />
Grammatiken vom Typ 1 werden auch kontextsensitive Grammatiken genannt. Wir<br />
werden sie jetzt e<strong>in</strong>führen und untersuchen. Die Produktionen haben hier die Eigenschaft,<br />
dass die Länge der l<strong>in</strong>ken Seite der Produktionen kle<strong>in</strong>er gleich der Länge<br />
der rechten Seite ist.<br />
Grammatiken vom Typ 0 heißen auch une<strong>in</strong>geschränkte Grammatiken (weil es ke<strong>in</strong>e<br />
E<strong>in</strong>schränkung für die Produktionen gibt) oder e<strong>in</strong>fach Grammatiken. Diese<br />
haben wir <strong>in</strong> Abschnitt 4.3 e<strong>in</strong>geführt. Sie entsprechen genau den rekursiv-aufzählbaren<br />
Sprachen.<br />
Def<strong>in</strong>ition. E<strong>in</strong>e Grammatik heißt kontextsensitiv oder Typ-1-Grammatik, falls<br />
<strong>in</strong> jeder Produktion<br />
α → β<br />
die Länge von α kle<strong>in</strong>er gleich der Länge von β ist. E<strong>in</strong>e Sprache heißt kontextsensitiv,<br />
falls sie von e<strong>in</strong>er kontextsensitiven Grammatik erzeugt werden kann. Daraus<br />
folgt, dass e<strong>in</strong>e kontextsensitive Sprache nie ε enthält. (E<strong>in</strong>ige Autoren erlauben<br />
deswegen auch die Regel S → ε <strong>in</strong> kontextfreien Grammatiken. Wir aber nicht!)
4.4. CHOMSKY-HIERARCHIE 109<br />
Beispiel 1. Die Sprache {a n b n c n ; n ≥ 0}, die nicht kontextfrei ist (siehe 1 <strong>in</strong><br />
Abschnitt 2.4) ist kontextsensitiv. In der Tat ist die Grammatik <strong>in</strong> Beispiel 1 <strong>in</strong><br />
Abschnitt 4.3 offensichtlich kontextsensitiv.<br />
Beispiel 2. Jede kontextfreie Sprache, die ε nicht enthält, ist kontextsensitiv. Das<br />
folgt aus der Chomsky-Normalform, die immer kontextsensitiv ist, siehe 2.7.<br />
Bemerkung 1. Der Name ” kontextsensitiv“ stammt von der folgenden Form der<br />
Produktionen:<br />
uAw → uvw,<br />
wobei A e<strong>in</strong>e Variable und v e<strong>in</strong> nicht leeres Wort über Σ ∪ V ist. Jede derartige<br />
Produktion erlaubt uns, A durch v zu ersetzen, falls sich A im Kontext u?w bef<strong>in</strong>det.<br />
Es zeigt sich, dass jede kontextsensitive Sprache mit Hilfe dieser Regeln gegeben<br />
werden kann:<br />
Satz 1. Jede kontextsensitive Sprache kann von e<strong>in</strong>er Grammatik mit Produktionen<br />
uAw → uvw,<br />
(A Variable; u, v, w Wörter <strong>in</strong> (Σ ∪ V ) ∗ und v = ε) erzeugt werden.<br />
Beweis. Sei G e<strong>in</strong>e kontextsensitive Grammatik. Jede Produktion<br />
A1A2 . . .An → B1B2 . . . Bm (n ≤ m)<br />
wird durch Produktionen des obigen Typs ersetzt. Wir nehmen an, dass Ai Variablen<br />
s<strong>in</strong>d. (Sonst ersetzen wir Ai durch Variable Ai ∗ und fügen die Produktionen<br />
Ai ∗ → Ai h<strong>in</strong>zu.) Falls n = 2, ersetzen wir<br />
A1A2 → B1B2 . . . Bm<br />
(m ≥ 2)<br />
durch die folgenden vier Produktionen, die neue Variablen C1 und C2 enthalten:<br />
A1A2<br />
C1A2<br />
→ C1A2<br />
→ C1C2<br />
C1C2B3 . . . Bm → C1B2B3 . . . Bm<br />
C1B2B3 . . .Bm → B1B2B3 . . . Bm.<br />
Jede dieser Produktionen hat die gewünschte Form. Und es ist klar, dass diese<br />
Ersetzung ke<strong>in</strong>en E<strong>in</strong>fluss auf die erzeugte Sprache hat.<br />
Analog ersetzen wir für n = 3<br />
A1A2A3 → B1B2 . . .Bm (m ≥ 3)<br />
durch sechs Produktionen mit neuen Variablen C1, C2, C3 wie folgt:<br />
A1A2A3 → C1A2A3<br />
C1A2A3 → C1C2A3<br />
C1C2A3 → C1C2C3<br />
C1C2C3B4 . . .Bm → C1C2B3B4 . . . Bm<br />
C1C2B3B4 . . . Bm → C1B2B3B4 . . .Bm<br />
C1B2B3B4 . . . Bm → B1B2B3B4 . . . Bm<br />
Usw. für alle n ≥ 2.<br />
Beispiel 3. E<strong>in</strong>e Grammatik für {a n b n c n ; n ≥ 1}, die nur Produktionen vom Typ<br />
uAw → uvw hat. Wir nehmen die Grammatik aus Beispiel 2 <strong>in</strong> Kapitel 4.3 und<br />
wenden die Prozedur des obigen Beweises darauf an. Statt<br />
CB → BC<br />
schreiben wir<br />
CB → C1B<br />
C1B → C1C2<br />
C1C2 → BC2<br />
BC2 → BC<br />
Bemerkung 2. Die Entscheidung, ob für e<strong>in</strong>en gegebenen gerichteten Graphen<br />
G und zwei Knoten x, y e<strong>in</strong> Pfad von x nach y führt, kann mit e<strong>in</strong>em e<strong>in</strong>fachen
110 KAPITEL 4. CHURCHSCHE THESE<br />
Algorithmus durchgeführt werden: wir berechnen die Menge M aller Knoten z, für<br />
die e<strong>in</strong> Pfad von x nach z führt wie folgt. Initialwert: M := {x}. Rekursiv setzen wir<br />
M := M ∪E(M), wobei E(M) die Menge aller Endknoten w der Kanten (v, w) ∈ E<br />
mit v ∈ M bezeichnet. Der Algorithmus endet, wenn M nicht mehr wächst, und<br />
dann ist die Antwort genau dann JA, wenn y ∈ M ist.<br />
Satz 2. Jede kontextsensitive Sprache ist rekursiv.<br />
Beweis. Für jede kontextsensitive Grammatik G wollen wir e<strong>in</strong>en Algorithmus f<strong>in</strong>den,<br />
der für e<strong>in</strong> beliebiges Wort w entscheidet, ob w <strong>in</strong> L(G) liegt. Ke<strong>in</strong>e Ableitung<br />
von w benutzt Wörter länger als n, der Länge von w. Es genügt also, e<strong>in</strong>en Graphen<br />
zu konstruieren, dessen Knoten alles Wörter über Σ ∪ V e<strong>in</strong>er Länge ≤ n s<strong>in</strong>d und<br />
genau die Relation ⇒ zwischen diesen Wörtern formen. Dieser Graph lässt sich mit<br />
e<strong>in</strong>em e<strong>in</strong>fachen ” brute-force“-Algorithmus konstruieren, der alle möglichen Produktionskomb<strong>in</strong>ationen<br />
durchgeht. Jetzt reicht es, e<strong>in</strong>en Algorithmus zu benutzen,<br />
der entscheidet, ob im Graph e<strong>in</strong> Pfad von S zu w führt.<br />
Schlussbemerkung. Die folgende Hierarchie von Klassen von Sprachen, die ε nicht<br />
enthalten, heißt Chomsky-Hierarchie:<br />
regulär ⊂ kontextfrei ⊂ kontextsensitiv ⊂ rekursiv ⊂ rekursiv-aufzählbar.<br />
Jede dieser Sprachklassen ist e<strong>in</strong> echter Teil der nächst höheren: die Sprache {0 n 1 n ;<br />
n ≥ 1} ist kontextfrei, aber nicht regulär (siehe 1.8 und 2.1), die Sprache {a n b n c n ;<br />
n ≥ 0} ist kontextsensitiv, aber nicht kontextfrei. Im nächsten Kapitel zeigen wir<br />
e<strong>in</strong>e Sprache Lhalt, die rekursiv aufzählbar, aber nicht rekursiv ist. Es gibt auch<br />
rekursive Sprachen, die nicht kontextsensitiv s<strong>in</strong>d, das beweisen wir aber nicht.<br />
4.5 Rekursive Funktionen<br />
Berechenbare Funktionen können auch ganz anders modelliert werden, als mit Masch<strong>in</strong>en,<br />
die sie berechnen: wir gehen von sehr e<strong>in</strong>fachen Funktionen (z.B. den konstanten<br />
Funktionen und der Nachfolgerfunktion succ) aus und wenden dann Rekursion<br />
und Verknüpfung an. Wir erhalten e<strong>in</strong>e sehr reiche Kollektion von Funktionen,<br />
die primitiv-rekursiv heißen. Es zeigt sich, dass jede primitiv-rekursive Funktion<br />
Tur<strong>in</strong>g-berechenbar ist. Leider gilt die umgekehrte Aussage nicht: es gibt Tur<strong>in</strong>gberechenbare<br />
Funktionen, die nicht primitiv-rekursiv s<strong>in</strong>d. Deshalb wird noch e<strong>in</strong><br />
M<strong>in</strong>imierungsoperator µ e<strong>in</strong>geführt. Funktionen, die sich mit primitiver Rekursion<br />
und M<strong>in</strong>imierung ableiten lassen, heißen rekursiv (oder auch µ-rekursiv). Daraus ergibt<br />
sich e<strong>in</strong>e neue Charakterisierung von Tur<strong>in</strong>g-berechenbaren Funktionen: es s<strong>in</strong>d<br />
genau die rekursiven Funktionen. Das ist e<strong>in</strong>e weitere Bestätigung der Churchschen<br />
These.<br />
Wir wollen also erst aus e<strong>in</strong>fachen Funktionen, die Basisfunktionen heißen, mit Hilfe<br />
von Verknüpfung und Rekursion weitere Funktionen def<strong>in</strong>ieren. Die Fakultätsfunktion<br />
def<strong>in</strong>iert man z.B. rekursiv mit Multiplikation, die Multiplikation wiederum<br />
rekursiv mit Addition und die Addition rekursiv mit der Nachfolgerfunktion succ.<br />
Hier endet aber diese Kette: succ ist e<strong>in</strong>e der Basisfunktionen. Wir arbeiten hier<br />
mit k-stelligen Funktionen natürlicher Zahlen, d.h. mit Funktionen<br />
k k f : → , wobei = × · · · × (k-mal), für k = 1, 2, 3, . . ..<br />
f hat also k Variablen im Bereich<br />
. Die konstante Funktion Ki mit<br />
Ki(n) = i für alle n<br />
gilt als 0-stellig, da sie von ke<strong>in</strong>er Variablen abhängt. Nicht-konstante Funktionen<br />
s<strong>in</strong>d k-stelllig für k ≥ 1.<br />
Besonders e<strong>in</strong>fache k-stellige Funktionen s<strong>in</strong>d die Projektionen πk 1 , . . . , πk k<br />
jektion πk i ordnet jedem k-Tupel se<strong>in</strong> i-tes Element zu,<br />
: die Pro
4.5. REKURSIVE FUNKTIONEN 111<br />
π k i (n1, n2, . . .,nk) = ni.<br />
Für k = 2 gibt es z.B. zwei Projektionen<br />
π2 1 (n, m) = n und π2 2 (n, m) = m.<br />
Für k = 1 ist π1 1(n) = n die Identitätsfunktion.<br />
Def<strong>in</strong>ition. Die folgenden Funktionen heißen Basisfunktionen:<br />
1. die Nachfolgerfunktion succ (mit succ(n) = n + 1)<br />
2. die Nullfunktion K0 (mit dem e<strong>in</strong>zigen Wert 0) und<br />
3. die Projektionen π k i<br />
für alle 1 ≤ i ≤ k, k = 1, 2, 3, . . ..<br />
Aus den Basisfunktionen können weitere Funktionen mit Hilfe der Verknüpfung<br />
def<strong>in</strong>iert werden:<br />
Beispiel 1. Konstante Funktionen. Die konstante Funktion K1 entspricht der Verknüpfung<br />
von K0 mit succ:<br />
K1 = succ(K0).<br />
Analog<br />
K2 = succ(K1) = succ(succ(K0))<br />
usw.<br />
Beispiel 2. Die Funktion f(n) = n + 2 für alle n ∈<br />
succ mit sich selbst:<br />
f(n) = succ(succ(n)).<br />
ist die Verknüpfung von<br />
Beispiel 3. Die Funktion g(n, m) = m+2 (für alle n, m ∈ ) ist e<strong>in</strong>e Verknüpfung<br />
der zweiten Projektion π2 2 (n, m) (die n wegfallen lässt) und der Funktion f aus<br />
Beispiel 2:<br />
g(n, m) = f(π2 2(n, m)) = succ(succ(π2 2(n, m)).<br />
Bemerkung 1. 1. Im Allgeme<strong>in</strong>en def<strong>in</strong>ieren wir die Verknüpfung mehrstelliger<br />
Funktionen wie üblich: falls<br />
f : k → (k ≥ 1)<br />
e<strong>in</strong>e k-stellige Funktion ist und<br />
g1, . . .,gk : m → (m ≥ 0)<br />
k m-stellige Funktionen s<strong>in</strong>d, ist die Verknüpfung von f mit g1, . . . , gk die<br />
m-stellige Funktion<br />
h :<br />
die durch<br />
m → ,<br />
h(n1, . . . , nm) = f(g1(n1, . . . , nm), g2(n1, . . . , nm), . . .,gk(n1, . . . , nm))<br />
für alle (n1, . . .,nm) auf m def<strong>in</strong>iert wird.<br />
2. Neben der Verknüpfung wollen wir die sogenannte primitive Rekursion verwenden,<br />
um neue Funktionen zu erzeugen. Zum Beispiel lässt sich die Fakultätsfunktion<br />
f(n) = n! mit Hilfe primitiver Rekursion durch die Multiplikation<br />
h(n, m) = n ∗ m und den Initialwert 1 = f(0) wie folgt def<strong>in</strong>ieren:<br />
f(0) = 1;<br />
f(n + 1) = h(n, f(n)) = n ∗ f(n).<br />
Die Def<strong>in</strong>ition e<strong>in</strong>er e<strong>in</strong>stelligen Funktion f(n) durch primitive Rekursion hat<br />
zwei Bestandteile: e<strong>in</strong>e Konstante k und e<strong>in</strong>e zweistellige Funktion h(n, m).<br />
Dann def<strong>in</strong>iert man<br />
f(0) = k<br />
und<br />
f(n + 1) = h(n, f(n)).
112 KAPITEL 4. CHURCHSCHE THESE<br />
Allgeme<strong>in</strong>er:<br />
Def<strong>in</strong>ition. Wir sagen, dass e<strong>in</strong>e k-stellige Funktion f(n1, . . .,nk) durch primitive<br />
Rekursion mit Hilfe e<strong>in</strong>er (k − 1)-stelligen Funktion g und e<strong>in</strong>er (k + 1)-stelligen<br />
Funktion h def<strong>in</strong>iert ist, falls für alle n1, . . . , nk−1, m ∈ gilt<br />
f(n1, . . . , nk−1, 0) = g(n1, . . .,nk−1) und<br />
f(n1, . . . , nk−1, m + 1) = h(n1, . . . , nk−1, m, f(n1, . . . , nk−1, m)).<br />
Beispiel 4. Addition. Es gilt<br />
n + 0 = n<br />
und<br />
n + (m + 1) = succ(n + m).<br />
Also ist add(n, m) = n + m durch primitive Rekursion mit<br />
g(n) = n = π 1 1(n)<br />
und<br />
h(n, m, i) = succ i = succ(π 3 3(n, m, i))<br />
def<strong>in</strong>iert. In der Tat gilt<br />
add(n, 0) = g(n)<br />
add(n, m + 1) = h(n, m, add(n, m)).<br />
Beispiel 5. Die Multiplikation ist die (primitiv-)rekursive Funktion:<br />
n ∗ 0 = 0<br />
n ∗ (m + 1) = (n ∗ m) + m.<br />
Genauer: für mal(n, m) = n ∗ m def<strong>in</strong>ieren wir<br />
g(n) = K0<br />
und<br />
h(n, m, i) = add(m, i) = add(π3 2 (n, m, i), π3 3 (n, m, i)).<br />
Dann gilt<br />
mal(n, 0) = g(n)<br />
mal(n, m + 1) = h(n, m, mal(n, m)).<br />
Def<strong>in</strong>ition. E<strong>in</strong>e Funktion heißt primitiv-rekursiv, falls sie durch endlich viele<br />
Anwendungen von Verknüpfung und primitiver Rekursion auf die Basisfunktionen<br />
def<strong>in</strong>iert werden kann.<br />
Mit anderen Worten ist die kle<strong>in</strong>ste Klasse von Funktionen, die alle Basisfunktionen<br />
enthält und unter Verknüpfung und primitiver Rekursion abgeschlossen ist, die<br />
Klasse aller primitiv-rekursiver Funktionen.<br />
Beispiele: Kn, f(n) = n + 2, g(n, m) = m + 2, add(n, m) und mal(n, m) s<strong>in</strong>d<br />
primitiv-rekursiv.<br />
Beispiel 6. Die Fakultätsfunktion m! ist primitiv-rekursiv, da sie mit der folgenden<br />
primitiven Rekursion def<strong>in</strong>iert werden kann:<br />
0! = 1<br />
(m + 1)! = mal(m + 1, m!).<br />
Hier ist also g = K1 und h(x, y) = mal(x + 1, y) = mal(succ(π2 1 (x, y), π2 2 (x, y)). Da<br />
g und h beide primitiv-rekursiv s<strong>in</strong>d, ist auch m! primitiv-rekursiv.<br />
Beispiel 7. Die Vorgängerfunktion <strong>in</strong> der Form<br />
0 falls n = 0<br />
f(n) =<br />
n − 1 falls n > 0<br />
ist primitiv-rekursiv:<br />
f(0) = 0 = K0<br />
f(n + 1) = n = π2 1 (n, f(n)).<br />
Also g = K0 und h(n, m) = π2 1(n, m).
4.5. REKURSIVE FUNKTIONEN 113<br />
Beispiel 8. Die modifizierte Subtraktion<br />
n ˙−m =<br />
ist primitiv-rekursiv:<br />
n ˙−0 = n<br />
n − m falls n ≥ m<br />
0 falls n < m<br />
n ˙−(m + 1) = f(n ˙−m) für f aus Beispiel 7.<br />
Hier gilt also g(n) = n und h(n, m, i) = f(π3 3 (n, m, i)) = f(i).<br />
Bemerkung 2. Die Klasse aller primitiv-rekursiven Funktionen ist so mächtig,<br />
dass es nicht e<strong>in</strong>fach ist, e<strong>in</strong> Beispiel e<strong>in</strong>er Funktion außerhalb dieser Klasse zu<br />
f<strong>in</strong>den (siehe Beispiel 9). Deswegen ist der folgende Satz e<strong>in</strong>e neue Bestätigung der<br />
Stärke von Tur<strong>in</strong>gmasch<strong>in</strong>en.<br />
Satz 1. Jede primitiv-rekursive Funktion ist Tur<strong>in</strong>g-berechenbar.<br />
Beweis. Es genügt, zu beweisen, dass gilt:<br />
1. alle Basisfunktionen s<strong>in</strong>d Tur<strong>in</strong>g-berechenbar,<br />
2. die Verknüpfung Tur<strong>in</strong>g-berechenbarer Funktionen ist Tur<strong>in</strong>g-berechenbar,<br />
und<br />
3. die primitive Rekursion, die mit zwei Tur<strong>in</strong>g-berechenbaren Funktionen arbeitet,<br />
ergibt e<strong>in</strong>e Tur<strong>in</strong>g-berechenbare Funktion.<br />
Dann s<strong>in</strong>d alle primitiv-rekursiven Funktionen Tur<strong>in</strong>g-berechenbar.<br />
(1) ist trivial und (2) auch: Die Verknüpfung f(g(n)) wird z.B. von e<strong>in</strong>er 2-Band-<br />
TM berechnet, wobei Band 1 die Funktion g(n) berechnet und das Ergebnis als<br />
E<strong>in</strong>gabe der Funktion f auf Band 2 kopiert.<br />
Wir wollen also (3) beweisen, d.h., dass es für die Funktion f mit<br />
f(n1, . . . , nk, 0) = g(n1, . . .,nk)<br />
und<br />
f(n1, . . . , nk, m + 1) = h(n1, . . . , nk, m, f(n1, . . . , nk, m))<br />
e<strong>in</strong>e TM gibt, falls Mg und Mh zwei TM s<strong>in</strong>d, die g und h berechnen.<br />
Unsere TM hat fünf Bänder:<br />
Band 1 (E<strong>in</strong>gabeband)<br />
Band 2 (Schrittzähler)<br />
Band 3 (simuliert Mg)<br />
Band 4 (simuliert Mh)<br />
n1 $ n2 $ . . . $ nk<br />
m<br />
FUNKTION g<br />
FUNKTION h<br />
Band 5 (Ausgabeband) ZWISCHENERGEBNIS<br />
Die Berechnung von f erfolgt <strong>in</strong> Schritten Nr. m = 0, 1, 2, . . ., die auf Band 2 gezählt<br />
werden und die wie folgt ablaufen:<br />
Schritt 0: Band 2 enthält 0, auf Band 3 wird n1, . . . , nk−1 (von Band 1)<br />
kopiert und g(n1, . . .,nk−1) wird berechnet. Das Ergebnis wird<br />
auf Band 5 geschrieben.<br />
Schritt m + 1: Falls nk der Inhalt von Band 2 ist, hält die TM. (Band 5 enthält<br />
dann das Ergebnis.) Falls nicht, wird auf Band 4 die E<strong>in</strong>gabe<br />
n1 $ . . . $ nk $ m $ j<br />
geschrieben. j = f(n1, . . .,nk−1, m) ist der Inhalt von Band 5,<br />
m der von Band 2. Jetzt wird h(n1, . . . , nk, m, j) berechnet und<br />
das Ergebnis auf Band 5 geschrieben. Der Inhalt von Band 2<br />
wird um e<strong>in</strong>s erhöht.
114 KAPITEL 4. CHURCHSCHE THESE<br />
Bemerkung 3. Nicht jede Tur<strong>in</strong>g-berechenbare Funktion ist primitiv-rekursiv. In<br />
der Tat s<strong>in</strong>d alle primitiv-rekursiven total (d.h. überall def<strong>in</strong>iert), und es gibt partielle<br />
Tur<strong>in</strong>g-berechenbare Funktionen.<br />
Aber auch alle totalen Tur<strong>in</strong>g-berechenbaren Funktionen s<strong>in</strong>d leider nicht primitivrekursiv.<br />
Das können wir abstrakt wie folgt zeigen: alle primitiv-rekursiven Funktionen<br />
können wir systematisch aufzählen, z.B. setzen wir f0 = K0, f1 = succ, f2 = π 1 1 .<br />
Mit den gegebenen Funktionen f0, . . . , fi machen wir alle möglichen Verknüpfungen<br />
und primitiven Rekursionen. Dabei entstehen fi+1, . . . , fj, dann ist fj+1 die nächste<br />
noch nicht e<strong>in</strong>genommene Projektion, usw. Diese Aufzählung kann bestimmt e<strong>in</strong>e<br />
TM durchführen. Dann ist die Funktion<br />
P(n) = 1 + fn(n, n, . . .,n)<br />
Tur<strong>in</strong>g-berechenbar. Aber P ist nicht primitiv-rekursiv: falls nämlich P = fn, haben<br />
wir<br />
P(n) = 1 + fn(n) = fn(n) – e<strong>in</strong> Widerspruch.<br />
Es ist U. Ackermann 1928 gelungen, e<strong>in</strong> viel konkreteres Beispiel e<strong>in</strong>er Funktion anzugeben,<br />
die nicht primitiv-rekursiv ist, sich aber mit e<strong>in</strong>em e<strong>in</strong>fachen Algorithmus<br />
berechnen läßt. Die Funktion, die man heute Ackermann-Funktion nennt, ist e<strong>in</strong>e<br />
von R. Peter und R. M. Rob<strong>in</strong>son später entdeckte Vere<strong>in</strong>fachung der ursprünglichen<br />
Idee:<br />
Beispiel 9. Die Ackermann-Funktion A :<br />
A(0, m) = m + 1<br />
A(n + 1, 0) = A(n, 1) und<br />
A(n + 1, m + 1) = A(n, A(n + 1, m)).<br />
Es gilt also<br />
A(0, 0) = 1,<br />
A(0, 1) = 2,<br />
A(1, 0) = A(0, 1) = 2,<br />
A(0, 2) = 3,<br />
A(1, 1) = A(0, A(1, 0)) = A(0, 2) = 3,<br />
A(2, 0) = A(1, 1) = 3,<br />
2 → ist wie folgt def<strong>in</strong>iert:<br />
usw. Wir erhalten e<strong>in</strong>en Algorithmus, um jeden Wert A(n, m) zu berechnen: alle<br />
möglichen Paare (n, m) werden so aufgezählt, dass der Wert A(n, m) direkt aus den<br />
vorigen Werten berechnet wird:<br />
(0, 0), (0, 1), (1, 0), (0, 2), (1, 1), (2, 0), . . ., Das können wir durch e<strong>in</strong>e TM realisieren,<br />
und wir sehen also, dass die Ackermann-Funktion TM-berechenbar ist.<br />
Trotzdem ist sie nicht primitiv-rekursiv! Man kann nämlich beweisen, dass sie<br />
schneller wächst, als jede primitiv-rekursive Funktion.<br />
Es gilt z.B. folgendes, wie sich leicht durch Induktion über m beweisen lässt:<br />
A(1, m) = m + 2<br />
A(2, m) = 2m + 3<br />
A(3, m) = 2 m+3 − 3<br />
A(4, m) = 22..2 − 3, wobei 22..2 Zum Beispiel<br />
m + 2 Exponentiationen hat.<br />
A(4, 1) = 216 − 3 und A(4, 2) = 2216 − 3 > 101000 .<br />
Bemerkung 4. Wir wollen jetzt die Klasse aller primitiv-rekursiven Funktionen<br />
durch e<strong>in</strong>e neue Operation ergänzen, um alle berechenbaren Funktionen repräsentieren<br />
zu können. Das wird der M<strong>in</strong>imierungsoperator µ se<strong>in</strong>, der z.B. jeder 2-stelligen<br />
Funktion f(n, m) die 1-stellige Funktion<br />
µf(n) = m<strong>in</strong>{m; f(n, m) = 0}<br />
zuordnet. Hier müssen wir aber aufpassen: µf ist nicht immer def<strong>in</strong>iert, da es für<br />
e<strong>in</strong>e Zahl n geschehen kann, dass f(n, m) = 0 für alle m ∈ . Deshalb arbeiten
4.5. REKURSIVE FUNKTIONEN 115<br />
wir jetzt mit partiellen Funktionen (das ist nicht überraschend, denn die Tur<strong>in</strong>gberechenbaren<br />
Funktionen s<strong>in</strong>d im allgeme<strong>in</strong>en auch partiell).<br />
Def<strong>in</strong>ition. Für jede partielle (k+1)-stellige Funktion f(n1, . . .,nk, nk+1) bezeichnen<br />
wir mit µf die folgende partielle k-stellige Funktion:<br />
µf(n1, . . . , nk) ist die kle<strong>in</strong>ste Zahl i mit f(n1, . . . , nk, i) = 0;<br />
falls ke<strong>in</strong>e solche Zahl i existiert, ist µf(n1, . . .,nk) undef<strong>in</strong>iert.<br />
E<strong>in</strong>e Funktion heißt rekursiv (oder µ-rekursiv), wenn sie durch die Basisfunktionen<br />
und endlich viele Anwendungen von<br />
1. Verknüpfung,<br />
2. primitiver Rekursion und<br />
3. M<strong>in</strong>imierung µ<br />
def<strong>in</strong>iert werden kann.<br />
Beispiel 10. Diepartielle Vorgängerfunktion<br />
n − 1 falls n > 0<br />
pred(n) =<br />
undef. für n = 0<br />
ist rekursiv, denn für die Funktion<br />
f(n, m) = (succm) ˙− n<br />
(siehe Beispiel 8) gilt<br />
pred(n) = µ((succm) ˙− n).<br />
Beispiel 11. Die Subtraktion <br />
n − m falls n ≥ m<br />
sub(n, m) =<br />
undef. falls n < m<br />
ist rekursiv: wir haben<br />
sub(n, 0) = n<br />
sub(n, m + 1) = pred(sub(n, m)),<br />
also ist sub primitiv-rekursiv durch g(n) = π1 1 (n) und h(n, m, i) = pred(i) =<br />
pred(π3 3(n, m, i)) def<strong>in</strong>iert (g und h s<strong>in</strong>d rekursiv).<br />
Beispiel 12. Die Division<br />
k falls n = mk<br />
n : m =<br />
undef. falls n nicht durch m teilbar ist<br />
ist rekursiv. Der erste Versuch wäre, n : m als µ(n − m ∗ k) zu def<strong>in</strong>ieren, denn<br />
n − m ∗ k = 0 genau dann, wenn k = n : m. Das ergibt leider 0 : 0 = 0. Deswegen<br />
müssen wir n − m ∗ k durch n − (succ(pred(m)) ∗ k ersetzen:<br />
n : m = µf(n, m)<br />
für<br />
f(n, m, k) = n − succ(pred(m)) ∗ k = sub(n, mal(succ(pred(m))), k).<br />
Jetzt gilt: die Division durch m = 0 ist undef<strong>in</strong>iert, für m > 0 ist f(n, m, k) =<br />
n − m ∗ k und µf(n, m) = n : m genau dann, wenn n : m def<strong>in</strong>iert ist.<br />
Satz 2. Jede rekursive Funktion ist Tur<strong>in</strong>g-berechenbar.<br />
Beweis. Es genügt zu den Punkten 1. - 3. aus Satz 1 e<strong>in</strong>en vierten Punkt h<strong>in</strong>zuzufügen:<br />
4. Falls f Tur<strong>in</strong>g-berechenbar ist, so ist es auch µf.
116 KAPITEL 4. CHURCHSCHE THESE<br />
Sei M e<strong>in</strong>e TM, die f berechnet. Wir konstruieren e<strong>in</strong>e 3-Band TM für µf wie folgt:<br />
Band 1 (E<strong>in</strong>gabeband) n1 $ n2 $ . . . $ nk<br />
Band 2 (Schrittzähler)<br />
Band 3 (simuliert M)<br />
i<br />
FUNKTION f<br />
Am Anfang wird i = 0 auf Band 2 geschrieben, und dann wird auf Band 3 immer<br />
f(n1, . . . , nk, i) berechnet. Falls das Ergebnis 0 ist, hält die TM, und Band 2 enthält<br />
die Ausgabe. Falls das Ergebnis nicht 0 ist, wird Band 2 um 1 erhöht (i := i + 1),<br />
und f(n1, . . . , nk, i) wird erneut berechnet, usw.<br />
Satz 3. (Ohne Beweis) Jede Tur<strong>in</strong>g-berechenbare Funktion ist rekursiv.<br />
Schlussbemerkung: Wir sehen, dass viele Modelle dieselbe Klasse von entscheidbaren<br />
Problemen beschreiben:<br />
• Tur<strong>in</strong>gmasch<strong>in</strong>en (und alle ihre Modifikationen),<br />
• RAMs,<br />
• Grammatiken,<br />
• rekursive Funktionen.<br />
Das ist e<strong>in</strong>e Untermauerung der Churchschen These.<br />
Überlegen Sie sich, warum die Bemerkung nach Satz 1 nicht auf µ-rekursive Funktionen<br />
verallgeme<strong>in</strong>ert werden kann (was Satz 3 widerlegen würde!). Die Regel<br />
P(n) = 1+fn(n), ergibt nämlich ke<strong>in</strong>en Algorithmus, der die Funktion P berechnet,<br />
da fn partielle Funktionen s<strong>in</strong>d!
Kapitel 5<br />
Unentscheidbare Probleme<br />
Es gibt wichtige praktische Fragen, die sich von ke<strong>in</strong>em Algorithmus lösen lassen.<br />
Beispiel: die Entscheidung, ob e<strong>in</strong> gegebenes Programm (sagen wir <strong>in</strong> PASCAL)<br />
auf e<strong>in</strong>e gegebene E<strong>in</strong>gabedatei hält. Es wäre von größter praktischer Bedeutung,<br />
e<strong>in</strong>en Algorithmus zur Verfügung zu haben, der als E<strong>in</strong>gabe e<strong>in</strong> Paar (P, D) hat,<br />
wobei P e<strong>in</strong> PASCAL-Programmcode und D e<strong>in</strong>e Datei für P ist, und das die<br />
richtige Ausgabe ” hält“ oder ” hält nicht“ ergibt. Solch e<strong>in</strong> Algorithmus existiert aber<br />
nicht. Das beweisen wir für e<strong>in</strong>e Variante, die (statt mit PASCAL-Programmen) mit<br />
Tur<strong>in</strong>gmasch<strong>in</strong>en arbeitet. Außerdem zeigen wir weitere Beispiele unentscheidbarer<br />
Probleme.<br />
Der formale Beweis, dass es ” vernünftige“ und wichtige Fragen gibt, die e<strong>in</strong>fach ke<strong>in</strong><br />
Algorithmus lösen kann, ist e<strong>in</strong>es der wichtigsten Ergebnisse <strong>in</strong> diesem <strong>Skript</strong>, denn<br />
daraus folgt, dass man bei dem Versuch, e<strong>in</strong>e Aufgabe zu lösen, immer darauf achten<br />
muss, dass die Aufgabe ke<strong>in</strong>e Variante e<strong>in</strong>es unlösbaren Problems ist. Wir beg<strong>in</strong>nen<br />
aber mit e<strong>in</strong>em positiven Ergebnis: es gibt e<strong>in</strong>e universelle Tur<strong>in</strong>gmasch<strong>in</strong>e, also<br />
e<strong>in</strong>e, die (wie moderne Rechner) programmiert werden kann.<br />
5.1 Universelle Tur<strong>in</strong>gmasch<strong>in</strong>e<br />
Wir konstruieren jetzt e<strong>in</strong>e universelle (oder ” programmierbare“) TM, die bei E<strong>in</strong>gaben<br />
der Form<br />
(c, w) c – Algorithmus, w – Datei<br />
die Datei w entsprechend des Algorithmus c berechnet. Da wir Algorithmen als<br />
Tur<strong>in</strong>gmasch<strong>in</strong>en <strong>in</strong>terpretieren, können wir genauer sagen: e<strong>in</strong>e universelle Tur<strong>in</strong>gmasch<strong>in</strong>e<br />
Mu erhält als E<strong>in</strong>gabe e<strong>in</strong> Wort<br />
c(M)w,<br />
wobei c(M) e<strong>in</strong>e passende Codierung der (beliebigen) Tur<strong>in</strong>gmasch<strong>in</strong>e M und w<br />
e<strong>in</strong> (beliebiges) E<strong>in</strong>gabewort für M ist. Dann berechnet Mu die E<strong>in</strong>gabe und liefert<br />
genau dasselbe Ergebnis, das die Masch<strong>in</strong>e M auf E<strong>in</strong>gabe w liefert. Das können<br />
wir entweder <strong>in</strong> der Akzeptor-Variante <strong>in</strong>terpretieren, also Mu hält genau dann<br />
auf c(M)w, wenn M auf w hält, und dann akzeptiert Mu genau dann, wenn M<br />
akzeptiert, oder <strong>in</strong> der Rechner-Variante, also Mu führt für c(M)w zu der gleichen<br />
Ausgabe wie M für w. Es zeigt sich, dass die Masch<strong>in</strong>e Mu, die wir jetzt beschreiben,<br />
beide Rollen erfüllt.<br />
117
118 KAPITEL 5. UNENTSCHEIDBARE PROBLEME<br />
Bemerkung 1. 1. Jede TM kann durch e<strong>in</strong>e TM mit dem Bandalphabet Σ =<br />
{0, 1} simuliert werden. Wir codieren die ursprünglichen E<strong>in</strong>gabesymbole si<br />
und das ursprüngliche Blanksymbol wie folgt:<br />
Symbol # s1 s2 ... sk<br />
Code 01 011 01 3 ... 01 k+1<br />
Die neue Masch<strong>in</strong>e hat also nur an den noch nicht beschrifteten Feldern Blanksymbole.<br />
Die e<strong>in</strong>zelnen Übergänge werden wie folgt simuliert:<br />
(a) e<strong>in</strong> Schritt nach rechts wird durch e<strong>in</strong>e Bewegung des Kopfes unter die<br />
nächste 0 nach rechts simuliert; analog für l<strong>in</strong>ks<br />
(b) Überschreibung von si und sj wird dadurch simuliert, dass 01 j+1 statt<br />
01 i+1 geschrieben wird. Dazu müssen, falls z.B. i = 1 und j = 2, alle<br />
Symbole 0, 1 rechts vom Lesekopf e<strong>in</strong> Feld nach rechts geschoben werden<br />
(und vorher muss die momentane Kopfposition gespeichert werden – z.B.<br />
dadurch, dass die momentan gelesene 0 gelöscht wird).<br />
2. Eigentlich kann jede TM durch e<strong>in</strong>e TM mit Σ = {|} simuliert werden. Die<br />
Idee ist gleich, aber die Details s<strong>in</strong>d aufwendiger.<br />
Wir beschränken uns auf TM mit dem b<strong>in</strong>ären Bandalphabet Σ = {0, 1}. Also<br />
hat die universelle Tur<strong>in</strong>gmasch<strong>in</strong>e Mu sowie alle simulierten Masch<strong>in</strong>en M dieses<br />
E<strong>in</strong>gabealphabet.<br />
Codierung c(M) von Tur<strong>in</strong>gmasch<strong>in</strong>en M: Für jede TM<br />
deren Zustände<br />
M = (Q, {0, 1}, δ, q0, q1)<br />
Q = {q0, q1, . . . , qn−1}<br />
so durchnummeriert s<strong>in</strong>d, dass q0 der Initialzustand und q1 der F<strong>in</strong>alzustand ist,<br />
def<strong>in</strong>ieren wir e<strong>in</strong> Codewort<br />
c(M) ∈ {0, 1} ∗<br />
wie folgt. Wir benutzen 0 i um die Zahl i zu codieren und 1 als Trennungssymbol. Das<br />
Wort c(M) hat die folgende Form: Am Anfang steht 111 als Trennungssymbol, dann<br />
folgt 0 n , das die Anzahl n aller Zustände bezeichnet. Dann werden die e<strong>in</strong>zelnen t<br />
Übergangsregeln aus R durch b<strong>in</strong>äre Wörter w1, . . . , wt codiert, wie später erklärt<br />
wird, und durch e<strong>in</strong>e 1 vone<strong>in</strong>ander getrennt. Am Ende schreiben wir wieder 111.<br />
Der Code hat also die Form<br />
c(M) = 1110 n 1w11w21 . . .1wt111.<br />
Um die Übergangsregeln zu codieren, schreiben wir für Zustände 10 i+1 statt qi und<br />
codieren die Symbole L, R, #, 0, 1 wie folgt<br />
Symbol L R # 0 1<br />
Code 10 100 10000 10 4 10 5<br />
Die Übergangsregel<br />
erhält also den Code<br />
die Übergangsregel<br />
den Code<br />
usw.<br />
(qi, 0) → (qj, L)<br />
w = 10 i+1 10 4 10 j+1 10,<br />
(qi, #) → (qj, 0)<br />
w = 10 i+1 10 3 10 j+1 10 4
5.1. UNIVERSELLE TURINGMASCHINE 119<br />
Beispiel 1. Wir codieren die Masch<strong>in</strong>e M1 mit Zuständen q0, q1 und Übergangsregeln<br />
wie folgt:<br />
(q0, 1) → (q1, R)<br />
(q1, #) → (q1, 1)<br />
c(M1) = 111001w11w2111<br />
wobei w1 der Code für (q0, 1) → (q1, R) ist:<br />
w1 = 1010 5 100100<br />
und w2 der Code für (q1, #) → (q1, 1) ist:<br />
Insgesamt ergibt sich<br />
w2 = 10010 3 10010 5 .<br />
c(M1) = 1110011010 5 100100110010 3 10010 5 111.<br />
Wir bemerken, dass e<strong>in</strong>zelne Übergangsregeln vone<strong>in</strong>ander durch 11 getrennt werden.<br />
Jede Tur<strong>in</strong>gmasch<strong>in</strong>e wird durch ihren Code vollständig beschrieben.<br />
Beispiel 2. Falls e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e den Code<br />
c(M2) = 11100011010 5 1010 3 11010 3 1010110010 4 10 3 100111<br />
hat, muss es die Masch<strong>in</strong>e<br />
mit den Übergangsregeln<br />
se<strong>in</strong>.<br />
M2 = ({q0, q1, q2}, {0, 1}, δ, q0, q1)<br />
(q0, 1) → (q0, #)<br />
(q0, #) → (q0, L)<br />
(q1, 0) → (q2, R)<br />
Bemerkung 2. Er<strong>in</strong>nern wir uns an die <strong>in</strong> Kapitel 3 e<strong>in</strong>geführte Sprache<br />
Lcode = { c(M) | M ist e<strong>in</strong>e TM, die c(M) nicht akzeptiert } .<br />
Zum Beispiel das Wort c(M1) <strong>in</strong> Beispiel 1 ist e<strong>in</strong> Codewort e<strong>in</strong>er TM. Akzeptiert<br />
diese TM das Wort c(M1) ? Wir haben Konfigurationen<br />
(q0, 111 . . .111)<br />
⊢ (q1, 111 . . .111)<br />
<br />
c(M1)<br />
c(M1)<br />
und da ke<strong>in</strong> Übergang (q1, 1) →? def<strong>in</strong>iert ist, hält M1 im F<strong>in</strong>alzustand q1. Das<br />
Wort c(M1) wird also akzeptiert, das heißt,<br />
c(M1) /∈ Lcode.<br />
In Beispiel 2 wird c(M2) von M2 wie folgt berechnet: erst löscht der Kopf das erste<br />
Symbol 1 und dann bewegt er sich immer nach l<strong>in</strong>ks. Also hält M2 nicht, deswegen<br />
akzeptiert sie das Wort c(M2) nicht, woraus folgt<br />
c(M2) ∈ Lcode.
120 KAPITEL 5. UNENTSCHEIDBARE PROBLEME<br />
Wie <strong>in</strong> Abschnitt 3.3 bewiesen, ist die Sprache Lcode nicht rekursiv-aufzählbar. Das<br />
bedeutet, dass ke<strong>in</strong> Algorithmus entscheiden kann, ob e<strong>in</strong>e beliebige TM ihr eigenes<br />
Wort akzeptiert oder nicht.<br />
In konkreten Fällen ist diese Entscheidung trotzdem möglich. Die Unentscheidbarkeit<br />
von Lcode (oder e<strong>in</strong>es beliebigen anderen Problems) bezieht sich immer nur auf<br />
die Klasse aller möglichen E<strong>in</strong>gaben, nie auf e<strong>in</strong>en E<strong>in</strong>zelfall.<br />
Universelle Tur<strong>in</strong>gmasch<strong>in</strong>e Mu Wir konstruieren jetzt e<strong>in</strong>e universelle Tur<strong>in</strong>gmasch<strong>in</strong>e<br />
Mu. Also reagiert sie auf die E<strong>in</strong>gabe c(M)w, wobei M e<strong>in</strong>e TM und w<br />
e<strong>in</strong> Wort über {0, 1} ist, wie folgt:<br />
1. Mu hält genau dann, wenn M auf das Wort w hält,<br />
2. Mu akzeptiert genau dann, wenn M das Wort w akzeptiert<br />
3. falls M gehalten hat, hat Mu auf Band 1 dasselbe Ausgabewort wie M.<br />
Die Masch<strong>in</strong>e Mu wird als e<strong>in</strong>e 3-Band TM beschrieben, aber wir wissen, dass das<br />
unwichtig ist, weil wir e<strong>in</strong>e 1-Band TM konstruieren können, die Mu simuliert.<br />
BAND 1<br />
BAND 2<br />
BAND 3<br />
# 1 1 1 . . . 1 1 1 1 0 1 . . . 1 # # . . .<br />
<br />
c(M)<br />
Enthält c(M)<br />
0 0 . . . 0<br />
<br />
i + 1<br />
w<br />
Zustand qi<br />
Band 1 enthält am Anfang die E<strong>in</strong>gabe c(M)w und die Bänder 2 und 3 s<strong>in</strong>d, wie<br />
üblich, leer. Zur Vorbereitung auf die Simulation führt Mu die folgenden Schritte<br />
aus:<br />
1. c(M) wird von Band 1 auf Band 2 kopiert und auf Band 1 gelöscht,<br />
2. der Kopf von Band 1 wird auf das erste Symbol von w gestellt<br />
3. Auf Band 3 wird 0 geschrieben (Zustand q0), und der Kopf wird auf die 0<br />
gestellt.<br />
BAND 1<br />
BAND 2<br />
BAND 3<br />
# 1 0 1 . . . 1 # # . . .<br />
<br />
⇑<br />
c(M)<br />
1 1 1 . . . 1 1 1<br />
<br />
⇑<br />
# 0 #<br />
⇑<br />
c(M)
5.1. UNIVERSELLE TURINGMASCHINE 121<br />
Dann wird M <strong>in</strong> rekursiven Schritten wie folgt simuliert (so dass das Band von M<br />
identisch mit dem Band 1 von Mu ist und der Zustand von M gleich qi ist, wobei<br />
0 i+1 auf Band 3 von Mu steht):<br />
Simulation von M: Der Kopf von Band 1 liest s = #, 0 oder 1, also e<strong>in</strong> Symbol,<br />
das den Code 10 p hat, wobei p = 3 (#), p = 4 (0) oder p = 5 (1) gilt.<br />
Jetzt beg<strong>in</strong>nt der Kopf auf Band 2 e<strong>in</strong>e systematische Suche nach der Komb<strong>in</strong>ation<br />
10 i+1 10 p ,<br />
wobei i + 1 die Zahl der 0’en auf Band 3 ist. Falls die Komb<strong>in</strong>ation 10 i+1 10 p nicht<br />
gefunden wurde, hat die Masch<strong>in</strong>e M ke<strong>in</strong>e Übergangsregel (qi, s) →?, deshalb hält<br />
M. Also hält auch Mu (wenn sie die rechte Gruppe 111 auf Band 2 erreicht hat,<br />
ohne die gesuchte Komb<strong>in</strong>ation zu f<strong>in</strong>den). Mu akzeptiert genau dann, wenn Band<br />
3 den Inhalt 00 hat, d.h., genau dann, wenn M im F<strong>in</strong>alzustand q1 gehalten hat.<br />
Falls die Komb<strong>in</strong>ation 10 i+1 10 p gefunden wurde, liest der Kopf auf Band 2 weiter<br />
bis zur nächsten Gruppe 11. Wir haben jetzt das Wort<br />
10 i+1 10 p 10 j+1 10 r 11 . . .<br />
auf Band 2 und das bedeutet, dass e<strong>in</strong>e Übergangsregel von M die Form<br />
(qi, s) → (qj, s ′ ) s ′ hat den Code 10 r (r = 1, . . .,5)<br />
hat. Die Masch<strong>in</strong>e Mu ändert den Band<strong>in</strong>halt von Band 3 zu 0 j+1 und bewegt den<br />
Kopf auf Band 1 nach l<strong>in</strong>ks oder rechts, falls r = 1 oder 2 ist, oder Mu überschreibt<br />
s mit<br />
#(falls r = 3), 0 (r = 4) oder 1 (r = 5).<br />
Jetzt ist Mu für den nächsten Simulationsschritt vorbereitet.<br />
Bemerkung 3. 1. Die obige Codierung kann auch auf nichtdeterm<strong>in</strong>istische Tur<strong>in</strong>gmasch<strong>in</strong>en<br />
mit dem Bandalphabet {0, 1} angewendet werden.<br />
2. Es ist e<strong>in</strong>fach zu entscheiden, ob e<strong>in</strong> b<strong>in</strong>äres Wort v der Code e<strong>in</strong>er (determ<strong>in</strong>istischen<br />
oder nichtdeterm<strong>in</strong>istischen) TM ist. Die Codierungen s<strong>in</strong>d nämlich<br />
alle von der Form<br />
(1) v = 1110 n 1w11w21 . . .1wt111,<br />
wobei w1, . . . , wt verschiedene Wörter der Form<br />
(2) 10 i+1 10 p 10 j+1 10 r mit i, j = 0, . . . , n − 1, p = 3, 4, 5 und r = 1, 2, 3, 4, 5<br />
s<strong>in</strong>d. Umgekehrt ist jedes Wort v, das (1) und (2) erfüllt, der Code e<strong>in</strong>er TM.<br />
Mit anderen Worten ist die Sprache aller Codierungen von allen nichtdeterm<strong>in</strong>istischen<br />
TM rekursiv. Auch die Sprache aller Codierungen aller determ<strong>in</strong>istischen TM<br />
ist rekursiv: hier muss der Algorithmus nur noch für alle Paare k, k ′ = 1, . . .,t von<br />
Indizes mit<br />
wk = 10 i+1 10 p 10 j+1 10 r<br />
und<br />
überprüfen, ob j = j ′ und r = r ′ .<br />
wk ′ = 10i + 110p 10 j′ +1 10 r ′
122 KAPITEL 5. UNENTSCHEIDBARE PROBLEME<br />
5.2 Das Halteproblem<br />
Gibt es e<strong>in</strong>en Algorithmus, der für jedes Paar<br />
(Algorithmus c, Datei w)<br />
entscheidet, ob c auf die Datei w hält? Aus Abschnitt 5.1 wissen wir, dass es e<strong>in</strong>en<br />
Algorithmus gibt, der auf die E<strong>in</strong>gabe (c, w) das Ergebnis von c auf die Datei w<br />
berechnet - das macht die universale Tur<strong>in</strong>gmasch<strong>in</strong>e! Dennoch ist die Antwort auf<br />
die obige Frage, die als Halteproblem bekannt ist, negativ. Auch dann, wenn wir uns<br />
nur auf die Algorithmen beschränken, die von TM mit dem Bandalphabet {0, 1}<br />
repräsentiert werden, ist die Antwort negativ. Für diese Masch<strong>in</strong>en M haben wir<br />
die Codierung c(M) aus Abschnitt 5.1, und wir können das Halteproblem präziser<br />
formulieren: ist die Sprache<br />
Lhalt = { v | v = c(M)w für e<strong>in</strong> b<strong>in</strong>äres Wort w und e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e M,<br />
rekursiv?<br />
die auf E<strong>in</strong>gabe w hält }<br />
Wir beweisen, dass Lhalt nicht rekursiv (also das Halteproblem nicht entscheidbar)<br />
ist, sie aber rekursiv-aufzählbar ist. Daraus folgt, dass das Komplement Lhalt nicht<br />
rekursiv-aufzählbar ist. Das bedeutet, dass das Problem, ob e<strong>in</strong> Algorithmus c auf<br />
die Datei w nicht hält, nicht e<strong>in</strong>mal mehr semi-entscheidbar ist.<br />
Bemerken wir, dass <strong>in</strong> jedem Wort v = c(M)w der Code c(M) e<strong>in</strong>deutig bestimmt<br />
ist (aufgrund der Trenngruppen 111 am Anfang und Ende von c(M)) und also auch<br />
w e<strong>in</strong>deutig bestimmt ist. Es gibt e<strong>in</strong>en Algorithmus, der überprüft, ob u diese Form<br />
hat – siehe Bemerkung <strong>in</strong> Abschnitt 5.1.<br />
Bemerkung 1. Viele (auch ungelöste!) mathematische Probleme kann man umformulieren<br />
zu Fragen, ob e<strong>in</strong>e leicht konstruierbare TM auf e<strong>in</strong>e E<strong>in</strong>gabe hält.<br />
Beispiel 1. Beispiel e<strong>in</strong>er TM mit sehr <strong>in</strong>teressantem Halteproblem. Es ist ziemlich<br />
trivial, e<strong>in</strong>e 5-Band-TM zu konstruieren, die auf Band 2 systematisch alle Zahlen<br />
n = 3, 4, 5, . . . schreibt und für jede Zahl n auf die Bänder 3 - 5 systematisch alle<br />
Zahlen a, b, c ≥ 2 schreibt und dann auf Band 1 die Zahl<br />
a n + b n − c n<br />
berechnet. Falls diese Zahl 0 ist, hält die TM. Falls nicht, berechnet die TM den<br />
nächsten Quadrupel (n, a, b, c). Die Entscheidung, ob diese Tur<strong>in</strong>gmasch<strong>in</strong>e M auf<br />
die leere E<strong>in</strong>gabe hält, das heißt, ob<br />
c(M) ∈ Lhalt<br />
gilt, ist bestimmt höchst kompliziert: dies ist äquivalent zum Beweis des berühmten<br />
Satzes von Fermat!<br />
Satz 1. Die Sprache Lhalt ist rekursiv-aufzählbar.<br />
Beweis. Die folgende Tur<strong>in</strong>gmasch<strong>in</strong>e akzeptiert Lhalt:<br />
v EINGABE <br />
Hat v die Form<br />
v = c(M)w für<br />
e<strong>in</strong>e TM M?<br />
TURINGMASCHINE M0<br />
JA <br />
Hält Mu auf<br />
E<strong>in</strong>gabe v?<br />
<br />
<br />
NEIN NEIN<br />
v nicht akzeptiert v nicht akzeptiert<br />
JA <br />
v akzeptiert
5.2. DAS HALTEPROBLEM 123<br />
Also überprüft M0, ob die E<strong>in</strong>gabe die Form c(M)w hat (siehe Bemerkung <strong>in</strong> 5.1),<br />
und falls das der Fall ist, simuliert sie die universale Tur<strong>in</strong>gmasch<strong>in</strong>e Mu. Die E<strong>in</strong>gabe<br />
v wird genau dann von M0 akzeptiert, wenn v = c(M)w und Mu (akzeptierend<br />
oder nicht akzeptierend) auf die E<strong>in</strong>gabe v hält. Äquivalent dazu ist: genau dann,<br />
wenn M auf die E<strong>in</strong>gabe w hält. Kürzer: L(M0) = Lhalt.<br />
Satz 2 (Unentscheidbarkeit des Halteproblems). Die Sprache Lhalt ist nicht rekursiv.<br />
Beweis. Die Annahme, dass Lhalt rekursiv ist, führt zu e<strong>in</strong>em Widerspruch: es<br />
folgt, dass die Sprache<br />
Lcode = {w; w = c(M) für e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e M mit w /∈ L(M)}<br />
rekursiv-aufzählbar ist. Das ist aber falsch, siehe Beispiel 2 <strong>in</strong> Kapitel 3.3.<br />
Sei Mhalt e<strong>in</strong>e TM, die Lhalt akzeptiert und auf jede E<strong>in</strong>gabe hält. Dann lässt sich<br />
<strong>in</strong> der Tat e<strong>in</strong>e TM konstruieren, die die Sprache Lcode akzeptiert:<br />
w EINGABE <br />
Hat w die Form<br />
w = c(M) für<br />
e<strong>in</strong>e TM M?<br />
TURINGMASCHINE Mcode<br />
JA<br />
Akzeptiert<br />
<br />
Mhalt E<strong>in</strong>gabe<br />
ww?<br />
JA<br />
Akzeptiert<br />
<br />
Mu E<strong>in</strong>gabe<br />
ww?<br />
<br />
<br />
<br />
NEIN NEIN NEIN<br />
w nicht akzeptiert w akzeptiert w akzeptiert<br />
Das heißt, dass die Tur<strong>in</strong>gmasch<strong>in</strong>e Mcode e<strong>in</strong>e E<strong>in</strong>gabe w wie folgt berechnet:<br />
JA <br />
w nicht<br />
akzeptiert<br />
1. Mcode überprüft, ob w = c(M) für e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e M gilt (siehe Bemerkung<br />
<strong>in</strong> 5.1).<br />
2. Falls ja, wiederholt Mcode die E<strong>in</strong>gabe und schreibt also<br />
auf das Band.<br />
ww = c(M)w<br />
3. Jetzt simuliert Mcode die Masch<strong>in</strong>e Mhalt bis sie hält.<br />
(a) Falls Mhalt die E<strong>in</strong>gabe ww nicht akzeptiert, hält Mcode und akzeptiert<br />
w. In diesem Fall hält nämlich die Masch<strong>in</strong>e M nicht auf die E<strong>in</strong>gabe w<br />
(denn c(M)w /∈ Lhalt); also wird w von M nicht akzeptiert – es folgt<br />
w ∈ Lcode.<br />
(b) Falls Mhalt akzeptiert, simuliert Mcode die universale TM auf dieselbe<br />
E<strong>in</strong>gabe ww. Da c(M)w ∈ Lhalt gilt, hält M auf die E<strong>in</strong>gabe w, also hält<br />
die universale TM auf die E<strong>in</strong>gabe c(M)w. Mcode akzeptiert genau dann,<br />
wenn Mu nicht akzeptiert.<br />
Die Tur<strong>in</strong>gmasch<strong>in</strong>e Mcode hält auf jede E<strong>in</strong>gabe: der erste Schritt hält (denn die<br />
Sprache aller Codes ist rekursiv, siehe 5.1), der zweite hält nach unserer Voraussetzung<br />
von Mhalt, und der letzte hält, denn Mu erhält nur solche E<strong>in</strong>gaben ww, die<br />
von Mhalt akzeptiert werden, das heißt E<strong>in</strong>gaben c(M)w mit w = c(M), so dass M<br />
auf w hält (oder äquivalent: Mu hält auf die E<strong>in</strong>gabe c(M)w = ww).<br />
Welche E<strong>in</strong>gaben w akzeptiert Mcode? Genau die der Form w = c(M), wobei entweder
124 KAPITEL 5. UNENTSCHEIDBARE PROBLEME<br />
• M auf w nicht hält, d.h., Mhalt akzeptiert die E<strong>in</strong>gabe c(M)w nicht, oder<br />
• M auf w hält und nicht akzeptiert, d.h., Mu akzeptiert die E<strong>in</strong>gabe c(M)w<br />
nicht.<br />
Also gilt: w ∈ L(Mcode) genau dann, wenn w = c(M) und w /∈ L(M); oder kürzer:<br />
L(Mcode) = Lcode, e<strong>in</strong> Widerspruch.<br />
Korollar 1. Das Problem, ob e<strong>in</strong>e TM nicht hält, ist nicht semi-entscheidbar. D.h.,<br />
die Sprache Lhalt ist nicht rekursiv-aufzählbar.<br />
Beweis. Das folgt aus Satz ??? : falls Lhalt und Lhalt rekursiv-aufzählbar wären,<br />
wäre Lhalt rekursiv.<br />
5.3 Weitere unentscheidbare Probleme<br />
Wir zeigen jetzt weitere Probleme, die nicht entscheidbar s<strong>in</strong>d. Wir benutzen ständig<br />
die Codierung c(M) von (determ<strong>in</strong>istischen und nichtdeterm<strong>in</strong>istischen) Tur<strong>in</strong>gmasch<strong>in</strong>en<br />
M aus Kapitel 5.1. Auch alle Modifikationen von Tur<strong>in</strong>gmasch<strong>in</strong>en mit<br />
Bandalphabet {0, 1} aus Abschnitt 3.2 s<strong>in</strong>d damit codiert. Falls M z.B. e<strong>in</strong>e nichtdeterm<strong>in</strong>istische<br />
k-Band TM ist, bezeichnen wir mit c(M) den Code e<strong>in</strong>er 1-Band-<br />
TM, die M simuliert. Auch für jeden Kellerautomaten erhalten wir e<strong>in</strong>e Codierung,<br />
<strong>in</strong> dem S<strong>in</strong>ne, dass wir ihn mit e<strong>in</strong>er nichtdeterm<strong>in</strong>istischen 2-Band TM simulieren<br />
(Beispiel 3 <strong>in</strong> Kapitel 3.4) und den Code der TM verwenden.<br />
Wir werden e<strong>in</strong>e TM, die auf jede E<strong>in</strong>gabe hält und die Sprache L akzeptiert, kurz<br />
Algorithmus für L nennen.<br />
5.3.1 Das Akzeptanzproblem<br />
Er<strong>in</strong>nern wir uns an den CYK-Algorithmus (Kapitel 2.8), der für jede kontextfreie<br />
Grammatik G mit Term<strong>in</strong>alsymbolen aus {0, 1} und jedes Wort w über {0, 1}<br />
entscheidet, ob w <strong>in</strong> L(G) liegt. Daraus folgt, dass das Akzeptanzproblem für Kellerautomaten<br />
entscheidbar ist; mit anderen Worten haben wir e<strong>in</strong>en Algorithmus,<br />
der für jeden Kellerautomaten M und jedes Wort w entscheidet, ob M das Wort w<br />
akzeptiert. Oder kürzer: die Sprache<br />
L (K)<br />
acc = {u; u = c(M)w für e<strong>in</strong>en Kellerautomaten M und e<strong>in</strong> Wort w aus L(M)}<br />
ist rekursiv. In der Tat kann e<strong>in</strong> Algorithmus, der L (K)<br />
acc entscheidet, wie folgt konstruiert<br />
werden:<br />
1. Wir überprüfen, ob die E<strong>in</strong>gabe u die Form u = c(M)w, wobei M e<strong>in</strong> Kellerautomat<br />
ist, hat – vergleiche die Bemerkung <strong>in</strong> 5.1.<br />
2. Für den gegebenen Kellerautomaten M konstruieren wir e<strong>in</strong>e kontextfreie<br />
Grammatik G(M), die die Sprache L(M) erzeugt.<br />
3. Der CYK-Algorithmus wird auf G(M) und w angewendet.<br />
Falls also M0 e<strong>in</strong>e TM ist, die diesen Algorithmus repräsentiert, gilt L (K)<br />
acc = L(M0).<br />
Im Kontrast hierzu zeigen wir jetzt, dass das Akzeptanzproblem für Tur<strong>in</strong>gmasch<strong>in</strong>en,<br />
also die Frage, ob e<strong>in</strong>e gegebene Tur<strong>in</strong>gmasch<strong>in</strong>e e<strong>in</strong> gegebenes E<strong>in</strong>gabewort<br />
akzeptiert, unentscheidbar ist. Kürzer: die Sprache<br />
Lacc = {u; u = c(M)w für e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e M und e<strong>in</strong> Wort w aus L(M)}
5.3. WEITERE UNENTSCHEIDBARE PROBLEME 125<br />
ist nicht rekursiv.<br />
Wir merken erst an, dass es zu jeder Tur<strong>in</strong>gmasch<strong>in</strong>e M e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e M<br />
gibt, die sich von M nur dar<strong>in</strong> unterscheidet, dass f<strong>in</strong>ale und nichtf<strong>in</strong>ale Zustände<br />
ausgetauscht werden. (Genauer: wenn wir <strong>in</strong> M die f<strong>in</strong>alen und nichtf<strong>in</strong>alen Zustände<br />
austauschen, erhalten wir e<strong>in</strong>e TM mit mehreren f<strong>in</strong>alen Zuständen, und M ist e<strong>in</strong>e<br />
TM, die M simuliert, siehe Abschnitt 3.2.1) Der Übergang von M zu M lässt<br />
sich offensichtlich durch e<strong>in</strong>en (kle<strong>in</strong>en) Algorithmus implementieren. Das bedeutet,<br />
dass es e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e ˆ M gibt, die auf die E<strong>in</strong>gabe c(M) die Ausgabe c(M)<br />
berechnet. Es gilt<br />
w ∈ L(M) genau dann, wenn M auf die E<strong>in</strong>gabe w hält und nicht akzeptiert.<br />
Wir beweisen jetzt, dass die Annahme, dass Lacc rekursiv ist, zu e<strong>in</strong>em Widerspruch<br />
führt: wenn Lacc rekursiv wäre, würde folgen, dass Lhalt rekursiv ist. In der Tat:<br />
falls Lacc von e<strong>in</strong>er Tur<strong>in</strong>gmasch<strong>in</strong>e Macc akzeptiert wird, die auf jede E<strong>in</strong>gabe hält,<br />
können wir die folgende Tur<strong>in</strong>gmasch<strong>in</strong>e Mhalt konstruieren, die Lhalt akzeptiert und<br />
auf jede E<strong>in</strong>gabe hält:<br />
u<br />
EINGABE<br />
<br />
Hat u die Form<br />
u = c(M)w für<br />
e<strong>in</strong>e TM M?<br />
JA <br />
TURINGMASCHINE Mhalt<br />
Akzeptiert<br />
Macc E<strong>in</strong>gabe<br />
c(M)w?<br />
NEIN<br />
c(M) wird<br />
<br />
von ˆM<br />
berechnet<br />
u nicht akzeptiert<br />
<br />
NEIN<br />
<br />
Akzeptiert<br />
c(M)w?<br />
Macc E<strong>in</strong>gabe<br />
<br />
<br />
<br />
NEIN<br />
JA<br />
JA<br />
u nicht akzeptiert u akzeptiert u akzeptiert<br />
Diese TM akzeptiert genau die E<strong>in</strong>gaben u = c(M)w, für die gilt, dass<br />
• entweder M akzeptiert w (d.h., Macc akzeptiert c(M)w), oder<br />
• M akzeptiert w (d.h., Macc akzeptiert c(M)w).<br />
Das heißt, genau die E<strong>in</strong>gaben c(M)w, für die M auf die E<strong>in</strong>gabe w hält. Kürzer:<br />
L(Mhalt) = Lhalt. Darüber h<strong>in</strong>aus hält Mhalt auf jede E<strong>in</strong>gabe – e<strong>in</strong> Widerspruch<br />
zu Satz 2 aus Kapitel 5.2.<br />
5.3.2 Akzeptanz des leeren Wortes<br />
E<strong>in</strong>e noch e<strong>in</strong>fachere Frage ist, ob e<strong>in</strong>e TM die leere E<strong>in</strong>gabe akzeptiert. Auch diese<br />
Frage ist aber unentscheidbar, d.h., die Sprache<br />
ist nicht rekursiv.<br />
Lε = {c(M); M ist e<strong>in</strong>e TM die ε akzeptiert}<br />
Wir merken erst an, dass es für jede Tur<strong>in</strong>gmasch<strong>in</strong>e M und jedes Wort w e<strong>in</strong>e<br />
Tur<strong>in</strong>gmasch<strong>in</strong>e Mw gibt, die das leere Wort genauso berechnet wie M das Wort<br />
w. Mw schreibt erst das Wort w = s1 . . . sn von l<strong>in</strong>ks nach rechts auf ihr Band<br />
(mit Hilfe von n neuen Zuständen q1, . . . , qn, wobei qn der Initialzustand von Mw<br />
ist) und dann geht sie <strong>in</strong> den Initialzustand q0 der Masch<strong>in</strong>e M über und beg<strong>in</strong>nt
126 KAPITEL 5. UNENTSCHEIDBARE PROBLEME<br />
die Berechnung wie M. Das bedeutet, dass zu den Übergangsregeln von M die<br />
folgenden Regeln h<strong>in</strong>zugefügt werden:<br />
(qn, #) → (qn, sn)<br />
(qn, sn) → (qn−1, L)<br />
(qn−1, #) → (qn−1, sn−1)<br />
(qn−1, sn−1) → (qn−2, L)<br />
.<br />
(q1, #) → (q1, s1)<br />
(q1, s1) → (q0, s1)<br />
(Jetzt steht der Kopf im Zustand q0 am Anfang des Wortes w = s1 . . . sn.)<br />
Offensichtlich kann der Übergang von (M, w) zu Mw durch e<strong>in</strong>en Algorithmus implementiert<br />
werden, d.h., es gibt e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e ˆ M, die auf die E<strong>in</strong>gabe c(M)w<br />
die Ausgabe c(Mw) berechnet.<br />
Die Annahme, dass Lε rekursiv ist, führt zu e<strong>in</strong>em Widerspruch: daraus würde<br />
folgen, dass Lacc rekursiv ist. In der Tat haben wir, falls Mε e<strong>in</strong> Algorithmus für Lε<br />
ist, den folgenden Algorithmus für Lacc:<br />
u EINGABE <br />
Hat u die Form<br />
u = c(M)w für<br />
e<strong>in</strong>e TM M?<br />
TURINGMASCHINE Macc<br />
JA <br />
c(Mw) wird<br />
von ˆ M<br />
berechnet.<br />
<br />
Akzeptiert<br />
c(Mw)?<br />
Mε E<strong>in</strong>gabe<br />
<br />
<br />
NEIN<br />
JA<br />
u nicht akzeptiert u akzeptiert<br />
NEIN u nicht<br />
akzeptiert<br />
Es ist klar, dass Mε die E<strong>in</strong>gabe u = c(M)w genau dann akzeptiert, wenn Mw<br />
das leere Wort akzeptiert und das geschieht genau dann, wenn M das Wort w<br />
akzeptiert. Das heißt, genau dann, wenn die E<strong>in</strong>gabe u = c(M)w <strong>in</strong> Lacc liegt.<br />
Kürzer: L(Macc) = Lacc. Außerdem hält Macc auf jede E<strong>in</strong>gabe – e<strong>in</strong> Widerspruch<br />
zu 5.3.1<br />
5.3.3 Ist e<strong>in</strong>e TM e<strong>in</strong> Algorithmus?<br />
Auch diese Frage, d.h., das Problem, ob e<strong>in</strong>e gegebene TM auf jede E<strong>in</strong>gabe hält,<br />
ist unentscheidbar. Mit anderen Worten ist die Sprache<br />
nicht rekursiv.<br />
Lalg = {c(M); M ist e<strong>in</strong>e TM, die auf jede E<strong>in</strong>gabe hält}<br />
Wir merken erst an, dass es für jede Tur<strong>in</strong>gmasch<strong>in</strong>e M e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e M ′<br />
gibt, die jede E<strong>in</strong>gabe so berechnet wie M die E<strong>in</strong>gabe ε: M ′ löscht erst das Band<br />
und dann simuliert sie M. Offensichtlich kann der Übergang von M zu M ′ durch<br />
e<strong>in</strong>en Algorithmus durchgeführt werden.<br />
Die Annahme, dass Lalg rekursiv ist, führt zu e<strong>in</strong>em Widerspruch: daraus würde<br />
folgen, dass Lε rekursiv ist. In der Tat haben wir den folgenden Algorithmus für<br />
Lε, falls Malg e<strong>in</strong> Algorithmus für die Sprache Lalg ist:
5.3. WEITERE UNENTSCHEIDBARE PROBLEME 127<br />
u<br />
EINGABE<br />
<br />
Hat u die Form<br />
u = c(M) für<br />
e<strong>in</strong>e TM M?<br />
JA <br />
c(M ′ ) wird<br />
von ˆ M<br />
berechnet.<br />
TURINGMASCHINE Mε<br />
<br />
Akzeptiert<br />
c(M ′ )?<br />
Malg E<strong>in</strong>gabe<br />
JA <br />
u akzeptiert<br />
<br />
Akzeptiert Mu<br />
die E<strong>in</strong>gabe<br />
c(M ′ )?<br />
<br />
<br />
<br />
NEIN<br />
NEIN NEIN<br />
u nicht akzeptiert u nicht akzeptiert u nicht akzeptiert<br />
Die Masch<strong>in</strong>e Mε hält auf jede E<strong>in</strong>gabe u: nur im letzten Schritt müssen wir aufpassen,<br />
ob Mu auf die E<strong>in</strong>gabe c(M ′ ) hält (äquivalent: ob M ′ auf die E<strong>in</strong>gabe ε<br />
hält) – das folgt daraus, dass Malg die E<strong>in</strong>gabe c(M ′ ) akzeptiert. Und e<strong>in</strong>e E<strong>in</strong>gabe<br />
u wird genau dann von Mε akzeptiert, wenn u = c(M) für e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e,<br />
für die gilt: M ′ hält auf jede E<strong>in</strong>gabe und M ′ akzeptiert ε. Das ist äquivalent dazu,<br />
dass M auf ε hält und akzeptiert. Also<br />
Das steht im Widerspruch zu 5.3.2<br />
5.3.4 Satz von Rice<br />
u ∈ L(Mε) genau dann, wenn u = c(M) ∈ Lε.<br />
Ist es entscheidbar, ob für e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e M die akzeptierte Sprache L(M)<br />
ist?<br />
• regulär,<br />
• kontextfrei, oder<br />
• nichtleer<br />
Alle drei Antworten s<strong>in</strong>d negativ. In der Tat gilt e<strong>in</strong> überraschend allgeme<strong>in</strong>er Satz<br />
<strong>in</strong> diesem Gebiet. Sei S e<strong>in</strong>e beliebige Eigenschaft formaler Sprachen (z.B. regulär,<br />
kontextfrei, nicht leer, usw.) Wir fragen, ob es entscheidbar ist, dass e<strong>in</strong>e TM e<strong>in</strong>e<br />
Sprache mit der Eigenschaft S akzeptiert. Kürzer, ob die Sprache<br />
LS = {c(M); M ist e<strong>in</strong>e TM und L(M) hat die Eigenschaft S}<br />
rekursiv ist. Das ist selbstverständlich der Fall, falls S trivial ist, d.h.,<br />
• entweder hat jede Sprache L(M) die Eigenschaft S, oder<br />
• ke<strong>in</strong>e Sprache L(M) hat die Eigenschaft S.<br />
Die drei oben erwähnten Eigenschaften s<strong>in</strong>d bestimmt nicht trivial. Der folgende<br />
Satz ergibt also die negativen Antworten:<br />
Satz 1 (Satz von Rice). Für jede nichttriviale Eigenschaft S von Sprachen ist es<br />
unentscheidbar, ob für e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e M die Sprache L(M) die Eigenschaft<br />
S hat. Kürzer: die Sprache LS ist nicht rekursiv.<br />
JA
128 KAPITEL 5. UNENTSCHEIDBARE PROBLEME<br />
Beweis. 1. Nehmen wir erst an, dass die leere Sprache ∅ die Eigenschaft S nicht<br />
hat. Da S nicht trivial ist, gibt es e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e M0, so dass gilt<br />
L(M0) hat die Eigenschaft S.<br />
Für jede Tur<strong>in</strong>gmasch<strong>in</strong>e M und jedes Wort w konstruieren wir die folgende<br />
Tur<strong>in</strong>gmasch<strong>in</strong>e M w :<br />
u EINGABE <br />
Akzeptiert M0<br />
die E<strong>in</strong>gabe u?<br />
Es gilt<br />
L(M w ) =<br />
TURINGMASCHINE M w<br />
JA <br />
Akzeptiert M<br />
die E<strong>in</strong>gabe w?<br />
<br />
<br />
NEIN NEIN<br />
u nicht akzeptiert u nicht akzeptiert<br />
JA <br />
<br />
L(M0) falls M die E<strong>in</strong>gabe w akzeptiert<br />
∅ falls M die E<strong>in</strong>gabe w nicht akzeptiert<br />
u akzeptiert<br />
Der Übergang von (M, w) zu M w kann offensichtlich durch e<strong>in</strong>en Algorithmus<br />
implementiert werden. Es gibt also e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e ˆ M, die auf die<br />
E<strong>in</strong>gabe c(M)w die Ausgabe c(M w ) berechnet.<br />
Die Annahme, dass LS rekursiv ist, führt zu e<strong>in</strong>em Widerspruch: es würde<br />
folgen, dass Lacc (5.3.1) rekursiv ist. In der Tat erhalten wir, falls MS e<strong>in</strong><br />
Algorithmus für die Sprache LS ist, den folgenden Algorithmus für Lacc:<br />
u<br />
EINGABE<br />
<br />
Hat u die Form<br />
u = c(M)w für<br />
e<strong>in</strong>e TM M?<br />
TURINGMASCHINE Macc<br />
JA <br />
c(M w ) wird<br />
von ˆ M<br />
berechnet.<br />
u nicht akzeptiert<br />
<br />
NEIN<br />
<br />
Akzeptiert<br />
c(M w )?<br />
MS E<strong>in</strong>gabe<br />
<br />
<br />
NEIN<br />
JA<br />
u nicht akzeptiert u nicht akzeptiert<br />
In der Tat akzeptiert Macc genau die Wörter c(M)w, für die MS die E<strong>in</strong>gabe<br />
c(M w ) akzeptiert, d.h., für die die Sprache L(M w ) die Eigenschaft S hat. Es<br />
gilt:<br />
L(M w ) hat die Eigenschaft S ⇐⇒ M akzeptiert w,<br />
denn für L(M w ) haben wir nur zwei Möglichkeiten: L(M w ) = L(M0) und<br />
L(M0) hat die Eigenschaft S, oder L(M w ) = ∅, und ∅ hat die Eigenschaft S<br />
nicht. Also: Macc akzeptiert genau die Wörter c(M)w, die <strong>in</strong> Lacc liegen. Da<br />
Macc auf jede E<strong>in</strong>gabe hält, bekommen wir e<strong>in</strong>en Widerspruch zu 5.3.1.<br />
2. Nehmen wir an, dass die leere Sprache ∅ die Eigenschaft S hat. Sei S die<br />
komplementäre Eigenschaft (das heißt, die Negation von S), die genau die<br />
Sprachen haben, die die Eigenschaft S nicht haben. Speziell hat ∅ also nicht<br />
die Eigenschaft S, und S ist sicher nichttrivial. Aus (1) folgt, dass L S nicht<br />
rekursiv ist. Daraus folgt, dass die Sprache LS (aller Wörter, die nicht <strong>in</strong><br />
LS liegen) nicht rekursiv ist, denn L S ist der Durchschnitt von L S und der
5.3. WEITERE UNENTSCHEIDBARE PROBLEME 129<br />
Sprache aller Codes {c(M); M e<strong>in</strong>e TM}. Die letztere Sprache ist rekursiv,<br />
siehe Bemerkung <strong>in</strong> 5.1 Falls also auch LS rekursiv wäre, müsste L S rekursiv<br />
se<strong>in</strong>. Aus Satz ??? folgt, dass LS nicht rekursiv ist.<br />
5.3.5 M<strong>in</strong>imierung von Tur<strong>in</strong>gmasch<strong>in</strong>en<br />
Wir zeigen, dass es im Gegensatz zu endlichen Automaten ke<strong>in</strong>en M<strong>in</strong>imierungsalgorithmus<br />
für Tur<strong>in</strong>gmasch<strong>in</strong>en gibt. Für jede TM (die, wie oben, das Bandalphabet<br />
{0, 1} hat) bezeichnen wir mit fM die partielle Funktion, die M wie folgt berechnet:<br />
falls M die E<strong>in</strong>gabe n (b<strong>in</strong>är) hat, und falls M hält, ist fM(n) die Zahl, die<br />
auf dem Band steht, wenn alle Blanksymbole und eventuell am Anfang stehende<br />
Nullen ignoriert werden. E<strong>in</strong> M<strong>in</strong>imierungsalgorithmus für Tur<strong>in</strong>gmasch<strong>in</strong>en ist e<strong>in</strong><br />
Algorithmus A, der jeder Tur<strong>in</strong>gmasch<strong>in</strong>e M e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e A(M) mit der<br />
m<strong>in</strong>imalen Anzahl von Zuständen zuordnet, die dieselbe Funktion berechnet,<br />
fM(n) = f A(M)(n) für alle n.<br />
Beispiel 1. Für jede Tur<strong>in</strong>gmasch<strong>in</strong>e M, die die Identitätsfunktion berechnet, d.h.,<br />
fM(n) = n für alle n ∈ erfüllt, hat die Tur<strong>in</strong>gmasch<strong>in</strong>e A(M) nur e<strong>in</strong>en Zustand.<br />
Denn die Identitätsfunktion kann von e<strong>in</strong>er TM mit e<strong>in</strong>em e<strong>in</strong>zigen Zustand und<br />
ke<strong>in</strong>er Übergangsregel realisiert werden.<br />
Satz 2. Es gibt ke<strong>in</strong>en M<strong>in</strong>imierungsalgorithmus für Tur<strong>in</strong>gmasch<strong>in</strong>en.<br />
Beweis. Wir merken erst an, dass es für jede Tur<strong>in</strong>gmasch<strong>in</strong>e M und jedes Wort<br />
w möglich ist, die folgende Tur<strong>in</strong>gmasch<strong>in</strong>e M (w) zu konstruieren<br />
TURINGMASCHINE M (w)<br />
n EINGABE <br />
Hält M auf die<br />
E<strong>in</strong>gabe w <strong>in</strong><br />
(b<strong>in</strong>är)<br />
höchstens n Schritten?<br />
JA<br />
<br />
M(w) schreibt Ausgabe 0<br />
NEIN <br />
M(w) lässt n ausgeben<br />
Also simuliert M (w) die Tur<strong>in</strong>gmasch<strong>in</strong>e M auf die E<strong>in</strong>gabe w für k ≤ n Schritte,<br />
bis M hält, und dann schreibt M (w) die Ausgabe 0; falls M <strong>in</strong> n Schritten nicht<br />
hält, schreibt M (w) die Ausgabe n. Der Übergang von M und w zu M (w) kann<br />
offensichtlich von e<strong>in</strong>er Tur<strong>in</strong>gmasch<strong>in</strong>e ˆ M durchgeführt werden ( ˆ M ist e<strong>in</strong>e e<strong>in</strong>fache<br />
Modifikation der universalen TM). Also ist ˆ M e<strong>in</strong>e TM, die auf die E<strong>in</strong>gabe c(M)w<br />
die Ausgabe c(M (w)) liefert. Es gilt:<br />
fM (w) (n) = n, falls M auf E<strong>in</strong>gabe w nicht hält,<br />
d.h., die Mach<strong>in</strong>e M (w) berechnet die Identitätsfunktion. Also gilt für jeden M<strong>in</strong>imierungsalgorithmus<br />
A,<br />
A(M (w)) hat 1 Zustand, falls M auf w nicht hält.<br />
Umgekehrt gilt: falls M auf E<strong>in</strong>gabe w hält, ist fM (w) nicht die Identitätsfunktion.<br />
Es gilt also:<br />
M hält nicht auf E<strong>in</strong>gabe w ⇐⇒ A(M (w)) berechnet die Identitätsfunktion.
130 KAPITEL 5. UNENTSCHEIDBARE PROBLEME<br />
Die Annahme, dass es e<strong>in</strong>en M<strong>in</strong>imierungsalgorithmus A gibt, führt zu e<strong>in</strong>em Widerspruch:<br />
es folgt, dass die Sprache Lhalt rekursiv-aufzählbar ist (siehe Korollar <strong>in</strong><br />
5.2). In der Tat akzeptiert die folgende Tur<strong>in</strong>gmasch<strong>in</strong>e M ∗ die Sprache Lhalt:<br />
u EINGABE <br />
Hat u die Form<br />
u = c(M)w für<br />
e<strong>in</strong>e TM M?<br />
NEIN<br />
<br />
u nicht akzeptiert<br />
Hat A(M(w))<br />
<br />
nur e<strong>in</strong>en<br />
Zustand?<br />
TURINGMASCHINE M ∗<br />
JA <br />
c(M(w)) wird<br />
von ˆM<br />
berechnet.<br />
JA<br />
Berechnet A(M(w))<br />
<br />
die<br />
Identitätsfunktion?<br />
<br />
<br />
NEIN<br />
NEIN<br />
u nicht akzeptiert u nicht akzeptiert<br />
<br />
M(w) wird<br />
von A<br />
m<strong>in</strong>imiert.<br />
JA <br />
u akzeptiert<br />
(Die letzte Entscheidung, ob e<strong>in</strong>e TM mit nur e<strong>in</strong>em Zustand die Identitätsfunktion<br />
berechnet, lässt sich bestimmt mit e<strong>in</strong>em kle<strong>in</strong>en Algorithmus durchführen.) Die<br />
Masch<strong>in</strong>e M ∗ hält auf jede E<strong>in</strong>gabe und akzeptiert alle Wörter u = c(M)w, wobei<br />
M (w) die Identitätsfunktion berechnet. Da fM (w) genau dann die Identitätsfunktion<br />
ist, wenn M auf die E<strong>in</strong>gabe w nicht hält, gilt<br />
M ∗ akzeptiert c(M)w ⇐⇒ M hält nicht auf w.<br />
Kürzer: L(M ∗ ) = Lhalt, e<strong>in</strong> Widerspruch.
Kapitel 6<br />
Komplexität von<br />
Algorithmen<br />
Bisher haben wir uns die Frage gestellt, ob e<strong>in</strong> Problem entscheidbar (d.h. mit<br />
Hilfe e<strong>in</strong>es Algorithmus lösbar) ist. Jetzt wollen wir auch die Effizienz von Algorithmen<br />
diskutieren. Es gibt wichtige Aufgaben, wie z.B. jeden Graphen mit der<br />
kle<strong>in</strong>stmöglichen Zahl an Farben zu färben (ohne dass e<strong>in</strong>e Kante gleichfarbige Knoten<br />
verb<strong>in</strong>det), für die es zwar Algorithmen gibt, aber ke<strong>in</strong> effizienter Algorithmus<br />
bekannt ist.<br />
Wir führen zuerst die Klasse P aller Probleme e<strong>in</strong>, die effizient lösbar s<strong>in</strong>d; z.B. das<br />
Problem, jeden Graphen, für den es möglich ist, mit zwei Farben zu färben. ” Effizient“<br />
bedeutet: <strong>in</strong> polynomialer Zeit durchführbar. Genauer: e<strong>in</strong> Problem gehört<br />
der Klasse P an, falls es mit e<strong>in</strong>em Algorithmus lösbar ist, für den es e<strong>in</strong> Polynom<br />
p(m) gibt, so dass für jede E<strong>in</strong>gabe der Größe m die Lösung <strong>in</strong> p(m) Zeite<strong>in</strong>heiten<br />
gefunden werden kann. Es zeigt sich, dass die Klasse P nicht von dem Modell der<br />
Berechnung abhängt: es kann e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e, e<strong>in</strong>e RAM oder e<strong>in</strong>e moderne<br />
Workstation se<strong>in</strong>. (Natürlich wird für diese drei Modelle das ausgewählte Polynom<br />
p(n) ganz verschieden se<strong>in</strong>, d.h., der ” Grad der Effizienz“ hängt sehr von der konkreten<br />
Implementierung ab. Aber die pr<strong>in</strong>zipielle Möglichkeit, die Zeit durch e<strong>in</strong><br />
Polynom zu beschränken, ist implementierungsunabhängig.)<br />
Danach wird die Klasse N P aller Probleme e<strong>in</strong>geführt, für die wenigstens die Überprüfung,<br />
ob e<strong>in</strong>e gegebene Datei das Problem löst, effizient ist. Z.B. das Problem,<br />
jeden Graphen, für den es möglich ist, mit drei Farben zu färben: es ist ke<strong>in</strong> effizienter<br />
Algorithmus bekannt, aber die Überprüfung, ob e<strong>in</strong>e vorgeschlagene Färbung<br />
wirklich drei Farben benutzt und ke<strong>in</strong>e Kante zwischen gleichfarbigen Knoten ergibt,<br />
ist effizient. Leider ist es bis heute nicht bekannt, ob P = N P. Aber es s<strong>in</strong>d<br />
viele Probleme bekannt, die ” N P-vollständig“ s<strong>in</strong>d - für diese gilt: wäre e<strong>in</strong>es dieser<br />
Probleme effizient lösbar, wären es alle anderen auch, denn dann folgt P = N P. Das<br />
erwähnte Problem der Dreifärbung von Graphen ist, wie wir beweisen werden, N Pvollständig.<br />
Es sche<strong>in</strong>t sehr unwahrsche<strong>in</strong>lich, dass dieses Problem effizient lösbar<br />
ist, aber falls ja, würde daraus folgen, dass viele andere wichtige Probleme (z.B.<br />
Travel<strong>in</strong>g Salesman Problem) effizient lösbar wären.<br />
Dieses Kapitel hat, wie die vorigen, theoretischen Charakter; z.B. benutzt die Klasse<br />
P beliebige Polynome zur Zeite<strong>in</strong>schränkung und das ist nicht ” realistisch“, falls<br />
das Polynom e<strong>in</strong>en zu großen Exponenten hat. Dennoch hat Komplexitätstheorie<br />
wichtige praktische Aspekte. Stellen Sie sich vor, dass Ihr Chef Sie damit beauftragt<br />
hat, e<strong>in</strong> Programm zu schreiben, das überprüft, ob e<strong>in</strong>e vorgeschlagene Produktspe-<br />
131
132 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
zifikation realisierbar ist. Trotz e<strong>in</strong>igen Wochen <strong>in</strong>tensiven Versuchens ist es Ihnen<br />
nicht gelungen, das Programm zu schreiben. Was jetzt? Wenn Sie die Produktspezifikation<br />
analysieren und feststellen, dass sie sehr allgeme<strong>in</strong> formuliert ist, liegt es<br />
vielleicht an der Allgeme<strong>in</strong>heit und nicht an Ihrer Unfähigkeit. Es wäre z.B. toll,<br />
wenn Sie zeigen können, dass das von Ihnen verlangte Programm eigentlich auch<br />
das Halteproblem lösen könnte – dann können Sie Ihrem Chef beweisen, dass er<br />
unlösbare Aufgaben erteilt. Das ist aber leider nicht sehr wahrsche<strong>in</strong>lich, denn das<br />
Halteproblem ist doch sehr allgeme<strong>in</strong>. Also versuchen Sie zu zeigen, dass Ihr Programm<br />
e<strong>in</strong>es von den hunderten N P-vollständiger Problemen lösen würde – das<br />
zeigt nicht, dass die Aufgabe pr<strong>in</strong>zipiell nicht effektiv implementierbar wäre, aber<br />
dass es schon e<strong>in</strong>er Schar ausgezeichneter Programmierer nicht gelungen ist, e<strong>in</strong>en<br />
effizienten Algorithmus zu entwickeln.<br />
6.1 Beispiele effizienter Algorithmen<br />
In diesem Abschnitt illustrieren wir e<strong>in</strong>e genaue Analyse der Effizienz von Algorithmen<br />
an e<strong>in</strong>igen wichtigen Beispielen von Graphen-Algorithmen. E<strong>in</strong> gerichteter<br />
Graph G = (V, E), wobei V die Menge aller (n) Knoten und E die Menge aller<br />
Kanten (d.h. geordneten Paaren von Knoten) ist, wird gewöhnlich durch se<strong>in</strong>e<br />
n × n-Adjazenzmatrix<br />
repräsentiert, wobei<br />
aij =<br />
(aij)<br />
<br />
1 falls (i, j) e<strong>in</strong>e Kante <strong>in</strong> E ist<br />
0 sonst<br />
Oder durch Adjazenzlisten, d.h., durch n l<strong>in</strong>eare Listen, wobei die i-te Liste alle<br />
Knoten j mit (i, j) ∈ E enthält und die heads (Listenköpfe) <strong>in</strong> e<strong>in</strong>em Array<br />
gespeichert werden. Beispiel: für den gerichteten Graphen<br />
<br />
1<br />
<br />
<br />
5<br />
<br />
<br />
<br />
<br />
2<br />
<br />
3 <br />
<br />
4<br />
haben wir die Adjazenzmatrix der Gesamtgröße m = n 2<br />
⎛<br />
0<br />
⎜<br />
⎜0<br />
⎜<br />
⎜0<br />
⎝0<br />
1 0<br />
1 1<br />
0 0<br />
0 1<br />
⎞<br />
0 0<br />
1 0 ⎟<br />
0 0 ⎟<br />
0 1⎠<br />
1 0 0 0 0<br />
und die Adjazenzlisten der Gesamtgröße m = n + k
6.1. BEISPIELE EFFIZIENTER ALGORITHMEN 133<br />
1 <br />
2<br />
2 <br />
2 <br />
4 <br />
3<br />
3<br />
4 <br />
5 <br />
3<br />
5 <br />
1<br />
<br />
<br />
<br />
Beispiel 1 (Topologisches Sortieren). In Abschnitt 2.7 haben wir den folgenden<br />
Algorithmus für das topologische Sortieren e<strong>in</strong>es gerichteten Graphen G = (V, E)<br />
beschrieben:<br />
1: {(1) Initialisierung}<br />
2: i := 0<br />
3: W := V {W – die Menge der noch nicht bearbeiteten Knoten}<br />
4: {(2) Rekursionsschritt}<br />
5: while e<strong>in</strong> Knoten x ∈ W ohne Vorgänger existiert do<br />
6: i := i + 1;<br />
7: ord(x) = i;<br />
8: W := W − {x}<br />
9: Löschen des Knotens x aus dem Graphen<br />
10: od<br />
Wie lange dauert dieser Algorithmus für e<strong>in</strong>en Graphen mit n Knoten? Nehmen<br />
wir an, dass e<strong>in</strong>e E<strong>in</strong>tragung <strong>in</strong> die Liste ord sowie die Modifikation der Variablen<br />
i und W e<strong>in</strong>e konstante Zahl A von Zeite<strong>in</strong>heiten dauert. Um e<strong>in</strong>en Knoten x ohne<br />
Vorgänger zu f<strong>in</strong>den, suchen wir <strong>in</strong> der Adjazenzmatrix e<strong>in</strong>e Spalte mit lauter Nullen;<br />
das dauert Km 2 Zeite<strong>in</strong>heiten, wobei K e<strong>in</strong>e Konstante ist und m die aktuelle<br />
Knotenzahl ( m = n, n − 1, . . .,1), und die Entfernung e<strong>in</strong>es Knotens dauert e<strong>in</strong>e<br />
konstante Zahl L von Zeite<strong>in</strong>heiten. Dann ist die gesamte Zahl von Zeite<strong>in</strong>heiten<br />
für diesen Algorithmus<br />
T = 2A +<br />
n<br />
m=1<br />
(Km 2 + 3A + L) > Cn 3<br />
<br />
für e<strong>in</strong>e Konstante C.<br />
Dieser Algorithmus kann viel effizienter implementiert werden. Diesmal stellen wir<br />
den Graphen mittels Adjazenzlisten dar. Wir bezeichnen für jeden Knoten v mit<br />
IN[v] (e<strong>in</strong> Array, v = 1, . . .,n)<br />
die Zahl aller Kanten mit dem Endknoten v und wir setzen<br />
U = {v; v ∈ V und IN[v] = 0}.<br />
Algorithmus für Topologisches Sortieren<br />
E<strong>in</strong>gabe: Gerichteter Graph G = (V, E) mit n Knoten und k Kanten<br />
Ausgabe: Topologische Sortierung ord : V → {1, . . .,n} von G, falls G azyklisch<br />
ist<br />
1: {(1) Initialisierung}<br />
2: i := 0 {i – die letzte Zahl, die ord benutzt hat}<br />
3: U := ∅ {U - die Menge aller Knoten v mit IN[v] = 0}<br />
4: IN[1] := 0, . . .,IN[n] := 0
134 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
5: for alle Knoten v <strong>in</strong> V do<br />
6: for alle Knoten w mit e<strong>in</strong>er Kante (v, w) <strong>in</strong> E do<br />
7: IN[w] := IN[w] + 1<br />
8: end for<br />
9: end for<br />
10: for alle Knoten v <strong>in</strong> V do<br />
11: if IN[w] = 0 then<br />
12: U := U ∪ {v}<br />
13: end if<br />
14: end for<br />
15: {(2) Rekursionsschritt}<br />
16: while U e<strong>in</strong>en Knoten v enthält do<br />
17: U := U − v<br />
18: i := i + 1<br />
19: ord(v) := i<br />
20: for alle Knoten w mit (v, w) ∈ E do<br />
21: IN[w] := IN[w] − 1<br />
22: if IN[w] = 0 then<br />
23: U := U ∪ {w}<br />
24: end if<br />
25: end for<br />
26: od<br />
27: {(3) Ausgabe}<br />
28: Falls n = i, ist ord e<strong>in</strong>e topologische Sortierung von G.<br />
29: Falls n > i, ist die Ausgabe e<strong>in</strong> Code dafür, dass G nicht azyklisch ist.<br />
Korrektheit: Für jeden azyklischen Graphen G ist ord e<strong>in</strong>e topologische Sortierung<br />
von G. Das folgt daraus, dass jeder azyklische Graph e<strong>in</strong>en Knoten ohne Vorgänger<br />
hat. Deshalb ist U = ∅, solange nicht alle Knoten sortiert worden s<strong>in</strong>d. Für jede<br />
Kante (v, w) von G gilt: falls <strong>in</strong> e<strong>in</strong>em Durchgang der Schleife 16–26 der Wert<br />
ord(v) := i zugeordnet wird, hat vor diesem Durchgang IN[w] e<strong>in</strong>en Wert ≥ 1.<br />
Deswegen wird der Wert ord(w) erst <strong>in</strong> e<strong>in</strong>em Durchgang i + k, k ≥ 1, zugewiesen<br />
und es folgt ord(v) < ord(w).<br />
Zeitkomplexität: Wir wollen die Zahl der Zeite<strong>in</strong>heiten bestimmen, die dieser Algorithmus<br />
für Graphen mit n Knoten und k Kanten braucht. Das hängt von der<br />
Implementierung ab. Wir nehmen an, dass die mengentheoretischen Operationen<br />
(<strong>in</strong>sert, delete) so implementiert werden, dass sie e<strong>in</strong>e konstante Zahl A von Zeite<strong>in</strong>heiten<br />
brauchen, und auch jede Zuweisung A Zeite<strong>in</strong>heiten benötigt.<br />
Dann dauert die Initialisierung:<br />
Zeile Zeitkomplexität<br />
2. A<br />
3. A<br />
4. An<br />
5.–9. n + Ak<br />
10.–14. 2An<br />
(3A + 1)n + Ak Zeite<strong>in</strong>heiten<br />
Nur die Zeilen 5.–9. benötigt e<strong>in</strong>e Erklärung: bezeichnen wir mit k(v) die Zahl aller<br />
Nachfolger von v. Die Implementierung mit Adjazenzlisten erlaubt e<strong>in</strong>e Durchführung<br />
der Schleife 6.–8. <strong>in</strong> Zeit Ak(v). Die ganze Schleife dauert n+ n v=1 Ak(v) = n+Ak<br />
Zeite<strong>in</strong>heiten.<br />
Im Rekursionsschritt dauert 20.–25. 3Ak(v) Schritte. Da die Rekursion n-mal wie-
6.1. BEISPIELE EFFIZIENTER ALGORITHMEN 135<br />
derholt wird, benötigt sie<br />
17. An<br />
18. An<br />
19. An<br />
20.–25. 3Ak<br />
3A(n + k) Zeite<strong>in</strong>heiten<br />
Die Zeitkomplexität des Algorithmus ist also<br />
(6A + 1)n + 4Ak Zeite<strong>in</strong>heiten.<br />
Bemerkung 1. Die Konstante A hängt von der konkreten Implementierung ab.<br />
Um von solchen Details <strong>in</strong> unserer Analyse absehen zu können, führen wir, für jede<br />
Funktion t(n), die Klasse<br />
O(t(n)) (gelesen: ” O von t(n)“)<br />
e<strong>in</strong>, die aus allen Funktionen f(n) besteht, die nicht schneller als t(n) wachsen (für<br />
große Werte von n):<br />
Def<strong>in</strong>ition. O(t(n)) bezeichnet die Klasse aller Funktionen f(n), für die es Konstanten<br />
n0 und C gibt, so dass<br />
f(n) ≤ Ct(n) für alle n ≥ n0.<br />
Beispiel 2. 1. Der Algorithmus für topologische Sortierung hat e<strong>in</strong>e l<strong>in</strong>eare<br />
Zeitkomplexität<br />
O(n + k)<br />
Es gilt (6A + 1)n + 4Ak ≤ C(n + k), wobei C = 6A + 1, für alle n ≥ 0.<br />
2. Jedes quadratische Polynom gehört zur Klasse<br />
In der Tat, für<br />
O(n 2 ).<br />
f(n) = a + bn + cn 2 =<br />
<br />
a b<br />
+ + c n<br />
n2 n 2<br />
gilt: falls n ≥ max{a, b}, ist f(n)leq(2 + c)n 2 . Es genügt also, n0 = max{a, b}<br />
und C = 2 + c zu setzen.<br />
3. Allgeme<strong>in</strong>er enthält die Klasse<br />
alle Polynome des Grades k.<br />
O(n k )<br />
4. Die exponentielle Funktion 2 n gehört nicht zu der Klasse O(n k ), denn<br />
lim<br />
n→∞<br />
2n = ∞.<br />
nk Bemerkung 2. Falls Graphen als Adjazenzmatrizen implementiert werden, benötigt<br />
jeder Algorithmus für das topologische Sortieren m<strong>in</strong>destens<br />
n 2<br />
2 Schritte
136 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
In der Tat muss jeder Algorithmus für jedes der n 2 Paare (i, j) entweder aij oder<br />
aji <strong>in</strong> der Adjazenzmatrix durchsuchen. (Stellen wir uns vor, dass e<strong>in</strong> Algorithmus<br />
A weder aij noch aji durchsucht. Für den Graphen G mit n Knoten und ke<strong>in</strong>er<br />
Kante ergibt A e<strong>in</strong> topologisches Sortieren. Bezeichnen wir mit G den Graphen, der<br />
genau zwei Kanten i → j und j → i enthält. Dann wird G mit dem Algorithmus A<br />
genau wie G bearbeitet, obwohl G zyklisch ist. Das ist e<strong>in</strong> Widerspruch.)<br />
Also ist auch bei dieser Implementierung die Zeitkomplexität l<strong>in</strong>ear <strong>in</strong> der Größe<br />
n 2 der E<strong>in</strong>gabe.<br />
Beispiel 3 (2-FÄRBUNG). Wir wollen e<strong>in</strong>en (ungerichteten) Graphen G mit zwei<br />
Farben, z.B. rot und blau, so färben, dass ke<strong>in</strong>e zwei benachbarten Knoten gleichfarbig<br />
s<strong>in</strong>d. Es ist klar, dass das für Graphen, die e<strong>in</strong> Dreieck enthalten, unmöglich<br />
ist. Allgeme<strong>in</strong>er: für e<strong>in</strong>en Graphen mit e<strong>in</strong>em Zyklus ungerader Länge existiert<br />
ke<strong>in</strong>e solche Färbung.<br />
In dem Fall, dass G ke<strong>in</strong>e Zyklen ungerader Länge hat, läßt sich e<strong>in</strong> e<strong>in</strong>facher Algorithmus<br />
wie folgt angeben: wir wählen e<strong>in</strong>en Knoten v und färben ihn rot. Alle<br />
Nachbarn von v werden blau gefärbt – da G ke<strong>in</strong> Dreieck enthält, verursacht diese<br />
Färbung ke<strong>in</strong>e Probleme. Dann werden alle Nachbarn der zuletzt gefärbten Knoten<br />
rot gefärbt - da G ke<strong>in</strong> Dreieck und ke<strong>in</strong>en Zyklus aus fünf Kanten enthält, verursacht<br />
auch dies ke<strong>in</strong>e Probleme. So wird fortgefahren, bis die ganze Komponente<br />
von v (d.h., alle Knoten, die mit v durch e<strong>in</strong>en ungerichteten Weg verbunden s<strong>in</strong>d)<br />
gefärbt ist. Dann wählen wir wieder e<strong>in</strong>en beliebigen, noch nicht gefärbten, Knoten,<br />
der rot gefärbt wird, usw. Wir beschreiben diesen Algorithmus formal. Die Mengen<br />
aller (schon) roter oder blauer Knoten werden mit ROT und BLAU bezeichnet, die<br />
Menge aller zuletzt gefärbten Knoten mit F.<br />
Algorithmus für 2-Färbung<br />
E<strong>in</strong>gabe: Ungerichteter Graph G = (V, E)<br />
Ausgabe: E<strong>in</strong>e 2-Färbung V = ROT ∪ BLAU, falls es e<strong>in</strong>e gibt.<br />
1: {1. Initialisierung}<br />
2: ROT := ∅<br />
3: BLAU := ∅<br />
4: F := ∅<br />
5: {2. Rekursionsschritt}<br />
6: while V = ∅ do<br />
7: wähle v aus V<br />
8: V := V − {v}<br />
9: ROT := ROT ∪ {v}<br />
10: F := F ∪ {v}<br />
11: while F = ∅ do<br />
12: wähle w <strong>in</strong> F<br />
13: for alle Knoten u ∈ V mit (u, w) ∈ E do<br />
14: if w ∈ ROT then<br />
15: BLAU := BLAU ∪ {u}<br />
16: else<br />
17: ROT := ROT ∪ {u}<br />
18: end if<br />
19: F := F ∪ {u}<br />
20: V := V − {u}<br />
21: end for<br />
22: F := F − {w}<br />
23: od<br />
24: od
6.1. BEISPIELE EFFIZIENTER ALGORITHMEN 137<br />
25: {3. Ausgabe}<br />
26: Falls ROT oder BLAU e<strong>in</strong>e Kante aus E enthalten, ist die Ausgabe e<strong>in</strong> Code<br />
dafür, dass G ke<strong>in</strong>e 2-Färbung hat. Falls weder ROT noch BLAU e<strong>in</strong>e Kante<br />
enthält, ist dies die gesuchte 2-Färbung.<br />
Korrektheit: In jedem Schritt des Algorithmus gilt für jeden Knoten v: entweder<br />
v ∈ V oder v ∈ ROT oder v ∈ BLAU. Da am Ende V = ∅ gilt, ist also jeder<br />
Knoten entweder rot oder blau gefärbt. Falls weder ROT noch BLAU e<strong>in</strong>e Kante<br />
enthält, haben wir e<strong>in</strong>e 2-Färbung gefunden.<br />
Es bleibt zu zeigen, dass G Zyklen ungerader Länge hat, falls ROT e<strong>in</strong>e Kante<br />
enthält (analog für BLAU). Sei v der Knoten <strong>in</strong> 7. Wir beweisen, dass jeder Knoten,<br />
der <strong>in</strong> 17. rot (oder <strong>in</strong> 15. blau) gefärbt wird, e<strong>in</strong>en Weg von gerader (oder ungerader)<br />
Länge nach v hat, wobei die Länge des ” leeren Weges“ von v nach v gleich 0 gesetzt<br />
wird. Am Anfang der Schleife ab 11. ist das klar, denn der e<strong>in</strong>zige roten Knoten ist<br />
v, und blaue gibt es nicht. Jeder Durchgang dieser Schleife erhält diese Eigenschaft:<br />
falls w rot ist und also e<strong>in</strong>en Weg der Länge 2k nach v hat, wird jeder blau zu<br />
färbende Knoten u (für den e<strong>in</strong>e Kante (u, w) gegeben ist) e<strong>in</strong>en Weg der Länge<br />
2k + 1 nach v haben. Analoges gilt, falls w blau ist.<br />
Sei (u, u ′ ) e<strong>in</strong>e Kante <strong>in</strong> ROT. Wir haben e<strong>in</strong>en Kreis, der mit e<strong>in</strong>en Weg der Länge<br />
2k von u nach v beg<strong>in</strong>nt, dann mit e<strong>in</strong>em Weg der Länge 2k ′ von v nach u ′ weitergeht<br />
und mit der Kante (u ′ , u) endet. Dieser Kreis hat die ungerade Länge 2k + 2k ′ + 1<br />
und enthält also e<strong>in</strong>en Zyklus ungerader Länge (denn e<strong>in</strong> Kreis, der nur Zyklen von<br />
gerader Länge enthält, hat selbst gerade Länge). Analog läßt sich für e<strong>in</strong>e Kante <strong>in</strong><br />
BLAU argumentieren.<br />
Zeitkomplexität: Falls Graphen als Adjazenzlisten implementiert werden und die<br />
mengentheoretischen Operationen konstante Zeit erforden, hat dieser Algorithmus<br />
e<strong>in</strong>e l<strong>in</strong>eare Zeitkomplexität O(n+k) (wobei n die Zahl aller Knoten und k die Zahl<br />
aller Kanten ist).<br />
In der Tat benötigt die Initialisierung die Zeit O(1). Die Färbung e<strong>in</strong>er Komponente<br />
K (die Zeilen 8.–23.), deren Zahl von Kanten k(K) ist, dauert O(k(K)), da jede<br />
Kante nur e<strong>in</strong>mal durchsucht wird. Falls der Graph G genau r Komponenten hat,<br />
gilt k = k(K1) + · · · + k(Kr) und die r Durchgänge der Schleife 6.–24. dauern<br />
O(n + k) Schritte.<br />
Die Überprüfung, ob ROT oder BLAU e<strong>in</strong>e Kante enthalten, benötigt auch die<br />
l<strong>in</strong>eare Zeit O(n + k). Insgesamt wird der Algorithmus also <strong>in</strong> O(n + k) Schritten<br />
durchgeführt.<br />
Beispiel 4 (3-FÄRBUNG). Die analoge Aufgabe, e<strong>in</strong>en gegebenen Graphen mit<br />
drei Farben zu färben, ist viel schwieriger. Ke<strong>in</strong> effizienter Algorithmus ist bekannt<br />
– und später werden wir Gründe dafür kennenlernen, weshalb es unwahrsche<strong>in</strong>lich<br />
ist, dass e<strong>in</strong> effizienter Algorithmus existiert.<br />
Ineffizient können wir e<strong>in</strong>fach alle möglichen Färbungen ausprobieren. Das ist bestimmt<br />
e<strong>in</strong> Algorithmus – aber er braucht O(3 n ) Schritte, da es 3 n Färbungsmöglichkeiten<br />
gibt. Und das ist sehr aufwendig.<br />
Beispiel 5 (GERICHTETER WEG). Für zwei Knoten v und w e<strong>in</strong>es gerichteten<br />
Graphen ist e<strong>in</strong> Weg der Länge d von v nach w e<strong>in</strong>e Liste<br />
von Knoten, so dass<br />
v = v0, v1, . . . , vd = w<br />
(vi−1, vi) e<strong>in</strong>e Kante für i = 1, . . .,d ist.
138 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
Jeder Knoten hat e<strong>in</strong>en (leeren) Weg der Länge 0 zu sich selbst.<br />
Seien e<strong>in</strong> gerichteter Graph G und zwei Knoten v und w gegeben, dann entscheiden<br />
wir <strong>in</strong> l<strong>in</strong>earer Zeit O(n+k), ob e<strong>in</strong> Weg von v nach w führt. Sei M die Menge aller<br />
Knoten zu denen e<strong>in</strong> Weg von v führt.<br />
Algorithmus für gerichteter Weg<br />
E<strong>in</strong>gabe: E<strong>in</strong> gerichteter Graph G = (V, E) und zwei Knoten v und w<br />
Augabe: JA, falls e<strong>in</strong> gerichteter Weg von v nach w führt, ansonsten NEIN<br />
{Initialisierung:}<br />
M := {v}<br />
{Rekursionsschritt:}<br />
while e<strong>in</strong>e Kante (x, y) mit x ∈ M und y /∈ M existiert do<br />
M := M ∪ {y}<br />
E := E − {(x, y)}<br />
od<br />
{Ausgabe:}<br />
JA, falls w ∈ M, NEIN falls w ∈ M.<br />
Zeitkomplexität: Falls der Graph mit Adjazenzlisten implementiert ist, dauert dieser<br />
Algorithmus O(n + k) Schritte, denn jede Liste wird höchstens e<strong>in</strong>mal durchsucht.<br />
6.2 Komplexitätsklasse P<br />
Alle Probleme, die e<strong>in</strong> Rechner mit polynomialer Zeitkomplexität lösen kann, formen<br />
die Klasse P. Genauer: e<strong>in</strong> Entscheidungsproblem gehört zu P, falls es e<strong>in</strong>en<br />
Algorithmus gibt, der für jede E<strong>in</strong>gabe der Länge n <strong>in</strong> höchstens p(n) Zeite<strong>in</strong>heiten<br />
entscheidet, ob die Antwort JA oder NEIN ist, wobei p(n) e<strong>in</strong> (gegebenes) Polynom<br />
ist. Es entsteht die Frage: welche Implementierung haben wir hier im S<strong>in</strong>n?<br />
Die Antwort ist: die Klasse P ist von der Implementierung unabhängig. Verschiedene<br />
Implementierungen können natürlich verschiedene Zeitkomplexitäten haben<br />
(wie im Fall des TOPOLOGISCHEN SORTIERENS <strong>in</strong> 6.1 gezeigt wurde); d.h.,<br />
das Polynom p(n) wird für jede Implementierung <strong>in</strong>dividuell gewählt werden. Aber<br />
die Existenz e<strong>in</strong>es Polynomes ist unabhängig von der Implementierung. Das zeigen<br />
wir, <strong>in</strong>dem wir Tur<strong>in</strong>gmasch<strong>in</strong>en als Implementierungsmodell nehmen und dann beweisen,<br />
dass dieselbe Klasse P auch z.B. mit RAM als Modell entsteht. Der Beweis<br />
für andere Berechnungsmodelle folgt analog.<br />
Def<strong>in</strong>ition. Wir sagen, dass e<strong>in</strong>e determ<strong>in</strong>istische TM e<strong>in</strong>e Zeitkomplexität t(n)<br />
hat, wobei t(n) e<strong>in</strong>e Funktion aus der Menge ist, falls die TM für jede E<strong>in</strong>gabe<br />
der Länge n <strong>in</strong> höchstens t(n) Schritten hält.<br />
Beispiel 1. Die Sprache L ⊆ {0, 1} ∗ aller Wörter, die ke<strong>in</strong>e zwei benachbarten<br />
E<strong>in</strong>sen enthalten, kann von der folgenden TM akzeptiert werden: M bleibt solange<br />
im Initialzustand q0, wie sie Nullen liest, also (q0, 0) → (q0, R). Falls M e<strong>in</strong>e 1 liest,<br />
geht sie <strong>in</strong> den Zustand q1 über: (q0, 1) → (q1, R). Falls nach der 1 gleich e<strong>in</strong>e 0<br />
folgt, gehen wir zurück zum Zustand q0, falls aber noch e<strong>in</strong>e 1 gelesen wird, hält<br />
die Masch<strong>in</strong>e im (nichtf<strong>in</strong>alen) Zustand q1. Und falls das Blanksymbol gelesen wird,<br />
hält die Masch<strong>in</strong>e im f<strong>in</strong>alen Zustand qF. Hier ist e<strong>in</strong>e vollständige Beschreibung<br />
von M:<br />
M = ({q0, q1, qF }, {0, 1}, δ, q0, qF)
6.2. KOMPLEXITÄTSKLASSE P 139<br />
wobei δ durch die folgenden Übergangsregeln bestimmt wird:<br />
(q0, 0) → (q0, R)<br />
(q0, 1) → (q1, R)<br />
(q0, #) → (qF,#)<br />
(q1, 0) → (q0, R)<br />
(q1, #) → (qF,#)<br />
Jede E<strong>in</strong>gabe der Länge n liest die TM von l<strong>in</strong>ks nach rechts und hält spätestens<br />
bei dem Symbol # h<strong>in</strong>ter dem E<strong>in</strong>gabewort, also nach höchstens n + 1 Schritten.<br />
Sie hat also die Zeitkomplexität<br />
t(n) = n + 1.<br />
Bemerkung 1. 1. Im Kapitel 3 haben wir verschiedene Varianten von TM e<strong>in</strong>geführt<br />
(zum Beispiel mit zusätzlichem Gedächtnis, mit mehreren Bändern,<br />
usw.). Die Def<strong>in</strong>ition der Klasse P (s.u.) ist unabhängig davon, welche der<br />
Varianten als TM geme<strong>in</strong>t ist; das beweisen wir exakt im Abschnitt 6.4.<br />
2. Zeitkomplexität ist nicht e<strong>in</strong>deutig def<strong>in</strong>iert (denn sie ist nur e<strong>in</strong>e Abschätzung<br />
für die Anzahl der Berechnungsschritte). Genau genommen ist jede Funktion<br />
t ′ (n) mit t ′ (n) ≥ n+1 für alle n auch e<strong>in</strong>e Zeitkomplexität der TM aus Beispiel<br />
1.<br />
Beispiel 2. Die Sprache aller Pal<strong>in</strong>drome (siehe Abschnitt 2.1, Beispiel 3) wird von<br />
der folgenden Tur<strong>in</strong>gmasch<strong>in</strong>e M akzeptiert. Die Masch<strong>in</strong>e M hat e<strong>in</strong> zusätzliches<br />
Gedächtnis (siehe 3.2.2) für die Symbole aus Σ und vier Zustände: q0, Initialzustand,<br />
qR und qL (für die Bewegung nach l<strong>in</strong>ks oder rechts des Kopfes der Tur<strong>in</strong>gmasch<strong>in</strong>e)<br />
und qF, e<strong>in</strong>en f<strong>in</strong>alen Zustand.<br />
Zustand q0: Falls # gelesen wird, hält die TM und akzeptiert. Falls e<strong>in</strong> Symbol aus<br />
Σ gelesen wird, speichert die TM es im Gedächtnis, löscht es und geht zu qR über.<br />
Zustand qR bewegt den Kopf nach rechts bis er # liest, dann bewegt sich der Kopf<br />
e<strong>in</strong>en Schritt nach l<strong>in</strong>ks. [Problem: nach dem Löschen des ersten Symbols steht die<br />
TM im Zustand qR auf e<strong>in</strong>em #; daher wird e<strong>in</strong> spezielles Löschsymbol benötigt.]<br />
Falls das jetzt gelesene Symbol mit dem Gedächtnis übere<strong>in</strong>stimmt, wird es gelöscht<br />
und die TM geht zu qL über; falls nicht, hält die TM und akzeptiert nicht. [Problem:<br />
zum Löschen am rechten Rand brauchen wir e<strong>in</strong>en weiteren Zustand, etwa qC.]<br />
Zustand qL bewegt den Kopf nach l<strong>in</strong>ks bis er # liest [bzw. das neue Löschsymbol],<br />
dann bewegt er den Kopf e<strong>in</strong>en Schritt nach rechts und geht zu q0 über.<br />
Wie lange dauert die Berechnung e<strong>in</strong>er E<strong>in</strong>gabe der Länge n? Der Übergang q0 → qR<br />
dauert e<strong>in</strong>en Schritt und der Übergang qR → qL dauert n + 2 Schritte. Es dauert<br />
also<br />
1 + (n + 2) + n = 2n + 3<br />
Schritte, bis wieder q0 erreicht wird. Jetzt beg<strong>in</strong>nt dieselbe Berechnung mit e<strong>in</strong>em<br />
Wort der Länge n − 2. Der Zustand q0 wird also <strong>in</strong> 2(n − 2) + 3 Schritten wieder<br />
erreicht. (Wir nehmen immer den schlechtesten Fall an, hier also den Fall, dass die<br />
E<strong>in</strong>gabe wirklich e<strong>in</strong> Pal<strong>in</strong>drom ist.) Die gesamte Berechnungszeit beträgt höchstens<br />
t(n) = (2n + 3) + (2n − 1) + · · · + 5 + 1<br />
Schritte. Diese Summe ist gleich n 2 + 4n + 4, wie durch Induktion leicht bewiesen<br />
werden kann (?). Das bedeutet, dass unsere TM die Zeitkomplexität<br />
t(n) = n 2 + 4n + 4
140 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
hat.<br />
Bemerkung 2. Wir können für die Sprache aller Pal<strong>in</strong>drome e<strong>in</strong>e fast doppelt<br />
so schnelle TM konstruieren, <strong>in</strong>dem wir die beiden ersten Buchstaben speichern<br />
(und löschen) und sie mit den beiden letzten vergleichen (und diese dann auch<br />
löschen). E<strong>in</strong>e noch schnellere TM würde drei (oder vier usw.) Buchstaben auf<br />
e<strong>in</strong>mal vergleichen. Wir können also e<strong>in</strong>e fast k-mal schnellere TM für e<strong>in</strong> beliebig<br />
großes k konstruieren. Wir beobachten, dass jede dieser TM e<strong>in</strong>e Zeitkomplexität<br />
hat, die von e<strong>in</strong>em quadratischen Polynom repräsentiert wird.<br />
Den gleichen Beschleunigungsprozess können wir mit jeder TM machen, <strong>in</strong>dem wir<br />
stets <strong>in</strong> e<strong>in</strong>em Schritt k Felder gleichzeitig lesen und bearbeiten. Aus diesem Grund<br />
ist nicht die Funktion t(n) selbst <strong>in</strong>teressant, nur die ” Geschw<strong>in</strong>digkeit des Wachstums“<br />
von t(n), also die Klasse O(t(n)).<br />
Def<strong>in</strong>ition. Wir bezeichnen mit<br />
P<br />
die Klasse aller formalen Sprachen, die von e<strong>in</strong>er TM mit polynomialer Zeitkomplexität<br />
akzeptiert werden können. Genauer: e<strong>in</strong>e Sprache L gehört zur Klasse P, falls<br />
es e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e M und e<strong>in</strong> Polynom p(n) gibt, so dass<br />
L = L(M)<br />
und M hält auf E<strong>in</strong>gaben der Länge n <strong>in</strong> höchstens p(n) Schritten.<br />
Bemerkung 3. Er<strong>in</strong>nern wir uns daran, dass<br />
Entscheidungsproblem ≡ formale Sprache.<br />
Genau genommen müssen wir e<strong>in</strong> Entscheidungsproblem erst codieren (z.B. b<strong>in</strong>är,<br />
mit Symbolen 0 und 1). Dann bezeichnet L ⊆ {0, 1} ∗ die Sprache aller Codierungen<br />
der E<strong>in</strong>gaben, auf die die Entscheidung JA ist. Weiter nehmen wir immer an, dass<br />
die Codierung von Problemen ” vernünftig“ ist.<br />
Wenn nämlich jemand freiwillig e<strong>in</strong>e extrem lange Codierung der E<strong>in</strong>gabe benutzt,<br />
kann er auch e<strong>in</strong> kompliziertes Problem <strong>in</strong> l<strong>in</strong>earer Zeit p(n) = n, wobei n die<br />
” unvernünftige“ Codelänge ist, lösen. Die folgenden Regeln s<strong>in</strong>d als ” vernünftig“<br />
anzusehen:<br />
1. Zahlen werden b<strong>in</strong>är oder dezimal repräsentiert. (Nicht unär!)<br />
2. Graphen werden durch Adjazenzmatrizen oder Adjazenzlisten dargestellt (siehe<br />
Abschnitt 6.1).<br />
3. Mengentheoretische Operationen (Insert, Delete, Vere<strong>in</strong>igung, Durchschnitt)<br />
werden so implementiert, dass ihre Ausführung e<strong>in</strong>e konstante Zahl von Zeite<strong>in</strong>heiten<br />
dauert.<br />
Beispiel 3 (PALINDROM). Die Entscheidung, ob e<strong>in</strong> Wort e<strong>in</strong> Pal<strong>in</strong>drom ist, ist<br />
e<strong>in</strong> Problem der Klasse P, denn die TM aus Beispiel 2 hat die Zeitkomplexität<br />
O(n 2 ).<br />
Beispiel 4 (2-FÄRBUNG). Das Problem, ob e<strong>in</strong> Graph mit zwei Farben gefärbt<br />
werden kann, gehört zur Klasse P. In Abschnitt 6.1 haben wir dafür e<strong>in</strong>en Algorithmus<br />
mit l<strong>in</strong>earer Zeitkomplexität beschrieben. Es ist nicht kompliziert, den<br />
Algorithmus mit e<strong>in</strong>er TM zu implementieren und zu beweisen, dass diese TM polynomiale<br />
Zeitkomplexität hat.
6.2. KOMPLEXITÄTSKLASSE P 141<br />
Beispiel 5 (2-ERFÜLLBARKEIT und 3-ERFÜLLBARKEIT). Analog zu der Situation<br />
der 2-Färbung und 3-Färbung haben wir hier e<strong>in</strong> anderes wichtiges Beispiel<br />
der Probleme, deren leichtere Variante zu P gehört und deren schwierige<br />
(wahrsche<strong>in</strong>lich) nicht. Es handelt sich um Boolesche Formeln über den Variablen<br />
x1, . . .,xn. Die e<strong>in</strong>fachsten Formeln s<strong>in</strong>d die Variablen xi selbst und ihre Negationen<br />
¬xi - diese Formeln heißen Literale. Die komplizierteren Formeln werden mit<br />
Hilfe der üblichen logischen Operationen, z.B. Konjunktion ∧, Disjunktion ∨ und<br />
Implikation → erzeugt.<br />
Jede Disjunktion von Literalen heißt Klausel.<br />
Beispiele:<br />
x ∨ y ∨ ¬z und ¬x.<br />
Jede Boolesche Formel phi hat e<strong>in</strong>e konjunktive Normalform (KNF), d.h., φ =<br />
φ1 ∧φ2 ∧ · · · ∧φn ist e<strong>in</strong>e Konjunktion der Klauseln φ1, . . . , φn. Z.B. hat die Formel<br />
φ = (x → y ∧ z) ∧ (¬x → ¬z)<br />
die folgende KNF: wir benutzen die Äquivalenz von<br />
und erhalten<br />
a → b und ¬a ∨ b<br />
φ = (¬x ∨ (y ∧ z)) ∧ (x ∨ ¬z)<br />
Da ¬x ∨ (y ∧ z) äquivalent zu (¬x ∨ y) ∧ (¬x ∨ z) ist (de Morgansches Gesetz), gilt<br />
φ = (¬x ∨ y) ∧ (¬x ∨ z) ∧ (x ∨ ¬z).<br />
Das ist also e<strong>in</strong>e Boolesche Formel, deren Klauseln je zwei Literale enthalten.<br />
E<strong>in</strong>e Formel φ heißt erfüllbar, falls die Variablen so mit true oder false belegt<br />
werden können, dass φ den Wert true annimmt. Beispiel: die obige Formel ist<br />
erfüllbar, denn für<br />
x = true, y = true, z = true<br />
gilt φ = true.<br />
Es ist ke<strong>in</strong> effizienter Algorithmus bekannt, der für jede Boolesche Formel unterscheidet,<br />
ob sie erfüllbar ist. Das Problem m-ERFÜLLBARKEIT ist: Gegeben,<br />
e<strong>in</strong>e Boolesche Formel φ <strong>in</strong> konjunktiver Normalform, wobei jede Klausel m Literale<br />
enthält, ist φ erfüllbar? Wir def<strong>in</strong>ieren die Größe der E<strong>in</strong>gabe φ als n + k, wobei<br />
n die Anzahl aller Variablen und k die Anzahl aller Klauseln von φ ist.<br />
2-ERFÜLLBARKEIT gehört zur Klasse P. Wir könnten hier e<strong>in</strong>en effizienten Algorithmus<br />
angeben, aber e<strong>in</strong>facher ist es zu zeigen (<strong>in</strong> Abschnitt 6.3), dass es e<strong>in</strong>e<br />
effiziente Reduktion dieses Problems auf e<strong>in</strong> anderes Problem der Klasse P gibt –<br />
daraus folgt dann <strong>in</strong>direkt, dass 2-ERFÜLLBARKEIT zur Klasse P gehört.<br />
3-ERFÜLLBARKEIT ist dagegen schwierig: <strong>in</strong> Abschnitt 6.4 zeigen wir, dass dieses<br />
Problem N P-vollständig ist, also genauso schwierig wie 3-FÄRBUNG.<br />
Beispiel 6 (UNIVERSALITÄT REGULÄRER AUSDRÜCKE). Das ist e<strong>in</strong> (rares)<br />
Beispiel e<strong>in</strong>es leicht zu formulierenden Problems, für das bewiesen wurde, dass es<br />
nicht effizient lösbar ist. Reguläre Ausdrücke haben wir <strong>in</strong> Kapitel 1 e<strong>in</strong>geführt: sie<br />
werden aus Buchstaben des Alphabets Σ, z.B. Σ = {a, b}, und Symbolen ∅ und ɛ mit<br />
Hilfe der Operatoren +, ·, und ∗ erzeugt. Jetzt arbeiten wir mit komprimierter<br />
Notation: statt xx . . . x (n-mal) schreiben wir x ↑ n (n b<strong>in</strong>är), z.B.<br />
xxxxx = x ↑ 101
142 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
Der reguläre Ausdruck<br />
ergibt also <strong>in</strong> komprimierter Notation<br />
(aaa + b ∗ )(aaa + b ∗ )<br />
(a ↑ 11 + b ∗ ) ↑ 10.<br />
E<strong>in</strong> regulärer Ausdruck über dem Alphabet Σ heißt universal, falls die dadurch<br />
def<strong>in</strong>ierte Sprache die ganze Sprache Σ ∗ ist. Z.B. ist der obige reguläre Ausdruck<br />
(über Σ = {a, b}) nicht universal, aber (a ∗ ↑ 11 + b ∗ ) ↑ 10 ist universal. Jeder<br />
reguläre Ausdruck über Σ ist also e<strong>in</strong> Wort über dem Alphabet<br />
Σ ∪ {∗, +, (, ), 0, 1, ↑}<br />
und die Länge dieses Wortes ist dann die Größe der E<strong>in</strong>gabe.<br />
Satz 1. Das Problem, zu entscheiden, ob e<strong>in</strong> gegebener regulärer Ausdruck <strong>in</strong> komprimierter<br />
Notation über {a, b} universal ist, gehört nicht zu P.<br />
Den Beweis kann der Leser unter 13.15 im Buch von Hopcroft und Ullman (siehe<br />
E<strong>in</strong>leitung [?]) f<strong>in</strong>den.<br />
6.3 Berechnungsprobleme und Reduzierbarkeit<br />
Die Komplexitätsklasse P wurde für Entscheidungsprobleme e<strong>in</strong>geführt. Analog<br />
können wir für Berechnungsprobleme die Klasse<br />
FP<br />
e<strong>in</strong>führen, die alle <strong>in</strong> polynomialer Zeit lösbaren Probleme enthält.<br />
Beispiel 1. 2-FÄRBUNG ist das Problem, zu jedem 2-färbbaren Graphen e<strong>in</strong>e<br />
2-Färbung zu berechnen. Darunter verstehen wir, wie üblich, e<strong>in</strong>e Funktion<br />
f : {0, 1} ∗ → {0, 1} ∗ ,<br />
die jedem b<strong>in</strong>ären Code w = c(G) e<strong>in</strong>es Graphen G e<strong>in</strong>en b<strong>in</strong>ären Code f(w) se<strong>in</strong>er<br />
2-Färbung zuordnet, falls G e<strong>in</strong>e 2-Färbung hat.<br />
So e<strong>in</strong>e Funktion kann <strong>in</strong> l<strong>in</strong>earer Zeit berechnet werden, siehe Beispiel 3 <strong>in</strong> 6.1.<br />
Wir verwenden wieder TM als Berechnungsmodell. Wir sagen, dass e<strong>in</strong>e TM e<strong>in</strong>e<br />
Funktion<br />
f : Σ ∗ → Γ ∗<br />
(Σ, Γ zwei Alphabete)<br />
berechnet, falls die TM für jede E<strong>in</strong>gabe s1s2 . . . sn (aus Σ ∗ ) nach endlich vielen<br />
Schritten mit dem Wort f(s1 . . . sn) (aus Γ ∗ ) auf dem Band hält, siehe Abschnitt<br />
3.5<br />
Def<strong>in</strong>ition. Wir bezeichnen mit FP die Klasse aller Funktionen f : Σ ∗ → Γ ∗ ,<br />
die von e<strong>in</strong>er TM <strong>in</strong> polynomialer Zeit berechnet werden können. D.h., für die e<strong>in</strong>e<br />
Tur<strong>in</strong>gmasch<strong>in</strong>e M und e<strong>in</strong> Polynom p(n) existieren, so dass M auf jede E<strong>in</strong>gabe<br />
s1 . . . sn aus Σ ∗ <strong>in</strong> höchstens p(n) Schritten hält und f(s1 . . . sn) auf das Band<br />
schreibt.
6.3. BERECHNUNGSPROBLEME UND REDUZIERBARKEIT 143<br />
Beispiel 2 (STARKE KOMPONENTEN). Zwei Knoten e<strong>in</strong>es gerichteten Graphen<br />
G können genau dann <strong>in</strong> beiden Richtungen durch e<strong>in</strong>en gerichteten Weg verbunden<br />
werden, wenn sie <strong>in</strong> e<strong>in</strong>em Kreis des Graphen liegen. Wir sagen dann, dass die beiden<br />
Knoten <strong>in</strong> derselben starken Komponente liegen.<br />
Genauer: e<strong>in</strong>e starke Komponente von G ist e<strong>in</strong>e maximale Menge von Knoten,<br />
die durch gerichtete Wege (<strong>in</strong> beiden Richtungen) mite<strong>in</strong>ander verbunden werden<br />
können. Beispiel: der folgende Graph<br />
• b<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
a •<br />
<br />
<br />
•<br />
<br />
c<br />
d •<br />
<br />
<br />
•<br />
<br />
e<br />
•<br />
<br />
f<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
hat drei starke Komponenten: {a, b, c}, {d, e} und {f}.<br />
Aufgrund des Algorithmus aus Beispiel 5 <strong>in</strong> 6.1 können wir e<strong>in</strong>en trivialen Algorithmus<br />
f<strong>in</strong>den, der für e<strong>in</strong>en Graphen mit n Knoten und k Kanten <strong>in</strong> der Zeit<br />
O(n 2 (n + k)) die starken Komponenten aufzählt: wir wählen e<strong>in</strong>en Knoten v und<br />
fragen für jeden Knoten w, ob e<strong>in</strong> Weg von v zu w sowie e<strong>in</strong> Weg von w nach v<br />
führt. Das braucht O(2(n + k)) = O(n + k) Schritte für jeden Knoten w, also <strong>in</strong>sgesamt<br />
O(n(n + k)) Schritte. Damit wird die starke Komponente von v <strong>in</strong> der Zeit<br />
O(n(n+k)) bestimmt. Außerdem gibt es höchstens n starke Komponenten, also ist<br />
die gesamte Komplexität O(n 2 (n + k)).<br />
Es existiert e<strong>in</strong> Algorithmus, der die starken Komponenten <strong>in</strong> l<strong>in</strong>earer Zeit O(n+k)<br />
berechnet. Diesen werden wir hier aber nicht vorführen.<br />
Bemerkung 1. Starke Komponenten jedes Graphen G formen e<strong>in</strong>en neuen gerichteten<br />
Graphen G. Genauer, die Knoten von G s<strong>in</strong>d die starken Komponenten v der<br />
Knoten v von G. Und für zwei starke Komponenten v, w von G gilt:<br />
(v, w) ist e<strong>in</strong>e Kante von G genau dann, wenn v = w und e<strong>in</strong> gerichteter Weg von<br />
v nach w führt <strong>in</strong> G.<br />
Zum Beispiel ergibt sich aus dem obigen Graphen G der folgende Graph<br />
• {a, b, c}<br />
•<br />
<br />
{d, e}<br />
•<br />
<br />
<br />
{f}<br />
Es ist klar, dass der neue Graph G azyklisch ist (denn jeder Kreis von G kann zu<br />
e<strong>in</strong>em Kreis aus G ergänzt werden, der dann mehrere starke Komponenten verb<strong>in</strong>den<br />
würde, das ist jedoch nicht möglich). Aufgrund von Beispiel 1 <strong>in</strong> 6.1 können<br />
also die starken Komponenten jedes gerichteten Graphen so sortiert werden, dass<br />
ord(v) ≤ ord(w) für jede Kante (v, w) von G.<br />
Bemerkung 2. Wir wollen verschiedene Entscheidungsprobleme bezüglich ihrer<br />
Komplexität vergleichen. Wann kann man sagen, dass e<strong>in</strong> Problem L ⊆ Σ ∗ nicht<br />
schwieriger ist, als e<strong>in</strong> Problem L0 ⊆ Γ ∗ ? Falls wir e<strong>in</strong>e Übersetzung f haben, die<br />
alle Instanzen des ersten Problems (d.h., Wörter über Σ) <strong>in</strong> Instanzen des zweiten
144 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
(Wörter über Γ) überführt, so dass die Lösungen von L genau den Lösungen von<br />
L0 entsprechen und f selbst effizient berechenbar ist:<br />
Def<strong>in</strong>ition. Wir sagen, dass e<strong>in</strong>e Sprache L ⊆ Σ∗ <strong>in</strong> polynomialer Zeit auf e<strong>in</strong>e<br />
Sprache L0 ⊆ Γ∗ reduzierbar ist, falls es e<strong>in</strong>e Funktion f : Σ∗ → Γ∗ der Klasse<br />
FP mit<br />
x ∈ L genau dann, wenn f(x) ∈ L0 (für alle x ∈ Σ ∗ )<br />
gibt.<br />
Aufpassen! Die Voraussetzung, dass die Reduktion f zur Klasse FP gehört, ist der<br />
Kern dieser Def<strong>in</strong>ition! Es ist nämlich trivial, e<strong>in</strong>e beliebige Funktion f zu def<strong>in</strong>ieren,<br />
für die gilt x ∈ L genau dann, wenn f(x) ∈ L0: man wähle zwei Wörter w ∈ L0<br />
und w ′ /∈ L0 und setze<br />
f(x) =<br />
<br />
w falls x ∈ L<br />
w ′ falls x /∈ L<br />
Beispiel 3 (KANTEN-2-FÄRBBARKEIT). Wir wollen für e<strong>in</strong>en gegebenen ungerichteten<br />
Graphen G wissen, ob sich se<strong>in</strong>e Kanten derart blau und rot färben lassen,<br />
so dass Kanten mit geme<strong>in</strong>samen Knoten nie gleichfarbig s<strong>in</strong>d. [Achtung: Wir haben<br />
gerade e<strong>in</strong> Entscheidungproblem formuliert; das zugehörige Berechnugsproblem<br />
besteht dar<strong>in</strong>, e<strong>in</strong>e legitime Kantenfärbung zu konstruieren, oder festzustellen, daß<br />
ke<strong>in</strong>e existiert. Insofern können wir das Entscheidungprobem auf dem Umweg über<br />
das Berechnungsproblem lösen.] Dieses Entscheidungsproblem können wir wie folgt<br />
auf das Problem von 2-Färbbarkeit (von Knoten) reduzieren: für jeden ungerichteten<br />
Graphen G = (V, E) bezeichnen wir mit ˆ G = (E, H) den dualen Graphen,<br />
dessen Knoten die Kanten von G s<strong>in</strong>d, und zwei Kanten von G formen <strong>in</strong> ˆ G e<strong>in</strong>e<br />
Kante (also gehören sie zu H) genau dann, wenn sie <strong>in</strong> G benachbart s<strong>in</strong>d. Beispiel:<br />
• 3<br />
<br />
<br />
1 •<br />
<br />
<br />
• 2<br />
<br />
<br />
<br />
•<br />
5<br />
G<br />
• 4<br />
•<br />
(2, 3)<br />
(1, 3) •<br />
<br />
• (1, 2)<br />
<br />
<br />
<br />
•<br />
<br />
(2, 4)<br />
<br />
Es gilt: jede 2-Färbung von ˆ G ergibt e<strong>in</strong>e Kanten-2-Färbung von G und umgekehrt.<br />
Folglich ist ˆ G genau dann 2-färbbar, wenn dies für G gilt.<br />
Ist diese Reduktion <strong>in</strong> polynomialer Zeit durchführbar? Das heißt, gehört die Funktion<br />
f : {0, 1} ∗ → {0, 1} ∗ , die jedem Code wG e<strong>in</strong>es Graphen G den Code f(wG) = w ˆ G<br />
des dualen Graphen zuordnet, zu FP? Falls die Graphen als Adjazenzmatrizen implementiert<br />
werden, wird zu e<strong>in</strong>er Matrix M die folgende Matrix f(M) zugeordnet:<br />
die Zeilen und Spalten von f(M) s<strong>in</strong>d mit allen Paaren (i, j) markiert, wobei i ≤ j<br />
und Mij = 1. Und f(M) hat e<strong>in</strong>e 1 <strong>in</strong> der Position von Zeile (i, j) und Spalte (i ′ , j ′ )<br />
genau dann, wenn i = i ′ oder j = j ′ . Das können wir <strong>in</strong> l<strong>in</strong>earer Zeit O(m), wobei<br />
m die Größe der E<strong>in</strong>gabe ist (m = n 2 für Graphen mit n Knoten), berechnen.<br />
Satz 1. Falls e<strong>in</strong>e Sprache L0 zur Klasse P gehört, gehören zu P auch alle Sprachen,<br />
die sich <strong>in</strong> polynomialer Zeit auf L0 reduzieren lassen.<br />
Beweis. Wir haben e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e M0, die L0 ⊆ Γ ∗ akzeptiert, und e<strong>in</strong>e<br />
polynomiale Zeitkomplexität p(n) hat. Für jede Sprache L ⊆ Σ ∗ und jede Funktion<br />
f : Σ ∗ → Γ ∗ der Klasse FP, die x ∈ L ⇐⇒ f(x) ∈ L0 erfüllt, zeigen wir, dass<br />
ˆG
6.3. BERECHNUNGSPROBLEME UND REDUZIERBARKEIT 145<br />
die Sprache L zu P gehört. Sei M e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e mit polynomialer Zeitkomplexität<br />
q(n), die f berechnet. Wir benutzen die folgende 2-Band Tur<strong>in</strong>gmasch<strong>in</strong>e<br />
˜M:<br />
BAND 1: E<strong>in</strong>gabeband<br />
(Simulation von M)<br />
BAND 2: Simulation von M0<br />
s1 s2 . . . sn<br />
Auf Band 1 wird erst M simuliert, so dass die E<strong>in</strong>gabe x = s1s2 . . . sn, nachdem<br />
M gehalten hat, das Wort f(x) auf Band 1 ergibt. Das Wort wird jetzt auf Band<br />
2 kopiert und M0 wird simuliert. Falls M0 akzeptiert, akzeptiert auch ˜ M, und<br />
umgekehrt.<br />
Die Masch<strong>in</strong>e ˜ M akzeptiert e<strong>in</strong> Wort x ∈ Σ ∗ genau dann, wenn M0 das Wort f(x)<br />
akzeptiert, d.h., genau dann, wenn f(x) ∈ L0 gilt. Das ist äquivalent zu x ∈ L. Es<br />
gilt also L = L( ˜ M). Für E<strong>in</strong>gaben der Länge n hält M nach höchstens q(n) Schritten<br />
und beschriftet höchstens q(n) Felder. In q(n) Schritten kopieren wir das Wort auf<br />
Band 2 und dann hält M0 <strong>in</strong> höchstens p(q(n)) Schritten. Die Zeitkomplexität von<br />
˜M ist also<br />
2q(n) + p(q(n)).<br />
Dieser Ausdruck ist e<strong>in</strong> Polynom, also gilt L( ˜ M) ∈ P.<br />
Beispiel 4. 2-ERFÜLLBARKEIT kann <strong>in</strong> polynomialer Zeit auf STARKE KOM-<br />
PONENTEN (Beispiel 2) reduziert werden; deswegen gehört 2-ERFÜLLBARKEIT<br />
zu P. [Achtung: STARKE KOMPONENTEN ist e<strong>in</strong> Berechnungsproblem; das zugehörige<br />
Entscheidungsproblem, das <strong>in</strong> Wirklichkeit Ziel unserer Reduktion ist,<br />
fragt, ob für e<strong>in</strong>en gerichteten Graphen, dessen Knotenmenge V disjunkte Vere<strong>in</strong>igung<br />
zweier isomorpher Mengen V ′ und V ′′ ist, und für e<strong>in</strong>e Bijektion f : V ′ → V ′′<br />
die Knoten v ′ ∈ V ′ und f(v ′ ) ∈ V ′′ immer <strong>in</strong> verschiedenen starken Komponenten<br />
liegen.] Wir beschreiben die Reduktion.<br />
Für jede Formel φ <strong>in</strong> konjunktiver Normalform mit 2 Literalen je Klausel konstruieren<br />
wir e<strong>in</strong>en gerichteten Graphen Gφ wie folgt:<br />
Knoten: für jede Variable x von φ hat Gφ zwei Knoten, markiert mit x und ¬x.<br />
Kanten: für jede Klausel α ∨ β von φ gibt es zwei Kanten <strong>in</strong> G:<br />
¬α<br />
•<br />
β<br />
• und •<br />
¬β<br />
<br />
<br />
α<br />
•<br />
Beispiel: für die Formel<br />
haben wir den Graphen<br />
φ = (x ∨ y) ∧ (¬x ∨ z) ∧ (¬z ∨ ¬y)<br />
x y <br />
• • •<br />
<br />
<br />
<br />
z<br />
<br />
<br />
<br />
<br />
<br />
<br />
¬x<br />
• <br />
• •<br />
¬y ¬z<br />
Diese Konstruktion ist e<strong>in</strong>e Reduktion <strong>in</strong> polynomialer Zeit, denn es gilt
146 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
1. φ ist erfüllbar genau dann, wenn x und ¬x <strong>in</strong> verschiedenen starken Komponenten<br />
von G liegen (für jede Variable x), und<br />
2. die Funktion f, die jeder Formel φ den Graphen Gφ zuordnet, hat e<strong>in</strong>e l<strong>in</strong>eare<br />
Zeitkomplexität.<br />
Es ist klar, dass (2) gilt: falls φ e<strong>in</strong>e Formel der Größe n (= Anzahl aller Variablen<br />
+ Anzahl aller Klauseln) ist, benötigt die Konstruktion von Gφ die Zeit O(n). Wir<br />
beweisen (1).<br />
1. Sei φ erfüllbar. Wir haben also e<strong>in</strong>e Belegung der Variablen, so dass jede<br />
Klausel von φ den Wert true hat (d.h., für jede Klausel α ∨ β gilt α = true<br />
oder β = true). Es folgt, dass von e<strong>in</strong>em true Knoten <strong>in</strong> Gφ ke<strong>in</strong>e Kante<br />
zu e<strong>in</strong>em false Knoten führt. (Für die Kante ¬α → β gilt, falls ¬α = true,<br />
dass β = true se<strong>in</strong> muss, denn α ∨ β ist e<strong>in</strong>e Klausel von φ; analoges gilt für<br />
¬β → α.) Falls die Variable x den Wert true hat, führt <strong>in</strong> Gφ also ke<strong>in</strong> Weg<br />
zu ¬x; falls x = false ist, führt ke<strong>in</strong> Weg von ¬x zu x. In beiden Fällen liegen<br />
x und ¬x <strong>in</strong> verschiedenen starken Komponenten.<br />
2. Seien x und ¬x immer <strong>in</strong> verschiedenen starken<br />
Komponenten. Wir er<strong>in</strong>nern an die obige Bemerkung 1: die starken Komponenten<br />
v der Knoten v des Graphen Gφ können so sortiert werden, dass für<br />
jede Kante v → w von G ord(v) ≤ ord(w) gilt. Wir belegen die Variablen wie<br />
folgt:<br />
x = true genau dann, wenn ord(¬x) < ord(x)<br />
(d.h., x hat genau dann den Wert true, wenn die starke Komponente von<br />
¬x vor der starken Komponente von x liegt). Wir müssen beweisen, dass für<br />
jede Klausel α ∨ β entweder α = true oder β = true gilt (denn dann gilt<br />
φ = true).<br />
Nehmen wir an, dass α = false, d.h.,<br />
ord(α) ≤ ord(¬α),<br />
dann beweisen wir β = true. Da Gφ die Kante ¬α → β enthält, gilt ord(¬α) ≤<br />
ord(β) und da er auch die Kante ¬β → α enthält, gilt ord(¬β) ≤ ord(α). Also<br />
Damit ist bewiesen, dass<br />
ord(¬β) ≤ ord(α) ≤ ord(¬α) ≤ ord(β).<br />
ord(¬β) < ord(β)<br />
(denn die Komponenten ¬β und β s<strong>in</strong>d wohl verschieden), also β = true.<br />
Konkrete Beispiele: Die Formel oben ist erfüllbar, denn die starken Komponenten<br />
des Graphen Gφ s<strong>in</strong>d<br />
Die Formel<br />
{x, z, ¬y} und {¬x, y, ¬z}.<br />
(y ∨ x) ∧ (¬y ∨ z) ∧ (¬z ∨ x) ∧ (¬x ∨ ¬t) ∧ (t ∨ ¬x)<br />
ist nicht erfüllbar, denn der entsprechende Graph
6.4. ROBUSTHEIT DER KLASSE P 147<br />
hat e<strong>in</strong>e e<strong>in</strong>zige starke Komponente.<br />
<br />
x•<br />
<br />
y<br />
<br />
• <br />
<br />
•z •t<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
¬x • ¬y • <br />
<br />
• ¬z <br />
<br />
• ¬t<br />
Notation. Für zwei Sprachen L und L0 schreiben wir<br />
L ⊳ L0<br />
falls L auf L0 <strong>in</strong> polynomialer Zeit reduzierbar ist. (Das Zeichen ⊳ ist dem Zeichen<br />
≤ ähnlich und deutet an, dass die Komplexität von L kle<strong>in</strong>er gleich der von L0 ist.)<br />
Satz 2. Die Relation ⊳ ist transitiv: für Sprachen Li ⊆ Σ∗ i (i = 1, 2, 3) gilt<br />
L1 ⊳ L2 ⊳ L3 =⇒ L1 ⊳ L3.<br />
Beweis. Aus L1 ⊳ L2 folgt, dass e<strong>in</strong>e Funktion f1 : Σ∗ 1 → Σ∗2 der Klasse FP<br />
x ∈ L1 ⇐⇒ f1(x) ∈ L2 erfüllt; aus L2 ⊳ L3 folgt, dass e<strong>in</strong>e Funktion f2 : Σ∗ 2 → Σ∗3 der Klasse FP y ∈ L2 ⇐⇒ f2(y) ∈ L3 erfüllt. Sei<br />
die Verknüpfung von f1 und f2. Es gilt<br />
h : Σ ∗ 1 → Σ∗3 , h(x) = f2(f1(x))<br />
x ∈ L1 ⇐⇒ f1(x) ∈ L2 ⇐⇒ h(x) = f2(f1(x)) ∈ L3.<br />
Also bleibt nur zu zeigen, dass h(x) <strong>in</strong> der Klasse FP liegt. In der Tat: die Funktion<br />
fi (i = 1, 2) wird durch e<strong>in</strong>e TM Mi <strong>in</strong> polynomialer Zeit pi(n) berechnet. Dann<br />
wird die Funktion h(x) = f2(f1(x)) durch die folgende TM berechnet:<br />
x<br />
<br />
M1<br />
f1(x)<br />
<br />
M2<br />
<br />
f2(f1(x))<br />
Für Wörter x der Länge n macht M1 höchstens p1(n) Schritte und schreibt also<br />
höchstens p1(n) Symbole. Das Wort f1(x) hat daher die Länge ≤ n + p1(n). Dann<br />
dauert die Berechnung von M2 höchstens p2(n+p1(n)) Schritte. Insgesamt braucht<br />
die obige TM höchstens<br />
p1(n) + p2(n + p1(n))<br />
Schritte, und das ist e<strong>in</strong> Polynom – also liegt h <strong>in</strong> FP.<br />
Natürlich ist die Relation ⊳ reflexiv, aber sie ist nicht antisymmetrisch.<br />
6.4 Robustheit der Klasse P<br />
Die Def<strong>in</strong>ition der Klasse P war auf dem Modell von TM aufgebaut. Sie ist aber von<br />
diesem Modell unabhängig, wie wir jetzt demonstrieren werden. Zuerst zeigen wir,<br />
dass, falls verschiedene Modifikationen von TM benutzt worden wären, die Klasse<br />
P dieselbe geblieben wäre. Die Zeitkomplexität ist für k-Band-TM genau wie oben<br />
für TM def<strong>in</strong>iert.
148 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
6.4.1 TM mit zusätzlichem Gedächtnis<br />
Er<strong>in</strong>nern wir daran, dass e<strong>in</strong>e TM mit zusätzlichem Gedächtnis die Möglichkeit<br />
e<strong>in</strong>es Zugriffs auf e<strong>in</strong> Gedächtnis hat, <strong>in</strong> dem Symbole e<strong>in</strong>es endlichen Alphabets<br />
A gespeichert werden, siehe 3.2.2. Dies ist allerd<strong>in</strong>gs e<strong>in</strong>e ” normale“ TM mit der<br />
Zustandsmenge Q × A. Für die Def<strong>in</strong>ition der Klasse P ist es also unerheblich, ob<br />
wir TM oder TM mit zusätzlichem Gedächtnis als Berechnungsmodell anwenden.<br />
6.4.2 TM mit mehrspurigem Band<br />
Auch dieses Modell ändert die Klasse P nicht, denn wie <strong>in</strong> 3.2.3 gezeigt wurde, ist<br />
e<strong>in</strong>e TM mit k-spurigem Band e<strong>in</strong>e ” normale“ TM mit dem Bandalphabet<br />
Σ = (Σ1 ∪ {#}) × · · · × (Σk ∪ {#}) − {(#, . . . , #)}.<br />
6.4.3 Mehr-Band TM<br />
In 3.2.4 haben wir das Modell e<strong>in</strong>er k-Band-TM e<strong>in</strong>geführt: die TM hat k Bänder<br />
mit k unabhängigen Lese- und Schreibköpfen, aber mit e<strong>in</strong>er Steuere<strong>in</strong>heit, die<br />
aufgrund des gegebenen Zustandes und der k gelesenen Symbole die Aktivität der<br />
k Köpfe steuert. Wir haben <strong>in</strong> 3.2.4 bewiesen, dass jede k-Band-TM durch e<strong>in</strong>e TM<br />
simuliert werden kann. Jetzt beweisen wir, dass dies <strong>in</strong> polynomialer Zeit möglich<br />
ist:<br />
Satz 1. Jede k-Band-TM mit e<strong>in</strong>er Zeitkomplexität t(n) ≥ n kann durch e<strong>in</strong>e 1-<br />
Band-TM mit e<strong>in</strong>er Zeitkomplexität O(t(n) 2 ) simuliert werden.<br />
Beweis. Wir führen den Beweis für k = 2 durch, der allgeme<strong>in</strong>e Fall läßt sich ganz<br />
analog durchführen. Wir gehen von der Simulation, die <strong>in</strong> Kapitel 3 (siehe 3.2.2)<br />
beschrieben wurde, aus. Jeder Berechnungsschritt der Simulation hat drei Unterabschnitte.<br />
Abschnitt 1 (der Anfang) dauert e<strong>in</strong>en Schritt, Abschnitt 2 (Kopfbewegung<br />
nach rechts oder l<strong>in</strong>ks) benötigt höchstens O(t(n)) Schritte, denn der Kopf<br />
wird unter das nächste Symbol ⇑ bewegt und <strong>in</strong> der Zeit t(n) kann die k-Band-<br />
TM auf jedem Band höchstens O(t(n)) neue Felder beschreiben. Im Abschnitt 3<br />
wird die Berechnung von Kopf i simuliert (<strong>in</strong> konstanter Zeit für i = 1, 2) und der<br />
Kopf wird zwischen die beiden Symbole ⇑ (<strong>in</strong> O(t(n)) Schritten bewegt. Jeder Simulationsdurchgang<br />
dauert also höchstens O(t(n)) Schritte. Da wir höchstens t(n)<br />
Durchgänge benötigen, hat die 1-Band-TM die Zeitkomplexität O(t(n) 2 ).<br />
Korollar 1. Jede Sprache, die von e<strong>in</strong>er k-Band-TM mit polynomialer Zeitkomplexität<br />
akzeptiert wird, gehört zur Klasse P.<br />
Beweis. Falls t(n) e<strong>in</strong> Polynom ist, ist auch t(n) 2 e<strong>in</strong> Polynom.<br />
Bemerkung 1. Mit anderen Worten würde die Klasse P die gleiche bleiben, falls<br />
wir bei der Def<strong>in</strong>ition von P anstelle der TM die k-Band-TM benutzt hätten. Das<br />
gilt auch für die Klasse FP.<br />
6.4.4 RAM<br />
In Kapitel 4 haben wir RAM als e<strong>in</strong> realistischeres Berechnungsmodell als TM e<strong>in</strong>geführt.<br />
Dann haben wir bewiesen, dass die Modelle RAM und TM die gleiche Leistung<br />
haben. Das gilt auch für die entsprechenden Klassen FP der <strong>in</strong> polynomialer<br />
Zeit berechenbaren Funktionen. Zuerst müssen wir aber erklären, was Zeitkomplexität<br />
für RAMs bedeutet. Es gibt zwei Varianten:
6.4. ROBUSTHEIT DER KLASSE P 149<br />
Uniforme Zeitkomplexität. Hierbei gilt analog zu TM, dass jede Durchführung<br />
e<strong>in</strong>es Befehls e<strong>in</strong>em Schritt entspricht. Trotz der Analogie zu TM ist diese Variante<br />
nicht realistisch genug: e<strong>in</strong> Feld der RAM kann nämlich e<strong>in</strong>e beliebig große<br />
Zahl enthalten. Wir können z.B. die ganze E<strong>in</strong>gabe s1 . . .sn als e<strong>in</strong>e (sehr große)<br />
Zahl i codieren und i <strong>in</strong> e<strong>in</strong>em Feld speichern – dann hat die E<strong>in</strong>gabe e<strong>in</strong>fach die<br />
Größe 1. Deshalb hat uniforme Zeitkomplexität nur ger<strong>in</strong>gere theoretische Bedeutung<br />
(obwohl sie manchmal benutzt wird mit der Voraussetzung, dass die Codierung<br />
” vernünftig“ durchgeführt wurde).<br />
Logarithmische Zeitkomplexität zählt die Anzahl aller Ziffern, die die Operanden<br />
des Befehls berechnen. Also, falls <strong>in</strong> e<strong>in</strong>em Feld e<strong>in</strong>e Zahl n steht, hat n die<br />
Größe<br />
dig(n) = kle<strong>in</strong>ste ganze Zahl größer oder gleich log n<br />
(dig(n) ist die Zahl aller Ziffern von n.)<br />
Jeder Befehl zählt als k+1 Schritte, wobei k die Summe der ” Größen“ der Operanden<br />
ist. Z.B. der Befehl STORE i dauert<br />
Und STORE ∗i dauert<br />
1 + dig(i) + dig(n) Schritte, wobei 〈R0〉 = n.<br />
1 + dig(i) + dig(n) + dig(m) Schritte, wobei 〈R0〉 = n und 〈Ri〉 = m.<br />
Satz 2. Jede RAM mit logarithmischer Zeitkomplexität t(n) kann von e<strong>in</strong>er Mehr-<br />
Band TM mit der Zeitkomplexität O(t(n) 2 ) simuliert werden.<br />
Beweis. In Satz 1 <strong>in</strong> 4.2 haben wir gezeigt, wie man e<strong>in</strong>e RAM e<strong>in</strong>em Programm<br />
von p Zeilen von e<strong>in</strong>er 6-Band-TM simulieren kann. Wir müssen nur beweisen, dass<br />
diese TM die Zeitkomplexität O(t(n) 2 ) hat.<br />
Für jede E<strong>in</strong>gabe der Länge n dauert die Berechnung der RAM höchstens t(n)<br />
Schritte, und es werden höchstens t(n) Befehle durchgeführt. Daraus folgt, dass<br />
jedes Register e<strong>in</strong>e Zahl mit O(t(n)) Ziffern enthält. Wir zeigen, dass jeder Befehl<br />
<strong>in</strong> höchstens O(t(n)) Schritten mit der TM simuliert wird – daraus folgt, dass die<br />
ganze Berechnung nur O(t(n) 2 ) Schritte dauert. Es ist klar, dass auf jedem Band<br />
der TM höchstens O(t(n)) Felder beschriftet werden.<br />
Der Beweis, dass jeder Befehl <strong>in</strong> O(t(n)) Schritten simuliert wird, muß für alle<br />
möglichen Befehle e<strong>in</strong>zeln durchgeführt werden. Wir nehmen zur Illustration den<br />
Fall<br />
STORE ∗i<br />
(detailliert im Beweis von Satz 1 <strong>in</strong> 4.2 beschrieben); die Zeitkomplexität der anderen<br />
Befehle läßt sich analog schätzen. Zuerst sucht der Kopf auf Band 2 die<br />
Komb<strong>in</strong>ation<br />
$ $ i $ j $ $.<br />
Da auf Band 2 höchstens O(t(n)) Felder beschriftet worden s<strong>in</strong>d, dauert die Suche<br />
höchstens O(t(n)) Schritte. Dann schreibt die TM die Zahl j auf Band 5, dazu<br />
werden auch O(t(n)) Schritte benötigt, denn j hat O(t(n)) Ziffern. Da 3t(n) =<br />
O(t(n)), sehen wir, dass STORE ∗i <strong>in</strong> O(t(n)) Schritten simuliert wird.<br />
Korollar 2. Jede RAM mit polynomialer logarithmischer Zeitkomplexität berechnet<br />
e<strong>in</strong>e Funktion der Klasse FP.<br />
Beweis. In der Tat wird e<strong>in</strong>e RAM, falls sie die Zeitkomplexität t(n) hat, wobei<br />
t(n) e<strong>in</strong> Polynom ist, von e<strong>in</strong>er Mehr-Band-TM mit der Zeitkomplexität O(t(n) 2 )
150 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
simuliert und diese wird wiederum von e<strong>in</strong>er Tur<strong>in</strong>gmasch<strong>in</strong>e M mit der Zeitkomplexität<br />
O(n 2 + (t(n)) 4 ) simuliert. Dann berechnet M dieselbe Funktion wie die<br />
RAM, und da n 2 + t(n) 4 e<strong>in</strong> Polynom ist, folgt daraus, dass die Funktion zu FP<br />
gehört.<br />
Schlußbemerkung: Die Klasse P ist unabhängig von unserer Wahl des Berechnungsmodells:<br />
wir konnten, statt TM, e<strong>in</strong>e beliebige determ<strong>in</strong>istische Variante von TM<br />
nehmen, um dieselbe Klasse zu beschreiben. Auch RAM, obwohl es e<strong>in</strong> viel stärkeres<br />
Modell ist, ergibt für Zahlenfunktionen ke<strong>in</strong>e größere Klasse von Funktionen,<br />
die polynomiale Zeitkomplexität haben, als die Klasse FP.<br />
6.5 Geometrische Algorithmen und reelle RAM<br />
Viele Algorithmen, speziell <strong>in</strong> der Computer-Graphik, arbeiten mit geometrischen<br />
Objekten <strong>in</strong> der Ebene oder im Raum, und für ihre Komplexität wird e<strong>in</strong> modifiziertes<br />
Berechnungsmodell benutzt: RAM, die mit reellen Zahlen arbeitet.<br />
Reelle RAM ist genau wie RAM (siehe 4.1) def<strong>in</strong>iert, nur enthält jedes Register<br />
und jedes Feld des E<strong>in</strong>- und Ausgabebandes e<strong>in</strong>e reelle Zahl. Auch die Liste aller<br />
Operationen ist gleich (zum Beispiel LOAD i, LOAD ∗i, LOAD !i für e<strong>in</strong>e beliebige<br />
natürliche Zahl i), aber die Operanden von ADD s<strong>in</strong>d reelle Zahlen.<br />
Wie <strong>in</strong> Kapitel 4 gezeigt wurde, s<strong>in</strong>d weitere Operationen (für RAM oder reelle<br />
RAM) e<strong>in</strong>fach zu programmieren, zum Beispiel die Multiplikation von zwei Zahlen.<br />
Wir nehmen ferner an, dass Multiplikation und Division an e<strong>in</strong>er reellen RAM so<br />
programmiert werden, dass sie <strong>in</strong> O(1) Schritten durchgeführt werden.<br />
Für die uniforme Komplexität im Fall der reellen RAM def<strong>in</strong>ieren wir die Größe<br />
der reellen Zahl x = n10 −m als dig(n) + dig(m).<br />
Beispiel 1 (LINIE). E<strong>in</strong>gabe: Punkte a, b und r der Ebene, a = b<br />
Ausgabe: JA, falls r auf der L<strong>in</strong>ie L(a, b), von a und b bestimmt, liegt.<br />
Falls ( )x und ( )y die x- und y-Koord<strong>in</strong>aten bezeichnen, ist die Antwort genau dann<br />
JA, wenn<br />
rx − ax<br />
ry − ay<br />
= bx − ax<br />
by − ay<br />
(im Fall ry = ay und by = ay) oder ganz allgeme<strong>in</strong>: genau wenn<br />
(rx − ax)(by − ay) = (bx − ax)(ry − ay).<br />
Diese Entscheidung dauert nur O(1) Schritte auf e<strong>in</strong>er reellen RAM.<br />
Beispiel 2 (ÜBER DER LINIE). E<strong>in</strong>gabe: Punkte a, b und r <strong>in</strong> der Ebene mit<br />
ax = bx<br />
Ausgabe: JA, falls r über der L<strong>in</strong>ie L(a, b) liegt.<br />
<br />
<br />
•<br />
<br />
<br />
<br />
<br />
• <br />
a<br />
b<br />
r<br />
•<br />
r über L(a, b), mit k > 0<br />
•a <br />
<br />
<br />
<br />
• b<br />
r<br />
•<br />
r über L(a, b), mit k < 0
6.5. GEOMETRISCHE ALGORITHMEN UND REELLE RAM 151<br />
Falls die L<strong>in</strong>ie L(a, b) die Gleichung y = kx + q hat, liegt r genau dann über dieser<br />
L<strong>in</strong>ie, wenn<br />
ry > krx + q.<br />
Auch diese Entscheidung dauert O(1) Schritte.<br />
Beispiel 3 (DAS INNERE EINES POLYGONS). E<strong>in</strong>gabe: E<strong>in</strong> konvexes Polygon<br />
P und e<strong>in</strong> Punkt r.<br />
Ausgabe: Entscheidung, ob r im Inneren von P liegt.<br />
Bemerkung 1. E<strong>in</strong> Polygon P ist e<strong>in</strong>e Liste von Punkten, die als die Ecken von<br />
P bezeichnet werden. E<strong>in</strong> Polygon P = (v0, v1, . . .,vn−1) heißt simple, falls sich die<br />
Strecken L(vi, vi+1) (wobei i+1 modulo n berechnet wird) nur <strong>in</strong> den ” erwarteten“<br />
Ecken schneiden, d.h., der Durchschnitt von L(vi, vi+1) und L(vj, vj+1) mit i =<br />
j ist vi, falls j + 1 = i, oder vj, falls i + 1 = j, und ansonsten leer. Falls wir<br />
aus der Ebene die Strecken e<strong>in</strong>es simplen Polygons P entfernen, erhalten wir zwei<br />
zusammenhängende Teile, e<strong>in</strong>en gebundenen, der das Innere von P genannt wird,<br />
und e<strong>in</strong>en weiteren, der als das Äußere von P bezeichnet wird.<br />
E<strong>in</strong> simples Polygon P heißt konvex, falls se<strong>in</strong> Inneres jede Strecke enthält, deren<br />
Endpunkte es enthält. Beispiele:<br />
•<br />
<br />
<br />
<br />
•<br />
<br />
•<br />
<br />
<br />
<br />
<br />
<br />
• <br />
• • <br />
•<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
•<br />
•<br />
<br />
<br />
• <br />
•<br />
• <br />
•<br />
<br />
<br />
<br />
•<br />
<br />
•<br />
•<br />
<br />
• <br />
<br />
<br />
<br />
• <br />
Konvexes Polygon Nichtkonvexes Polygon Nichtsimples Polygon<br />
E<strong>in</strong> konvexes Polygon wird als e<strong>in</strong>e Liste v0, v1, . . . , vn−1 von Punkten angegeben,<br />
wobei wir annehmen, dass die Orientierung im Uhrzeigers<strong>in</strong>n erfolgt und ke<strong>in</strong>e zwei<br />
benachbarten Ecken auf der gleichen L<strong>in</strong>ie liegen:<br />
v0<br />
vn−1<br />
v1<br />
·<br />
·<br />
·<br />
• • <br />
•<br />
<br />
<br />
<br />
<br />
•<br />
• <br />
<br />
<br />
<br />
<br />
•<br />
•<br />
<br />
<br />
vn−2<br />
Um unseren Algorithmus zu vere<strong>in</strong>fachen, nehmen wir zusätzlich an, dass die x-<br />
Koord<strong>in</strong>aten der Punkte v0, . . . , vn−1 vone<strong>in</strong>ander verschieden s<strong>in</strong>d.<br />
Algorithmus für das INNERE EINES POLYGONS<br />
1. Wir wählen e<strong>in</strong>en Punkt p im Inneren von P.<br />
2. Die Halbl<strong>in</strong>ien von p zu den Ecken v0, . . .,vn−1 teilen die Ebene <strong>in</strong> n Sektoren.<br />
Wir bestimmen den Sektor, <strong>in</strong> dem sich der gegebene Punkt r bef<strong>in</strong>det, <strong>in</strong><br />
O(log n) Schritten wie folgt.<br />
v2
152 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
<br />
<br />
v0 <br />
<br />
v1 <br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
vi+1 <br />
<br />
<br />
<br />
<br />
<br />
vi <br />
<br />
<br />
<br />
•<br />
p<br />
•<br />
• •<br />
•<br />
• •<br />
a<br />
Wir suchen also i0 = 0, . . .,n−1, so dass r im Sektor (vi0, p, vi0+1) liegt (hier<br />
wird i0 + 1 modulo n berechnet, d.h., (n − 1) + 1 = 0). Wir wenden b<strong>in</strong>äres<br />
Suchen an: falls wir, für jedes i = 0, . . . , n − 1, <strong>in</strong> konstanter Schrittzahl O(1)<br />
entscheiden, ob i0 kle<strong>in</strong>er, gleich oder größer als i ist, berechnen wir i0 <strong>in</strong><br />
O(log n) Schritten. Falls r rechts von p liegt (rx ≥ px) brauchen wir nur die<br />
Ecken rechts von p betrachten. Sei also vi e<strong>in</strong>e solche Ecke:<br />
<br />
<br />
<br />
<br />
<br />
vi0 <br />
<br />
•<br />
r<br />
•<br />
<br />
<br />
<br />
•<br />
<br />
<br />
•<br />
vi0+1<br />
<br />
<br />
<br />
<br />
•<br />
<br />
vi <br />
<br />
<br />
<br />
Falls r über L(p, vi) liegt, gilt i0 > i. Falls r unter L(p, vi), aber über L(p, vi+1)<br />
liegt, gilt i0 = i . Und falls r unter L(p, vi+1) liegt, gilt i0 < i. Diese Entscheidung<br />
benötigt e<strong>in</strong>e konstante Zahl von Schritten. Analoges gilt für a l<strong>in</strong>ks von<br />
p (rx ≤ px).<br />
3. Falls der Sektor (vi, p, vi+1), <strong>in</strong> dem r liegt, berechnet worden ist, gilt: r liegt<br />
genau dann im Inneren des Polygons P, wenn es im Inneren des Dreiecks<br />
(vi, p, vi+1) liegt. Dies bestimmen wir <strong>in</strong> konstanter Zahl O(1) von Schritten.<br />
(Sei αx + βy + γ = 0 die Gleichung der L<strong>in</strong>ie L(vi, vi+1). Dann liegt r genau<br />
dann im Inneren des Dreiecks, wenn αx + βy + γ dieselben Zeichen für die<br />
Koord<strong>in</strong>aten von r und p hat.)<br />
Zeitkomplexität Der Algorithmus wird <strong>in</strong><br />
Schritten durchgeführt.<br />
O(1) + O(log n) + O(1) = O(log n)<br />
Beispiel 4 (KONVEXE HÜLLE). E<strong>in</strong>gabe: Punkte v1, . . . , vn <strong>in</strong> der Ebene mit<br />
paarweise verschiedenen x-Koord<strong>in</strong>aten.<br />
Ausgabe: Konvexe Hülle, d.h., das kle<strong>in</strong>ste Polygon, das alle Punkte enthält.<br />
Bemerkung 2. Jede Ecke der konvexen Hülle ist e<strong>in</strong>er der gegebenen Punkte.<br />
Das kann man sich leicht am Gummiband-Modell klarmachen: stellen wir uns e<strong>in</strong><br />
elastisches Gummiband vor, das so gestreckt wird, dass es alle gegebenen Punkte<br />
enthält, und anschließend losgelassen wird. Es formt dann die konvexe Hülle.
6.5. GEOMETRISCHE ALGORITHMEN UND REELLE RAM 153<br />
Die Ausgabe des folgenden Algorithmus ist also e<strong>in</strong>e Liste mit Punkten vi (für e<strong>in</strong>ige<br />
i = 1, . . .,n), die die konvexe Hülle, im Uhrzeigers<strong>in</strong>n orientiert, repräsentiert.<br />
Algorithmus für die KONVEXE HÜLLE<br />
1. Sortieren<br />
Wir sortieren die gegebenen Punkte nach ihren x-Koord<strong>in</strong>aten. Weiter nehmen<br />
wir also an, dass vi für alle i = 1, . . .,n l<strong>in</strong>ks von vi+1 steht.<br />
2. Berechnung der oberen Hülle<br />
Der Punkt v1 liegt l<strong>in</strong>ks von allen anderen Punkten und der Punkt vn liegt<br />
rechts – also s<strong>in</strong>d v1 und vn bestimmt <strong>in</strong> der konvexen Hülle enthalten. Die<br />
konvexe Hülle besteht aus (a) e<strong>in</strong>er Liste mit Punkten von v1 zu vn, die wir<br />
die obere Hülle nennen und (b) e<strong>in</strong>er Liste mit Punkten von vn zu v1, der<br />
unteren Hülle.<br />
In dem folgenden Beispiel<br />
v8<br />
<br />
<br />
•<br />
<br />
<br />
<br />
<br />
v4 <br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
v12<br />
<br />
<br />
<br />
•<br />
•<br />
<br />
obere Hülle<br />
v6<br />
<br />
<br />
<br />
<br />
<br />
•<br />
<br />
v10 <br />
<br />
<br />
v14<br />
v2 • <br />
<br />
v1 v5<br />
• •<br />
•<br />
<br />
<br />
•<br />
<br />
<br />
<br />
ist die obere Hülle<br />
und die untere Hülle ist<br />
<br />
v13<br />
v3<br />
<br />
•<br />
v7<br />
•<br />
untere Hülle<br />
v11 •<br />
•<br />
•<br />
v9<br />
v1, v4, v8, v12, v14<br />
v14, v13, v9, v3, v1.<br />
Die Berechnung der oberen Hülle verfolgt die folgende divide-and-conquer<br />
Strategie:<br />
2a Die Punkte v1, . . . , vn werden <strong>in</strong> zwei ungefähr gleich große Teile aufgeteilt.<br />
Nehmen wir an, dass n gerade ist, dann arbeiten wir mit der ” l<strong>in</strong>ken Hälfte“<br />
v1, . . .,v n/2 und der ” rechten Hälfte“ v n/2+1, . . . , vn. Für beide Hälften<br />
bestimmen wir rekursiv die obere Hülle.
154 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
v1 = p1<br />
pi0<br />
.<br />
p2<br />
..<br />
•<br />
<br />
<br />
<br />
.<br />
•<br />
<br />
<br />
<br />
<br />
..<br />
<br />
•<br />
<br />
<br />
•<br />
<br />
<br />
<br />
•<br />
<br />
<br />
<br />
<br />
<br />
ps<br />
<br />
<br />
<br />
<br />
<br />
<br />
• <br />
.<br />
•<br />
q2<br />
•<br />
<br />
<br />
•<br />
<br />
•<br />
q1<br />
..<br />
•<br />
<br />
<br />
<br />
.<br />
•<br />
<br />
<br />
<br />
<br />
..<br />
<br />
•<br />
<br />
<br />
•<br />
<br />
<br />
<br />
•<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
• <br />
<br />
•<br />
• <br />
<br />
•<br />
<br />
•<br />
obere Hülle für v1, . . . , v n/2<br />
Wir bezeichnen die obere Hülle von v1, . . . , v n/2 mit<br />
p1, p2, . . . , ps<br />
und die obere Hülle für v n/2+1, . . .,vn mit<br />
q1, q2, . . .,qt.<br />
qj0<br />
qt = vn<br />
obere Hülle für v n/2+1, . . . , vn<br />
2b Wir berechnen die obere Tangente der beiden gefundenen oberen Hüllen: das<br />
ist das Segment L(pi0, qj0), so dass alle Punkte p1, . . .,ps, q1, . . .,qt unter ihm<br />
liegen.<br />
2c Die obere Hülle der Punkte v1, . . .,vn ist<br />
3. Berechnung der unteren Hülle<br />
Dies geschieht analog zu (2).<br />
p1, p2, . . . , pi0, qj0, qj0+1, . . . , qt.<br />
4. Die konvexe Hülle ergibt sich aus der oberen Hülle gefolgt von der unteren<br />
Hülle.<br />
Zeitkomplexität: Schritt (1) hat die Zeitkomplexität O(n log n). Wir zeigen jetzt,<br />
dass auch Schritt (2) diese Zeitkomplexität hat; analoges gilt für Schritt (3). Da<br />
(4) <strong>in</strong> n Zeite<strong>in</strong>heiten geschrieben werden kann, ist damit bewiesen, dass der ganze<br />
Algorithmus die Zeitkomplexität<br />
O(n log n)<br />
hat. Wir zeigen später, dass dies optimal ist.<br />
Zeitkomplexität von Schritt (2): Sie hängt von der Zeitkomplexität von (2b) ab.<br />
Wir zeigen, dass die obere Tangente <strong>in</strong> O(log n) Schritten gefunden werden kann.<br />
Dann folgt, falls Schritt (2) <strong>in</strong> t(n) Zeite<strong>in</strong>heiten berechnet wird, dass die Schritte<br />
(2a) - (2c) die folgende Zeitkomplexität haben:<br />
(2a) 2t( n<br />
(2b)<br />
2 )<br />
O(log n)<br />
Zeite<strong>in</strong>heiten<br />
Zeite<strong>in</strong>heiten<br />
(2c) O(n) Zeite<strong>in</strong>heiten<br />
Es gibt also Konstanten n0 und K, so dass<br />
für alle n ≥ n0 gilt t(n) ≤ 2t( n<br />
) + K.<br />
2
6.5. GEOMETRISCHE ALGORITHMEN UND REELLE RAM 155<br />
Da die Gleichung t(n) = 2t( n<br />
2 ) + K · n die Lösung t(n) = K · n · log n hat, ist damit<br />
bewiesen, dass Schritt 2 die Zeitkomplexität O(n log n) hat.<br />
Wie wird die obere Tangente berechnet? Wir zeigen zuerst, wie man für jeden<br />
Punkt pi (i = 1, . . .,s) <strong>in</strong> der Zeit O(log t) die obere Tangente von pi zu den Punkten<br />
q1, . . . , qt berechnet, also wie man den Index j(i) f<strong>in</strong>det, so dass alle Punkte q1, . . . , qs<br />
unter der L<strong>in</strong>ie L(pi, q j(i)) liegen.<br />
•<br />
<br />
<br />
<br />
<br />
<br />
•<br />
<br />
<br />
<br />
•<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
•<br />
<br />
<br />
<br />
pi •<br />
<br />
<br />
<br />
<br />
<br />
•<br />
• <br />
•<br />
<br />
<br />
<br />
<br />
<br />
<br />
•<br />
<br />
<br />
q<br />
<br />
j(i)<br />
<br />
<br />
•<br />
<br />
•<br />
qj+1<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
•<br />
<br />
qj<br />
<br />
• qj−1<br />
• <br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
Das können wir <strong>in</strong> der Zeit O(log t) durch b<strong>in</strong>äres Suchen zwischen j = 1, . . .,t<br />
berechnen, falls wir für jedes j <strong>in</strong> konstanter Zeit O(1) bestimmen, ob j(i) größer,<br />
gleich oder kle<strong>in</strong>er als j ist. In der Tat:<br />
• falls qj−1 und qj+1 unter L(pi, qj) liegen gilt j = j(i),<br />
• falls qj−1 über L(pi, qj) liegt gilt j > j(i),<br />
• falls qj+1 über L(pi, qj) liegt gilt j < j(i).<br />
Analog kann man zeigen, dass <strong>in</strong> der Zeit O(log n) die globale obere Tangente<br />
L(pi0, qj0) berechnet werden kann. Hier müssen wir für jedes Paar (i, j) entscheiden,<br />
welcher der 9 Fälle (i = i0, j = j0 oder i = i0, j < j0 usw.) zutrifft. Jetzt bestimmen<br />
wir i0 durch b<strong>in</strong>äres Suchen zwischen i = 1, . . .,s: für jedes i benötigen wir die Zeit<br />
O(log t), um j(i) zu berechnen, und dann nur konstante Zeit, um zu entscheiden,<br />
ob i0 größer, gleich oder kle<strong>in</strong>er als i ist:<br />
pi0<br />
•<br />
<br />
•<br />
•<br />
pi+1<br />
<br />
<br />
pi<br />
•<br />
<br />
<br />
<br />
<br />
<br />
<br />
•<br />
<br />
pi−1<br />
<br />
<br />
•<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
•<br />
• <br />
<br />
<br />
<br />
<br />
<br />
• <br />
qj0<br />
•<br />
<br />
<br />
<br />
<br />
<br />
<br />
•<br />
<br />
<br />
<br />
•<br />
<br />
<br />
q <br />
j(i)<br />
<br />
<br />
•<br />
<br />
•<br />
<br />
<br />
<br />
•<br />
<br />
<br />
<br />
<br />
•<br />
• <br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
• falls pi−1 und pi+1 unter L(pi, q j(i)) liegen, gilt i = i0,<br />
• falls pi−1 über L(pi, q j(i)) liegt, gilt i < i0,<br />
• falls pi+1 über L(pi, q j(i)) liegt, gilt i > i0.
156 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
Daraus folgt, dass wir mit b<strong>in</strong>ärem Suchen i0 <strong>in</strong> der Zeit<br />
f<strong>in</strong>den können. Es gilt j0 = j(i0).<br />
O((log t)(log s)) = O(log(t + s)) = O(log n)<br />
Bemerkung 3. Der obige Algorithmus für die KONVEXE HÜLLE ist optimal. Wir<br />
können nämlich SORTIEREN auf KONVEXE HÜLLE <strong>in</strong> l<strong>in</strong>earer Zeit reduzieren<br />
– deshalb kann ke<strong>in</strong> Algorithmus schneller als Ω(n log n) se<strong>in</strong>.<br />
In der Tat formen wir mit gegebenen Zahlen x1, . . .,xn <strong>in</strong> l<strong>in</strong>earer Zeit die n Punkte<br />
v1, . . . , vn der Kurve y = x 2 mit den gegebenen x-Koord<strong>in</strong>aten:<br />
x3<br />
x1<br />
x4 x2<br />
y = x 2<br />
Da die Kurve y = x2 konvex ist, enthält die konvexe Hülle der Punkte v1, . . . , vn<br />
jeden dieser Punkte. Also antwortet jeder Algorithmus A, der das Problem KON-<br />
VEXE HÜLLE löst, auf die E<strong>in</strong>gabe v1, . . .,vn mit der Ausgabe vi1, vi2, . . .,v<strong>in</strong>, die<br />
e<strong>in</strong>e Orientierung der gegebenen Punkte im Uhrzeigers<strong>in</strong>n repräsentiert. Sei k der<br />
Index, für den vik der letzte Punkt (nach rechts) ist, dann gilt<br />
xik > xik+1 > · · · > x<strong>in</strong> > xi1 > xi2 > · · · > xik−1<br />
Wir können k <strong>in</strong> l<strong>in</strong>earer Zeit O(n) bestimmen und also <strong>in</strong> der Zeit n + t(n) + n<br />
sortieren, wobei t(n) die Zeit ist, die A benötigt, um die konvexe Hülle zu berechnen.<br />
Es gilt also t(n) = Ω(n log n).<br />
Beispiel 5 (PLANARE 3-FÄRBBARKEIT). E<strong>in</strong>gabe: E<strong>in</strong> planarer Graph (das<br />
heißt, e<strong>in</strong> Graph, dessen Knoten Punkte der Ebene s<strong>in</strong>d, und dessen Kanten L<strong>in</strong>ien<br />
s<strong>in</strong>d, die sich nur <strong>in</strong> den Knoten schneiden).<br />
Ausgabe: Entscheidung, ob der Graph mit drei Farben gefärbt werde kann.<br />
Bemerkung 4. 1. Wir wissen, dass für Graphen im allgeme<strong>in</strong>en 2-FÄRBBAR-<br />
KEIT ” leicht“ und 3-FÄRBBARKEIT ” sehr schwierig“ ist, wie genau später<br />
bewiesen wird. Es folgt, dass zum Beispiel 4-FÄRBBARKEIT auch ” sehr<br />
schwierig“ se<strong>in</strong> muß: e<strong>in</strong>e triviale Reduktion<br />
3-FÄRBBARKEIT ⊳ 4-FÄRBBARKEIT
6.5. GEOMETRISCHE ALGORITHMEN UND REELLE RAM 157<br />
erfolgt, wenn zu dem gegebenen Graphen G e<strong>in</strong> neuer Knoten a h<strong>in</strong>zugefügt<br />
und mit allen alten Knoten verbunden wird. Der neue Graph G ist genau dann<br />
<br />
<br />
<br />
<br />
<br />
•<br />
<br />
<br />
<br />
<br />
<br />
<br />
G<br />
a<br />
• <br />
• • <br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
•<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
•<br />
<br />
Graph G<br />
4-färbbar, wenn G 3-färbbar ist (denn a muß e<strong>in</strong>e andere Farbe haben als<br />
jeder Knoten x = a). Und die Konstruktion von G verlangt nur l<strong>in</strong>eare Zeit.<br />
2. Für planare Graphen ist 2-FÄRBBARKEIT ” leicht“ (denn das gilt für alle<br />
Graphen) und 4-FÄRBBARKEIT noch leichter: nach dem berühmten Satz ist<br />
jeder planare Graph 4-färbbar! Um so erstaunlicher ist die folgende Reduktion,<br />
die zeigt, dass PLANARE 3-FÄRBBARKEIT m<strong>in</strong>destens so schwierig ist wie<br />
allgeme<strong>in</strong>e 3-FÄRBBARKEIT:<br />
Reduktion: 3-FÄRBBARKEIT ⊳ PLANARE 3-FÄRBBARKEIT<br />
E<strong>in</strong>gabe: e<strong>in</strong> beliebiger Graph G.<br />
Den können wir immer <strong>in</strong> polynomialer Zeit <strong>in</strong> der Ebene repräsentieren (ohne zu<br />
verlangen, dass die Kanten sich nicht überschneiden). Genauer:<br />
1. für die n Knoten von G wählen wir (beliebig) n verschiedene Punkte der Ebene<br />
und<br />
2. die Kante (u, v) von G wird durch e<strong>in</strong>e L<strong>in</strong>ie von Punkt u nach v repräsentiert,<br />
so dass ke<strong>in</strong> Knoten außer u, v auf der L<strong>in</strong>ie liegt, und falls sich zwei L<strong>in</strong>ien<br />
außer e<strong>in</strong>em Knoten schneiden, liegt der Schnittpunkt auf ke<strong>in</strong>er weiteren<br />
L<strong>in</strong>ie des Graphen.<br />
E<strong>in</strong> Beispiel e<strong>in</strong>er solchen Repräsentation ist im Bild 6.1 gezeigt.<br />
Ausgabe: e<strong>in</strong> planarer Graph G ∗ , der genau dann 3-färbbar ist, wenn G 3-färbbar<br />
ist.<br />
Für die Konstruktion des Graphen G ∗ benutzen wir den Hilfsgraphen H <strong>in</strong> Abbildung<br />
6.2.<br />
Dieser Graph ist 3-färbbar, Abbildung 6.3 zeigt drei Beispiele von Färbungen mit<br />
den Farben 1, 2, 3.<br />
Lemma 1. Jede 3-Färbung von H färbt N und S mit denselben Farben, analog für<br />
O und W.<br />
Beweis. Nehmen wir an, dass N mit 1 und S mit 2 gefärbt wird. Wie wird der<br />
Mittelpunkt M gefärbt?<br />
Farbe 1: wählt man für die vertikalen Nachbarn von M die Farben 2 (oben) und 3<br />
(unten), dann bleibt für die horizontalen Nachbarn ke<strong>in</strong>e Farbe übrig (Bild (6.4a)).<br />
Färbt man dagegen beide vertikalen Nachbarn mit Farbe 3, so muß der rechte<br />
horizontale Nachbar die Farbe 2 erhalten, während der Knoten zwischen S und O<br />
die Farbe 1 erhalten muß. Dies erzw<strong>in</strong>gt die Farbe 2 für den Knoten O. Aber nun<br />
kann der Knoten zwischen N und O nicht mehr gefärbt werden (Bild (6.4b)).
158 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
(6.1a) Adjazenzmatrix<br />
(6.1b) Erste Repräsentation<br />
(6.1c) Zweite Repräsentation<br />
⎡<br />
0<br />
⎢<br />
⎢0<br />
⎢<br />
⎢0<br />
⎢<br />
⎢1<br />
⎣1<br />
0 0<br />
0 0<br />
0 0<br />
1 1<br />
1 1<br />
1 1<br />
1 1<br />
1 1<br />
0 0<br />
0 0<br />
⎤<br />
1<br />
1 ⎥<br />
1 ⎥<br />
0 ⎥<br />
0⎦<br />
1 1 1 0 0 0<br />
•<br />
<br />
<br />
•<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
• •<br />
<br />
•<br />
<br />
•<br />
<br />
<br />
<br />
<br />
• •<br />
<br />
<br />
<br />
•<br />
<br />
• •<br />
<br />
•<br />
<br />
<br />
Abbildung 6.1: Zwei Repräsentationen e<strong>in</strong>es (nichtplanaren) Graphen<br />
1<br />
•<br />
2<br />
• • 3 • 3<br />
• <br />
<br />
<br />
<br />
<br />
<br />
1 2 <br />
<br />
•<br />
1<br />
• •<br />
•<br />
<br />
2 <br />
<br />
1<br />
<br />
• •<br />
<br />
•<br />
<br />
3 3 <br />
2<br />
<br />
(6.3a) •<br />
1<br />
Farbe 2 entfällt aus demselben Grund.<br />
N<br />
•<br />
• • •<br />
• <br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
W <br />
O<br />
•<br />
M<br />
• •<br />
•<br />
<br />
<br />
<br />
<br />
<br />
• •<br />
<br />
•<br />
<br />
<br />
<br />
<br />
•<br />
<br />
S<br />
Abbildung 6.2: Graph H<br />
2<br />
•<br />
3<br />
• • 1 • 3<br />
• <br />
<br />
<br />
<br />
<br />
<br />
1 2 <br />
<br />
•<br />
3<br />
• •<br />
•<br />
<br />
2 <br />
<br />
1<br />
<br />
• •<br />
<br />
•<br />
<br />
3 1 <br />
3<br />
<br />
(6.3b) •<br />
2<br />
Abbildung 6.3: 3-Färbungen von H<br />
3<br />
•<br />
2<br />
• • 1 • 2<br />
• <br />
<br />
<br />
<br />
<br />
<br />
1 3 <br />
<br />
•<br />
2<br />
• •<br />
•<br />
<br />
3 <br />
<br />
1<br />
<br />
• •<br />
<br />
•<br />
<br />
2 1 <br />
2<br />
<br />
(6.3c) •<br />
3<br />
Farbe 3 - hier haben die vertikalen Nachbarn von M die Farben 2, 1 (Bild (6.4b),<br />
was für die horizontalen Nachbarn ke<strong>in</strong>e Farbe übrigläßt.<br />
Konstruktion von Graphen G ∗ Gegeben ist e<strong>in</strong> Graph G, repräsentiert durch Punkte<br />
und L<strong>in</strong>ien <strong>in</strong> der Ebene. Auf jeder Kante (u, v), die durch andere Kanten geschnitten<br />
wird (Bild 6.5a) füge neue Knoten h<strong>in</strong>zu, von u aus h<strong>in</strong>ter jedem Schnittpunkt,<br />
wie <strong>in</strong> Bild 6.5b angedeutet; der letzte erhält das Label O. Für die L<strong>in</strong>ien
6.5. GEOMETRISCHE ALGORITHMEN UND REELLE RAM 159<br />
1<br />
•<br />
• • 2 •<br />
• <br />
<br />
<br />
<br />
<br />
<br />
? <br />
<br />
•<br />
1<br />
• •<br />
•<br />
<br />
? <br />
<br />
• •<br />
<br />
•<br />
<br />
3 <br />
<br />
(6.4a) •<br />
2<br />
1<br />
•<br />
• • 3 • ?<br />
• <br />
<br />
<br />
<br />
<br />
<br />
<br />
•<br />
1<br />
• •<br />
•<br />
<br />
2 <br />
<br />
3<br />
<br />
• •<br />
<br />
•<br />
<br />
3 <br />
1<br />
<br />
(6.4b) •<br />
2<br />
Abbildung 6.4: Färbungsversuche des Graphen H<br />
1<br />
•<br />
• • 2 •<br />
• <br />
<br />
<br />
<br />
<br />
<br />
? <br />
<br />
•<br />
3<br />
• •<br />
•<br />
<br />
? <br />
<br />
• •<br />
<br />
•<br />
<br />
1 <br />
<br />
(6.4c) •<br />
2<br />
von u ′ nach v ′ , die (u, v) schneiden, wird jeweils e<strong>in</strong> Knoten mit dem Label S h<strong>in</strong>zugefügt,<br />
von u ′ aus h<strong>in</strong>ter dem Schnitt mit (u, v).<br />
(6.5a)<br />
(6.5b)<br />
•<br />
u<br />
•<br />
u<br />
u<br />
•<br />
′<br />
• S<br />
• v ′<br />
O<br />
•<br />
u<br />
•<br />
′<br />
• S<br />
• v ′<br />
O<br />
•<br />
u<br />
•<br />
′<br />
• S<br />
• v ′<br />
•<br />
<br />
<br />
<br />
•<br />
<br />
u = W O • = W<br />
<br />
<br />
•<br />
<br />
•<br />
<br />
<br />
<br />
<br />
<br />
O • = W<br />
<br />
<br />
•<br />
<br />
•<br />
<br />
<br />
<br />
<br />
<br />
O •<br />
<br />
<br />
•<br />
<br />
(6.5c)<br />
O<br />
•<br />
Abbildung 6.5: Konstruktion von G ∗<br />
Daraufh<strong>in</strong> werden die Überschneidungen durch e<strong>in</strong>e Kette von Hilfsgraphen H,<br />
verbunden an den Knoten O bzw. W, ersetzt, wie <strong>in</strong> Bild 6.5c angedeutet. Konkretes<br />
Beispiel: für den Graphen <strong>in</strong> 6.1c) haben wir erst den folgenden Graphen<br />
• v<br />
• v<br />
• v
160 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
und dann den planaren Graphen G ∗<br />
Eigenschaften von G ∗<br />
• •<br />
<br />
•<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
•<br />
u<br />
<br />
•<br />
•<br />
v<br />
•<br />
N•W<br />
•<br />
S<br />
• •<br />
•<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
•<br />
u = O<br />
•<br />
v<br />
• •<br />
<br />
• N<br />
•<br />
•<br />
• <br />
<br />
<br />
• •<br />
•<br />
W<br />
<br />
• <br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
•<br />
<br />
<br />
<br />
<br />
<br />
<br />
•<br />
<br />
<br />
<br />
<br />
S<br />
•<br />
<br />
<br />
<br />
<br />
<br />
<br />
1. G ∗ ist planar. In der Tat, alle Schnittpunkte von L<strong>in</strong>ien wurden durch Kopien<br />
von H überbrückt und es entstehen ke<strong>in</strong>e neuen.<br />
2. Falls G ∗ 3-färbbar ist, ist auch G 3-färbbar. Man benutzt dieselben Farben<br />
der Knoten wie <strong>in</strong> G ∗ . Falls e<strong>in</strong>e L<strong>in</strong>ie (u, v) von G ke<strong>in</strong>en Schnittpunkt <strong>in</strong><br />
G aufweist, dann ist (u, v) auch e<strong>in</strong>e L<strong>in</strong>ie von G ∗ und deswegen haben u, v<br />
verschiedene Farben. Andernfalls schneidet (u, v) andere L<strong>in</strong>ien, was wie <strong>in</strong><br />
Bild 6.5 durch H elim<strong>in</strong>iert wird. Dann hat u(= W) dieselbe Farbe wie jeder<br />
O-Knoten von 6.5b, siehe Lemma oben. Da v und der benachbarte O-Knoten<br />
von G ∗ verschiedene Farben haben, s<strong>in</strong>d auch die Farben von u und v verschieden.<br />
Ganz analog verfährt man mit L<strong>in</strong>ien (u ′ , v ′ ), die (u, v) schneiden:<br />
u ′ hat dieselbe Farbe wie S, die sich von der Farbe von v ′ unterscheiden muß<br />
(dies gilt auch, wenn e<strong>in</strong>e entlang der Knoten N und S verbundene Kette von<br />
Kopien von H entlang von (u ′ , v ′ ) auftritt.<br />
3. Falls G 3-färbbar ist, ist auch G ∗ 3-färbbar. Wir färben <strong>in</strong> G ∗ erst die ” alten“<br />
Knoten von G mit den Farben 1, 2, 3. Danach werden für e<strong>in</strong>e G-Kante (u, v)<br />
<strong>in</strong> 6.5b alle O-Knoten mit denselben Farben wie u gefärbt. Als letztes färben<br />
wir die Knoten des angeklebten Graphen H wie folgt.<br />
Die Farbe von 0 und W ist schon gegeben, zum Beispiel Farbe 1. Die anderen<br />
Farben hängen von der Färbung des Anfangsknotens u ′ = N der L<strong>in</strong>ie (u ′ , v ′ )<br />
ab, deren Überbrückung H präsentiert (Bild 6.6).
6.6. KOMPLEXITÄTSKLASSE N P 161<br />
•<br />
u <br />
•<br />
<br />
<br />
1 •<br />
<br />
•<br />
1 <br />
•<br />
<br />
<br />
<br />
•<br />
<br />
•<br />
1 <br />
•<br />
<br />
<br />
<br />
•<br />
<br />
•<br />
1 •<br />
1 • u′<br />
1<br />
3 •<br />
′ v<br />
(6.6a)<br />
• v<br />
•<br />
u <br />
•<br />
<br />
<br />
1 •<br />
<br />
•<br />
1 <br />
•<br />
<br />
<br />
<br />
•<br />
<br />
•<br />
1 <br />
•<br />
<br />
<br />
•<br />
<br />
•<br />
1 •<br />
2 • u′<br />
2<br />
3 •<br />
′ v<br />
(6.6b)<br />
Abbildung 6.6: Färbung e<strong>in</strong>er Kopie des Graphen H<br />
(a) Falls u ′ Farbe 1 hat (siehe 6.6a), benutzen wir die Färbung von Bild 6.3a.<br />
(b) Falls u ′ die Farbe 2 oder 3 hat, (siehe 6.6b), benutzen wir die Färbung<br />
von Bild 6.3b bzw. 6.3c.<br />
4. Die Konstruktion von G ∗ aus G dauert O(k 2 ) Schritte, wobei k die Zahl<br />
aller Kanten von G ist (falls G schon <strong>in</strong> der Ebene repräsentiert wird, was<br />
auch <strong>in</strong> polynomialer Zeit durchgeführt wird). In der Tat müssen wir für<br />
jede Kante höchstens k Schneidungen überbrücken, und das dauert (da e<strong>in</strong>e<br />
Überbrückung <strong>in</strong> konstanter Zeit O(1) durchgeführt wird) O(k) Schritte pro<br />
Kante.<br />
6.6 Komplexitätsklasse N P<br />
Probleme, die grundsätzlich schwieriger zu lösen s<strong>in</strong>d als die der Klasse P, die sich<br />
aber trotzdem <strong>in</strong> polynomialer Zeit von e<strong>in</strong>er nichtdeterm<strong>in</strong>istischen TM lösen lassen,<br />
formen die Komplexitätsklasse N P. Intuitiv kann man N P wie folgt erklären:<br />
falls e<strong>in</strong> Entscheidungsproblem die Eigenschaft hat, dass man <strong>in</strong> polynomialer Zeit<br />
überprüfen kann, ob e<strong>in</strong>e ” angebotene“ Lösung wirklich die Aufgabe löst, gehört<br />
das Problem zu N P. Bevor wir N P formal def<strong>in</strong>ieren, zeigen wir diese <strong>in</strong>tuitive<br />
Erklärung an e<strong>in</strong>em Beispiel.<br />
Beispiel 1 (ZERLEGBARKEIT). Wir sollen entscheiden, ob für e<strong>in</strong>e Zahl n (E<strong>in</strong>gabe)<br />
e<strong>in</strong>e Zerlegung <strong>in</strong> e<strong>in</strong> Produkt n = pq zweier kle<strong>in</strong>erer Zahlen existiert. Obwohl<br />
das e<strong>in</strong> Problem ist, dass <strong>in</strong> der Mathematik seit tausenden von Jahren behandelt<br />
wurde, gibt es ke<strong>in</strong>en effizienten Algorithmus dafür. Wir wissen also nicht, ob ZER-<br />
LEGBARKEIT zu P gehört. Aber dieses Problem gehört offensichtlich zu N P:<br />
falls uns jemand Zahlen p und q nennt, können wir effizient überprüfen, ob sie e<strong>in</strong>e<br />
Lösung bilden, d.h., ob das Produkt pq der E<strong>in</strong>gabe gleicht.<br />
Das letzte kann mit e<strong>in</strong>er nichtdeterm<strong>in</strong>istischen TM wie folgt gelöst werden: Band 1<br />
ist das E<strong>in</strong>gabeband. Auf Band 2 wird nichtdeterm<strong>in</strong>istisch e<strong>in</strong>e Zahl p geschrieben<br />
und auf Band 3 nichtdeterm<strong>in</strong>istisch e<strong>in</strong>e Zahl q. Die NTM multipliziert p mit q und<br />
vergleicht pq mit Band 1: falls pq auf Band 1 steht, hält die NTM und akzeptiert,<br />
falls nicht, hält sie und akzeptiert nicht. Für jede Zahl n, die zerlegbar ist, gibt es<br />
e<strong>in</strong>e Berechnung, die n <strong>in</strong> l<strong>in</strong>earer Zeit akzeptiert.<br />
Def<strong>in</strong>ition. Wir sagen, dass e<strong>in</strong>e nichtdeterm<strong>in</strong>istische Tur<strong>in</strong>gmasch<strong>in</strong>e M die<br />
Zeitkomplexität p(n) hat, falls es für jede E<strong>in</strong>gabe der Länge n, die M akzeptiert,<br />
e<strong>in</strong>e akzeptierende Berechnung gibt, die höchstens p(n) Berechnungsschritte<br />
benötigt.<br />
Mit N P bezeichnen wir die Klasse aller Sprachen (oder Entscheidungsprobleme), die<br />
von e<strong>in</strong>er NTM mit polynomialer Zeitkomplexität akzeptiert (oder gelöst) werden<br />
können. Genauer: e<strong>in</strong>e Sprache L gehört zu N P, falls es e<strong>in</strong>e NTM und e<strong>in</strong> Polynom<br />
p(n) gibt, so dass die NTM die Zeitkomplexität p(n) hat und L akzeptiert.<br />
• v
162 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
Beispiel 2. 1. Jedes Problem der Klasse P gehört zu N P.<br />
2. ZERLEGBARKEIT ist e<strong>in</strong> Problem der Klasse N P; es ist nicht bekannt, ob<br />
es zur Klasse P gehört.<br />
3. ERFÜLLBARKEIT (siehe Beispiel 5 <strong>in</strong> 6.2) ist e<strong>in</strong> Problem der Klasse N P:<br />
für jede Boolesche Formel f(x1, . . . , xn) und jede ” potentielle Lösung“, d.h.<br />
jede (beliebig berechnete) Belegung aller Variablen x1, . . . , xn, können wir<br />
effizient entscheiden, ob der Wert von f true oder false ist. Es ist e<strong>in</strong>fach,<br />
e<strong>in</strong>e NTM mit polynomialer Zeitkomplexität zu konstruieren, die das Problem<br />
ERFÜLLBARKEIT löst: Band 1 ist e<strong>in</strong> E<strong>in</strong>gabeband, auf dem e<strong>in</strong> Code der<br />
Formel f(x1, . . .,xn) gespeichert wird. Auf Band 2 erzeugt die NTM nichtdeterm<strong>in</strong>istisch<br />
n Werte 0 oder 1. Dann berechnet sie den Wert von f mit diesen<br />
n Variablenwerten (mit 1 = true und 0 = false).<br />
4. TRAVELING SALESMAN PROBLEM (TSP) ist e<strong>in</strong> Problem der Klasse<br />
N P mit großer praktischer Relevanz. Die E<strong>in</strong>gabe ist e<strong>in</strong>e Liste S1, . . . , Sn<br />
von Städten und e<strong>in</strong>e Matrix von Zahlen<br />
d(i, j) ≥ 0 für i, j = 1, . . .,n<br />
die die Distanz von Si zu Sj repräsentieren (oder die Kosten der Reise von<br />
Si nach Sj). Die Aufgabe ist, zu entscheiden, ob alle Städte besucht werden<br />
können, ohne dass die gesamten Kosten e<strong>in</strong>e gegebene Zahl k überschreiten.<br />
Das heißt: die E<strong>in</strong>gabe besteht aus Zahlen k und dij für i, j = 1, . . .,n. Die<br />
Lösung ist e<strong>in</strong>e Rundfahrt, d.h. e<strong>in</strong>e Permutation (i1, i2, . . . , <strong>in</strong>) der Zahlen<br />
1, . . .,n, so dass<br />
(∗) d(i1, i2) + d(i2, i3) + · · · + d(<strong>in</strong>−1, <strong>in</strong>) + d(<strong>in</strong>, i1) ≤ k.<br />
Auch für dieses Problem gibt es ke<strong>in</strong>en effizienten Algorithmus. Aber das<br />
Problem gehört sicher zu N P: falls e<strong>in</strong>e Permutation gegeben wird, benötigt<br />
die Überprüfung der Ungleichung (∗) nur l<strong>in</strong>eare Zeit.<br />
Satz 1. Jede NTM mit der Zeitkomplexität p(n) kann von e<strong>in</strong>er TM mit der Zeitkomplexität<br />
O(K p(n) ) wobei K e<strong>in</strong>e Konstante ist<br />
simuliert werden.<br />
Beweis. Im Beweis des Satzes 1 <strong>in</strong> 3.4 haben wir e<strong>in</strong>e Simulation e<strong>in</strong>er nichtdeterm<strong>in</strong>istischen<br />
Tur<strong>in</strong>gmasch<strong>in</strong>e M durch e<strong>in</strong>e determ<strong>in</strong>istische 3-Band Tur<strong>in</strong>gmasch<strong>in</strong>e<br />
M gezeigt. Wir beweisen, dass M die Zeitkomplexität O(r 2p(n) ) für e<strong>in</strong>e Konstante<br />
r hat, falls M die Zeitkomplexität p(n) hat. Danach simulieren wir M mit e<strong>in</strong>er<br />
(1-Band) TM, deren Komplexität O(n 2 + (r 2p(n) ) 2 ) ist, siehe Satz 1 <strong>in</strong> 6.4. Da<br />
(r 2p(n) ) 2 = r 4p(n) , setzen wir K = r 4 : die Funktion n 2 + r 4p(n) gehört zu O(K p(n) ).<br />
Sei, wie im Beweis des Satzes 1 <strong>in</strong> 3.4, e<strong>in</strong>e Numerierung der Übergänge (q, s) →<br />
(qi, si) für i = 1, . . .,r gegeben. Für jede E<strong>in</strong>gabe der Länge n brauchen wir nur die<br />
ersten p(n) Berechnungsschritte der Masch<strong>in</strong>e M zu simulieren. Die Masch<strong>in</strong>e M<br />
erzeugt systematisch alle Listen aus Zahlen<br />
i1i2 . . . ik<br />
auf Band 2 – die Anzahl dieser Listen ist<br />
mit k ≤ p(n) (und 1 ≤ is ≤ r für s = 1, . . .,k)<br />
r + r 2 + r 3 + · · · + r p(n) ∈ O(r p(n) ).<br />
Für jede Liste wird M (<strong>in</strong> k ≤ p(n) Schritten) simuliert, also dauert die ganze Simulation<br />
e<strong>in</strong>er E<strong>in</strong>gabe höchstens O(p(n)r p(n) ) Schritte. Es gilt p(n)r p(n) ∈ O(r 2p(n) ).
6.7. N P-VOLLSTÄNDIGKEIT 163<br />
Korollar 1. Jedes Problem der Klasse N P kann von e<strong>in</strong>em Algorithmus mit exponentieller<br />
Zeitkomplexität<br />
gelöst werden.<br />
K p(n)<br />
6.7 N P-Vollständigkeit<br />
K – Konstante, p(n) – Polynom<br />
Wir haben oben erwähnt, dass ke<strong>in</strong> effizienter Algorithmus für Probleme wie ZER-<br />
LEGBARKEIT oder TSP bekannt ist. Mit anderen Worten ist es nicht bekannt, ob<br />
diese Probleme <strong>in</strong> der Klasse P liegen. Eigentlich ist auch die folgende allgeme<strong>in</strong>e<br />
Frage bisher unbeantwortet:<br />
Offenes Problem: Gilt P = N P?<br />
Trotz <strong>in</strong>tensiver Bemühungen vieler Wissenschaftler und trotz vieler Nebenergebnisse<br />
zu diesem Thema ist die Antwort noch nicht bekannt. Es gibt aber Probleme,<br />
die <strong>in</strong> der Klasse N P e<strong>in</strong>e besondere Stellung haben: wenn man für e<strong>in</strong>es dieser<br />
Probleme feststellen würde, dass es zu P gehöre, so würde jedes Problem der Klasse<br />
N P zu P gehören – also wäre die Antwort auf die obige Frage positiv. Solche<br />
Probleme (zu denen z.B. TSP gehört) heißen N P-vollständig. Er<strong>in</strong>nern wir uns an<br />
den Begriff der Reduktion <strong>in</strong> polynomialer Zeit (6.3):<br />
Def<strong>in</strong>ition. E<strong>in</strong>e Sprache L heißt N P-hart, falls es für jede Sprache L ′ der Klasse<br />
NP e<strong>in</strong>e Reduktion auf L <strong>in</strong> polynomialer Zeit gibt, oder kürzer:<br />
L ′ ∈ N P =⇒ L ′ ⊳ L.<br />
E<strong>in</strong>e Sprache, die N P-hart ist und zu N P gehört, heißt N P-vollständig.<br />
Satz 1. Falls e<strong>in</strong>e N P-harte Sprache <strong>in</strong> P liegt, gilt P = N P.<br />
Beweis. Sei L e<strong>in</strong>e N P-harte Sprache <strong>in</strong> P. Für jede Sprache L ′ <strong>in</strong> N P gibt es<br />
e<strong>in</strong>e Reduktion auf L <strong>in</strong> polynomialer Zeit. Aus L ∈ P folgt also L ′ ∈ P (Satz 1 <strong>in</strong><br />
6.3). Damit ist P = N P bewiesen.<br />
Satz 2 (Cookscher Satz.). ERFÜLLBARKEIT ist N P-vollständig.<br />
Beweis. 1. ERFÜLLBARKEIT ist e<strong>in</strong> Problem der Klasse NP: siehe Beispiel 2<br />
Nr. 3 <strong>in</strong> Abschnitt 6.6.<br />
2. Für jede Sprache L <strong>in</strong> N P zeigen wir, dass L auf ERFÜLLBARKEIT <strong>in</strong><br />
polynomialer Zeit reduzierbar ist. Wir haben e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e M mit<br />
polynomialer Zeitkomplexität p(n), die L akzeptiert. Wir können für M, ohne<br />
Beschränkung der Allgeme<strong>in</strong>heit, das folgende annehmen:<br />
(a) Die Zustände von M s<strong>in</strong>d wie folgt durchnumeriert:<br />
q0 (<strong>in</strong>itial), q1 (f<strong>in</strong>al), q2, . . . , qm.<br />
Der f<strong>in</strong>ale Zustand q1 ist e<strong>in</strong> Haltezustand.<br />
(b) Die Bandsymbole von M s<strong>in</strong>d s1, . . .,sk und s0<br />
def<br />
= #.<br />
(c) Die Zellen des Bandes s<strong>in</strong>d mit ganzen Zahlen durchnumeriert. Die E<strong>in</strong>gabe<br />
steht <strong>in</strong> den Zellen 1, . . .,n.
164 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
Zelle Nr.:<br />
−2 −1 0 1 2 n n+1 n+2 n+3<br />
. . . # # # si1<br />
si2 . . . s<strong>in</strong> # # # . . .<br />
⇑<br />
q0<br />
Initialkonfiguration<br />
(d) Die Übergänge s<strong>in</strong>d mit y = 1, 2, . . ., d durchnumeriert und wie folgt <strong>in</strong><br />
e<strong>in</strong>e Tabelle geschrieben:<br />
y Übergang Nr. y<br />
1 (q i(1), s j(1)) → (q i ′ (1), s j ′ (1))<br />
2 (q i(2), s j(2)) → (q i ′ (2), s j ′ (2))<br />
.<br />
.<br />
d (q i(d), s j(d)) → (q i ′ (d), s j ′ (d))<br />
Hier ist s j(y) e<strong>in</strong> Bandsymbol und s j ′ (y) ist entweder L, R oder e<strong>in</strong> Bandsymbol.<br />
Bemerkung 1. In der Zeit p(n) kann die TM höchstens p(n) Felder beschriften,<br />
also genügt es, die Bandzellen Nr. −p(n), −p(n) + 1, . . .,0, 1, . . ., p(n) zu<br />
betrachten.<br />
Die Reduktion der Sprache L auf ERFÜLLBARKEIT bedeutet, dass für jedes<br />
Wort w über Σ e<strong>in</strong>e Boolesche Formel φw konstruiert wird, so dass<br />
φw ist erfüllbar ⇐⇒ w ∈ L<br />
und dass die Konstruktion <strong>in</strong> polynomialer Zeit durchgeführt wird. Die Aussage<br />
w ∈ L bedeutet, dass es e<strong>in</strong>e Berechnung des Wortes w durch M gibt,<br />
die im Zustand q1 hält. E<strong>in</strong>e solche Berechnung können wir durch e<strong>in</strong>e Formel<br />
φw e<strong>in</strong>deutig beschreiben, wenn wir die folgenden Booleschen Variablen<br />
e<strong>in</strong>führen:<br />
NAME BEDEUTUNG: ist true belegt genau dann, wenn UMFANG<br />
q t i Zur Zeit t hat M den Zustand qi. t = 0, . . .,p(n)<br />
i = 0, . . .,m<br />
k t r Zur Zeit t steht der Kopf im Feld r t = 0, . . .,p(n)<br />
r = −p(n), . . .,p(n)<br />
s t j,r Zur Zeit t steht im Feld r das Symbol sj t = 0, . . .,p(n)<br />
j = 0, . . .,k<br />
r = −p(n), . . .,p(n)<br />
u t y Zur Zeit t wird der Übergang Nr. y durchgeführt t = 0, . . .,p(n) − 1<br />
y = 1, . . .,d<br />
Mit Hilfe dieser Variablen können wir alle Bed<strong>in</strong>gungen e<strong>in</strong>er akzeptierenden<br />
Berechnung von w formal darstellen:<br />
(a) Initialisierung. Zur Zeit t = 0 ist die folgende Belegung true:<br />
q0 0 (Initialzustand q0)<br />
k0 1 (<strong>in</strong>itiale Kopfposition 1)<br />
s0 i1,1 , . . .,s0 <strong>in</strong>,n (die gegebene E<strong>in</strong>gabe w = si1 . . .s<strong>in</strong> <strong>in</strong> Feldern 1, . . .,n)<br />
s0 0,b<br />
für alle b = −p(n), . . .,p(n) außer b = 1, . . .,n<br />
(das Symbol s0 = # <strong>in</strong> allen Zellen des Bandes außer der E<strong>in</strong>gabe)
6.7. N P-VOLLSTÄNDIGKEIT 165<br />
Jede von diesen Variablen formt e<strong>in</strong>e Klausel von φw, also ist der Anfang<br />
von φw:<br />
(1) φw = q 0 0 ∧ k 0 1 ∧<br />
n<br />
b=1<br />
s 0 ib,b ∧<br />
p(n) <br />
b=−p(n)<br />
b=1,...,n<br />
s 0 0,b ∧ . . .<br />
(b) Akzeptanz von w. E<strong>in</strong>e weitere Klausel von φw gewährleistet, dass w<br />
zum Zeitpunkt t = 1, . . .,p(n) akzeptiert wird, d.h., der Zustand ist q1<br />
(f<strong>in</strong>aler Haltezustand). Das ist die Klausel<br />
(2) q 1 1 ∨ q 2 1 ∨ · · · ∨ q p(n)<br />
1<br />
(die genau dann true ist, wenn q t 1 für e<strong>in</strong>en Zeitpunkt t true ist).<br />
(c) Randbed<strong>in</strong>gungen. Wir müssen auch sicherstellen, dass zu jedem Zeitpunkt<br />
t die TM<br />
i. genau e<strong>in</strong>en Zustand hat,<br />
ii. <strong>in</strong> jedem Feld genau e<strong>in</strong> Symbol steht,<br />
iii. der Kopf genau e<strong>in</strong>e Position hat und<br />
iv. genau e<strong>in</strong> Übergang (falls es sich um ke<strong>in</strong>e Haltekonfiguration handelt)<br />
durchgeführt wird.<br />
Z.B. verlangt (i), dass φw für jeden Zeitpunkt t = 0, 1, . . ., p(n) die folgende<br />
Klausel hat:<br />
(3)<br />
m<br />
i=0<br />
q t i = qt 0 ∨ qt 1 ∨ · · · ∨ qt m<br />
(also: es gibt e<strong>in</strong>en Zustand zum Zeitpunkt t), sowie die Klauseln<br />
(4) q t i → ¬qt i ′ für alle i = i′<br />
(also: zwei Zustände qi und qi ′ können nicht gleichzeitig vorhanden se<strong>in</strong>).<br />
Analoges gilt für (ii)–(iv).<br />
(d) Übergänge. Nehmen wir an, dass die Zeile y der Übergangstabelle die<br />
Bewegung des Kopfes nach l<strong>in</strong>ks darstellt:<br />
ZEILE y: (q i(y), s j(y)) → (q i ′ (y), L)<br />
(Bewegung nach rechts oder Überschreibung des Bandsymbols werden<br />
analog behandelt). Dann müssen wir zu der Konjunktion von φw Klauseln<br />
h<strong>in</strong>zufügen, die gewährleisten, dass ut y die erwartete Auswirkung<br />
zum Zeitpunkt t hat:<br />
Falls der Kopf im Feld r steht, wird er als nächstes im Feld r − 1 stehen:<br />
(5) (u t y ∧ kt r ) → kt+1 r−1 für alle r = −p(n) + 1, . . . , p(n).<br />
Der Zustand zum Zeitpunkt t muß q i(y) se<strong>in</strong> und der zum Zeitpunkt t+1<br />
muß q i ′ (y) se<strong>in</strong>, also hat φw zwei Klauseln<br />
(6) u t y → q t i(y) und u t y → q t i ′ (y)<br />
Falls der Kopf im Feld r steht, muß das Symbol im Feld r gleich s j(y)<br />
se<strong>in</strong>:<br />
(7) (u t y ∧ k t r) → s t j(y),r für alle r = -p(n), . . . , p(n)
166 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
Alle Bandsymbole bleiben unverändert:<br />
(8)<br />
Es gilt:<br />
(u t y ∧ s t j,r) → s t+1<br />
j,r<br />
für alle j = 0, . . .,k<br />
und alle r = −p(n), . . . , p(n) − 1.<br />
Wenn alle Klauseln (5)–(8) zu φw h<strong>in</strong>zugefügt worden s<strong>in</strong>d, wird der<br />
Übergang Nr. y korrekt ausgeführt. Damit ist die Konstruktion von φw<br />
vollständig.<br />
φw ist erfüllbar ⇐⇒ M akzeptiert die E<strong>in</strong>gabe w.<br />
In der Tat ergibt jede akzeptierende Berechnung von w e<strong>in</strong>e Belegung der<br />
Variablen von φw für die alle Teile der Konjunktion true s<strong>in</strong>d, also w = true:<br />
wir setzen qt i = true, falls die Berechnung M zur Zeit t den Zustand qi<br />
hatte, analog mit kt r und stj,r ; wir setzen uty = true, falls der Übergang Nr.<br />
y im Schritt t durchgeführt wurde. Umgekehrt beschreibt jede Belegung der<br />
Variablen von φw, für die alle Teile der Konjunktion von φw true s<strong>in</strong>d, e<strong>in</strong>e<br />
akzeptierende Berechnung von w.<br />
Wie viel Zeit benötigen wir, um φw zu konstruieren?<br />
Der Teil (1) braucht O(p(n)) Symbole (also O(p(n)) Zeite<strong>in</strong>heiten), dasselbe<br />
gilt für den Teil (2). Es läßt sich leicht zeigen, dass die Randbed<strong>in</strong>gungen nur<br />
O(p(n) 2 ) Symbole benötigen. Der letzte Teil, der die d Übergänge repräsentiert,<br />
braucht<br />
O(p(n)) Symbole für (5)<br />
O(1) Symbole für (6)<br />
O(p(n)) Symbole für (7) und<br />
O(p(n)) Symbole für (8),<br />
und da d e<strong>in</strong>e Konstante ist, brauchen wir für den letzten Teil O(p(n)) Symbole.<br />
Also reichen <strong>in</strong>sgesamt<br />
O(p(n) 2 ) Symbole.<br />
Es folgt, dass die Konstruktion von φw höchstens O(p(n) 2 ) Schritte verlangt.<br />
Bemerkung 2. Die Idee, dass e<strong>in</strong>e Sprache L genau dann zu N P gehört, wenn<br />
angebotene Lösungen <strong>in</strong> polynomialer Zeit überprüft werden können, läßt sich sich<br />
durch den Begriff Zertifikat formalisieren. Z.B. ist für 3-FÄRBUNG e<strong>in</strong> Zertifikat<br />
e<strong>in</strong>es ungeordneten Graphen e<strong>in</strong>e Färbung (korrekt oder nicht) se<strong>in</strong>er Knoten mit<br />
drei Farben. Wir formen die Sprache Lcheck aller Wörter wz, wobei w e<strong>in</strong> Code<br />
e<strong>in</strong>es Graphen ist und z e<strong>in</strong> Code se<strong>in</strong>es Zertifikates, das korrekt ist. Diese Sprache<br />
gehört der Klasse P an, denn für jeden Graphen und jede Färbung ist die Korrektheit<br />
effizient überprüfbar. Wichtig ist hier, dass die angebotenen Lösungen nicht<br />
” komplizierter“ zu codieren s<strong>in</strong>d als die E<strong>in</strong>gaben selbst. Genauer: für die Wörter<br />
wz (w – E<strong>in</strong>gabe, z - Zertifikat) nehmen wir an, dass die Länge z des Wortes z<br />
durch p(w), wobei p(n) e<strong>in</strong> Polynom ist, begrenzt werden kann:<br />
Def<strong>in</strong>ition. Für e<strong>in</strong>e Sprache L ⊆ Σ ∗ heißt e<strong>in</strong>e Sprache Lcheck e<strong>in</strong>e Zertifikatensprache,<br />
falls<br />
1. Lcheck <strong>in</strong> P liegt und<br />
2. es gibt e<strong>in</strong> Polynom p(n), so dass für jedes Wort w über Σ der Länge n gilt:<br />
w ∈ L ⇐⇒ wz ∈ Lcheck für irgende<strong>in</strong> Wort z der Länge ≤ p(n).
6.7. N P-VOLLSTÄNDIGKEIT 167<br />
Satz 3. E<strong>in</strong>e Sprache gehört genau dann zur Klasse N P, wenn sie e<strong>in</strong>e Zertifikatensprache<br />
hat.<br />
Beweis. 1. Gegeben e<strong>in</strong>e Zertifikatensprache Lcheck ⊆ Γ ∗ für L ⊆ Σ ∗ *, wir<br />
beweisen, dass L ∈ N P.<br />
Sei M e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e mit polynomialer Zeitkomplexität q(n), die Lcheck<br />
akzeptiert. Dann haben wir die folgende nichtdeterm<strong>in</strong>istische Tur<strong>in</strong>gmasch<strong>in</strong>e<br />
M ∗ , die L akzeptiert:<br />
Band 1<br />
E<strong>in</strong>gabeband<br />
Band 2<br />
Erzeugung von z<br />
Band 3<br />
Simulation von M<br />
. . .<br />
w1 w2 wn<br />
z1 z2 . . . zk für k ≤ p(n)<br />
. . . . . .<br />
w1 w2 wn z1 z2 zk<br />
Auf Band 1 steht die Eigabe w der Länge n. Auf Band 2 wird nichtdeterm<strong>in</strong>istisch<br />
e<strong>in</strong> Wort z über der Länge k ≤ p(n) geschrieben. Dann werden<br />
w und danach z auf Band 3 kopiert, und die Masch<strong>in</strong>e M wird simuliert;<br />
falls M hält und akzeptiert, hält auch M ∗ und akzeptiert. Es folgt also,<br />
dass M ∗ genau die Wörter w akzeptiert, für die es e<strong>in</strong> Wort z der Länge<br />
≤ p(n) mit wz ∈ Lcheck gibt – also akzeptiert M ∗ die Sprache L. Die Erzeugung<br />
von z dauert 2k ∈ O(p(n)) Schritte und die Simulation von M dauert<br />
q(n+k) ∈ O(q(p(n))) Schritte, also hat M ∗ e<strong>in</strong>e polynomiale Zeitkomplexität.<br />
2. Für jede Sprache L ⊆ Σ ∗ der Klasse N P konstruieren wir e<strong>in</strong>e Zertifikatensprache.<br />
Wir haben e<strong>in</strong>e nichtdeterm<strong>in</strong>istische Tur<strong>in</strong>gmasch<strong>in</strong>e M mit polynomialer<br />
Zeitkomplexität p(n), die L akzeptiert. Für jedes Wort w ∈ L der<br />
Länge n gibt es e<strong>in</strong>e Boolesche Formel φw der Länge O(p 2 (n)), die die Berechnung<br />
von w vollständig beschreibt – siehe den obigen Beweis des Cookschen<br />
Satzes. Da φw e<strong>in</strong>e Formel <strong>in</strong> KNF ist, ist sie e<strong>in</strong> Wort aus den Symbolen<br />
∨, ∧, (, ), x0, x1, x10, . . . , xi (i ≤ p(n) 2 )<br />
wobei i b<strong>in</strong>är dargestellt wird, also e<strong>in</strong> Wort über<br />
Γ = {∨, ∧, (, ), x, 0, 1}.<br />
Das Wort w hat die Länge O(p 2 (n)). Genauer gibt es nur e<strong>in</strong>e Konstante<br />
K, so dass für jedes Wort w ∈ L der Länge n die Berechnung von w durch<br />
e<strong>in</strong>e Formel φw der Länge ≤ Kp 2 (n) repräsentiert wird. Nehmen wir der<br />
E<strong>in</strong>fachheit halber an, dass Γ ∩ Σ = ∅. Dann ist die folgende Sprache Lcheck<br />
über Σ ∪ Γ e<strong>in</strong>e Zertifikatensprache für L: Lcheck besteht aus allen Wörtern<br />
wφ, wobei w e<strong>in</strong> Wort über Σ (der Länge n) ist und φ e<strong>in</strong>e Boolesche Formel<br />
der Länge ≤ Kp 2 (n), die e<strong>in</strong>e akzeptierende Berechnung von w beschreibt,<br />
ist.<br />
(a) Lcheck gehört zu P.<br />
In der Tat, für jedes Wort u der Länge m über Σ ∪ Γ überprüfen wir,<br />
i. ob u = wφ für w ∈ Σ ∗ und φ ∈ Γ ∗ , wobei w die Länge n und φ die<br />
Länge ≤ Kp 2 (n) hat und
168 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
ii. falls ja, ob φ = φw die Formel aus dem Beweis des Cookschen Satzes<br />
ist.<br />
Das kann <strong>in</strong> l<strong>in</strong>earer Zeit O(m) überprüft werden.<br />
(b) w ∈ L ⇐⇒ es gibt e<strong>in</strong> Wort wφ ∈ Lcheck, so dass φ die Länge ≤ Kp 2 (n)<br />
hat, wobei n die Länge von w ist.<br />
Das folgt aus der Konstruktion von Lcheck.<br />
6.8 Weitere N P-vollständige Probleme<br />
Satz 1. Sei L e<strong>in</strong>e N P-vollständige Sprache. Dann ist jede Sprache <strong>in</strong> N P, auf<br />
die L <strong>in</strong> polynomialer Zeit reduziert werden kann, auch N P-vollständig.<br />
Beweis. Sei L0 ⊆ Γ ∗ e<strong>in</strong>e Sprache der Klasse N P, und sei f : Σ ∗ → Γ ∗ e<strong>in</strong>e<br />
Reduktion von L ⊆ Σ ∗ auf L0 <strong>in</strong> polynomialer Zeit. Wir beweisen, dass L0 N Pvollständig<br />
ist.<br />
Für jede Sprache L ′ ⊆ (Σ ′ ) ∗ der Klasse N P gibt es e<strong>in</strong>e Reduktion g : (Σ ′ ) ∗ → Σ ∗<br />
von L ′ nach L <strong>in</strong> polynomialer Zeit. Es genügt zu zeigen, dass die zusammengesetzte<br />
Abbildung f(g(x)) von (Σ ′ ) ∗ nach Γ ∗ e<strong>in</strong>e Reduktion <strong>in</strong> polynomialer Zeit von L ′<br />
nach L0 ist. Damit ist die N P-Vollständigkeit von L0 bewiesen.<br />
Für jedes Wort x über Σ gilt<br />
x ∈ L ′ ⇐⇒ g(x) ∈ L ⇐⇒ f(g(x)) ∈ L0,<br />
also müssen wir nur zeigen, dass f(g(x)) e<strong>in</strong>e Funktion der Klasse FP ist. Sei M<br />
e<strong>in</strong>e TM, die f berechnet und die polynomiale Zeitkomplexität p(n) hat, und sei<br />
M e<strong>in</strong>e TM, die g berechnet und die polynomiale Zeitkomplexität q(n) hat. Dann<br />
haben wir e<strong>in</strong>e 2-Band Masch<strong>in</strong>e M ∗ , die auf Band 1 die Masch<strong>in</strong>e M simuliert<br />
(<strong>in</strong> q(n) Schritten) und das Ergebnis auf Band 2 kopiert, wo sie die Masch<strong>in</strong>e M<br />
simuliert (<strong>in</strong> p(q(n)) Schritten). Das Ergebnis von M ∗ auf Band 2 ist das Wort<br />
f(g(x)), das <strong>in</strong> O(p(q(n))) Schritten berechnet wurde.<br />
Beispiel 1 (3-ERFÜLLBARKEIT). Wir wissen, dass 2-ERFÜLLBARKEIT zu P<br />
gehört. Trotzdem ist 3-ERFÜLLBARKEIT, d.h., das Problem der Erfüllbarkeit für<br />
Formeln, die <strong>in</strong> KNF höchstens drei Literale je Klausel enthalten, NP-vollständig:<br />
1. 3-ERFÜLLBARKEIT gehört zu N P – klar.<br />
2. Für ERFÜLLBARKEIT existiert e<strong>in</strong>e Reduktion <strong>in</strong> polynomialer Zeit auf<br />
3-ERFÜLLBARKEIT:<br />
In der Tat kann jede Klausel aus vier Literalen<br />
mit zwei Klauseln aus je drei Literalen<br />
a1 ∨ a2 ∨ a3 ∨ a4<br />
(a1 ∨ a2 ∨ b) ∧ (¬b ∨ a3 ∨ a4)<br />
ersetzt werden. Es ist klar, dass a1 ∨ a2 ∨ a3 ∨ a4 genau dann erfüllt ist, wenn die<br />
letzte Formel mit b = true oder b = false erfüllt. Analog wird<br />
mit drei Klauseln ersetzt:<br />
a1 ∨ a2 ∨ a3 ∨ a4 ∨ a5<br />
(a1 ∨ a2 ∨ b) ∧ (¬b ∨ a3 ∨ c) ∧ (¬c ∨ a4 ∨ a5)<br />
usw. Diese Übersetzung dauert l<strong>in</strong>eare Zeit O(n), denn für jede Klausel der Länge<br />
n benötigen wir n − 2 Klauseln der Länge 3.
6.8. WEITERE N P-VOLLSTÄNDIGE PROBLEME 169<br />
Beispiel 2 (3-FÄRBUNG.). Dies ist das Problem, ob e<strong>in</strong> gegebener Graph mit<br />
drei Farben gefärbt werden kann. Während 2-FÄRBUNG zu P gehört (Beispiel<br />
3 <strong>in</strong> 6.1), zeigen wir jetzt, dass 3-FÄRBUNG N P-vollständig ist. Also gilt auch<br />
hier: falls jemand e<strong>in</strong>en effizienten Algorithmus für 3-FÄRBUNG f<strong>in</strong>det, beweist er<br />
P = N P!<br />
1. 3-FÄRBUNG ist <strong>in</strong> N P. Falls e<strong>in</strong>e 3-Färbung der Knoten vorgeschlagen wird,<br />
können wir <strong>in</strong> l<strong>in</strong>earer Zeit entscheiden, ob sie korrekt ist.<br />
2. 3-ERFÜLLBARKEIT läßt sich <strong>in</strong> polynomialer Zeit auf 3-FÄRBUNG reduzieren.<br />
Um den zweiten Teil zu beweisen, benutzen wir den folgenden Hilfsgraphen<br />
a<br />
•<br />
• b<br />
•<br />
•<br />
• <br />
•<br />
•<br />
d<br />
<br />
Hilfsgraph<br />
Wenn se<strong>in</strong>e Knoten mit drei Farben, z.B. weiß, schwarz, blau gefärbt werden gilt:<br />
(1) Falls a, b und c schwarz s<strong>in</strong>d, muß d auch schwarz se<strong>in</strong>.<br />
(Das ist leicht zu überprüfen, denn falls b und c schwarz s<strong>in</strong>d, ist ke<strong>in</strong>er der beiden<br />
Knoten direkt unter b und c schwarz und die Spitze des rechten Dreiecks muß also<br />
schwarz se<strong>in</strong>. Dasselbe gilt dann für das l<strong>in</strong>ke Dreieck.)<br />
(2) Falls a oder b oder c weiß ist, darf d weiß se<strong>in</strong>.<br />
Genauer: färben wir a, b, c so mit den drei Farben, so dass m<strong>in</strong>destens e<strong>in</strong>mal weiß<br />
benutzt wird, dann läßt sich der ganze Hilfsgraph so färben, dass d weiß wird. (Das<br />
ist auch leicht zu überprüfen).<br />
Wir konstruieren jetzt für jede Boolesche Formel φ mit Klauseln aus drei Literalen<br />
e<strong>in</strong>en Graphen Gφ, so dass<br />
φ ist erfüllbar ⇐⇒ Gφ ist 3-färbbar.<br />
Der Graph Gφ hat drei verschiedene Typen von Knoten. Typ 1 s<strong>in</strong>d drei Knoten,<br />
die mit den drei Farben markiert werden und e<strong>in</strong> Dreieck formen:<br />
• c<br />
•<br />
S •<br />
• B<br />
•<br />
W
170 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
Typ 2: für jede Variable x der Formel φ wird e<strong>in</strong> extra Dreieck an den Knoten B<br />
angehängt. Die beiden freien Knoten dieses Dreiecks werden mit x und ¬x markiert.<br />
Z.B. erhalten wir, falls φ nur die Variablen x, y, z hat, den folgenden Graphen:<br />
• •<br />
S •<br />
•<br />
<br />
B<br />
•<br />
W<br />
<br />
• •<br />
• •<br />
x ¬x<br />
y ¬y<br />
z ¬z<br />
Typ 3: für jede Klausel α ∨β ∨γ der Formel φ nehmen wir den obigen Hilfsgraphen:<br />
α<br />
•<br />
β<br />
•<br />
•<br />
•<br />
• <br />
•<br />
•<br />
W<br />
<br />
und die vier Knoten, die mit α, β, γ, W markiert s<strong>in</strong>d, werden mit den gerade markierten<br />
Knoten des Typs 2 identifiziert. Beispiel: für<br />
erhalten wir den Graphen<br />
γ<br />
•<br />
φ = y ∨ ¬x ∨ ¬z (1 Klausel)<br />
•<br />
•<br />
• •<br />
S •<br />
•<br />
<br />
B<br />
•<br />
W<br />
<br />
• •<br />
•<br />
•<br />
<br />
<br />
•<br />
x ¬x<br />
y ¬y<br />
z ¬z<br />
•<br />
<br />
<br />
•<br />
<br />
Wir beweisen zuerst:<br />
φ erfüllbar =⇒ Gφ ist 3-färbbar.<br />
•
6.8. WEITERE N P-VOLLSTÄNDIGE PROBLEME 171<br />
Für die gegebene Belegung der Variablen mit φ = true färben wir wie folgt:<br />
1. S, B und W wie angedeutet (schwarz, blau, weiß),<br />
2. Knoten des Typs 2 s<strong>in</strong>d weiß, falls ihr Wert true ist, und schwarz, falls der<br />
Wert false ist,<br />
3. <strong>in</strong> jedem der Hilfsgraphen ist m<strong>in</strong>destens e<strong>in</strong>er der Knoten a, b, c weiß gefärbt,<br />
deshalb können wir e<strong>in</strong>e Färbung f<strong>in</strong>den, die auch d weiß färbt f<strong>in</strong>den, siehe<br />
(2) oben.<br />
Umgekehrt beweisen wir:<br />
Gφ 3-färbbar =⇒ φ erfüllbar.<br />
Wir können, ohne Beschränkung der Allgeme<strong>in</strong>heit, annehmen, dass die gegebene<br />
Färbung die Knoten des Typs 1 wie angedeutet färbt. Wir setzen dann<br />
x = true ⇐⇒ der x-Knoten des Typs 2 ist weiß.<br />
Wir beweisen, dass φ = true, d.h., dass <strong>in</strong> jeder Klausel α ∨ β ∨ γ von φ e<strong>in</strong>es<br />
der Literale α, β, γ true ist. Da ke<strong>in</strong> Knoten des Typs 2 blau gefärbt werden kann<br />
(wegen der Kante zu B), s<strong>in</strong>d sie schwarz oder weiß. Aufgrund der Eigenschaft (1)<br />
des Hilfsgraphen können nicht α, β, γ gleichzeitig schwarz se<strong>in</strong> – also ist α, β oder<br />
γ true.<br />
Es ist klar, dass für e<strong>in</strong>e Formel φ der Größe<br />
n = Anzahl aller Variablen + Anzahl aller Klauseln<br />
die Konstruktion des Graphen Gφ <strong>in</strong> l<strong>in</strong>earer Zeit O(n) durchführbar ist.<br />
Beispiel 3. k-FÄRBUNG ist NP-vollständig für jedes k ≥ 3. Wir können z.B. 3-<br />
FÄRBUNG auf 4-FÄRBUNG <strong>in</strong> polynomialer Zeit wie folgt reduzieren: e<strong>in</strong> Graph<br />
G ist genau dann 3-färbbar, wenn der folgende Graph<br />
4-färbbar ist.<br />
• Neuer Knoten<br />
• <br />
• <br />
• <br />
• <br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
• • G<br />
Bemerkung 1. E<strong>in</strong> Graph ist planar, falls er so <strong>in</strong> der Ebene gezeichnet werden<br />
kann, dass die Kanten sich nicht überkreuzen. Das k-Färbungsproblem für planare<br />
Graphen ist<br />
1. trivial für k ≥ 4, denn jeder planare Graph ist 4-färbbar, aber trotzdem<br />
2. N P-vollständig für k = 3 (vergl. Bemerkung 4 <strong>in</strong> Abschnitt 6.5).<br />
Wir er<strong>in</strong>nern daran, dass e<strong>in</strong> Hamiltonscher Kreis <strong>in</strong> e<strong>in</strong>em ungerichteten Graphen<br />
e<strong>in</strong> Kreis ist, der jeden Knoten genau e<strong>in</strong>mal besucht. Das Problem HAMILTON-<br />
SCHER KREIS hat als E<strong>in</strong>gabe e<strong>in</strong>en Graphen G und wir sollen entscheiden, ob G<br />
e<strong>in</strong>en Hamiltonschen Kreis hat.
172 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
Beispiel 4. (ohne Beweis) HAMILTONSCHER KREIS ist e<strong>in</strong> N P-vollständiges<br />
Problem.<br />
Beispiel 5. TSP ist N P-vollständig. Wir haben <strong>in</strong> Beispiel 2 Nr. 4 <strong>in</strong> Abschnitt<br />
6.6 bemerkt, dass TSP zur Klasse N P gehört. Es ist also genug, e<strong>in</strong>e Reduktion<br />
von HAMILTONSCHER KREIS auf TSP <strong>in</strong> polynomialer Zeit zu f<strong>in</strong>den. Das ist<br />
trivial: für jeden Graphen G mit Knoten 1, . . .,n setzen wir<br />
dij =<br />
<br />
1 falls (i, j) e<strong>in</strong>e Kante ist<br />
2 sonst<br />
Dann hat dieses TSP genau dann e<strong>in</strong>e Lösung mit Gesamtkosten n, wenn G e<strong>in</strong>en<br />
Hamiltonschen Kreis hat.<br />
Schlußbemerkung: Für hunderte von Problemen (e<strong>in</strong>schließlich praktisch sehr wichtiger<br />
wir z.B. TSP oder 3-FÄRBUNBG) ist heute bekannt, dass sie N P-vollständig<br />
s<strong>in</strong>d. Das Problem ZERLEGBARKEIT (Beispiel 1) ist e<strong>in</strong>es der wenigen Probleme,<br />
für die nicht bekannt ist, ob sie N P-vollständig s<strong>in</strong>d. Es gilt aber, falls P = N P,<br />
dass <strong>in</strong> N P Probleme existieren, die nicht N P-vollständig s<strong>in</strong>d (ohne Beweis).<br />
6.9 Komplexitätsklasse coN P<br />
Def<strong>in</strong>ition. Mit coN P bezeichnen wir die Klasse aller Sprachen L, für die gilt: die<br />
komplementäre Sprache liegt <strong>in</strong> N P:<br />
L ∈ coN P ⇐⇒ L ∈ N P<br />
Beispiel 1 (PRIMZAHL). E<strong>in</strong>gabe: Zahl n<br />
Ausgabe: JA genau dann, wenn n e<strong>in</strong>e Primzahl ist.<br />
Dies ist also komplemaentär zu ZERLEGBARKEIT, deswegen<br />
PRIMZAHL ∈ coN P.<br />
Beispiel 2 (GÜLTIGKEIT). E<strong>in</strong>gabe: Boolsche Formal φ <strong>in</strong> KNF.<br />
Ausgabe: JA genau dann, wenn φ gültig ist, d.h. für jede Belegung der Variablen<br />
gilt φ = true.<br />
Dies ist e<strong>in</strong> Problem <strong>in</strong> coN P, denn e<strong>in</strong>e Belegung mit φ = false ist e<strong>in</strong> Zertifikat<br />
für die komplementäre Sprache!<br />
Bemerkung 1. 1.<br />
P ⊆ coN P.<br />
In der Tat, bei e<strong>in</strong>er determ<strong>in</strong>istischen TM genügt es, die f<strong>in</strong>alen und nichtf<strong>in</strong>alen<br />
Zustände zu vertauschen.<br />
2. coN P ist unter Reduktion abgeschlossen:<br />
L0 ∈ coN P, L ⊳ L0 =⇒ L ∈ coN P<br />
Es gilt nämlich L ⊳ L0: wir haben doch f : Γ ∗ → Σ ∗ <strong>in</strong> FP, so dass<br />
und dies bedeutet<br />
w ∈ L ⇐⇒ f(w) ∈ L0,<br />
w ∈ L ⇐⇒ f(w) ∈ L0.
6.9. KOMPLEXITÄTSKLASSE CON P 173<br />
Def<strong>in</strong>ition. E<strong>in</strong>e Sprache L0 heißt coN P-vollständig, falls sie <strong>in</strong> coN P liegt und<br />
L ∈ coN P =⇒ L ⊳ L0.<br />
Beispiel 3. GÜLTIGKEIT ist coN P-vollständig.<br />
<strong>in</strong> der Tat, gegeben L ∈ coN P, dann gibt es weil L ∈ N P, e<strong>in</strong>e Reduktion <strong>in</strong><br />
polynomialer Zeit von L auf ERFÜLLBARKEIT. Sei f diese Reduktion: jedem<br />
Wort w wird e<strong>in</strong>e Formel f(w) zugeordnet mit<br />
w ∈ L ⇐⇒ f(w) erfüllbar.<br />
E<strong>in</strong>e Formel φ ist genau dann gültig, wenn ¬φ immer false, d.h. unerfüllbar ist. Sei<br />
jetzt g die folgende Funktion:<br />
g(w) = ¬f(w)<br />
Aus f ∈ FP folgt bestimmt g ∈ FP. Und<br />
w ∈ L ⇐⇒ w /∈ L<br />
⇐⇒ f(w) nicht erfüllbar<br />
⇐⇒ g(w) gültig<br />
Offenes Problem: Gilt N P = coN P ? Die Antwort ist ja, falls GÜLTIGKEIT <strong>in</strong><br />
N P liegt:<br />
Satz 1. Falls N P = coN P, endhält N P ke<strong>in</strong>e coN P-vollständige Sprache.<br />
Beweis. Sei L0 coN P-vollständig. Wir beweisen, dass<br />
L0 ∈ N P =⇒ L ∈ N P für alle L ∈ coN P<br />
d.h., falls L0 ∈ N P, gilt coN P ⊆ N P):<br />
Es gibt Reduktion f <strong>in</strong> polynomialer Zeit von L nach L0 (da L ∈ coN P). Gegeben<br />
e<strong>in</strong>e NTM M, die L0 <strong>in</strong> polynomialer Zeit akzeptiert, die Komb<strong>in</strong>ation<br />
Band 1<br />
Band 2<br />
f berechnet<br />
M simuliert<br />
ergibt e<strong>in</strong>e NTM, die L <strong>in</strong> polynomialer Zeit akzeptiert, also L ∈ N P.<br />
Und<br />
L0 ∈ N P =⇒ L ∈ coN P für alle L ∈ N P<br />
(d.h., N P ⊆ coN P): hier existiert e<strong>in</strong>e Reduktion f von L auf L0, und die obige<br />
NTM akzeptiert <strong>in</strong> polynomialer Zeit die Sprache L, das beweist L ∈ N P, also<br />
L ∈ coN P.<br />
Bemerkung 2. Für PRIMZAHL gilt auch<br />
PRIMZAHL ∈ N P,<br />
aber dies ist e<strong>in</strong> nichttriviales Ergebnis, dessen Beweis hier nicht durchgeführt wird.<br />
Die Klasse<br />
N P ∩ coN P<br />
aller Probleme, die effektives Zertifikat für Antwort JA sowie für Antwort NEIN<br />
habe, enthält also <strong>in</strong>terssante Probleme. Wir wissen, dass sie P enthält.<br />
Offenes Problem Gilt P = N P ∩ coN P?
174 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
6.10 Komplexität von Optimierungsproblemen<br />
Viele Probleme s<strong>in</strong>d weder als Entscheidungsprobleme, noch als Berechnungsprobleme<br />
zu verstehen, sondern als Probleme, die für e<strong>in</strong>en maximalen (oder m<strong>in</strong>imalen)<br />
Wert e<strong>in</strong>es Parameters e<strong>in</strong>e Konstruktion verlangen. Solche Maximierungs- oder<br />
M<strong>in</strong>imierungsprobleme heißen Optimierungsprobleme.<br />
Beispiel 1 (MINIMALE FÄRBUNG). E<strong>in</strong>gabe: Ungerichteter Graph G<br />
Ausgabe: E<strong>in</strong>e Färbung von G mit m<strong>in</strong>imaler Zahl von Farben.<br />
Gibt es e<strong>in</strong>e effiziente Lösung dieses Problems? Bestimmt nicht (falls P = N P),<br />
denn jeder Algorithmus für MINIMALE FÄRBUNG kann natürlich 3-FÄRBUNG<br />
lösen. Für jedes M<strong>in</strong>imierungsproblem M haben wir das zugrunde liegende Entscheidungsproblem,<br />
dessen E<strong>in</strong>gabe e<strong>in</strong> Paar (x, y) ist, wobei x die E<strong>in</strong>gabe von<br />
M und y e<strong>in</strong>e Zahl ist. Die Entscheidung lautet: hat P e<strong>in</strong>e Lösung der E<strong>in</strong>gabe<br />
x mit e<strong>in</strong>em Parameter ≤ y? Es ist klar, dass e<strong>in</strong> M<strong>in</strong>imierungsproblem, das e<strong>in</strong>e<br />
effiziente Lösung hat, die Eigenschaft hat, dass das zugrunde liegende Entscheidungsproblem<br />
zu P gehört.<br />
Analoges gilt für Maximierungsprobleme.<br />
Beispiel 2 (MAXIMALES MATCHING). E<strong>in</strong>gabe: Ungerichteter Graph G Ausgabe:<br />
E<strong>in</strong>e maximale Menge von Kanten, die vone<strong>in</strong>ander disjunkt s<strong>in</strong>d.<br />
Dies ist e<strong>in</strong> Optimierungsproblem mit vielen praktischen Anwendungen. Der Name<br />
stammt von der Anwendung, wobei e<strong>in</strong>e Gruppe von Männern und Frauen die<br />
Knotenmenge von G formen und e<strong>in</strong>e Kante e<strong>in</strong>en Mann x mit e<strong>in</strong>er Frau y genau<br />
dann verb<strong>in</strong>det, wenn sie e<strong>in</strong> potentielles Paar formen. Die Aufgabe ist dann, die<br />
größte Menge von aktuellen Paaren zu bilden, für die ke<strong>in</strong>(e) Teilnehmer(<strong>in</strong>) mehrmals<br />
auftritt. Dieser Graph ist offensichtlich 2-färbbar; oft wird das MAXIMALE<br />
MATCHING Problem nur für 2-färbbare Graphen untersucht.<br />
Es gibt e<strong>in</strong>en effizienten Algorithmus, der MAXIMALES MATCHING löst. Die<br />
Grundidee ist, dass jedes Match<strong>in</strong>g M durch e<strong>in</strong>en erweiternden Weg verbessert<br />
werden kann. Für das gegebene Match<strong>in</strong>g M heißt e<strong>in</strong>e Kante des Graphen G frei,<br />
falls sie nicht <strong>in</strong> M liegt, und e<strong>in</strong> Knoten heißt frei, falls er ke<strong>in</strong> Endknoten e<strong>in</strong>er<br />
Kante <strong>in</strong> M ist.<br />
Def<strong>in</strong>ition. Für e<strong>in</strong> Match<strong>in</strong>g M im Graphen G heißt e<strong>in</strong> Weg <strong>in</strong> G erweiternd,<br />
falls se<strong>in</strong>e Endknoten frei s<strong>in</strong>d und se<strong>in</strong>e Kanten abwechselnd frei und unfrei s<strong>in</strong>d.<br />
Beispiel 3. Im Graphen G<br />
hat das Match<strong>in</strong>g M:<br />
x1<br />
x2<br />
x3<br />
x4<br />
x5<br />
•<br />
• y1<br />
•<br />
•<br />
•<br />
<br />
<br />
• y2<br />
<br />
<br />
<br />
<br />
• y3<br />
<br />
• y4<br />
•<br />
<br />
• y5
6.10. KOMPLEXITÄT VON OPTIMIERUNGSPROBLEMEN 175<br />
x1 •<br />
• y1<br />
x2<br />
•<br />
• y2<br />
x3 •<br />
• y3<br />
x4 •<br />
• y4<br />
x5 •<br />
• y5<br />
den folgenden erweiternden Weg: x4, y1, x1, y2, x2, y3, x3, y4.<br />
Satz 1. Falls e<strong>in</strong> Match<strong>in</strong>g M e<strong>in</strong>en erweiternden Weg W hat, gibt es e<strong>in</strong> größeres<br />
Match<strong>in</strong>g M ′ , das aus M dadurch ensteht, dass die freien und unfreien Kanten von<br />
W ausgetauscht werden.<br />
Beweis. M ′ ist e<strong>in</strong> Match<strong>in</strong>g, denn für die <strong>in</strong>neren Knoten x des Weges W gibt es<br />
genau e<strong>in</strong>e Kante <strong>in</strong> M, auf der x liegt, und die wird <strong>in</strong> M ′ mit genau e<strong>in</strong>er Kante<br />
von W ausgetauscht. Für die beiden Endknoten von W (die <strong>in</strong> M frei s<strong>in</strong>d) gibt es<br />
auch genau e<strong>in</strong>e Kante <strong>in</strong> M ′ .<br />
Da beide Endknoten des Weges W frei s<strong>in</strong>d, hat W mehr freie als unfreie Kanten,<br />
also hat M ′ mehr Kanten als M.<br />
Im obigen Beispiel erhalten wir das Match<strong>in</strong>g<br />
x1<br />
x2<br />
x3<br />
x4<br />
x5<br />
•<br />
• y1<br />
•<br />
•<br />
•<br />
<br />
<br />
<br />
• y2<br />
<br />
• y3<br />
• y4<br />
•<br />
Dieses Match<strong>in</strong>g hat immer noch erweiternden Wege, etwa x5, y2, x1, y5, oder auch<br />
x5, y3, x2, y2, x1, y5. Diese liefern die neuen Match<strong>in</strong>gs<br />
x1<br />
x2<br />
x3<br />
x4<br />
x5<br />
•<br />
• y1<br />
<br />
•<br />
• y2<br />
•<br />
• y3<br />
<br />
•<br />
<br />
• y4<br />
•<br />
<br />
• y5<br />
bzw.<br />
• y5<br />
x1<br />
x2<br />
x3<br />
x4<br />
x5<br />
•<br />
• y1<br />
<br />
•<br />
• y2<br />
•<br />
•<br />
<br />
<br />
• y3<br />
• y4<br />
•<br />
• y5<br />
für die es ke<strong>in</strong>e erweiternden Wege mehr gibt – deshalb s<strong>in</strong>d sie maximal:
176 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
Satz 2. Jedes Match<strong>in</strong>g, für das es ke<strong>in</strong>en erweiternden Weg gibt, ist maximal.<br />
Beweis. Mit anderen Worten sollen wir für jedes Match<strong>in</strong>g M zeigen, dass, falls es<br />
e<strong>in</strong> größeres Match<strong>in</strong>g M ∗ gibt, M e<strong>in</strong>en erweiternden Weg hat.<br />
Sei G der Graph, dessen Knoten die Knoten von G s<strong>in</strong>d und dessen Kanten alle<br />
Kanten <strong>in</strong><br />
(M − M ∗ ) ∪ (M ∗ − M)<br />
s<strong>in</strong>d, d.h. alle Kanten, die <strong>in</strong> genau e<strong>in</strong>em der Match<strong>in</strong>gs M und M ∗ liegen. Jeder<br />
Knoten von G liegt auf höchstens zwei Kanten. Das bedeutet, dass G e<strong>in</strong>e disjunkte<br />
Vere<strong>in</strong>igung von Zyklen und (maximalen) Wegen ist. Da sich <strong>in</strong> jedem Zyklus die<br />
Kanten von M und M ∗ abwechseln, gilt: <strong>in</strong> jedem Zyklus ist die Zahl von Kanten<br />
aus M gleich der Zahl der Kanten aus M ∗ . Andererseits hat G mehr Kanten aus M ∗<br />
als aus M, da M ∗ mehr Elemente als M enthält. Es gibt also e<strong>in</strong>en maximalen Weg<br />
W <strong>in</strong> G, auf dem mehr Kanten aus M ∗ als aus M liegen. Das bedeutet, dass beide<br />
Endkanten von W <strong>in</strong> M ∗ liegen. Da der Weg W maximal ist, s<strong>in</strong>d se<strong>in</strong>e Endknoten<br />
frei im Match<strong>in</strong>g M. Also ist W e<strong>in</strong> erweiternder Weg für M.<br />
Algorithmus für MAXIMALES MATCHING<br />
E<strong>in</strong>gabe: Ungerichteter Graph G = (V, E)<br />
Ausgabe: Maximales Match<strong>in</strong>g M ⊆ E<br />
1: Initialisierung M := ∅<br />
2: while e<strong>in</strong> erweiternder Weg W für M existiert do<br />
3: M := M ′ für M ′ aus Satz 1<br />
4: od<br />
Korrektheit: folgt aus Satz 1 und 2. Am Ende des while-Zyklus (der aufgrund von<br />
Satz 1 konvergiert) hat M ke<strong>in</strong>en erweiternden Weg und ist also maximal.<br />
Zeitkomplexität: hängt natürlich von der Zeitkomplexität des Suchen des erweiternden<br />
Weges <strong>in</strong> Zeile 2 ab. Es s<strong>in</strong>d Algorithmen bekannt, die für Graphen mit<br />
n Knoten und k Kanten die Zeitkomplexität O(nk) haben. Dann hat der ganze<br />
Algorithmus oben Zeitkomplexität O(nk).<br />
Beispiel 4 (MAXFLOW). Das Problem MAXIMALES MATCHING ist e<strong>in</strong> Spezialfall<br />
des MAXFLOW Problems: gegeben seien e<strong>in</strong> gerichteter Graph G und zwei<br />
Knoten s (source) und t (target), wir suchen den maximalen Fluß Kanten-disjunkter<br />
Wege von s nach t. (Die Wege dürfen also geme<strong>in</strong>same Knoten haben, aber ke<strong>in</strong>e<br />
geme<strong>in</strong>samen Kanten.) Auch hier wird die Lösung mit Hilfe von erweiternden Wegen<br />
berechnet. Gegeben e<strong>in</strong> Fluß H mit Wegen von s nach t, e<strong>in</strong>e Kante von G<br />
heißt frei, falls sie auf ke<strong>in</strong>em Weg von H liegt. E<strong>in</strong> erweiternder Weg für H ist<br />
e<strong>in</strong>e Liste<br />
s = v0, v1, . . .,vn−1, vn = t<br />
von Knoten von G, so dass für jedes i = 1, . . .,n gilt<br />
• entweder ist (vi−1, vi) e<strong>in</strong>e freie Kante von G, oder<br />
• (vi, vi−1) ist e<strong>in</strong>e unfreie Kante von G.<br />
Wir erweitern H, <strong>in</strong>dem alle freien Kanten (vi−1, vi) unfrei werden und alle unfreien<br />
Kanten (vi, vi−1) frei werden.<br />
Beispiel: Sei G der Graph und H der mit dickeren L<strong>in</strong>ien gekennzeichneter Fluß wie<br />
folgt:
6.10. KOMPLEXITÄT VON OPTIMIERUNGSPROBLEMEN 177<br />
Der folgende erweiternde Weg<br />
führt zum folgenden Fluß:<br />
x<br />
• •<br />
y<br />
s • •<br />
•<br />
z<br />
x′<br />
y<br />
•<br />
′<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
•<br />
<br />
<br />
<br />
t<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
•<br />
<br />
<br />
′ z<br />
s, y, z ′ , z, x ′ , x, y ′ , t<br />
x<br />
• •<br />
y<br />
s • •<br />
•<br />
z<br />
x′<br />
y<br />
•<br />
′<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
• <br />
<br />
t<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
•<br />
<br />
<br />
′ z<br />
Auch für MAXFLOW gibt es e<strong>in</strong>en Algorithmus, der aufrund erweiternder Wege <strong>in</strong><br />
der Zeit O(nk) das Problem löst.<br />
Um das Konzept e<strong>in</strong>es Optimierungsproblems zu formalisieren, nehmen wir an, dass<br />
die E<strong>in</strong>gabe sowie potentielle Lösungen <strong>in</strong> demselben Alphabet Σ codiert werden.<br />
Z.B. nehmen wir für MINIMALE FÄRBUNG an, dass die E<strong>in</strong>gabe G b<strong>in</strong>är (z.B.<br />
als Adjazenzmatrix) codiert wird, also über Σ = {0, 1}. Jede Färbung mit k Farben<br />
1, 2, . . .,k kann auch über Σ codiert werden, z.B. als das Wort 0 i1 10 i2 1 . . .10 <strong>in</strong> 1,<br />
wobei der Knoten 1 mit der Farbe i1 gefärbt wird, der Knoten 2 mit der Farbe i2,<br />
usw. Wir haben e<strong>in</strong>e Relation L auf der Menge Σ ∗ aller Wörter, wobei<br />
vLw<br />
bedeutet, dass die Instanz v des Problems durch w gelöst wird. D.h., dass v e<strong>in</strong>en<br />
Graphen G codiert, w e<strong>in</strong>e Färbung codiert und diese Färbung für G korrekt ist.<br />
Schließlich haben wir e<strong>in</strong>en Parameter c(v, w), den wir optimieren wollen, und der<br />
von der E<strong>in</strong>gabe v und der Lösung w abhängen kann. Wir betrachten also e<strong>in</strong>e<br />
Funktion<br />
c : L →<br />
Für MINIMALE FÄRBUNG ist<br />
Allgeme<strong>in</strong>:<br />
c(v, w) = Anzahl der <strong>in</strong> w verwendeten Farben.<br />
Def<strong>in</strong>ition. 1. E<strong>in</strong> Optimierungsproblem ist e<strong>in</strong> 5-Tupel (Σ, E, A, L, c), wobei<br />
Σ e<strong>in</strong> Alphabet ist (<strong>in</strong> dem E<strong>in</strong>gaben und Lösungen codiert werden),<br />
E e<strong>in</strong>e Sprache über Σ ist (aller möglichen E<strong>in</strong>gaben),<br />
A e<strong>in</strong>e Sprache über Σ ist (aller möglichen Lösungen oder Ausgaben)
178 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
L ⊆ E × A ist e<strong>in</strong>e Relation auf der Menge Σ ∗ (<strong>in</strong>sbesondere folgt aus vLw<br />
sofort v ∈ E und w ∈ A) und<br />
c e<strong>in</strong>e Funktion (Kostenfunktion) ist, die jedem Paar (v, w) ∈ L die Kosten<br />
c(v, w) ∈ N der Lösung w zur E<strong>in</strong>gabe v zuordnet.<br />
2. E<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e löst das M<strong>in</strong>imierungsproblem (Maximierungsproblem)<br />
(Σ, E, A, L, c), falls sie für jede E<strong>in</strong>gabe v ∈ E mit e<strong>in</strong>er Ausgabe<br />
w ∈ A hält, für die gilt<br />
(a) vLw und<br />
(b) c(v, w) ≤ c(v, w ′ ) (c(v, w) ≥ c(v, w ′ )) für alle w ′ ∈ A mit vLw ′ .<br />
Die Relation L kann auch mit ihrer charakteristischen Funktion χL : E × A →<br />
{true,false} identifiziert werden.<br />
Beispiel: die TM, die den oberen Algorithmus für MAXIMALES MATCHING implementiert,<br />
ist e<strong>in</strong>e Lösung des Problems. Wie erwähnt, hat diese TM e<strong>in</strong>e polynomiale<br />
Zeitkomplexität. Deswegen gehört MAXIMALES MATCHING zur folgenden<br />
Klasse:<br />
Def<strong>in</strong>ition. Die Klasse PO besteht aus allen Optimierungsproblemen (das heißt,<br />
allen M<strong>in</strong>imierungs- und Maximierungsproblemen) (Σ, E, A, L, c), für die gilt:<br />
1. E und A s<strong>in</strong>d Sprachen der Klasse P (d.h., wir haben e<strong>in</strong>e effiziente Prozedur,<br />
die entscheidet, ob e<strong>in</strong> Wort e<strong>in</strong>e E<strong>in</strong>- oder Ausgabe codiert)<br />
2. es gibt e<strong>in</strong> Polynom p(x), so daß jedes Paar (u, v) ∈ L der Bed<strong>in</strong>gung |v| ≤<br />
p(|u|) genügt (d.h., zu e<strong>in</strong>er E<strong>in</strong>gabe kann es nur “kurze” Lösungen geben);<br />
3. χL : E × A → {true,false} ist e<strong>in</strong>e Funktion der Klasse FP<br />
4. c ist e<strong>in</strong>e Funktion der Klasse FP und<br />
5. es gibt e<strong>in</strong>e TM mit polynomialer Zeitkomplexität, die das Optimierungsproblem<br />
löst.<br />
Beispiel 5. MINMALE FÄRBUNG gehört nicht zu PO, falls P = N P, denn<br />
3-FÄRBUNG ist e<strong>in</strong> N P-vollständiges Problem.<br />
Beispiel 6. MAXIMALES MATCHING gehört zu PO.<br />
In der Tat<br />
1. gibt es Algorithmen, die <strong>in</strong> l<strong>in</strong>earer Zeit entscheiden, ob e<strong>in</strong> b<strong>in</strong>äres Wort e<strong>in</strong>en<br />
Graphen oder e<strong>in</strong> Match<strong>in</strong>g codiert<br />
2. ist jedes Match<strong>in</strong>g als Teilmenge der Kantenmenge l<strong>in</strong>ear <strong>in</strong> der E<strong>in</strong>gabegröße<br />
beschränkt<br />
3. gibt es e<strong>in</strong>en Algorithmus, der <strong>in</strong> l<strong>in</strong>earer Zeit entscheidet, ob e<strong>in</strong>e Menge von<br />
Knoten e<strong>in</strong> Match<strong>in</strong>g ist<br />
4. kann die Bewertung der Zahl c(w, v) aller Knoten des Match<strong>in</strong>g v <strong>in</strong> l<strong>in</strong>earer<br />
Zeit durchgeführt werden und<br />
5. haben wir e<strong>in</strong>en effizienten Algorithmus für die Lösung von MAXIMALES<br />
MATCHING oben gezeigt.
6.11. APPROXIMATION VON OPTIMIERUNGSPROBLEMEN 179<br />
Bemerkung 1. Für jedes M<strong>in</strong>imierungsproblem<br />
(Σ, E, A, L, c)<br />
def<strong>in</strong>ieren wir das zugrunde liegende Entscheidungsproblem: gegeben e<strong>in</strong> Paar<br />
(w, n) mit w ∈ E und n ∈ , gibt es e<strong>in</strong>e Lösung v ∈ A, so dass<br />
(∗) vLw und c(w, v) ≤ n?<br />
Für jedes M<strong>in</strong>imierungsproblem der Klasse PO gehört das zugrunde liegende Entscheidungsproblem<br />
zur Klasse P. In der Tat können wir für jede E<strong>in</strong>gabe (w, n)<br />
<strong>in</strong> polynomialer Zeit die entsprechende m<strong>in</strong>imale Lösung v f<strong>in</strong>den, berechnen wir<br />
<strong>in</strong> polynomialer Zeit den Wert c(w, v) und schließlich entscheiden wir <strong>in</strong> der Zeit<br />
O(log n), ob dieser Wert kle<strong>in</strong>er gleich n ist.<br />
Analog für Maximierungsprobleme: hier wird die Ungleichung von (∗) umgedreht.<br />
Umgekehrt gilt also: falls P = N P, enthält PO ke<strong>in</strong> Optimierungsproblem, dessen<br />
zugrunde liegendes Entscheidungsproblem N P-vollständig ist.<br />
Beispiel 7 (MINIMALES TSP). (siehe 6.6, Beispiel 2 Nr. 4)<br />
E<strong>in</strong>gabe: w = (di,j)i,j=1,...,n, wobei di,j ∈<br />
Stadt j s<strong>in</strong>d.<br />
Ausgabe: Permutation v = (i1, i2, . . . , <strong>in</strong>), die die Kosten<br />
m<strong>in</strong>imiert.<br />
die Kosten des Weges von Stadt i zu<br />
c(w, v) = di1,i2 + di2,i3 + · · · + d<strong>in</strong>−1,<strong>in</strong> + d<strong>in</strong>,i1<br />
Diese Aufgabe gehört nicht zu PO, falls P = N P, denn wir wissen, dass das zugrunde<br />
liegende Entscheidungsproblem N P-vollständig ist.<br />
6.11 Approximation von Optimierungsproblemen<br />
Falls es für e<strong>in</strong> Optimierungsproblem ke<strong>in</strong>en effizienten Algorithmus gibt, der die<br />
optimale Lösung f<strong>in</strong>det, können wir versuchen, e<strong>in</strong>e suboptimale Lösung effizient zu<br />
konstruieren.<br />
Beispiel 1. MINIMALE KNOTEN-ÜBERDECKUNG<br />
E<strong>in</strong>gabe: Ungerichteter Graph<br />
Ausgabe: M<strong>in</strong>imale Menge D an Knoten, so dass jede Kante e<strong>in</strong>en Knoten aus D<br />
enthält.<br />
Es ist bekannt, dass das zugrunde liegende Entscheidungsproblem (ob e<strong>in</strong>e Knotendeckung<br />
mit höchstens n Knoten existiert) N P-vollständig ist. E<strong>in</strong>e suboptimale<br />
Lösung kann wie folgt beschrieben werden:<br />
Algorithmus für KNOTEN-ÜBERDECKUNG<br />
E<strong>in</strong>gabe: Ungerichteter Graph G<br />
Ausgabe: E<strong>in</strong>e Knotenüberdeckung D<br />
1: D := ∅<br />
2: V := die Menge aller Knoten von G<br />
3: E := die Menge aller Kanten von G<br />
4: while E e<strong>in</strong>e Kante (x, y) enthält do<br />
5: D := D ∪ {x, y}
180 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
6: E := E − {v : v e<strong>in</strong>e Kante mit Endknoten x oder y}<br />
7: od<br />
Korrektheit: Wir konstruieren hier e<strong>in</strong>e Menge D von Knoten mit der Eigenschaft,<br />
dass jede im Schritt 6 entfernte Kante e<strong>in</strong>en Endknoten <strong>in</strong> D hat. Da am Ende alle<br />
Kanten entfernt worden s<strong>in</strong>d, ist D e<strong>in</strong>e Knotenüberdeckung.<br />
Zeitkomplexität ist l<strong>in</strong>ear, denn jede Kante des Graphen wird von dem Algorithmus<br />
nur e<strong>in</strong>mal besucht.<br />
Beziehung zum Optimum: Bezeichnen wir für jeden Graphen G mit opt(G) die m<strong>in</strong>imale<br />
Größe e<strong>in</strong>er Knoten-Überdeckung und mit c(G) die Größe der Überdeckung,<br />
die unser Algorithmus konstruiert. Es gilt<br />
c(G) ≤ 2opt(G).<br />
In der Tat hat der Algorithmus die folgende Eigenschaft: D wird mittels paarweise<br />
disjunkter Kanten des Graphen G konstruiert. Jede Überdeckung D0 muß wenigsten<br />
e<strong>in</strong>en Endknoten von jeder dieser Kanten enthalten, also muß D0 m<strong>in</strong>destens<br />
halbsoviele Elemente wie D haben.<br />
Def<strong>in</strong>ition. Sei (Σ, E, A, L, c) e<strong>in</strong> Optimierungsproblem. E<strong>in</strong> ε-approximierender<br />
Algorithmus (ε ≥ 0 e<strong>in</strong>e reelle Zahl) ist e<strong>in</strong> Algorithmus der Klasse P, der für jede<br />
E<strong>in</strong>gabe w ∈ E e<strong>in</strong>e Ausgabe v ∈ A mit vLw berechnet, so dass der relative Fehler<br />
von c(w, v) im Vergleich zum optimalen Wert opt(w) kle<strong>in</strong>er gleich ε ist; d.h., es gilt<br />
c(w, v) − opt(w)<br />
opt(w)<br />
Beispiel 2. Für MINIMALE KNOTEN-ÜBERDECKUNG haben wir e<strong>in</strong>en 1approximierenden<br />
Algorithmus gefunden: es gilt c(w, v) ≤ 2opt(v), also<br />
c(w, v) − opt(w)<br />
opt(w)<br />
≤ ε.<br />
≤ 1.<br />
Dieser Algorithmus ist nicht ε-approximierend für ε < 1, denn schon für den Graphen<br />
mit zwei Knoten und e<strong>in</strong>er Kante gilt opt = 1, c(w, v) = 2.<br />
Beispiel 3 (SIT (Schedul<strong>in</strong>g Independent Tasks)). Es sollen Aufgaben W1, . . . , Wn<br />
mit gegebener zeitlicher Dauer t1, . . .,tn durch k Masch<strong>in</strong>en bewältigt werden. Wir<br />
nehmen an, dass jede Masch<strong>in</strong>e unabhängig von den anderen jede Aufgabe bearbeiten<br />
kann. Unsere Ziel ist es, e<strong>in</strong>en Plan (schedule) zu erstellen, d.h. jeder Arbeit Wi<br />
(i = 1, . . .,n) e<strong>in</strong>e Masch<strong>in</strong>e S(i) = 1, . . .,k zuzuordnen, so dass der Zeitbedarf T<br />
zur Erledigung aller Aufgaben m<strong>in</strong>imal ist. Die Laufzeit der Masch<strong>in</strong>e m(= 1, . . .,k)<br />
beträgt ti, wobei über alle i mit S(i) = m summiert wird. Der Zeitbedarf ist somit<br />
T = max{ <br />
S(i)=1<br />
ti, . . . , <br />
S(i)=k<br />
Da die Zahl k der Masch<strong>in</strong>en konstant ist, bezeichnen wir das Problem als SIT(k).<br />
Wir haben also:<br />
E<strong>in</strong>gabe von SIT(k): Zahlen t1, . . . , tn.<br />
Ausgabe von SIT(k): e<strong>in</strong>e Funktion<br />
S : {1, . . .,n} → {1, . . .,k},<br />
ti}.
6.11. APPROXIMATION VON OPTIMIERUNGSPROBLEMEN 181<br />
für die die Zahl<br />
m<strong>in</strong>imal ist.<br />
T = max{ <br />
S(i)=1<br />
ti, . . ., <br />
S(i)=k<br />
E<strong>in</strong> 1/3-approximierender Algorithmus A für SIT(k)<br />
Der folgende Algorithmus erledigt erst die längsten Arbeiten und erst dann die<br />
kürzeren. Außerdem zieht er die am wenigsten benutzten Masch<strong>in</strong>en vor. Wir benutzen<br />
die Hilfsvariable<br />
E<strong>in</strong>gabe: Zahlen t1, . . . , tk<br />
ti}<br />
Tm = die Zeit, die Masch<strong>in</strong>e m bisher gearbeitet hat<br />
Ausgabe: Funktion S : {1, . . ., n} → {1, . . ., k}<br />
1: sortiere die gegebenen Zeiten, so dass t1 ≥ t2 ≥ · · · ≥ tn<br />
2: for m = 1 to k do<br />
3: Tm := 0<br />
4: end for<br />
5: for i = 1 to n do<br />
6: m := e<strong>in</strong> Index mit Tm = m<strong>in</strong>{T1, . . . , Tk}<br />
7: S(i) := m<br />
8: Tm := Tm + ti<br />
9: end for<br />
Korrektheit: In der zweiten Schleife ab Zeile 5 wird jede Aufgabe Wi e<strong>in</strong>er Masch<strong>in</strong>e<br />
S(i) zugeordnet.<br />
Zeitkomplexität: Das Sortieren <strong>in</strong> Zeile 1 dauert O(n·log n) Zeite<strong>in</strong>heiten, die Initialisierung<br />
<strong>in</strong> Zeilen 2–4 dauert O(1) E<strong>in</strong>heiten, jeder der n Durchläufe der Schleife ab<br />
Zeile 5 dauert O(1) Zeite<strong>in</strong>heiten (<strong>in</strong>sbesondere besitzt die Menge, deren M<strong>in</strong>imum<br />
<strong>in</strong> Zeile 6 zu bestimmen ist, immer k Elemente). Insgesamt wird der Zeitbedarf des<br />
Algorithmus durch das Sortieren <strong>in</strong> Zeile 1 dom<strong>in</strong>iert und betragt<br />
O(n log n).<br />
Dies ist also e<strong>in</strong> Algorithmus der Klasse P.<br />
Approximierung: Dieser Algorithmus ist 1/3-approximierend. Anstatt dies hier zu<br />
beweisen, zeigen wir (für e<strong>in</strong> beliebig kle<strong>in</strong>es ε > 0) e<strong>in</strong>en ε-approximierenden Algorithmus<br />
für SIT(k).<br />
Beispiel 4 (E<strong>in</strong> ε-approximierender Algorithmus für SIT(k)). Die Idee ist e<strong>in</strong>fach:<br />
wir wählen e<strong>in</strong>e ” geeignete“ Konstante und verteilen die ersten r (längsten) Aufgaben<br />
optimal – z.B. suchen wir aus allen k r möglichen Zuordnungen die beste aus.<br />
Den Rest berechnen wir mit dem Algorithmus aus Beispiel 3. Wir werden zeigen,<br />
dass jede Wahl<br />
(1) r ><br />
k − 1<br />
ε<br />
e<strong>in</strong>en ε-approximierbaren Algorithmus ergibt. Für e<strong>in</strong>e ausgewählte Konstante r<br />
beschreiben wir also den entsprechenden Algorithmus.<br />
Approximierender Algorithmus Ar für SIT(k):<br />
1: sortiere t1 ≥ t2 ≥ · · · ≥ tn<br />
2: f<strong>in</strong>de für die E<strong>in</strong>gabe t1, . . .,tr die optimale Planung Sopt : {1, . . .,r} → {1, . . .,k}<br />
3: for m = 1 to k do
182 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
4: Tm := <br />
Sopt(i)=m ti<br />
5: end for<br />
6: for i = r + 1 to n do<br />
7: m := e<strong>in</strong> Index mit Tm = m<strong>in</strong>{T1, . . . , Tk}<br />
8: S(i) := m<br />
9: Tm := Tm + ti<br />
10: end for<br />
Korrektheit: klar<br />
Zeitkomplexität: Für jede Konstante r hat dieser Algorithmus dieselbe Zeitkomplexität<br />
O(n · log n) wie oben <strong>in</strong> Beispiel 3. Genauer: der Algorithmus braucht die<br />
Zeit<br />
O(n log n + k r+1 ).<br />
Für jede Konstante r ist dies e<strong>in</strong>fach O(n log n). Wenn aber ε <strong>in</strong> (1) gegen Null<br />
geht, wächst r und die Zeitkomplexität steigt exponentiell.<br />
In der Tat kann die optimale Zuordnung <strong>in</strong> Zeile 2 wie folgt gefunden werden: wir<br />
durchsuchen alle k r möglichen Zurodnungen: für jede Zuordnung S berechnen wir<br />
<strong>in</strong> der Zeit O(k) die gesamte Bearbeitungszeit T(S), die die m Arbeiten unter der<br />
Planung S dauern, und dann f<strong>in</strong>den wir <strong>in</strong> der Zeit O(k r ) das M<strong>in</strong>imum aller T(S).<br />
Schritt 2 dauert also O(k · k r ) Zeite<strong>in</strong>heiten.<br />
O(k k/ε )<br />
Zeite<strong>in</strong>heiten und der Algorithmus hat also die Zeitkomplexität O(n·log n+k M+1 ).<br />
Approximierung: Wir beweisen, dass unser Algorithmus ε-approximierbar ist, falls<br />
(1) gilt:<br />
(2) aus r ≥ k<br />
ε<br />
folgt T − Topt<br />
Topt<br />
Beweis. T sei der Zeitbedarf der Zuordnung, die unser Algorithmus f<strong>in</strong>det. Es<br />
muß m<strong>in</strong>destens e<strong>in</strong>e Aufgabe Wi geben, die genau zur Zeit T beendet wird. Falls<br />
i ≤ r, ist Wi e<strong>in</strong>e der optimal zugeordneten Aufgaben W1, . . . , Wr – also stimmt der<br />
Zeitbedarf T (zufällig) mit dem (optimalen) Zeitbedarf für die ersten r Aufgaben<br />
übere<strong>in</strong> und ist folglich selber optimal, T = Topt, was (2) beweist. Wir können also<br />
(3) i > r<br />
annehmen. Also erfolgt die Zuordnung der Aufgabe Wi durch den obigen Algorithmus<br />
A. Die Aufgabe Wi beg<strong>in</strong>nt zur Zeit T −ti. Daraus folgt, dass alle k Masch<strong>in</strong>en<br />
im Zeitraum [0, T −ti) durchgängig beschäftigt s<strong>in</strong>d. Falls es nämlich e<strong>in</strong>e Masch<strong>in</strong>e<br />
geben sollte, deren Tätigkeit zur Zeit T0 < T − ti aufhört, würde der Algorithmus<br />
A die Aufgabe Wi auf dieser Masch<strong>in</strong>e zum Zeitpunkt T0 beg<strong>in</strong>nen lassen (denn<br />
A bevorzugt die weniger beschäftigten Masch<strong>in</strong>en) und somit würde Wi nicht zur<br />
Zeit T enden. Die Gesamtarbeitszeit aller k Masch<strong>in</strong>en im Zeitraum [0, T −ti), also<br />
e<strong>in</strong>em Intervall der Länge T − ti, beträgt also k(T − ti). Aber der Algorithmus A<br />
verplant nur Aufgaben Wj mit j < i <strong>in</strong> diesem Zeitraum (da Wi selbst erst zur Zeit<br />
T − ti anfängt). Im Intervall [0, T − ti) werden also nur die Aufgaben W1, . . . , Wi−1<br />
bearbeitet. Die Gesamtarbeitszeit k(T − ti) ist also höchstens so groß wie die Zeit<br />
t1 + · · · + ti−1, die die Bearbeitung der Aufgaben W1, . . . , Wi−1 verlangt:<br />
(4) k(T − ti) ≤ t1 + · · · + ti−1.<br />
Es gilt also<br />
(5) T ≤ t1 + · · · + ti−1<br />
k<br />
+ ti.<br />
≤ ε
6.11. APPROXIMATION VON OPTIMIERUNGSPROBLEMEN 183<br />
Anderseits dauern alle n Aufgaben <strong>in</strong>sgesamt t1 + · · · + tn Zeite<strong>in</strong>heiten. Die optimale<br />
Zuordnung ergibt e<strong>in</strong>en Zeitbedarf von Topt Zeite<strong>in</strong>heiten, dabei s<strong>in</strong>d die k<br />
Masch<strong>in</strong>en maximal kTopt Zeite<strong>in</strong>heiten aktiv (falls alle die ganze Zeit beschäftigt<br />
s<strong>in</strong>d). Daraus folgt<br />
(6) kTopt ≥ t1 + · · · + tn.<br />
Dann gilt<br />
(7) Topt ≥ t1 + · · · + tn<br />
k<br />
Die Komb<strong>in</strong>ation von (5) und (7) ergibt<br />
T − Topt ≤ t1 + · · · + ti−1<br />
k<br />
Aus (2) wissen wir, dass ti ≤ tr (denn i > r), also<br />
(8) T − Topt ≤ tr.<br />
≥ t1 + · · · + ti−1<br />
.<br />
k<br />
+ ti − t1 + · · · + ti−1<br />
k<br />
Jetzt benutzen wir (6) nochmals: da t1 ≥ t2 · · · ≥ tn, gilt<br />
Topt ≥ t1 + · · · + tn<br />
k<br />
und komb<strong>in</strong>iert mit (8), bekommen wir<br />
(9)<br />
Da r ≥ k<br />
ε<br />
T − Topt<br />
Topt<br />
≥ t1 + · · · + tr<br />
k<br />
≤ tr<br />
r·tr<br />
k<br />
= k<br />
r .<br />
≥<br />
r · tr<br />
k<br />
= ti<br />
k ist, folgt r ≤ ε, also ist (9) die gewünschte Ungleichung.<br />
Satz 1. Für ke<strong>in</strong> ε > 0 gibt es e<strong>in</strong>en ε-approximierenden Algorithmus für TSP,<br />
falls P = N P.<br />
Beweis. Wir wissen, dass HAMILTONSCHER KREIS e<strong>in</strong> N P-vollständiges Problem<br />
ist. Wir beweisen, dass wir e<strong>in</strong>en Algorithmus A der Klasse P für HAMIL-<br />
TONSCHER KREIS f<strong>in</strong>den können, falls e<strong>in</strong> ε-approximierender Algorithmus Aε<br />
für TSP gegeben ist – es folgt, dass P = N P. E<strong>in</strong> ungerichteter Graph G als E<strong>in</strong>gabe<br />
wird von A wie folgt bearbeitet:<br />
Der Algorithmus Aε wird auf das TSP angewendet mit n Städten und<br />
<br />
1 falls (i, j) e<strong>in</strong>e Kante von G ist<br />
di,j =<br />
2 + ⌈εn⌉ falls nicht,<br />
wobei ⌈εn⌉ die kle<strong>in</strong>ste ganze Zahl ≥ εn ist. Bezeichnen wir mit c die Kosten der<br />
Tour, die Aε f<strong>in</strong>det. Der Algorithmus A liefert die Antwort<br />
JA genau dann, wenn c ≤ (1 + ε)n.<br />
Korrektheit des Algorithmus A: wir beweisen<br />
In der Tat:<br />
G hat e<strong>in</strong>en Hamiltonschen Kreis ⇐⇒ c ≤ (1 + ε)n.
184 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
1. Jeder Hamiltonsche Kreis von G besteht aus n Kanten, also betragen die<br />
Kosten copt = n. Da Aε ε-approximierend ist, gilt also<br />
und somit<br />
c − n<br />
n<br />
≤ ε<br />
c ≤ (ε + 1)n.<br />
2. Falls die gefundene Rundreise der Bed<strong>in</strong>gung c ≤ (1 + ε)n genügt, zeigen wir,<br />
dass sie nur Kanten aus G enthält, also e<strong>in</strong>en Hamiltonschen Kreis <strong>in</strong> G bildet.<br />
Dazu reicht es, c < 2 + ⌈εn⌉ + (n − 1) zu beweisen, denn jede Rundreise, die<br />
m<strong>in</strong>destens e<strong>in</strong>mal die Kanten von G verläßt, kostet m<strong>in</strong>destens 2 + ⌈εn⌉ (=<br />
Kosten e<strong>in</strong>er Kante außerhalb von G) plus n−1 (die untere Grenze der Kosten<br />
der anderen n − 1 Kanten). Wegen εn < ⌈εn⌉ + 1 folgt<br />
c ≤ (ε + 1)n < n + ⌈εn⌉ + 1 = 2 + ⌈εn⌉ + (n − 1).<br />
Zeitkomplexität des Algorithmus A: für den Algorithmus Aε existiert e<strong>in</strong> Polynom<br />
p(n), so dass Aε die Rundreise <strong>in</strong> der Zeit p(n) f<strong>in</strong>det. Dann dauert die Bearbeitung<br />
des Graphen G höchstens O(n 2 ) Schritte für die Konstruktion von TSP und dann<br />
p(n) Schritte für Aε , <strong>in</strong>sgesamt also O(n 2 + p(n)) Schritte. Das bedeutet, dass A<br />
<strong>in</strong> der Klasse P liegt – im Widerspruch zur N P-Vollständigkeit von HAMILTON-<br />
SCHEM KREIS.<br />
Zusammenfassung: Für Optimierungsprobleme, für die wir ke<strong>in</strong>en effizienten Algorithmus<br />
f<strong>in</strong>den können, können wir versuchen, approximierbare Algorithmen zu<br />
f<strong>in</strong>den. Es gibt Aufgaben, die sogar für jedes ε e<strong>in</strong>en ε-approximierbaren Algorithmus<br />
besitzen, z.B. SIT(k). Leider gibt es aber wichtige Optimierungsaufgaben, die<br />
ke<strong>in</strong>en ε-approximierbaren Algorithmus erlauben, z.B. TSP.<br />
6.12 Raumkomplexität<br />
Bisher haben wir e<strong>in</strong>en Algorithmus als effizient betrachtet, falls er wenig Zeit<br />
braucht. E<strong>in</strong> anderer wichtiger Gesichtspunkt ist der Speicherbedarf e<strong>in</strong>es Algorithmus.<br />
Wie die Zeitkomplexität ist auch die Raumkomplexität pr<strong>in</strong>zipiell von der<br />
Implementation unabhängig, falls wir nur die Frage stellen, ob polynomial großer<br />
Speicher genügt. Deswegen können wir wieder Tur<strong>in</strong>gmasch<strong>in</strong>en als Berechnungsmodell<br />
verwenden. Wir sagen, dass e<strong>in</strong>e TM die Raumkomplexität s(n) hat, wo-<br />
bei s(n) e<strong>in</strong>e Funktion über der Menge<br />
aller natürlichen Zahlen ist, falls für<br />
jede E<strong>in</strong>gabe w der Länge n die TM hält und der Kopf höchstens s(n) Bandfelder<br />
durchgegangen ist.<br />
Def<strong>in</strong>ition. Wir bezeichnen mit<br />
PSPACE<br />
die Klasse aller formalen Sprachen, die von e<strong>in</strong>er TM mit polynomialer Raumkomplexität<br />
akzeptiert werden können. Genauer: e<strong>in</strong>e Sprache L gehört zur Klasse<br />
PSPACE, falls es e<strong>in</strong>e Tur<strong>in</strong>gmasch<strong>in</strong>e M und e<strong>in</strong> Polynom p(n) gibt, so dass<br />
L = L(M) und M hat die Raumkomplexität p(n).<br />
Bemerkung 1. 1. Die vorher e<strong>in</strong>geführten Klassen P und N P werden oft<br />
PT IME und N PT IME<br />
bezeichnet, um sie von PSPACE zu unterscheiden.
6.12. RAUMKOMPLEXITÄT 185<br />
2. Es gilt<br />
PT IME ⊆ PSPACE<br />
denn <strong>in</strong> e<strong>in</strong>em Schritt kann e<strong>in</strong>e TM nur e<strong>in</strong> Bandfeld besuchen. Es folgt, dass<br />
Probleme wie 2-FÄRBUNG, 2-ERFÜLLBARKEIT usw. <strong>in</strong> PSPACE liegen.<br />
3. Das Problem der UNIVERSALITÄT REGULÄRER AUSDRÜCKE (Beispiel<br />
6 <strong>in</strong> 6.2) gehört nicht zur Klasse PSPACE.<br />
4. Die Klasse ” N PSPACE “, die zu N PT IME analog wäre, brauchen wir nicht<br />
e<strong>in</strong>zuführen:<br />
Satz 1 (Savitch-Satz). Jede nichtdeterm<strong>in</strong>istische Tur<strong>in</strong>gmasch<strong>in</strong>e mit polynomialer<br />
Raumkomplexität kann durch e<strong>in</strong>e (determ<strong>in</strong>istische) Tur<strong>in</strong>gmasch<strong>in</strong>e mit polynomialer<br />
Raumkomplexität simuliert werden.<br />
Beweis. Sei M e<strong>in</strong>e NTM mit Raumkomplexität p(n) > n, dann konstruieren wir<br />
e<strong>in</strong>e (determ<strong>in</strong>istische) Tur<strong>in</strong>gmasch<strong>in</strong>e M ∗ , mit der Raumkomplexität O(p 2 (n)),<br />
die dieselbe Sprache akzeptiert. Wir können annehmen, dass M das Band löscht,<br />
bevor sie im f<strong>in</strong>alen Zustand hält. Dann ist (qF,#) die e<strong>in</strong>zige akzeptierende Konfiguration.<br />
Es gibt e<strong>in</strong>e Konstante C, so dass die Berechnung e<strong>in</strong>es Wortes der Länge n höchstens<br />
2 Cp(n)<br />
Konfigurationen durchläuft. In der Tat haben die Konfigurationen die Form<br />
(q, s1 . . . si . . . s p(n)),<br />
wobei q e<strong>in</strong> Zustand ist, s1 . . .s p(n) ist der Inhalt des Bandes und i ist die Kopfposition.<br />
Falls die Masch<strong>in</strong>e<br />
r Zustände<br />
und<br />
m Symbole <strong>in</strong> Σ ∪ {#}<br />
hat, ist die Zahl der Konfigurationen gleich r (für Zustände q) mal p(n) (für Kopfpositionen<br />
i) mal der Zahl m p(n) aller Wörter s1 . . . s p(n) über Σ ∪ {#}. Es gilt<br />
für e<strong>in</strong>e geeignete Konstante C.<br />
rp(n)m p(n) < rm p(n) m p(n) = rm 2p(n) < 2 Cp(n)<br />
Es folgt, dass für jedes von M akzeptierte Wort s1 . . . sn sn e<strong>in</strong>e akzeptierende<br />
Berechnung von höchstens 2 Cp(n) Schritten existiert. In der Tat, nehmen wir die<br />
kürzeste akzeptierende Berechnung von s1 . . . sn, dann wird ke<strong>in</strong>e der 2 C p(n) Konfigurationen<br />
wiederholt. Es gilt:<br />
M akzeptiert s1 . . . sn genau dann, wenn (q0, s1 . . . sn) ⊢ ∗ (qF , #).<br />
Und das können wir durch die Begrenzung 2 Cp(n) der Zahl der Schritte wie folgt<br />
verschärfen:<br />
Für zwei Konfigurationen K und K ′ schreiben wir<br />
REACH(K, K ′ , i) = true
186 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
falls <strong>in</strong> höchstens 2 i Berechnungsschritten aus der Konfiguration K die Konfiguration<br />
K ′ erreicht werden kann. (Z.B. bedeutet REACH(K, K ′ , 0), dass die Konfiguration<br />
K ′ <strong>in</strong> höchstens e<strong>in</strong>em Schritt aus Konfiguration K erreicht werden kann –<br />
d.h., entweder K = K ′ oder K ′ ist e<strong>in</strong>e Folgekonfiguration von K.). Es gilt<br />
M akzeptiert s1 . . . sn genau dann,<br />
wenn REACH(K, K ′ , Cp(n)) = true für K = (q0, s1 . . .sn), K ′ = (qF , #)<br />
Es genügt also, e<strong>in</strong>en Algorithmus zu f<strong>in</strong>den, der die Antwort REACH(K, K ′ , i)<br />
mit polynomialer Raumkomplexität für alle Paare K, K ′ von Konfigurationen und<br />
alle Zahlen i = 0, . . .,Cp(n) berechnet. Die Idee ist, dass es für i = 0 nur die<br />
Überprüfung ist, ob K ′ e<strong>in</strong>e der Folgekonfigurationen ist, die <strong>in</strong> O(1) Zeite<strong>in</strong>heiten<br />
berechnet wird, und aus dem Fall REACH(−, −, i) können wir REACH(−, −, i +<br />
1) wie folgt berechnen: Seien K, K ′ Konfigurationen, für die REACH(K, K ′ , i +<br />
1) = true ist. Also gibt es e<strong>in</strong>e Berechnung <strong>in</strong> 2 i+1 = 2 · 2 i Schritten; sei K die<br />
Konfiguration, die aus K <strong>in</strong> dieser Berechnung <strong>in</strong> 2 i Schritten erreicht wird – dann<br />
gilt REACH(K, K, i) = true und REACH(K, K ′ , i) = true. Umgekehrt: falls es<br />
e<strong>in</strong>e Konfiguration K gibt mit<br />
REACH(K, K, i) = true = REACH(K, K ′ , i),<br />
gilt bestimmt REACH(K, K ′ , i + 1).<br />
Die Antwort REACH(K, K ′ , i) kann für i = 0, . . .,Cp(n) also rekursiv durch den<br />
folgenden determ<strong>in</strong>istischen Algorithmus berechnet werden:<br />
i = 0 : Antwort true genau dann, wenn K = K ′ oder K ⊢ K ′ .<br />
i + 1 : Antwort true genau dann, wenn es e<strong>in</strong>e Konfiguration K gibt mit<br />
REACH(K, K, i) ∧ REACH(K, K ′ , i) = true.<br />
Für i = 0 muß dieser Algorithmus nur die zwei Konfigurationen K, K ′ (Wörter<br />
der Länge p(n) + 1) speichern, also ist der Raumbedarf O(p(n)). Für i + 1 müssen<br />
wir, für den rekursiven Ablauf, i speichern, und neben den E<strong>in</strong>gaben K und K ′<br />
wird die lokale Variable K gespeichert. Dann wird REACH(K, K, i) überprüft.<br />
Falls die Antwort true ist, können wir denselben Raum (!) wieder benutzen, um<br />
REACH(K, K ′ , i) zu überprüfen. Da i ≤ Cp(n) und K, K ′ , K Wörter der Länge<br />
p(n) + 1 s<strong>in</strong>d, wird <strong>in</strong> e<strong>in</strong>em Schritt der Rekursion Raum O(p(n)) genügen. Die<br />
Rekursion hat Cp(n) Schritte, also brauchen wir <strong>in</strong>sgesamt Raum O(Cp 2 (n)).<br />
Korollar 1. N PT IME ⊆ PSPACE<br />
Beweis. In der Tat sagt uns der Savitch-Satz, dass PSPACE = N PSPACE. Und<br />
N PT IME ⊆ N PSPACE ist analog zur Bemerkung 1 Nr. 2 oben.<br />
Bemerkung 2. Die Klasse PSPACE enthält also alle Probleme, für die es (Zeit-)<br />
effizient entscheidbar ist, ob e<strong>in</strong>e angebotene Lösung wirklich das Problem löst. Z.<br />
B. TSP, 3-FÄRBBARKEIT usw. Es ist nicht bekannt, ob N PT IME = PSPACE<br />
gilt.<br />
Wir zeigen jetzt e<strong>in</strong> <strong>in</strong>teressantes Beispiel e<strong>in</strong>es Prolems, für das nicht klar ist, ob es<br />
zu N PT IME gehört, da es ke<strong>in</strong>en vernünftigen Begriff von ” angebotener Lösung“<br />
gibt, das aber zu PSPACE gehört.<br />
Beispiel 1 (QUANTIFIZIERTE BOOLESCHE FORMELN).<br />
E<strong>in</strong>gabe: E<strong>in</strong>e quantifizierte Boolesche Formel φ ohne freie Variablen.
6.12. RAUMKOMPLEXITÄT 187<br />
Ausgabe: JA genau dann, wenn φ den Wert true hat.<br />
Bisher sprachen wir nur über Boolesche Formeln ohne Quantoren (∀x), (∃x). Die<br />
quantifizierten Booleschen Formeln, QBF, <strong>in</strong> Variablen xi (i = 1, . . .,n) können wie<br />
folgt def<strong>in</strong>iert werden:<br />
1. Jede Variable xi ist e<strong>in</strong>e QBF<br />
2. Die Konstanten true und false s<strong>in</strong>d QBF<br />
3. Falls E1, E2 zwei QBF s<strong>in</strong>d, s<strong>in</strong>d auch<br />
QBF’n.<br />
4. Falls E e<strong>in</strong>e QBF ist, s<strong>in</strong>d auch<br />
(für jede Variable x) QBF’n.<br />
E1 ∨ E2, E1 ∧ E2, E1 → E2 und ¬E2<br />
(∀x)E und (∃x)E<br />
Das heißt: die Menge aller QBF ist die kle<strong>in</strong>ste Menge, für die 1 – 4 gilt. Beispiel:<br />
E = (∀x)(∃y)(x → ((∀x)(¬y ∨ x))).<br />
Dies ist e<strong>in</strong>e geschlossene QBF, dass heißt, alle Variablen werden quantifiziert (der<br />
<strong>in</strong>nere Quantor (∀x) wirkt über die Formel (¬y ∨ x), der äußere über (∃y)(x →<br />
((∀x)(¬y ∨x))) ). Jede geschlossene Formel hat e<strong>in</strong>en Wert, den wir bekommen, <strong>in</strong>dem<br />
wir für jede quantifizierte Variable die Belegung mit true oder false betrachten.<br />
Zum Beispiel <strong>in</strong> E müssen wir, aufgrund des äußeren (∀x), die zwei Formeln<br />
und<br />
E1 = (∃y)(true → ((∀x)(¬y ∨ x)))<br />
E2 = (∃y)(false → ((∀x)(¬y ∨ x)))<br />
bewerten: falls beide Werte true s<strong>in</strong>d, ist E true (sonst false). Also<br />
WERT(E) = WERT(E1) ∧ WERT(E2)<br />
Um den Wert von E1 zu bewerten, müssen wir die Werte von<br />
und<br />
E11 = true → ((∀x)(¬true ∨ x))<br />
E12 = true → ((∀x)(¬false ∨ x))<br />
kennen: falls e<strong>in</strong>er der Werte true ist, ist E1 true (sonst false), also<br />
WERT(E1) = WERT(E11) ∨ WERT(E12).<br />
Der Wert von E11 ist false: betrachten wir die Belegung x = true. Aber der Wert<br />
von E12 ist true, da ¬false ∨ x = true ∨ x den Wert true hat für x = false,true.<br />
Also<br />
WERT(E1) = false ∨ true = true.<br />
Analog kann man zeigen, dass WERT(E2) = true, also<br />
WERT(E) = true.
188 KAPITEL 6. KOMPLEXITÄT VON ALGORITHMEN<br />
Im allgeme<strong>in</strong>en def<strong>in</strong>ieren wir die Menge V ar(E) aller freien Variablen e<strong>in</strong>er QBF<br />
wie folgt:<br />
V ar(xi) = {xi}<br />
V ar(true) = V ar(false) = ∅<br />
V ar(E1 ∨ E2) = V ar(E1) ∪ V ar(E2), analog mit ∧, →<br />
V ar(¬E) = V ar(E)<br />
V ar((∀x)E) = V ar((∃x)E) = V ar(E) − {x}<br />
E<strong>in</strong>e QBF heißt geschlossen, falls sie ke<strong>in</strong>e freien Variablen hat, falls also V ar(E) =<br />
∅. Den Wert<br />
WERT(E)<br />
e<strong>in</strong>er geschlossenen QBF def<strong>in</strong>ieren wir wie folgt:<br />
Hier ist<br />
WERT(true) = true<br />
WERT(false) = false<br />
WERT(E1 ∨ E2) = WERT(E1) ∨ WERT(E2), analog mit ∧, →<br />
WERT(¬E) = ¬WERT(E)<br />
WERT((∀x)E) = WERT(E(true/x)) ∧ WERT(E(false/x))<br />
WERT((∃x)E) = WERT(E(true/x)) ∨ WERT(E(false/x))<br />
E(true/x)<br />
die QBF, die wir aus E bekommen, <strong>in</strong>dem alle freien Vorkommen der Variablen x<br />
durch true ersetzt werden, analog E(false/x).<br />
Bemerkung 3. Das Problem QBF gehört zur Klasse PSPACE.<br />
In der Tat existiert e<strong>in</strong> Algorithmus mit Raumkomplexität O(n 2 ), wobei n die Länge<br />
des Wortes E ist, der entscheidet, ob E true ist. Hier bezeichnet E e<strong>in</strong>e geschlossene<br />
Boolesche Formel. Den Wert<br />
berechnen wir rekursiv wie folgt<br />
WERT(E) = true oder false<br />
• falls E = true, ist WERT(E) = true<br />
• falls E = false, ist WERT(E) = false<br />
• falls E = ∀xi(E ′ ) oder E = ∃xi(E ′ ), berechnen wir erst (rekursiv) den Wert<br />
von E(true/xi) Dann speichern wir das Ergebnis (<strong>in</strong> 1 Bit) und auf demselben<br />
Raum (!) berechnen wir E(false/xi), speichern das Ergebnis (wieder 1 Bit)<br />
und entscheiden, ohne zusätzlichen Raum, den Wert von E aufgrund dieser<br />
zwei Werte.<br />
Algorithmus für QBF<br />
E<strong>in</strong>gabe: E, e<strong>in</strong>e QBF ohne freie Variablen.<br />
Ausgabe: der Wert von E, WERT(E), rekursiv berechnet:<br />
WERT(true) := true;<br />
WERT(false) := false;<br />
WERT(∀xi(E)) := WERT(E(true/xi)) ∧ WERT(E(false/xi));<br />
WERT(∃xi(E)) := WERT(E(true/xi)) ∨ WERT(E(false/xi));
6.12. RAUMKOMPLEXITÄT 189<br />
Korrektheit: Jede QBF kann <strong>in</strong> die Form mit Quantoren nach außen gebracht werden.<br />
Falls die Formel <strong>in</strong> dieser Form ke<strong>in</strong>e freien Variablen besitzt, muß sie e<strong>in</strong>e der<br />
4 Typen oben se<strong>in</strong>. Die Rekursion erfolgt nach der Zahl k aller Quantoren von E.<br />
Für k = 0 ist E = true oder E = false, falls k > 0 ist, gilt E = ∀xi(E) oder<br />
E = ∃xi(E), wobei für E die Zahl aller Quantoren k − 1 ist. Nach k Rekursionsschritten<br />
wird also WERT(E) berechnet se<strong>in</strong>.<br />
Raumkomplexität: Sei E e<strong>in</strong>e QBF der Länge n. Die Zahl k aller Quantoren <strong>in</strong><br />
E erfüllt k < n. Die Rekursion hat also Tiefe n und <strong>in</strong> jedem rekursiven Schritt<br />
brauchen wir, wie oben erklärt wurde, nur Raum um 2 Bit größer als der Raum<br />
des nächsten Schrittes. Das Wort E hat Länge n, also haben die <strong>in</strong> der Rekursion<br />
gespeicherten Wörter Länge O(n), was mit n rekursiven Schritten Raum O(n 2 )<br />
verlangt.<br />
Offenes Problem: Liegt QBF <strong>in</strong> N PT IME?<br />
In der Tat sche<strong>in</strong>t dies unwahrsche<strong>in</strong>lich, denn QBF ist PSPACE-vollständig,<br />
das heißt für jedes Problem der Klasse PSPACE gibt es e<strong>in</strong>e Reduktion auf QBF<br />
<strong>in</strong> polynomialer Zeit (!). Falls also QBF ∈ N PT IME ist, folgt N PT IME =<br />
PSPACE.