18.09.2013 Aufrufe

Skript in PDF - Theoretische Informatik - Technische Universität ...

Skript in PDF - Theoretische Informatik - Technische Universität ...

Skript in PDF - Theoretische Informatik - Technische Universität ...

MEHR ANZEIGEN
WENIGER ANZEIGEN

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

YUMPU macht aus Druck-PDFs automatisch weboptimierte ePaper, die Google liebt.

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.

Hurra! Ihre Datei wurde hochgeladen und ist bereit für die Veröffentlichung.

Erfolgreich gespeichert!

Leider ist etwas schief gelaufen!