THEORETISCHE INFORMATIK II

THEORETISCHE INFORMATIK II Vorlesungsskript Jiˇr´ı Ad´amek Institut fu ¨r Theoretische Informatik Technische Universit¨at Braunschweig Juni 2013 ...
11 downloads 4 Views 1MB Size
THEORETISCHE INFORMATIK II

Vorlesungsskript

Jiˇr´ı Ad´amek

Institut fu ¨r Theoretische Informatik Technische Universit¨at Braunschweig

Juni 2013

Inhaltsverzeichnis 1 Endliche Automaten

1

1.1

Mathematische Grundbegriffe . . . . . . . . . . . . . . . . . . . . . . .

2

1.2

Definition der endlichen Automaten . . . . . . . . . . . . . . . . . . .

5

1.3

Nichtdeterministische Automaten . . . . . . . . . . . . . . . . . . . . .

10

1.4

Regul¨ are Sprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

16

1.5

21

1.6

Ableitungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ¨ Aquivalente Zust¨ ande . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1.7

Konstruktion eines Quotient-DEA . . . . . . . . . . . . . . . . . . . .

25

1.8

Minimierung von Automaten . . . . . . . . . . . . . . . . . . . . . . . . ¨ Nerode-Aquivalenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

26

1.10 Beweise der Regularit¨ at . . . . . . . . . . . . . . . . . . . . . . . . . . .

31

1.11 Moore- und Mealy-Automaten . . . . . . . . . . . . . . . . . . . . . . .

34

1.9

2 Kontextfreie Sprachen und Kellerautomaten

23

28

37

2.1

Die Idee einer formalen Grammatik . . . . . . . . . . . . . . . . . . . .

37

2.2

Kontextfreie Grammatik . . . . . . . . . . . . . . . . . . . . . . . . . .

38

2.3

Anwendungen von kontextfreien Grammatiken . . . . . . . . . . . . .

42

2.4

Ableitungsb¨ aume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

44

2.5

Kontextfreie und regul¨ are Sprachen . . . . . . . . . . . . . . . . . . . .

49

2.6

Eigenschaften kontextfreier Sprachen . . . . . . . . . . . . . . . . . . .

54

2.7

Nullierbare Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . .

61

2.8

Chomsky-Normalform . . . . . . . . . . . . . . . . . . . . . . . . . . . .

63

2.9

Algorithmen f¨ ur formale Sprachen . . . . . . . . . . . . . . . . . . . . .

69

2.10 Kellerautomaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

71

2.11 Kellerautomaten und kontextfreie Sprachen . . . . . . . . . . . . . . .

75

3 Turingmaschinen

79

3.1

Definition einer Turingmaschine . . . . . . . . . . . . . . . . . . . . . .

79

3.2

Modifikationen von Turingmaschinen . . . . . . . . . . . . . . . . . . .

85

3.2.1

TM mit mehreren finalen Zust¨anden . . . . . . . . . . . . . . .

85

3.2.2

TM mit zus¨ atzlichem Ged¨achtnis . . . . . . . . . . . . . . . . .

86

i

ii

INHALTSVERZEICHNIS 3.2.3

TM mit erweitertem Bandalphabet . . . . . . . . . . . . . . .

87

3.2.4

TM mit mehrspurigem Band . . . . . . . . . . . . . . . . . . .

88

3.2.5

TM mit mehreren B¨andern . . . . . . . . . . . . . . . . . . . .

89

3.3

Nichtdeterministische Turingmaschinen . . . . . . . . . . . . . . . . .

92

3.4

Rekursiv aufz¨ ahlbare Sprachen . . . . . . . . . . . . . . . . . . . . . . .

96

3.5

Rekursive Sprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

97

4 Church-Turing-These, rekursive Funktionen und Grammatiken

101

4.1

Berechenbare Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . 101

4.2

Primitive Rekursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

4.3

µ-rekursive Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

4.4

Grammatiken und Turingmaschinen . . . . . . . . . . . . . . . . . . . 110

4.5

Universelle Turingmaschine . . . . . . . . . . . . . . . . . . . . . . . . . 116

4.6

Das Halteproblem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

4.7

Ein Rechner als Turing-Maschine . . . . . . . . . . . . . . . . . . . . . 122

5 Unentscheidbare Probleme

125

5.1

Das Akzeptanzproblem . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

5.2

Akzeptanz des leeren Wortes . . . . . . . . . . . . . . . . . . . . . . . . 126

5.3

Ist eine TM ein Algorithmus? . . . . . . . . . . . . . . . . . . . . . . . 127

5.4

Das Problem von “hello world” Programmen . . . . . . . . . . . . . . 128

5.5

Satz von Rice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

5.6

Minimierung von Turingmaschinen . . . . . . . . . . . . . . . . . . . . 131

6 Komplexit¨ at von Algorithmen

133

6.1

Beispiele effizienter Algorithmen . . . . . . . . . . . . . . . . . . . . . . 134

6.2

Komplexit¨ atsklasse P . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140

6.3

Berechnungsprobleme und Reduzierbarkeit . . . . . . . . . . . . . . . 144

6.4

Robustheit der Klasse P . . . . . . . . . . . . . . . . . . . . . . . . . . 149 6.4.1

TM mit zus¨ atzlichem Ged¨achtnis . . . . . . . . . . . . . . . . . 150

6.4.2

TM mit mehrspurigem Band . . . . . . . . . . . . . . . . . . . 150

6.4.3

Mehr-Band TM . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

6.4.4

RAM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

6.5

Geometrische Algorithmen und reelle RAM . . . . . . . . . . . . . . . 152

6.6

Komplexit¨ atsklasse N P . . . . . . . . . . . . . . . . . . . . . . . . . . . 163

6.7

N P-Vollst¨ andigkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165

6.8

Weitere N P-vollst¨ andige Probleme . . . . . . . . . . . . . . . . . . . . 170

6.9

Komplexit¨ atsklasse coN P . . . . . . . . . . . . . . . . . . . . . . . . . 174

6.10 Komplexit¨ at von Optimierungsproblemen . . . . . . . . . . . . . . . . 176 6.11 Approximation von Optimierungsproblemen . . . . . . . . . . . . . . 181 6.12 Raumkomplexit¨ at . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186

Kapitel 3

Turingmaschinen kapTM

Weder endliche Automaten noch Kellerautomaten sind gen¨ ugend starke Berechnungsmodelle, denn sie sind nicht f¨ahig, selbst so einfache Sprachen wie z. B. {an bn cn ; n ≥ 1} zu akzeptieren. Wir f¨ uhren jetzt ein Modell einer Maschine ein, die eine sehr starke Leistung hat, obwohl die Definition nicht komplizierter als die der Kellerautomaten ist: die Turingmaschinen. Diese Maschinen wurden von Alan Turing in den 1930’er als Formalisierung des intuitiven Begriffs des Algorithmus eingef¨ uhrt. Turing versuchte zu zeigen, dass jeder Rechenprozess, den ein Mensch aufgrund einer (endlichen, eindeutigen) Anweisung durchf¨ uhren kann, auch automatisch von einer Maschine durchgef¨ uhrt werden kann. Was einem menschlichen Rechner zur Verf¨ ugung steht, ist eine endliche Liste von Instruktionen, die zusammen mit den Daten in seinem Ged¨ achtnis eine endliche Menge von (inneren) Zust¨anden formt. Außerdem hat er einen unbeschr¨ankten Raum, in dem er lesen, schreiben und u ¨berschreiben darf. Das kann (zweidimensional) durch einen beliebig erweiterbaren Papierstoß realisiert werden, oder ¨aquivalent, falls alle Zeilen als Erweiterungen der ersten angesehen werden, als ein (eindimensionales) unendliches Band. Das formale Modell ist dann dem eines Kellerautomaten ¨ahnlich: anstelle des Kellers gibt es hier ein Band, auf dem sich ein read-and-write-Kopf unbeschr¨ankt bewegt. Die Leistungsf¨ ahigkeit von Turingmaschinen ist trotzdem unvergleichlich gr¨oßer als die der Kellerautomaten. Es zeigt sich, dass die Klasse aller Probleme, die mit Turingmaschinen gel¨ ost werden k¨ onnen, dieselbe ist wie die Klasse aller Probleme, die moderne Rechner mit modernen Programmiersprachen l¨osen k¨onnen. Die Churchsche These, die wir s0p¨ ater genauer erl¨autern, behauptet, dass die Turingmaschine sogar ein ganz allgemeines Modell des Begriffs des Algorithmus ist. Also kann ein Problem genau dann mit einem Algorithmus gel¨ost werden, wenn eine Turingmaschine es l¨ osen kann. Diese These kann nicht bewiesen werden (der Begriff des Algorithmus ist eben doch nur intuitiv), aber sie wurde mehrmals u ¨berzeugend dadurch untermauert, dass andere – oft grunds¨atzlich verschiedene – Berechnungsmodelle dieselbe Klasse l¨ osbarer Probleme ergeben.

3.1

Definition einer Turingmaschine

Eine Turingmaschine besteht – analog zum Kellerautomaten – aus inneren Zust¨anden, externem Speicher und einer Betriebseinheit, die aufgrund des momentanen Zustandes und des gerade gelesenen Symbols entscheidet, welcher der n¨achste Zustand ist und wie der Speicher ge¨andert wird. Im Vergleich zu Kellerautomaten hat hier der Speicher den Typ eines (unbeschr¨ankten) Bandes, auf dem sich ein 79

80

KAPITEL 3. TURINGMASCHINEN

Lese-/Schreibkopf frei bewegt: ...

a b b a ⇑ {

● q0

q3 ●



... Band

Kopf

Betriebseinheit ● q1

● q2

(Obwohl das Band unbeschr¨ ankt ist, ist zu jedem Zeitpunkt nur ein endlicher Teil beschrieben; der Rest ist leer.) Noch ein Unterschied im Vergleich zu den Kellerautomaten: wir arbeiten zuerst nur mit deterministischen Turingmaschinen, denn sie sind (wie im Fall der endlichen Automaten) genauso leistungsf¨ahig wie die nichtde¨ terministischen. Das beweisen wir sp¨ater. Die Ubergangsfunktion δ einer Turingmaschine entscheidet aufgrund des momentanen Zustandes q und des gerade gelesenen Bandsymbols s, ob 1. sich der Zustand zu q ′ ¨andert und sich der Kopf nach links (L) oder rechts (R) bewegt oder andert und der Kopf das momentane Bandsymbol mit 2. sich der Zustand zu q ′ ¨ einem neuen Symbol s′ u ¨berschreibt. Das beschreiben wir als Funktion δ(q, s) = (q ′ , s′ ), wobei s′ = L, R oder s′ ∈ Σ ist. (Σ ist das gegebene Eingabealphabet). Wir m¨ ussen aber auch Bandfelder, die nicht beschriftet sind, behandeln. Dazu f¨ uhren wir ein Spezialsymbol # (Blank) ein, das unbeschriftete Felder bezeichnet. In der Formel δ(q, s) = (q ′ , s′ ) sind q und q ′ also Zust¨ ande, s ein Symbol aus Σ ∪ {#} und s′ ein Symbol aus Σ ∪ {#,L,R}. Obwohl die Turingmaschine, wie wir sie jetzt definieren, deterministisch ist, gibt es neben 1. und 2. noch eine weitere M¨oglichkeit f¨ ur ihr Verhalten, n¨amlich dass 3. die Maschine im Zustand q auf dem Bandsymbol s h¨alt und die Berechnung endet. Formal wird dies dadurch beschrieben, dass δ(q, s) nicht definiert ist. Hier ist δ also eine partielle Funktion. Es gibt einen wichtigen Grund f¨ ur diesen dritten Fall: der Kopf der Turingmaschine ist kein read-only-Kopf (wie im Fall der endlichen Automaten und Kellerautomaten). Der Impuls, eine Berechnung zu beenden, erfolgt hier also nicht durch das Ende der Eingabe. Im Vergleich mit den DEA oder Kellerautomaten ergibt sich eine kleine Vereinfachung: es gen¨ ugt ein finaler Zustand, wir brauchen keine Menge F ⊆ Q (vergleiche 3.2 unten). sectDefTuringmaschine defTuringmaschine

¯ = Σ ∪ {∗} als die Menge aller Bandsymbole. Notation. Wir bezeichnen Σ Definition. Eine Turingmaschine (TM) ist ein F¨ unftupel M = (Q, Σ, δ, q0 , qF ) wobei

3.1. DEFINITION EINER TURINGMASCHINE Q Σ δ q0 ∈ Q qF ∈ Q

81

eine endliche Menge (aller Zust¨ande), eine endliche Menge (das Eingabealphabet), die die Symbole L, R und # nicht enth¨ alt, ¨ eine partielle Funktion (die Ubergangsfunktion) mit Definitionsbereich Q × (Σ ∪ {#}) und Wertebereich Q × (Σ ∪ {#,L,R}), der Initialzustand und der Finalzustand ist.

Notation. Wir schreiben statt δ(q, s) = (q ′ , s′ ) oft nur (q, s) → (q ′ , s′ ) ¨ und sprechen von Ubergangsregeln. Wenn s′ = L, bedeutet diese Regel, dass der ¯ liegt, wird das gelesene Lesekopf nach links geht. Analog f¨ ur s′ = R. Wenn s′ in Σ ′ Symbol s durch s u ¨berschrieben und der Kopf bewegt sich nicht.

sectBspAltDreiEinsEins bspAltDreiEinsEins

Beispiel 1. Teilbarkeit durch 5. Der Algorithmus, der f¨ ur eine Zahl entscheidet, ob sie durch 5 teilbar ist, ist einfach: akzeptiert werden Zahlen mit der letzten Ziffer 0 oder 5. Wir lesen also die Eingabe s1 . . . sn bis wir das letzte beschriebene Feld sn erreichen (also: bis # erscheint und dann einen Schritt zur¨ uck). Falls sn = 0 oder 5, gehen wir in den Finalzustand qF u ¨ber: (q0 , i) → (q0 , R) f¨ ur i = 0, 1, . . . , 9 (wir lesen weiter) (q0 , #) → (q1 , L) einen Schritt zur¨ uck und in den neuen Zustand q1 (q1 , 0) → (qF , 0) } falls sn = 0 oder 5, ist der letzte Zustand qF (q1 , 5) → (qF , 5) Genauer: die folgende TM M = ({q0 , q1 , qF }, {0, 1, . . . , 9}, δ, q0 , qF ), ¨ deren Ubergangsregeln oben aufgelistet sind, akzeptiert die Sprache aller W¨orter u ber Σ = {0, 1, . . . , 9}, die mit 0 oder 5 enden. Beispiel einer Berechnung: f¨ ur die ¨ Eingabe 132 wird die TM die folgenden Schritte machen: ...

# # 1 3 2 # # # #

...

Initialkonfiguration

⇑ q0 ...

# # 1 3 2 # # # #

...

⇑ q0 ...

# # 1 3 2 # # # #

...

⇑ q0 ...

# # 1 3 2 # # # #

...

⇑ q0 ...

# # 1 3 2 # # # #

...

Haltekonfiguration

⇑ q1 ¨ Da kein Ubergang (q1 , 2) → definiert ist, h¨alt hier die Turingmaschine. Die Eingabe 132 wird nicht akzeptiert, da q1 nicht der Finalzustand ist.

82

KAPITEL 3. TURINGMASCHINEN

Die Berechnung von Eingaben formalisieren wir jetzt. Konfigurationen: Eine Konfiguration einer Turingmaschine ist die vollst¨andige Information u ¨ber die TM zu einem Zeitpunkt der Berechnung; sie wird durch (1) den momentanen Zustand q, (2) den Inhalt des Bandes und (3) die Position des Kopfes bestimmt. Also ist (1) ein Element der Menge Q. Wir k¨onnen (2) und (3) zusammenfassen, indem wir sagen, welches Wort uL links vom Kopf steht, welches Wort uR rechts steht und welches Symbol a aus Σ = Σ ∪ {#} der Kopf liest. Dabei ist uL entweder leer, oder hat das erste Symbol aus Σ und die weiteren aus Σ: uL ∈ Σ × Σ ∪ {ε}. ∗

Analog uR ∈ Σ × Σ ∪ {ε}. ∗

Eine Konfiguration ist also ein Quadrupel ∗ ∗ (q, u, a, v), wobei q ∈ Q, u ∈ Σ × Σ ∪ {ε}, a ∈ Σ und v ∈ Σ × Σ ∪ {ε}. Die Menge aller solcher Quadrupel K = Q × (Σ × Σ ∪ {ε}) × Σ × (Σ × Σ ∪ {ε}) ∗



heißt Konfigurationsmenge. Die u ¨blichere (und u ¨bersichtlichere) Schreibweise ist, u, a, v zu konkatenieren und a zu unterstreichen: (q, uav). In Beispiel 1 hat die Berechnung also die Konfigurationen (q0 , 132) (q0 , 132) (q0 , 132) (q0 , 132#) und (q1 , 132) Berechnung: Die Eingabe s1 s2 . . . sn ∈ Σ∗ wird immer so auf das Band geschrieben, dass die Buchstaben ohne Leerzeichen hintereinander stehen. Der Kopf wird auf den ersten Buchstaben gestellt und der Zustand ist initial. Mit anderen Worten heißt das: wir erwarten am Anfang, dass die Konfiguration die folgende Form hat: (∗) (q0 , s1 s2 . . . sn ), wobei s1 . . . sn ∈ Σ∗ . Der Fall der leeren Eingabe ε ∈ Σ∗ (also n = 0) entspricht der Konfiguration (q0 , #). Konfigurationen der Form (∗) heißen Initialkonfigurationen. Falls die Turingmaschine eine Konfiguration (q, s1 s2 . . . si−1 si si+1 . . . sn ) erreicht hat, gibt es zwei M¨ oglichkeiten: entweder ist δ(q, si ) nicht definiert, dann heißt die Konfiguration Haltekonfiguration, oder es gilt δ(q, si ) = (q ′ , s′ ) mit s′ ∈ {L,R} ∪ Σ, dann definieren wir die Folgekonfiguration wie folgt: 1. falls s′ =L, dann ist die Folgekonfiguration (q ′ , s1 s2 . . . si−1 si si+1 . . . sn ) 2. falls s′ =R, dann ist die Folgekonfiguration (q ′ , s1 s2 . . . si−1 si si+1 . . . sn ) 3. falls s′ ∈ Σ, dann ist die Folgekonfiguration (q ′ , s1 s2 . . . si−1 s′ si+1 . . . sn ).

3.1. DEFINITION EINER TURINGMASCHINE Konfiguration (q, s1 s2 . . . si−1 si si+1 . . . sn ) (q, s1 s2 . . . si−1 si si+1 . . . sn ) (q, s1 s2 . . . si−1 si si+1 . . . sn ) (q, s1 s2 . . . si−1 si si+1 . . . sn )

δ(q, si ) (q ′ , L) (q ′ , R) (q ′ , s′ ) nicht definiert

83

Folgekonfiguration (q , s1 s2 . . . si−1 si si+1 . . . sn ) (q ′ , s1 s2 . . . si−1 si si+1 . . . sn ) (q ′ , s1 s2 . . . si−1 s′ si+1 . . . sn ) keine (Haltekonfiguration) ′

Tabelle 3.1: Definition tabFolgekonfiguration der Folgekonfiguration der TM

tTabFolgekonfiguration

Diese Definition ist in Tabelle 3.1 zusammengefasst. Bemerkung 1. Wie ist der Fall 1 zu verstehen, falls i = 1 gilt? Die Folgekonfiguraurlich (q ′ , #s1 . . . sn ). Analog folgt im Fall 2 aus i = n, tion zu (q0 , s1 . . . sn ) ist nat¨ dass die Folgekonfiguration (q ′ , s1 . . . sn #) ist. Notation. Die Relation Folgekonfiguration“ auf der Menge K aller Konfiguratio” nen bezeichnen wir mit dem Symbol ⊢. Also ergibt der 1. Fall (q, s1 s2 . . . si−1 si si+1 . . . sn ) ⊢ (q ′ , s1 s2 . . . si−1 si si+1 . . . sn ) usw. Die reflexive und transitive H¨ ulle dieser Relation wird mit ⊢∗ bezeichnet; d.h., ∗ ′ K ⊢ K bedeutet, dass K und K ′ zwei Konfigurationen sind, die entweder gleich sind oder dass es Konfigurationen K = K0 , K1 , . . . , K n = K ′ mit Ki−1 ⊢ Ki f¨ ur i = 1, . . . , n gibt. Wir sagen, dass die Konfiguration K ′ von K berechenbar ist. In Beispiel 1 in Abschnitt 3.1 gilt (q0 , 132) ⊢ (q0 , 132) ⊢ . . . ⊢ (q1 , 132) und, die letzte Konfiguration hat keine Folgekonfiguration, da sie eine Haltekonfiguration ist.

sectDefTMKonfiguration defTMKonfigurationen

Definition. F¨ ur jede Turingmaschine ist die Berechnung einer Eingabe s1 s2 . . . sn ∈ Σ∗ eine endliche oder unendliche Liste von Konfigurationen: K0 ⊢ K1 ⊢ K2 ⊢ . . . wobei 1. K0 die Initialkonfiguration mit K0 = (q0 , s1 s2 . . . sn ) ist, und 2. falls die Liste endlich ist, ist die letzte Konfiguration eine Haltekonfiguration. Wir sagen, dass die Turingmaschine die Eingabe genau dann akzeptiert, wenn ihre Berechnung endlich ist und der Zustand der letzten Konfiguration final ist. Bemerkung 2. Die Berechnung einer Eingabe w hat also drei m¨ogliche Ergebnisse: 1. die TM h¨ alt und akzeptiert w, 2. die TM h¨ alt und akzeptiert w nicht, 3. die TM h¨ alt nicht (und akzeptiert w deshalb nicht). Am Anfang ist die Eingabe kompakt“, also ohne Unterbrechung (durch #) auf dem ” Band geschrieben. Im Verlauf der Berechnung kann # an jeder Stelle erscheinen.

84

KAPITEL 3. TURINGMASCHINEN

Beispiel 1. (Fortsetzung) Die Berechnung der Eingabe 132 haben wir beschrieben. Die letzte Konfiguration ist (q1 , 132). Da q1 nicht final ist, wird 132 nicht akzeptiert. Auch das leere Wort wird nicht akzeptiert: hier haben wir eine 1-Schritt-Berechnung, denn (q0 , #) ist eine Haltekonfiguration, und q0 ist nicht final.

sectDefSpracheEinerTM defSpracheEinerTM

Diese Turingmaschine h¨ alt auf jede Eingabe (eine wichtige Eigenschaft, wie wir sp¨ ater erfahren werden) und akzeptiert genau die Eingaben, deren letztes Symbol 0 oder 5 ist. Definition. F¨ ur jede Turingmaschine M = (Q, Σ, δ, q0 , F ) bezeichnen wir mit L(M ) die Sprache aller W¨ orter u ¨ber Σ, die M akzeptiert.

sectBspAltDreiEinsDrei bspAltDreiEinsDrei

Beispiel 2. DEA als Turing-Maschine. Gegeben sei ein DEA, A = (Q, Σ, δ, q0 , F ), definieren wir eine TM ¯ q0 , qf ) wobei qf ∈/ Q A¯ = (Q ∪ {qf }, Σ, δ, wie folgt: / q ′ in A entspricht der Ubergang ¨ (q, s)

¨ (a) jedem Ubergang (q, s) in A¯

/ (q ′ , R)

und ¨ (b) f¨ ur jeden Zustand q ∈ F , der in A final ist, den Ubergang (q, ∗)

/ (qf , ∗) .

Dann hat die Turing-Maschine dieselbe Berechnung einer Eingabe s1 . . . sn wie der DEA: wir starten in . . . s1 s2

. . . sn

...

⇑ q0 ¨ und f¨ ur den Ubergang (q0 , s1 )

/ q1 in A ist die n¨achste Konfiguration

. . . s1 s2

. . . sn

...

. . . sn

...

⇑ q1 usw. Wenn wir die Konfiguration . . . s1 s2

⇑ qn erreichen, dann qn final ⇒ die n¨ achste Konfiguration mit Zustand qf akzeptiert und qn nicht final ⇒ keine weitere Konfiguration und die letzte akzeptiert nicht.

3.2. MODIFIKATIONEN VON TURINGMASCHINEN

85

Bemerkung 3. F¨ ur einen DEA von k Zust¨anden und m Eingaben hat die entsprechende TM km + 1 Zust¨ ande. Beispiel 3. Eine Turing-Maschine f¨ ur die Sprache a+ b+ c+ Da diese Sprache regul¨ ar ist, wird sie durch einen DEA akzeptiert: a



/ qo

b



a

/ q1

c



/ q2

b a,c

b,c



c

/ q3

'

a,b

q5

~w

a,b,c

U

a,b,c

Diesen DEA k¨ onnen wir als eine TM mit 5 × 3 + 1 = 16 Zust¨anden simulieren. Beispiel 4. Die Sprache aller W¨orter der Form [an bn cn ] mit n = 1, 2, 3, . . . ist nicht kontextfrei. (Beweis analog zu dem f¨ ur an bn cn .) Aber sie kann durch eine einfache TM akzeptiert werden. Die Simulieren den folgenden Algorithmus: 1. u ufe, ob das innere Wort in der Sprache a+ b+ c+ liegt: dann gen¨ ugt die TM ¨berpr¨ aus dem vorigen Beispiel. 2. rekursiv l¨ osche ein a dann ein b und dann ein c solange bis der Inhalt des Bandes die Form [## . . . #] Wenn 2. gelungen ist, akzeptiere, sonst akzeptiere nicht.

3.2

Modifikationen von Turingmaschinen

sectModifikationenTM

Wir behaupteten in der Einleitung zu diesem Kapitel, dass Turingmaschinen zu einer starken Leistung f¨ ahig sind. Das ist auf den ersten Blick nicht leicht zu erkennen. Aber wir f¨ uhren jetzt kompliziertere Maschinen ein, mit deren Hilfe schon recht komplizierte Sprachen akzeptiert werden k¨onnen. Anschließend zeigen wir, dass sich alle diese neuen Maschinen auf den einfachen Fall reduzieren lassen. (Das ist keine ¨ Uberraschung: erinnern wir uns an die Churchsche These, die behauptet, dass sich alle Berechnungsmodelle auf TM reduzieren lassen!)

subsectTMmehrereFinal

3.2.1

TM mit mehreren finalen Zust¨ anden

Wir k¨ onnen das Konzept der Turingmaschinen zu einer Maschine M = (Q, Σ, δ, q0 , F ) verallgemeinern, die der obigen entspricht, nur ist F ⊆ Q eine Menge finaler Zust¨ ande. Jede solche Maschine kann durch die folgende TM M ′ = (Q ∪ {qF }, Σ, δ ′ , q0 , qF ) ¨ simuliert werden: qF ist ein neuer Zustand, und δ ′ besteht aus allen Ubergangsre′ geln, die in δ enthalten sind, und zus¨atzlich werden in δ noch die folgenden Regeln

86

KAPITEL 3. TURINGMASCHINEN

(q, s) → (qF , s) aufgenommen, wobei q ∈ F ein Zustand ist, f¨ ur den δ(q, s) undefiniert ist. (Also f¨ uhren Haltekonfigurationen (q, s) von M , bei denen q final ist, zu Haltekonfigurationen (qF , s) von M ′ .) Die Anzahl von Schritten, die M ′ macht, ist n + 1 wenn M n Schritte macht.

3.2.2

TM mit zus¨ atzlichem Ged¨ achtnis

subsect-TM-gedaechtnis

Wir k¨ onnen die Definition einer TM so modifizieren, dass die Maschine in jedem Schritt zus¨ atzlich einen Zugriff auf ein Ged¨achtnis hat, wobei Symbole eines end¨ lichen Alphabets A gespeichert werden. Die Ubergangsfunktion δ entscheidet jetzt aufgrund (1) des Zustandes, (2) des gelesenen Symbols aus Σ ∪ {#} und (3) des ¨ gespeicherten Symbols aus A. Die Uberg¨ ange haben jetzt die Form (q, a, s)

sectBspaltDreiZweiEins bspAltDreiZweiEins

/ (q ′ , s′ ) mit q, q ′ ∈ Q, a ∈ A, s ∈ Σ ¯ und s′ ∈ Σ ¯ ∪ L, R

F¨ ur Initialkonfigurationen nehmen wir an, dass ein ausgew¨ahltes Symbol a0 ∈ A gemerkt wird. Beispiel 1. Die Sprache aller W¨orter, deren erstes Symbol nie wieder vorkommt, also L = {s1 . . . sn ∈ Σ∗ ; s1 ≠ si f¨ ur i = 2, . . . , n}, kann durch eine TM mit zus¨atzlichem Ged¨achtnis wir folgt akzeptiert werden: die TM liest das erste Symbol und speichert es im Ged¨achtnis (also A = Σ, d.h., das zus¨ atzliche Ged¨ achtnis kann ein Symbol aus Σ speichern). Dies in Initialzustand q0 . Dann vergleicht die TM im Zustand q1 die anschließend gelesenen Symbole mit ¨ dem gespeicherten und h¨ alt und akzeptiert nicht, falls sie eine Ubereinstimmung feststellt. Sobald die TM das Blanksymbol liest, h¨alt sie und akzeptiert im Zustand q0 , der initial sowie final ist. Diese TM braucht nur zwei Zust¨ande: q0 , initial und final, in dem s1 gespeichert wird, und q1 , in dem nach rechts gegangen und mit dem Speicher verglichen wird. Bemerkung 1. Eine TM mit zus¨atzlichem Ged¨achtnis ist eigentlich eine TM in dem vorher definierten Sinne, deren Zustandsmenge das kartesische Produkt Q×A ist (d. h. die Menge aller Paare (q, a), wobei q ein Zustand und a ∈ A ist). Die ¨ Uberg¨ ange der Maschine sind also von (q, a) ∈ Q × A und s ∈ S abh¨angig. Der Initialzustand ist (q0 , a0 ), und alle Zust¨ande (qF , a), a ∈ A, sind final. Zum Beispiel gilt f¨ ur die Maschine aus Beispiel 1, dass A = Σ (mit s0 ∈ Σ beliebig gew¨ ahlt) und die Zustandsmenge Q = {q0 , q1 } × Σ ist. Wir k¨ onnen sie wie folgt als normale“ TM beschreiben, wobei der Initialzustand ” ¨ (q0 , s0 ) und alle Zust¨ ande (q0 , s) final sind. So gibt es die folgenden Ubergangsregeln: ((q0 , s0 ), s) → ((q1 , s), R) f¨ ur alle s ∈ Σ ((q1 , s), s′ ) → ((q1 , s), R) f¨ ur alle s′ ∈ Σ, s′ ≠ s ((q1 , s), #) → ((q0 , s0 ), #). Zum Beispiel wird die Eingabe stt wie folgt berechnet: ((q0 , s0 ), stt) ⊢ ((q1 , s), stt) ⊢ ((q1 , s), stt) ⊢ ((q1 , s), stt#) ⊢ ((q0 , s0 ), stt#). Hier h¨ alt die TM und akzeptiert.

3.2. MODIFIKATIONEN VON TURINGMASCHINEN

3.2.3

87

TM mit erweitertem Bandalphabet

subsectTMErwBandalph

sectBspAltDreiZweiVier bspAltDreiZweiVier

Manchmal ist es geschickt, zus¨ atzliche (Hilfs-)Symbole auf das Band schreiben zu d¨ urfen, die nicht zum Eingabealphabet geh¨oren. Das bedeutet, dass außer dem Eingabealphabet Σ noch ein Bandalphabet Γ mit Σ ⊆ Γ gegeben wird und die ¨ Ubergangsfunktion δ mit allen Symbolen aus Γ arbeitet, d.h., δ ist eine partielle Funktion mit Definitionsbereich Q×(Γ∪{#}) und Wertebereich Q×(Γ∪{#, L, R}). Eine TM mit erweitertem Bandalphabet ist also ein 6-Tupel M = (Q, Σ, Γ, δ, q0 , qF ) wobei Σ ⊆ Γ das Eingabealphabet und δ ∶ Q × (Γ ∪ {#}) → Q × (Γ ∪ {#, L, R}) eine partielle Funktion ist. Die Sprache, die M akzeptiert, ist die Sprache L(M ) ⊆ Σ∗ aller W¨ orter u ur die M im Finalzustand ¨ber dem (kleineren) Eingabealphabet Σ, f¨ h¨ alt. Beispiel 2. Eine 1-Band TM, die die Sprache {an bn cn ; n ≥ 1} akzeptiert. Hier haben wir Σ = {a, b, c}, und wir benutzen Γ = {a, b, c, [, ]}. Die TM wird erst die Eingabe mit [ und ] umklammern: (q0 , a) → (q0 , L) (q0 , #) → (q0 , [ ) (q0 , [ ) → (q1 , R) (q1 , x) → (q1 , R) f¨ uR x = a, b, c (q1 , #) → (q1 , ] ). Jetzt kann sie die TM von Beispiel 2 in Abschnitt 3.1 simulieren. Beispiel 3. Eine einfache TM f¨ ur die Sprache an bn cn (n ≥ 1). Wir l¨oschen die Symbole nicht, sondern ersetzen sie mit einem neuen Symbol X. Die TM hat das Bandalphabet a, b, c, X und arbeitet wie folgt (der Kopf ignoriert das Symbol X): (1) Das gelesene a wird durch X ersetzt. (2) Kopf geht nach rechts zum ersten b, das mit X ersetzt wird. Wenn keine b gefunden wird oder erst c vorkommt, h¨alt die TM und akzeptiert nicht. (3) Kopf geht nach rechts zum ersten c, das mit X ersetzt wird. Wenn kein c vor # gefunden wird, h¨ alt die TM und akzeptiert nicht. (4) Kopf geht nach links bis # und dann rechts bis (4a) ein a gefunden wird, dann wiederholt sich der Zyklus (1) - (3) oder (4b) b oder c gefunden wird, dann h¨alt die TM und akzeptiert nicht oder (4c) # gefunden wird, dann h¨alt die TM und akzeptiert. Bemerkung 2. F¨ ur jede TM mit erweitertem Bandalphabet M gibt es eine ( nor” male“) TM, die M simuliert. (a) Nehmen wir erst an, dass Γ eine Untermenge von Σ+ ist. D.h. die neuen Symbole ¨ sind W¨ orter s1 . . . sk im urspr¨ unglichen Alphabet Σ. Jeden Ubergang (q, s1 . . . sk )

/ (q ′ , s′ . . . sl ) 1

88

KAPITEL 3. TURINGMASCHINEN ¨ der TM k¨ onnen wir durch eine Sequenz von Uberg¨ angen einer neuen TM mit Bandalphabet Σ simulieren: der Kopf, statt das Wort s1 . . . sk auf einmal zu lesen, liest es in k Schritten und speichert es im zus¨atzlichen Ged¨achtnis. Dann Schreibt der Kopf, statt s′1 . . . s′l auf einmal, das Wort in l Schritten, indem er s1 . . . sk im zus¨ atzlichen Ged¨achtnis zur Verf¨ ugung hat.

(b) Wenn Γ ein beliebiges Alphabet ist, k¨onnen wir es mit W¨ortern aus Σ codieren: da die Menge Γ endlich ist und die Menge Σ+ unendlich ist, gibt es eine injektive Funktion γ ∶ Γ → Σ+ mit γ(s) = s f¨ ur alle s ∈ Σ(⊆ Γ). Dann k¨onnen wir, statt Γ, ¯ = γ(Γ), die Untermenge von Σ+ ist, arbeiten mit der gleichm¨ achtigen Menge Γ und den Fall (a) anwenden.

3.2.4

TM mit mehrspurigem Band

subsectTMMehrspur

Wir arbeiten hier mit einer Modifikation von TM, die darin besteht, dass das Band in k Spuren unterteilt wird, die alle gleichzeitig gelesen werden. Stellen wir uns erst vor, dass k = 2 ist. Wir schreiben Symbole aus dem Eingabealphabet Σ = Σ1 auf Spur 1 und Symbole eines Hilfsalphabetes Σ2 auf Spur 2: ... ...

# 0 1 0 0 1 # # # # # a # b # # a # ⇑

... ...

Die Maschine entscheidet in jedem Schritt abh¨angig vom Zustand und dem Inhalt beider Spuren (1) was der n¨ achste Zustand wird und (2) ob sich der Kopf bewegt oder beide Spuren gleichzeitig u ¨berschrieben werden.

sectBspAltDreiZweiZwei bspAltDreiZweiZwei

Eine 2-Spur-TM ist eigentlich eine TM im vorher definierten Sinne, deren Bandalphabet aus Paaren (s1 , s2 ), mit s1 ∈ Σ1 und s2 ∈ Σ2 , geformt wird. Die einzige Ausnahme ist das Paar (#, #), das jetzt als Blank-Symbol dient. Also ist eine 2Spur-TM einfach eine TM mit dem Eingabealphabet Σ = Σ1 × Σ2 − {(#, #)}. Analoges gilt f¨ ur k-spurige Maschinen, die auf der i-ten Spur Symbole aus Σi tragen (i = 1, . . . , k): das sind also die normalen“ TM mit Eingabealphabet ” Σ = Σ1 × Σ2 × ⋅ ⋅ ⋅ × Σk − {(#, #, . . . , #)} und mit dem Blanksymbol (#, #, . . . , #). Beispiel 4. Primzahltest Wir zeigen, wie man eine 3-spurige TM konstruiert, die die Sprache L aller Primzahlen (in bin¨ arer Darstellung) akzeptiert. Hiermit kann man auch gut die Idee von Turing illustrieren, dass jeder Algorithmus mit einer TM automatisiert werden kann. Wir verwenden hier den primitiven Algorithmus, der jede Zahl n durch alle Testzahlen 2, 3, 4, . . . , n−1 teilt und n akzeptiert, falls alle Divisionen einen positiven Rest ergeben. EINGABESPUR TESTZAHLSPUR HILFSSPUR

... ... ...

1 0 1 1 1 1 0 1 1 0 1 1 1 ⇑ q0

... ... ...

Die Spuren der TM sind (1) Eingabespur, die w¨ahrend der Berechnung unver¨andert bleibt, (2) Testzahlspur, die am Anfang mit 1 beschriftet wird und in jedem Berech-

3.2. MODIFIKATIONEN VON TURINGMASCHINEN

89

nungsdurchgang um eins vergr¨ oßert wird (sodass in dem ersten Berechnungsdurchgang durch 2 dividiert wird, im zweiten mit 3, usw.) und (3) eine Hilfsspur. Wir schreiben am Anfang also die gegebene Zahl n = 1, 2, 3, . . . auf Spur 1, die Zahl 1 auf Spur 2 und nichts auf Spur 3. Der Initialzustand q0 u uft (durch Vergleich ¨berpr¨ mit Spur 2), ob auf Spur 1 eine Zahl n ≥ 2 steht. Im Fall von n = 0 oder n = 1, wird der Zustand q0 zu q− , einem nicht-finalen Haltezustand ver¨ andert. (Also werden 0 und 1 nicht akzeptiert.) Falls n ≥ 2 ist, werden Berechnungsdurchg¨ ange rekursiv durchgef¨ uhrt, die man wie folgt beschreiben kann: Anfang eines Berechnungsdurchganges: Spur 1 wird auf Spur 3 kopiert. Die Zahl auf Spur 2 wird um 1 vergr¨ oßert. Die Spuren 1 und 2 werden verglichen und falls die Zahlen gleich sind, wird der Zustand zu q+ , einem finalen Haltezustand ge¨ andert (die Eingabe wird also akzeptiert, denn keine Zahl kleiner n, die n teilt, wurde gefunden). Rumpf eines Berechnungsdurchganges: Die Zahl von Spur 3 wird durch die auf Spur 2 dividiert (z.B. durch wiederholte Subtraktion). Ende eines Berechnungsdurchganges: Jetzt steht auf Spur 3 der Rest der Eingabe modulo der Testzahl. Falls der Rest 0 ist, wird der Zustand zu q− ver¨andert. Falls der Rest positiv ist, wird der Kopf nach links zum ersten Symbol 1 von Spur 1 geschoben und ein neuer Berechnungsdurchgang beginnt. Es ist leicht einzusehen, dass sich diese informale Beschreibung der Turingmaschine relativ einfach durch eine formal definierte TM realisieren l¨asst.

3.2.5

TM mit mehreren B¨ andern

Die n¨ achste Modifikation von TM ist eine Maschine, die mehrere B¨ander hat und bei der auf jedem Band ein Lese-/Schreibkopf steht. Die k K¨opfe bewegen sich unabh¨ angig voneinander und schreiben auch unabh¨angig voneinander auf ihren individuellen B¨ andern. Die Kontrolle ist aber zentral (durch den gegebenen Zustand): Band 1

...

... ● q0

⇑ Kopf 1 Y

●2 q1

q4 ●

● ● ●

Band 2

...

...

q3

q2

⇑ Kopf 2 \ SCHEMA EINER 2-BAND TM

sectDefKBandTM defKBandTM

¨ Das bedeutet, dass der Ubergangsfunktion δ hier der Zustand q und die k gelesenen Symbole k (s1 , s2 , . . . , sk ) ∈ Σ zur Verf¨ ugung stehen. (Wir bezeichnen mit Ak = A × A × ⋅ ⋅ ⋅ × A die Menge aller k-Tupel von Elementen aus A). Hier ist Σ die Menge aller Bandsymbole von allen k B¨ andern. Als Ergebnis haben wir einen neuen Zustand q ′ und ein k-Tupel von Symbolen aus {L,R} ∪ Σ ∪ {#}. Das heißt, dass δ eine partielle Funktion mit Urbildbereich Q × (Σ ∪ {#})k und Wertebereich Q × (Σ ∪ {#,L,R})k ist. Definition. Eine k-Band-Turingmaschine ist ein F¨ unftupel M = (Q, Σ, δ, q0 , qF ), die wie eine TM definiert wird, nur ist δ jetzt eine partielle Funktion mit Urbildbereich Q × (Σ)k und Wertebereich Q × (Σ ∪ {L,R})k .

90

KAPITEL 3. TURINGMASCHINEN

Die Berechnung durch eine k-Band TM ist analog zum Fall einer 1-Band TM definiert. Eine Konfiguration hat die Form (q, u1 a1 v1 , u2 a2 v2 , . . . , uk ak vk ), wobei q der Zustand und ui ai vi der Inhalt des i-ten Bandes bezeichnet. Falls δ(q, a1 . . . ak ) definiert ist, wird die Folgekonfiguration individuell auf jedem Band berechnet. Falls δ(q, a1 . . . ak ) undefiniert ist, heißt die Konfiguration Haltekonfiguration. Band 1 dient als Eingabeband, das heißt, die Initialkonfiguration f¨ ur eine Eingabe s1 . . . sn ist (q0 , s1 . . . sn , #, #, . . . , #) ´¹¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¸¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹¶ (k−1)−mal

sectBspAltDreiZweiDrei bspAltDreiZweiDrei

Die Eingabe wird akzeptiert, falls die Maschine eine Haltekonfiguration mit dem finalen Zustand erreicht. Beispiel 5. Eine 2-Band TM, die die Sprache {an bn cn ; n ≥ 1} akzeptiert. Die TM hat ein Eingabeband (Band 1) und ein Hilfsband (Band 2). Band 1 bleibt unver¨ andert, Band 2 ist am Anfang leer. Band 1

a a ... a b b ... b c c ... c # # ⇑

Band 2

# # # ... ⇑

Initialkonfiguration

Erste Etappe der Berechnung: Solange der Kopf 1 a liest, schreibt Kopf 2 a, und beide K¨ opfe bewegen sich ein Feld nach rechts. Nur am Anfang schreibt Kopf 2 ein x anstelle von a. Band 1

a a ... a b b ... b c c ... c # # ⇑

Band 2

x a ... a # # # ...

⇑ Zweite Etappe: Hier bewegen sich Kopf 1 und Kopf 2 gleichzeitig in entgegengesetzte Richtungen: Kopf 1 nach rechts und Kopf 2 nach links, bis Kopf 1 c und Kopf 2 x liest. Falls Kopf 1 w¨ ahrend dieser Bewegung immer b und Kopf 2 immer a liest, gehen wir zur dritten Etappe u ¨ber; falls nicht, h¨alt die TM in einem nicht-finalen Zustand (Eingabe nicht akzeptiert). Band 1

. . . ## a a . . . a b b . . . b c c . . . ⇑

Band 2

... # x a ... a # # # ...

⇑ Dritte Etappe: Beide K¨ opfe bewegen sich gleichzeitig nach rechts, bis Kopf 1 # liest. Falls in jedem dieser Schritte außer dem letzten Kopf 1 c und Kopf 2 a liest und

3.2. MODIFIKATIONEN VON TURINGMASCHINEN

91

falls beide K¨ opfe im letzten Schritt # lesen, dann h¨alt die TM im finalen Zustand qF (Eingabe akzeptiert). Falls nicht, h¨alt die TM und akzeptiert nicht. ¨ Formal k¨ onnen wir die Uberg¨ ange wie folgt beschreiben: (q0 , a, #) → (q1 , a, x) Erste Etappe: (q1 , a, x) → (q1 , R, R) (q1 , a, #) → (q1 , a, a) (q1 , a, a) → (q1 , R, R) Zweite Etappe: (q1 , b, #) → (q2 , R, L) (q2 , b, a) → (q2 , R, L) (q2 , c, x) → (q2 , R, R) Dritte Etappe: (q2 , c, a) → (q2 , R, R) (q2 , #, #) → (qF , #, #). ˆ = {a, b, c, x} und ¨ Das sind alle Uberg¨ ange f¨ ur die 2-Band TM mit Bandalphabet Σ Eingabealphabet Σ = {a, b, c}, die die Sprache aller an bn cn (n ≥ 1) akzeptiert. (Vergleichen Sie das mit Beispiel 2 in Abschnitt 3.1). Beispiele von Berechnungen: Die Eingabe aabbcc wird wie folgt berechnet: (q0 , aabbcc, #) ⊢ (q0 , aabbcc, x) ⊢ (q0 , aabbcc, x#) ⊢ (q0 , aabbcc, xx) ⊢ (q0 , aabbcc, xx#) ⊢ (q0 , aabbcc, xx#) ⊢ (q0 , aabbcc, xx#) ⊢ (q0 , aabbcc, xx#) ⊢ (q0 , aabbcc#, xx#) ⊢ (qF , aabbcc#, xx#) und wird akzeptiert. Die Eingabe aabcc wird wie folgt berechnet: (q0 , aabcc, #) ⊢ (q0 , aabcc, x) ⊢ (q0 , aabcc, x#) ⊢ (q0 , aabcc, xx) ⊢ (q0 , aabcc, xx#) ⊢ (q0 , aabcc, xx) ⊢ (q0 , aabcc, xx#) und wird nicht akzeptiert. Bemerkung 3. Simulation einer 2-Band-TM durch eine 1-Band-TM Sei M = (Q, Σ, δ, q0 , F ) eine 2-Band-TM. Wir konstruieren eine 1-Band-TM mit zus¨atzlichem Ged¨ achtnis, M , die die Maschine M Schritt f¨ ur Schritt simuliert. Das Band von M ist 4-spurig:

Band 1

a a b a a ⇑

Band 2

0 1 0

... ... ... ...

a # 0 ⇑

a # 1 #

b # 0 #

a ⇑ # #

a # # #

# # # #

# # # #

# # # #

# # # #

... ... ... ...

⇑ Maschine M

Maschine M

Band 1 der Maschine M wird auf die Spur 1 von M kopiert, die Kopfposition des Kopfes von Band 1 steht auf der Spur 2. Analog wird Band 2 auf Spur 3 von M kopiert und die Kopfposition des Bandes auf Spur 4. Das Eingabealphabet von M

92

KAPITEL 3. TURINGMASCHINEN

ist also Σ = (Σ ∪ {#}) × {⇑, #} × (Σ ∪ {#}) × {⇑, #} − {(#, #, #, #)}, wobei (#, #, #, #) das Blank-Symbol ist. Die Zust¨ ande von M und M sind dieselben. Die Maschine M muss sich die letzten von Kopf 1 und Kopf 2 gelesenen Symbole merken, also hat sie ein zus¨atzliches Ged¨ achtnis der Form (s1 , s2 , x), wobei si ∈ Σi ∪ {#} das aktuelle Symbol von Band i (= 1, 2) der Turingmaschine M ist und x ∈ {l, r} aussagt, ob Kopf 2 (also das Symbol ⇑ auf Spur 4)links oder rechts von Kopf 1 (dem Symbol ⇑ auf Spur 2) steht. 1. Anfang der Simulation: Auf Spur 1 steht die Eingabe v1 v2 . . . vn von M , die Spuren 2 - 4 sind leer. Wir schreiben je ein ⇑ auf die Spuren 2 und 4 unter v1 von Spur 1. SPUR SPUR SPUR SPUR

1 2 3 4

... ... ... ...

# # # #

v1 v2 . . . vn # ⇑ # ... # # ... ⇑ # ...

... ... ... ...

2. Berechnungsschritt: Am Anfang der Simulation einers Schrittes von M steht der Kopf von M unter dem Symbol ⇑ auf Spur 2. Das gerade gelesene Symbol von Spur 1 wird als s1 im zus¨atzlichen Ged¨achtnis gespeichert. Danach sucht der Kopf von M das Symbol ⇑ auf Spur 4: entweder stehen die beiden Symbole ⇑ untereinander, sonst suchen wir links bzw. rechts, falls im zus¨atzlichen Ged¨ achtnis x = l bzw. x = r steht. Sobald ⇑ gefunden ist, wird das gerade gelesene Symbol von Spur 3 als s2 gespeichert. Aufgrund des Zustandes q von M und des Paares (s1 , s2 ) im zus¨atzlichen Ged¨achtnis werden jetzt die Kopfpositionssymbole auf den Spuren 3 und 4 so bewegt, wie die Maschine M die K¨ opfe bewegt, und die Symbole auf den Spuren 1 und 3 werden so u ¨berschrieben, wie M die Symbole auf beiden B¨andern u ¨berschreibt. (Das geschieht in endlich vielen Schritten der Kopfbewegung von M .) Die Eingabe x ∈ {l, r} im Ged¨ achtnis wir aktualisiert und der Kopf wird nach ⇑ auf Spur 2 bewegt. 3. Ende der Simulation: Die Maschine M h¨alt genau dann, wenn eine Haltekonfiguration von M erreicht wird. Und M akzeptiert genau dann, wenn M akzeptiert.

quivalenzKBandTMEinBandTM

quivalenzKBandTMEinBandTM

ministischeTuringmaschine

ministischeTuringmaschine

Satz 1. F¨ ur jede k-Band-TM gibt es eine (1-Band-) TM, die dieselbe Sprache akzeptiert. Beweis. F¨ ur k = 2 folgt der Beweis aus der gerade beschriebenen Simulation und dem Fakt, dass eine 4-spurige TM mit zus¨atzlichem Ged¨achtnis durch eine TM simuliert werden kann (siehe Kapitel 3.2.2). F¨ ur k > 2 ist der Beweis analog und wird dem Leser u ¨berlassen.

3.3

Nichtdeterministische Turingmaschinen

Analog zum Fall nichtdeterministischer Automaten f¨ uhren wir hier nichtdeterministische TM ein. Statt einer partiellen Funktion δ ∶ Q × Σ → Q × Σ ∪ {L,R} haben wir hier eine Relation δ: Definition. Eine nichtdeterministische Turingmaschine M (NTM) ist ein F¨ unftupel M = (Q, Σ, δ, q0 , qF ), das wie eine TM definiert wird, außer dass hier δ

3.3. NICHTDETERMINISTISCHE TURINGMASCHINEN

93

eine Relation δ ⊆ [Q × Σ] × [Q × (Σ ∪ {L,R})] ist.

Wir schreiben, wie oben, (q, s) → (q ′ , s′ ) falls die Relation δ das Quadrupel (q, s, q ′ , s′ ) enth¨alt. Der ganze Unterschied bez¨ uglich der Notation zwischen einer TM und einer nichtdeterministischen TM ist, ¨ dass f¨ ur eine deterministische TM f¨ ur zwei beliebige Ubergangsregeln ′ ′ ′ ′ (q, s) → (q , s ) und (q, s) → (q , s ) gilt, dass, falls die linken Seiten gleich sind (q = q und s = s), auch die rechten Seiten gleich sein m¨ ussen (q ′ = s′ und s′ = s′ ). F¨ ur nichtdeterministische TM gilt keine solche Einschr¨ ankung.

Beispiel 1. stochastischer Zahlengenerator. Wir beschreiben eine nichtdeterministische Turingmaschine M , die auf ihr Band entweder eine beliebige Zahl n ≥ 1 (in bin¨arer Form) schreibt und h¨alt oder nie h¨ alt. Im Initialzustand q0 schreibt M eine 1 und geht zum Zustand q1 , in dem die folgende Wahl getroffen wird: entweder wird der Haltezustand qF erreicht, oder es wird ein neues Symbol 0, 1 geschrieben und (unter Verwendung eines Hilfezustandes q2 ) der Kopf nach rechts bewegt. Formal: M = ({q0 , q1 , q2 , qF }, {0, 1}, δ, q0 , qF ) ¨ wobei δ durch die folgenden Ubergangsregeln beschrieben wird: (q0 , #) → (q0 , 1) (q0 , 1) → (q1 , R) (q1 , #) → (q2 , 0) Beispiel: (q1 , #) → (q2 , 1) (q1 , #) → (qF , #) (q2 , i) → (q1 , R) f¨ ur i = 0, 1.

94

KAPITEL 3. TURINGMASCHINEN ...

... ⇑ q0

...

1 ⇑ q0

...

...

1

... ⇑ q1

...

1 0 ⇑ q2

...

...

1 0

... ⇑ q1

...

1 0 1 ⇑ q2

...

...

1 0 1

... ⇑ q1

...

1 0 1

...

⇑ qF Konfigurationen und die Berechnung von Eingaben sind genauso definiert wie f¨ ur die (deterministischen) TM. Hier hat eine Eingabe nat¨ urlich nicht nur eine, sondern mehrere Berechnungen. sectDefTMAkzeptiertW defTMAkzeptiertW

sectBspAltDreiVierZwei bspAltDreiVierZwei

Definition. Eine nichtdeterministische Turingmaschine M akzeptiert die Eingabe w ∈ Σ∗ , falls es f¨ ur w mindestens eine Berechnung gibt, so dass M nach endlich vielen Schritten eine Haltekonfiguration mit dem finalen Zustand erreicht. Die Sprache aller Eingaben, die M akzeptiert, wird mit L(M ) bezeichnet. Bemerkung 1. Die k-Band-TM lassen sich analog zu den nichtdeterministischen k-Band-TM verallgemeinern: hier ist δ eine Relation k δ ⊆ [Q × Σ ] × [Q × (Σ ∪ {L,R})k ]. Beispiel 2. Test der Zerlegbarkeit. Wir zeigen eine nichtdeterministische 3-Band-TM, die die Sprache L ⊆ {∣}∗ aller zerlegbarer Zahlen, also Zahlen der Form n = pq mit p > 1 und q > 1 akzeptiert. Wie in Beispiel 4 in Abschnitt 3.2.4 hat M ein Eingabeband, ein Testzahlband und ein Hilfsband. Im Initialzustand schreibt M die Zahl zwei (∣∣) auf Band 2 (jede Testzahl ist gr¨ oßer oder gleich ∣∣) und ver¨andert den Zustand zu q1 . In q1 , dem einzigen nichtdeterministischen Zustand, gibt es zwei M¨oglichkeiten: entweder wird ein neuer Strich auf Band 2 geschrieben, und der Zustand q1 bleibt, oder der Zustand ver¨ andert sich zu q2 . Im Zustand q2 wird wie folgt deterministisch berechnet:

3.3. NICHTDETERMINISTISCHE TURINGMASCHINEN

95

1. Die Zahl n auf Band 1 wird mit der Zahl m auf Band 2 verglichen. Falls n ≤ m ist, h¨ alt die Maschine, ohne zu akzeptieren. 2. Falls n > m, wird n auf Band 3 kopiert. 3. Band 2 wird von Band 3 abgezogen, bis auf Band 3 der Rest der Division von n durch die Testzahl steht. Dann h¨alt die Maschine. 4. Falls Band 3 leer ist, wird die Eingabe akzeptiert, falls Band 3 nicht leer ist, wird sie nicht akzeptiert. Wir sehen, dass die Testzahl m eine beliebige Zahl m = 2, 3, 4, . . . sein kann. Die Eingabe n wird genau dann akzeptiert, wenn es ein m < n gibt, das n teilt.

sectBspAltDreiVierDrei bspAltDreiVierDrei

Beispiel 3. Simulation eines Kellerautomaten Wir k¨ onnen einfach jeden Kellerautomaten durch eine nichtdeterministische 2Band-Turingmaschine M simulieren, bei der auf Band 1 die Eingabe des Kellerautomaten und auf Band 2 der Kellerinhalt steht. M hat ein zus¨atzliches Ged¨achtnis, in ¨ dem die Ubergangsregeln des Kellerautomaten notiert werden. Am Anfang schreibt ¨ die NTM das Symbol k0 auf Band 2. Jede Ubergangsregel ′ (q, s, k) → (q , k1 . . . kn ), s ∈ Σ, des Kellerautomaten wird wie folgt simuliert: Band 1

Band 2

. . . s s′ s′′ . . . ⇑ . . . k k ′ k ′′ . . . ⇑

¨ Ubergang

. . . s s′ s′′ . . . ⇑ k1 . . . kn k ′ k ′′ . . . ⇑

Falls die Maschine M im Zustand q die Symbole s (Band 1) und k (Band 2) liest, andert sie ihren Zustand zu q ′ , bewegt den Kopf 1 einen Schritt nach rechts und ¨ macht folgendes auf Band 2: 1. Falls n ≠ 0 (also k1 . . . kn ≠ ε), wird k von kn u ¨berschrieben, und der Kopf 2 schreibt, sich nach links bewegend, die Symbole kn−1 , . . . , k1 . 2. Falls n = 0, l¨ oscht Kopf 2 das Symbol k und bewegt sich einen Schritt nach rechts. ¨ Analog wird jede spontane Ubergangsregel ′ (q, #, k) → (q , k1 . . . kn ) simuliert: der einzige Unterschied ist, dass hierbei Kopf 1 stehenbleibt.

tzSimulationNTMDurchTM

tzSimulationNTMDurchTM

Satz 1. Jede NTM kann durch eine (deterministische) TM simuliert werden. Beweis. Sei M eine NTM, und sei r eine Zahl, so dass es f¨ ur jedes Paar (q, s) aus ¨ Q × (Σ ∪ {#}) h¨ ochstens r Uberg¨ ange (q, s) → (q ′ , s′ ) gibt. Dann k¨onnen wir die ¨ Uberg¨ ange durchnummerieren: ur i = 1, 2, . . . , r (q, s) → (q ′ i , s′ i ) f¨ (Wiederholungen sind erlaubt). Die einzige Ausnahme ist δ(q, s) = ∅ (Haltekonfiguration). Wir simulieren M mit einer 4-Band-TM wie folgt: Band 1 ist das Eingabeband mit einem read-only Kopf. Auf Band 2 werden systematisch alle Zahlen k = 0, 1, 2, 3, . . .

96

KAPITEL 3. TURINGMASCHINEN

geschrieben, sie geben die L¨ ange der Berechnung vor. Auf Band 3 werden systematisch alle k-Tupel aus Zahlen 1, . . . , r erzeugt (k = 1, 2, 3, . . . ). Auf Band 4 werden f¨ ur jeden Eintrag i1 i2 . . . ik von Band 3 die ersten k Takte der Maschine M simuliert, aber in jedem Takt w¨ahlen ¨ ¨ wir den Ubergang, dessen Index auf Band 2 steht. Also wird im Takt n der Ubergang (q, s) → (q ′ in , s′ in ) gew¨ ahlt, wobei q der momentane Zustand ist und s das gerade gelesene Symbol. In einer Haltekonfiguration von M mit q = qF h¨alt M und akzeptiert die Eingabe, andernfalls, also auch bei Haltekonfigurationen mit q =/ qF wird k erh¨ oht und die Simulation fortgesetzt. Es gibt also die folgenden M¨oglichkeiten f¨ ur die Berechnung einer Eingabe w: 1. M h¨ alt auf w nach k Schritten f¨ ur irgendeine Zahl k und akzeptiert w, d.h., es gibt eine akzeptierende Berechnung der L¨ange k von w. Dann h¨alt auch M auf w und akzeptiert w (mit einem der rk m¨oglichen Inhalte von Band 3); 2. M akzeptiert w nicht, d.h., alle von M bei Eingabe w erreichbaren Haltekonfigurationen haben einen von qF verschienedenen Zustand. Dann h¨alt M nie, denn M schreibt immer l¨anger werdende k-Tupel (k = 1, 2, 3, . . . ) auf Band 2. Damit geh¨ ort w weder zu L(M ) noch zu L(M ). Es folgt, dass L(M ) = L(M ).

3.4 sectEntscheidRek defRekursiveSprache sectBspAltDreiDreiEins bspAltDreiDreiEins

Rekursiv aufz¨ ahlbare Sprachen

Definition. Eine Sprache L heißt rekursiv aufz¨ ahlbar oder semientscheidbar , falls es eine Turingmaschine M gibt, die L akzeptiert. Beispiel 1. Die folgenden Sprachen sind rekursiv aufz¨ahlbar, denn die oben konstruierten TM akzeptieren sie: 1. Die Sprache aller durch 5 teilbaren Zahlen (siehe Beispiel 1 in Abschnitt 3.1). 2. Die Sprache aller Primzahlen (siehe Beispiel 4 in Abschnitt 3.2.4). 3. Die Sprache {an bn cn ; n ≥ 1} (siehe Beispiel 5 in Abschnitt 3.2.5 und Satz 1 in Abschnitt 3.2.5). 4. Jede kontextfreie Sprache (siehe Beispiel 3 in Abschnitt 3.3).

sectBspAltDreiDreiZwei bspAltDreiDreiZwei

Beispiel 2. Eine Sprache Lcode , die nicht rekursiv aufz¨ahlbar ist. Es ist nicht m¨ oglich, ein nat¨ urliches“ Beispiel einer nicht rekursiv aufz¨ahlbaren ” Sprache zu finden, da alle nat¨ urlichen“ Beispiele durch irgendeinen Algorithmus ” beschrieben werden. Aber vorausgesetzt, dass wir eine Codierung f¨ ur alle TM mit dem Bandalphabet {0, 1} haben (eine solche Codierung wird in Kapitel 5.1 ausf¨ uhrlich beschrieben), k¨ onnen wir eine konkrete Sprache, die nicht rekursiv aufz¨ahlbar ist, konstruieren. Wir nehmen also an, dass es f¨ ur jede Turingmaschine M mit Bandalphabet {0, 1} ein Wort c(M ) u ¨ber {0, 1} gibt, sodass der Code c(M ) die Sprache der Turingmaschine M vollst¨andig beschreibt. Das heißt, dass f¨ ur alle Turingmaschinen M und M ′ gilt: c(M ) = c(M ′ ) ⇒ L(M ) = L(M ′ ). Mit Lcode bezeichnen wir die Sprache aller Codew¨orter w = c(M ) solcher Turingmaschinen M , die ihr eigenes Codewort nicht akzeptieren: Lcode = {w; w = c(M ) f¨ ur eine Turingmaschine M mit w ∉ L(M )}. Diese Sprache ist nicht rekursiv aufz¨ahlbar.

3.5. REKURSIVE SPRACHEN

ctSatzLLStrichRekursiv satzLLStrichRekursiv

97

ˆ mit L(M ˆ ) = Lcode gibt, Beweis. Die Annahme, dass es eine Turingmaschine M ˆ ) dieser Maschine M ˆ f¨ uhrt zu einem Widerspruch. F¨ ur das Codewort w ˆ = c(M zeigen wir n¨ amlich, dass (a) aus w ˆ ∉ Lcode folgt w ˆ ∈ Lcode und (b) aus w ˆ ∈ Lcode folgt w ˆ ∉ Lcode . Dann ist weder w ˆ ∈ Lcode noch w ˆ ∉ Lcode wahr. ˆ ) und w ˆ ), folgt aus der Definition von Lcode , dass Zu (a): Da w ˆ ∉ L(M ˆ = c(M w ˆ ∈ Lcode . ˆ) Zu (b): Da w ˆ ∈ Lcode , gibt es M mit w ˆ = c(M ) und w ˆ ∉ L(M ). Aus c(M ) = c(M ˆ ); es gilt also w ˆ ) = Lcode . folgt aber L(M ) = L(M ˆ ∉ L(M Satz 1. Falls L und L′ rekursiv aufz¨ ahlbaren Sprachen sind, sind auch die Sprachen L ∪ L′ , L ∩ L′ , LL′ und L∗ rekursiv aufz¨ ahlbar. Beweis. Sei M eine TM, die L akzeptiert, und M ′ eine TM, die L′ akzeptiert. Wir nehmen an, dass M und M ′ auf jede Eingabe halten. (1) L + L′ . Diese Sprache wird von einer 2-Band TM akzeptiert, die auf Band 1 die Maschine M und gleichzeitig auf Band 2 die Maschine M ′ simuliert. Falls beide Maschinen halten, ist der Zustand der neuen Maschine genau dann final, wenn einer der entsprechenden Zust¨ande (von M oder M ′ ) final ist. (2) L ∩ L′ . Der Beweis ist analog zu 1., nur ist ein Zustand genau dann final, wenn beide Zust¨ ande (von M sowie von M ′ ) final sind.

3.5

Rekursive Sprachen

Wie oben erw¨ ahnt, repr¨ asentiert eine TM eine formale Darstellung des Begriffs eines Algorithmus, indem sie eine beliebige Eingabe berechnet (und entweder akzeptiert oder nicht). Die Frage ist, ob wir nur terminierende Algorithmen betrachten d¨ urfen, oder ob wir auch Algorithmen erlauben, die unendlich lange berechnen. Im Berechnungsmodell der TM entsprechen den terminierenden Algorithmen die TM, die auf jede Eingabe halten. Das bedeutet, dass das Nichtakzeptieren immer dadurch erfolgt, dass die TM in einem nichtfinalen Zustand h¨alt. Die allgemeineren, nicht terminierenden Algorithmen werden von allgemeinen TM repr¨asentiert. Probleme, die ein terminierender Algorithmus l¨ost, heißen entscheidbar . Die entsprechenden formalen Sprachen werden entweder entscheidbar oder rekursiv genannt. Definition. Eine Sprache heißt rekursiv oder entscheidbar wenn sie von einer TM, die auf jede Eingabe h¨ alt, akzeptiert wird. Beispiel 1. Alle bisher konstruierten TM halten auf jede Eingabe. Deswegen sind alle obere rekursiv aufz¨ ahlbaren Sprachen eigentlich rekursiv. Bemerkung 1. Um ein Beispiel einer Sprache, die zwar rekursiv aufz¨ahlbar aber nicht rekursiv zeigen zu k¨ onnen, werden wir erst die Eigenschaften von rekursiven Sprachen erforschen. Merken Sie, dass in Satz 1 von Abschnitt 3.4 (¨ uber Eigenschaften von rekursiv aufz¨ ahlbaren Sprachen) nichts u ¨ber Komplement L = Σ∗ − L behauptet wurde? Dies ist ein entscheidender Unterschied zu rekursiven Sprachen.: Satz 1. Wenn L und L′ rekursive Sprachen im Alphabet Σ sind, sind auch die Sprachen ¯ = Σ∗ − L L ∪ L′ , L ∩ L′ , LL′ , L∗ und L rekursiv.

98

KAPITEL 3. TURINGMASCHINEN

Beweis. (1) L∪L′ und L∩L′ : der Beweis ist gleich zu dem im Satz 1 von Abschnitt 3.4. (2) LL′ . Hier benutzen wir eine 4-Band-Turingmaschine M . Band 1 ist ein Eingabeband mit einem read-only-Kopf. Auf Band 2 steht die Zahl i der Etappe (am Anfang i = 0). Auf Band 3 wird M simuliert, und auf Band 4 wird M ′ simuliert. Jede Eingabe s1 . . . sn der L¨ange n wird in n + 1 Etappen berechnet. Die i-te Etappe besteht daraus, dass das Wort s1 . . . si auf Band 3 und das Wort si+1 . . . sn auf Band 4 kopiert werden, und dann simuliert unsere TM die Maschine M auf Band 2 und die Maschine M ′ auf Band 3, bis beide Maschinen M und M ′ halten. Falls sie beide akzeptieren, h¨alt auch M und akzeptiert. Falls M oder M ′ nicht akzeptiert und i < n, wird die n¨achste Etappe mit i ∶= i + 1 durchgef¨ uhrt. Falls M oder M ′ nicht akzeptiert und i = n, h¨alt M und akzeptiert nicht. (3) L∗ . Dieser Beweis ist analog zu 3. Zun¨achst pr¨ uft M , ob das Eingabeband leer ist und akzeptiert gegebenenfalls. Ansonsten erzeugen wir auf Band 2, statt nur einer Zahl i allein, alle m¨oglichen aufsteigenden Listen (i0 , i1 , . . . , ir ) von Zahlen mit 0 = i0 < i1 < i2 < ⋅ ⋅ ⋅ < ir = n wobei r = 1, . . . , n. Band 3 simuliert M : wir kopieren erst s1 s2 . . . si1 auf Band 3 und, falls die Simulation in einem finalen Zustand von M h¨alt, si1 +1 si1 +2 . . . si2 auf Band 3 und, falls die Simulation wieder in einem finalen Zustand h¨alt, si2 +1 . . . si3 auf Band 3 usw. Falls alle Simulationen in finalen Zust¨anden von M halten, wird die Eingabe von M akzeptiert. Falls irgendeine der Simulationen in einem nichtfinalen Zustand h¨ alt, beginnt eine neue Etappe (mit der n¨achsten Liste auf Band 2). Wenn alle Listen auf Band 2 durchgegangen worden sind, ohne dass bis dahin M akzeptiert hat, h¨alt M in einem nichtfinalen Zustand. ¯ Gegeben sei eine TM, M , die L akzeptiert, bezeichnen wir durch M ¯ dieselbe (4) L: TM, nur alle Zust¨ ande außer qF sind final und qF ist nicht-final. Wenn M ein ¯ : hier ist wichtig, dass M auf die Wort nicht akzeptiert, dann akzeptiert es M ¯ final ist. Es gibt Eingabe h¨ alt! Dann h¨ alt sie in einem Zustand q ≠ qF der in M ∗ ¯ also L(M ) = Σ − L(M ). ¯ rekursiv Bemerkung 2. Es ist erstaunlich, dass die Implikation L rekursiv ⇒ L die folgende Umkehrung hat: Satz 2. Wenn eine rekursiv aufz¨ ahlbare Sprache L ⊆ Σ∗ auch rekursiv das aufz¨ ahl∗ ¯ = Σ − L besitzt, dann ist L rekursiv. bare Komplement L Beweis. Gegeben sind TM M f¨ ur die Sprache L und ¯ f¨ ¯ M ur die Sprache L Wir konstruieren eine TM, M1 , die L akzeptiert und auf jede Eingabe h¨alt: M1 ist eine 2-Band TM, die auf Band 1 die Maschine M und auf Band 2 die Maschine ¯ simuliert. Die Maschine M1 rechnet so lange, bis auf Band 1 oder Band 2 die M Berechnung h¨ alt. Wenn das passiert, dann (a) M1 akzeptiert genau wenn M auf Band 1 akzeptiert (falls M h¨alt) und

3.5. REKURSIVE SPRACHEN

99

¯ auf Band 2 nicht akzeptiert (falls M ¯ h¨alt). (b) M1 akzeptiert genau wenn M Die einzige Frage ist: h¨ alt M1 auf jede Eingabe w2 ? Ja! Wenn w ∈ L, h¨alt die ¯ L(M¯)), dann h¨alt die Maschine M ¯. Maschine M . Und wenn w ∈ L(= Bemerkung 3. Jede rekursive Sprache ist selbstverst¨andlich rekursiv aufz¨ahlbar, und jede kontextfreie Sprache ist rekursiv, wie sofort bewiesen wird.

¨ REGULAR KONTEXTFREI REKURSIV ¨ REKURSIV AUFZAHLBAR ALLE SPRACHEN Beispiel 5 in Abschnitt 3.2.5 zeigt, dass die Sprache L = {an bn cn ; n ≥ 1} rekursiv (aber nicht kontextfrei) ist. Ein Beispiel einer Sprache, die rekursiv aufz¨ahlbar aber nicht rekursiv ist, wird in Kapitel 5 vorgef¨ uhrt. Dort zeigen wir, dass ein solches Beispiel die Sprache Lhalt aller W¨ orter c(M )w ist, wobei M eine Turingmaschine und w ein Eingabewort ist, auf das die Turingmaschine M h¨ alt. (Das bedeutet, dass das Halteproblem“ nicht ” entscheidbar ist.)

100

KAPITEL 3. TURINGMASCHINEN

Kapitel 4

Church-Turing-These, rekursive Funktionen und Grammatiken 4.1

Berechenbare Funktionen

Der ber¨ uhmte Logiker Alfonzo Chruch, als er gesehen hat, dass sein am Anfang der 1930’er eingef¨ uhrte λ-Kalk¨ ul genau dieselbe ”berechenbare” Funktion, definiert als die µ-rekursive Funktion hat einige Jahre vor Turings Paper u ¨ber TM die These formuliert, dass der intuitive Begriff einer Funktion, die mechanisch berechnet werden kann, mit dem Begriff von µ-rekursiven Funktionen u ¨bereinstimmt. Sp¨ater hat Turing, unabh¨ angig von Chruch, seine These formuliert: die mechanisch berechenbare Funktionen sind genau die, die eine TM berechnen kann. Wie werden berechnen TM Funktionen berechnet? Wir beginnen mit zwei Beispielen. Beispiel 1. Die Funktion f (x) = 2x f¨ ur x in bin¨aren Darstellung schreibt eine 0 am Ende des Wortes: (q0 , 0) → (q0 , R) (q0 , 1) → (q0 , R) (q0 , #) → (qF , 0) Beispiel 2. Die Nachfolgegeschwindigkeit succ(x) = x + 1 kann in der bin¨aren Darstellung auch einfach als TM dargestellt werden. Noch einfacher ist sie im Alphabet Σ = {∣}. Hier ist Σ∗ die un¨ are Darstellung von nat¨ urliche Zahlen: statt 0, 1, 2, . . . schreiben wir ε, ∣, ∣∣ Die TM f¨ ur succ ist deswegen wie folgt: (q0 , #) → (qF , ∣) (q0 , ∣) → (q0 , R) Bemerkung 1. Daraus, dass die Nachfolgefunktion durch eine TM berechenbar werden kann folgt, dass die Addition auch berechnet werden kann, denn Addition ist eine rekursive Anwendung von succ. Analog: Multiplikation kann durch eine TM berechnet werden, denn dies ist eine rekursive Anwendung von Addition. ¨ Um diese Uberlegung zu pr¨ asentieren, werden wir die primitiv rekursiven Funktionen einf¨ uhren und beweisen, dass sie durch eine TM berechenbar sind. Erst m¨ ussen wir aber erkl¨ aren, wie Funktionen durch eine TM programmiert werden. 101

102KAPITEL 4. CHURCH-TURING-THESE, REKURSIVE FUNKTIONEN UND GRAMMATIKEN Definition. Wir sagen, dass eine TM eine partielle Funktion f von Σ∗ nach Γ∗ berechnet wenn das Bandalphabet die menge Σ ∪ Γ enth¨alt und auf jede Eingabe w aus Σ∗ Solche Funktionen heißen partiell-berechenbar. (a) M h¨ alt, wenn f (w) definiert ist, und auf dem Band steht f (w) und (b) M h¨ alt nicht, wenn f (w) nicht definiert ist Beispiel 3. Die partielle Funktion pred ∶ N → N definiert durch pred(n) = n − 1 f¨ ur n ≠ 0 wird im Alphabet Σ = {∣} wie folgt berechnet: (q0 , #) → (q0 , R) (q0 , ∣) → (qF , #) In der Tat, f¨ ur Eingabe 0 h¨ alt die TM nicht, denn sie geht stets nach rechts. F¨ ur Eingabe n = ∣∣ . . . ∣, n ≠ 0, l¨ oscht sie ein ∣ und h¨alt. Definition. Eine (¨ uberall definierte) Funktion heißt berechenbar oder rekursiv wenn sie durch eine TM, die auf jede Eingabe h¨alt berechnet werden kann. Bemerkung 2. 1. Wie im Fall von Sprachenakzeptanz k¨onnen wir auch f¨ ur Funktionen den Begriff der TM modifizieren und zum Beispiel eine MehrbandTM benutzen. Es ist dann u ¨blich, Band 1 als Eingabeband und Band 2 als Ausgabeband (mit Inhalt f (w), nachdem die TM h¨alt) zu verwenden. 2. Der Finalzustand spielt bei Berechnungen keine Rolle (und k¨onnte, f¨ ur diese Anwendung der TM, aus der Definition entfernt werden). 3. F¨ ur Funktionen zweier (oder mehrerer) Variablen werden die verschiedenen Variablen voneinander durch eine leere Zelle getrennt. Also zum Beispiel eine Funktion f (w1 , w2 ) zweier Variabler aus Σ∗ mit Werten in Γ∗ wird von einer TM berechnet, falls die TM auf jede Eingabe w1 #w2 mit Bandinhalt f (w1 , w2 ) h¨ alt. sectBspAltDreiFuenfDrei bspAltDreiFuenfDrei

Beispiel 4. Addition. Wir wollen die Funktion f (n, m) = n + m (un¨ ar dargestellt) durch eine TM berechnen: es gen¨ ugt, das erste Symbol ∣“ zu streichen und die ” L¨ ucke, die die zwei Variablen voneinander trennt, durch ∣“ zu ersetzen: ” (q0 , ∣) → (q1 , #) (q0 , #) → (qF , R) (q1 , #) → (q2 , R) (q2 , ∣) → (q2 , R) (q2 , #) → (qF , ∣) Genauer, die TM M = ({q0 , q1 , q2 , qF }, {∣}, δ, q0 , qF ) ¨ mit der oben definierten Ubergangsfunktion δ berechnet die Addition in un¨arer Darstellung.

sectBspAltDreiFuenfVier bspAltDreiFuenfVier

Beispiel 5. Multiplikation. Die Funktion f (n, m) = n ∗ m (un¨ar dargestellt) kann von der folgenden 2-Band-TM berechnet werden: Band 1 ist das Eingabeband, aus Band 2 schreibt die Maschine n-mal hintereinander die Zahl m, das heißt, m Symbole ∣“. Dann h¨alt sie und hat auf Band 2 ” (Ausgabeband) die Zahl n ∗ m.

4.1. BERECHENBARE FUNKTIONEN

ctBspAltDreiFuenfFuenf bspAltDreiFuenfFuenf

ctBspAltDreiFuenfSechs bspAltDreiFuenfSechs

103

Bemerkung 3. Wer der Churchschen These glaubt, erwartet, dass jede durch einen (terminierenden) Algorithmus gegebene, voll-definierte Funktion durch eine TM berechenbar sein muss: man implementiert einfach den Algorithmus auf einer TM. Beispiel 6. Division. Die Funktion n ∶ m (ganzzahlig) falls m ≠ 0 f (n, m) = { undefiniert falls m = 0 kann von der folgenden 2-Band-TM berechnet werden: Band 1 ist das Eingabeband, auf Band 2 schreibt die TM erst n und dann versucht sie, m Striche auf Band 2 wegzuwischen“. Falls dies nicht m¨oglich ist, h¨alt sie. Falls es jedoch m¨oglich ist, ” versucht die Maschine erneut, m Striche auf Band 2 zu l¨oschen und so weiter. Beispiel 7. Eine unberechenbare Funktion β ∶

N → N.

Diese Funktion, die als busy beaver“ (fleißiger Biber) bekannt ist, ist wie folgt ” definiert: β(0) = 0 und f¨ ur jedes n > 0 ist β(n) = k, falls k die gr¨ oßte Zahl ist, die eine TM mit n Zust¨anden auf die leere Eingabe schreiben kann. D.h., die TM h¨ alt auf der leeren Eingabe mit ∣k auf dem Band. Wir k¨ onnen β(n) einfach bestimmen, wenn wir alle TM mit n Zust¨anden durchgehen (und die, die auf die leere Eingabe nicht halten, ausschließen). (a) β(1): ¨ Die TM mit der einzigen Ubergangsregel (q0 , #) → (q0 , ∣) schreibt ∣ auf die leere Eingabe. Daraus folgt β(1) ≥ 1. Aber jede Maschine mit nur einem Zustand, die mehr als einen Strich auf die leere Eingabe schreibt, h¨ alt nie. Also gilt β(1) = 1. (b) β(2): Die folgende TM (q0 , #) → (q0 , ∣) (q0 , ∣) → (q1 , R) schreibt ∣∣ auf das leere Band. Umgekehrt, f¨ ur jede (q1 , #) → (q1 , ∣) TM mit zwei Zust¨ anden darf δ nur auf drei Elementen der vierelementigen Menge Q × Σ definiert sein, damit die Maschine h¨alt. Daraus folgt sofort β(2) = 2. (c) Im allgemeinen gilt (∗) β(n + 2) > β(n) f¨ ur jedes n. In der Tat, falls β(n) = k, d.h., falls eine Turingmaschine M mit n Zust¨anden ∣k schreibt, konstruieren wir eine Turingmaschine, M ′ , die n + 2 Zust¨ande hat und ∣k+1 schreibt – woraus β(n + 2) ≥ k + 1 > β(n) folgt. Wir f¨ ugen zwei neue Zust¨ande q ′ ′′ und q zu den Zust¨ anden von M hinzu. H¨alt M im Zustand q auf einem Feld ∣, so ¨ erg¨anzen wir M um drei neue Ubergangsregeln: (q, ∣) → (q ′ , L) (q ′ , ∣) → (q ′ , L) (q ′ , #) → (q ′′ , ∣). H¨ alt dagegen M im Zustand q auf einem Feld #, so kann sich dieses Feld wegen der Maximalit¨ at von β(n) nur direkt neben dem Ergebnis ∣k von M befinden. Wir ¨ k¨ onnen M nun um die Ubergangsregel (q, #) → (q ′′ , ∣) erg¨anzen. In jedem Fall h¨alt ′ ′′ die Maschine M im Zustand q , nachdem sie ∣k+1 geschrieben hat.

104KAPITEL 4. CHURCH-TURING-THESE, REKURSIVE FUNKTIONEN UND GRAMMATIKEN sectSatzZuFGibtEsR satzZuFGibtEsR

Satz 1. F¨ ur jede berechenbare Funktion f (n) gibt es eine Konstante r mit der Eigenschaft, dass β(n + r) ≥ f (n) f¨ ur alle n. Beweis. f (n) wird von einer Turingmaschine M berechnet. Sei r die Zahl aller Zust¨ ande von M . Wir konstruieren f¨ ur jede Zahl n eine Turingmaschine Mn , die n + r Zust¨ ande hat und f (n) Striche auf die leere Eingabe schreibt – damit ist β(n + r) ≥ f (n) bewiesen. Zu den Zust¨anden von M werden n neue Zust¨ande q 0 (initial), q 1 , . . . , q n−1 hinzugef¨ ugt, sodass Mn auf die leere Eingabe n-mal einen ∣ schreibt und sich dabei nach links bewegt: f¨ ur i = 0, . . . , n − 1 (q i , #) → (q i , ∣) (q i , ∣) → (q i+1 , L) f¨ ur i = 0, . . . , n − 2 (q n−1 , ∣) → (q0 , ∣) ¨ Der letzte Ubergang bedeutet, dass von jetzt an die Maschine M (mit der Eingabe ∣n ) simuliert wird – sie schreibt also ∣f (n) und h¨alt. Folgerung 4. Die busy-beaver-Funktion β(n) ist nicht berechenbar. Falls n¨ amlich β(n) berechenbar w¨are, m¨ usste auch β(2n) berechenbar sein (wir h¨ atten eine TM, die erst die Zahl aller ∣′ e der Eingabe verdoppelt, siehe Beispiel ?? und dann die TM f¨ ur β(n) simuliert). Dann w¨ urde es eine Konstante r geben mit β(n + r) ≥ β(2n) f¨ ur alle n. Speziell ergibt n = r + 2 β(2r + 2) ≥ β(2r + 4), ein Widerspruch zu (c) oben.

4.2

Primitive Rekursion

Wir betrachten hier Funktionen mehrerer Variablen aus N die durch Rekursion und Verkn¨ upfung aus sehr einfachen ”Basis”-Funktionen konstruiert werden. Die Fakult¨ atsfunktion definiert man z.B. rekursiv mit Multiplikation, die Multiplikation wiederum rekursiv mit Addition und die Addition rekursiv mit der Nachfolgerfunktion succ. Hier endet aber diese Kette: succ ist eine der Basisfunktionen. Wir arbeiten hier mit k-stelligen Funktionen nat¨ urlicher Zahlen, d.h. mit Funktionen f ∶ Nk → N, wobei Nk = N × ⋅ ⋅ ⋅ × N (k-mal), f¨ ur k = 1, 2, 3, . . . . f hat also k Variablen im Bereich N. Die konstante Funktion Ki mit Wert i gilt als 0-stellig, da sie von keiner Variablen abh¨angt. Nicht-konstante Funktionen sind k-stelllig f¨ ur k ≥ 1. Besonders einfache k-stellige Funktionen sind die Projektionen π1k , . . . , πkk : die Projektion πik ordnet jedem k-Tupel sein i-tes Element zu.

sectDfBasisfunktion dfBasisfunktion

Beispiel 1. πik (n1 , n2 , . . . , nk ) = ni . F¨ ur k = 2 gibt es z.B. zwei Projektionen π12 (n, m) = n und π22 (n, m) = m. F¨ ur k = 1 ist π11 (n) = n die Identit¨atsfunktion. Definition. Die folgenden Funktionen heißen Basisfunktionen: 1. die Nachfolgerfunktion succ (mit succ(n) = n + 1) 2. die Nullfunktion K0 (mit dem einzigen Wert 0) und 3. die Projektionen πik f¨ ur alle 1 ≤ i ≤ k, k = 1, 2, 3, . . . .

4.2. PRIMITIVE REKURSION

ectBspAltVierFuenfEins bspAltVierFuenfEins

105

Aus den Basisfunktionen k¨ onnen weitere Funktionen mit Hilfe der Verkn¨ upfung definiert werden: Beispiel 2. Konstante Funktionen. Die konstante Funktion K1 entspricht der Verkn¨ upfung von K0 mit succ: K1 = succ(K0 ). Analog K2 = succ(K1 ) = succ(succ(K0 )) usw.

ectBspAltVierFuenfZwei bspAltVierFuenfZwei

Beispiel 3. Die Funktion f (n) = n + 2 f¨ ur alle n ∈ N ist die Verkn¨ upfung von succ mit sich selbst: f (n) = succ(succ(n)).

ectBspAltVierFuenfDrei bspAltVierFuenfDrei

Beispiel 4. Die Funktion g(n, m) = m + 2 (f¨ ur alle n, m ∈ N) ist eine Verkn¨ upfung der zweiten Projektion π22 (n, m) (die n wegfallen l¨asst) und der Funktion f aus Beispiel 3: g(n, m) = f (π22 (n, m)) = succ(succ(π22 (n, m)). Bemerkung 1. Im Allgemeinen definieren wir die Verkn¨ upfung mehrstelliger Funktionen wie u ¨blich: falls f ∶ Nk → N (k ≥ 1) eine k-stellige Funktion ist und g1 , . . . , gk ∶ Nm → N (m ≥ 0) k m-stellige Funktionen sind, ist die Verkn¨ upfung von f mit g1 , . . . , gk die m-stellige Funktion h ∶ Nm → N, die durch h(n1 , . . . , nm ) = f (g1 (n1 , . . . , nm ), g2 (n1 , . . . , nm ), . . . , gk (n1 , . . . , nm )) f¨ ur alle (n1 , . . . , nm ) auf Nm definiert wird. Beispiel 5. Aus der Nachfolgefunktion succ l¨asst sich die Addition add ∶ N×N → N wie folgt rekursiv definieren: add(n, 0) = n add(n, succm))succ(add(n, m)) Dies ist im Beispiel von primitiver Rekursion: Definition. Gegeben sei eine (k − 1)-stellige Funktion g und eine (k + 1)-stellige Funktion h, definieren wir ihre primitive Rekursion als die k-stellige Funktion f wie folgt: f (n1 , . . . , nk−1 , 0) = g(n1 , . . . , nk−1 ) und f (n1 , . . . , nk−1 , m + 1) = h(n1 , . . . , nk−1 , m, f (n1 , . . . , nk−1 , m)).

ectBspAltVierFuenfVier bspAltVierFuenfVier

Beispiel 6. Addition. add(n, m) = n + m wird durch primitive Rekursion mit g(n) = n = π11 (n) und h(n, m, i) = succ i = succ(π33 (n, m, i)) definiert. In der Tat gilt add(n, 0) = g(n) add(n, m + 1) = h(n, m, add(n, m)).

ctBspAltVierFuenfFuenf bspAltVierFuenfFuenf

Beispiel 7. Die Multiplikation ist durch primitive Rekursion aus Addition definiert: n∗0=0

106KAPITEL 4. CHURCH-TURING-THESE, REKURSIVE FUNKTIONEN UND GRAMMATIKEN

sectDfPrimitivRekursiv dfPrimitivRekursiv

n ∗ (m + 1) = (n ∗ m) + m. Genauer: f¨ ur mul(n, m) = n ∗ m definieren wir g(n) = K0 und h(n, m, i) = add(m, i) = add(π23 (n, m, i), π33 (n, m, i)). Dann gilt mul(n, 0) = g(n) mul(n, m + 1) = h(n, m, mul(n, m)). Definition. Eine Funktion heißt primitiv-rekursiv , falls sie durch endlich viele Anwendungen von Verkn¨ upfung und primitiver Rekursion auf die Basisfunktionen definiert werden kann. Mit anderen Worten ist die kleinste Klasse von Funktionen, die alle Basisfunktionen enth¨ alt und unter Verkn¨ upfung und primitiver Rekursion abgeschlossen ist, die Klasse aller primitiv-rekursiver Funktionen.

sectBspAltVierFuenfSechs bspAltVierFuenfSechs

Beispiele: Kn , f (n) = n+2, g(n, m) = m+2, add(n, m) und mul(n, m) sind primitivrekursiv. Beispiel 8. Die Fakult¨ atsfunktion m! ist primitiv-rekursiv, da sie mit der folgenden primitiven Rekursion definiert werden kann: 0! = 1 (m + 1)! = mul(m + 1, m!). Hier ist also g = K1 und h(x, y) = mul(x + 1, y) = mul(succ(π12 (x, y), π22 (x, y)). Da g und h beide primitiv-rekursiv sind, ist auch m! primitiv-rekursiv.

sectBspAltVierFuenfAcht bspAltVierFuenfAcht

Beispiel 9. Die modifizierte Subtraktion n − m falls n ≥ m n −˙ m = { 0 falls n < m ist primitiv-rekursiv: n −˙ 0 = n n −˙ (m + 1) = f (n −˙ m) f¨ ur f aus Beispiel ??. Hier gilt also g(n) = n und h(n, m, i) = f (π33 (n, m, i)) = f (i). Bemerkung 2. Die Klasse aller primitiv-rekursiven Funktionen ist so m¨achtig, dass es nicht einfach ist, ein Beispiel einer Funktion außerhalb dieser Klasse zu finden (siehe Beispiel 10). Deswegen ist der folgende Satz eine neue Best¨atigung der St¨ arke von Turingmaschinen.

ursivUndTuringberechenbar

ursivUndTuringberechenbar

Satz 1. Jede primitiv-rekursive Funktion ist Turing-berechenbar. Beweis. Es gen¨ ugt, zu beweisen, dass gilt: 1. alle Basisfunktionen sind Turing-berechenbar, 2. die Verkn¨ upfung Turing-berechenbarer Funktionen ist Turing-berechenbar, und 3. die primitive Rekursion, die mit zwei Turing-berechenbaren Funktionen arbeitet, ergibt eine Turing-berechenbare Funktion. Dann sind alle primitiv-rekursiven Funktionen Turing-berechenbar. (1) ist trivial und (2) auch: Die Verkn¨ upfung f (g(n)) wird z.B. von einer 2-BandTM berechnet, wobei Band 1 die Funktion g(n) berechnet und das Ergebnis als Eingabe der Funktion f auf Band 2 kopiert.

4.2. PRIMITIVE REKURSION

107

Wir wollen also (3) beweisen, d.h., dass es f¨ ur die Funktion f mit f (n1 , . . . , nk , 0) = g(n1 , . . . , nk ) und f (n1 , . . . , nk , m + 1) = h(n1 , . . . , nk , m, f (n1 , . . . , nk , m)) eine TM gibt, falls Mg und Mh zwei TM sind, die g und h berechnen. Unsere TM hat f¨ unf B¨ ander: Band 1 (Eingabeband) Band 2 (Schrittz¨ ahler)

n1 $ n2 $

...

$ nk

m

Band 3 (simuliert Mg )

FUNKTION g

Band 4 (simuliert Mh )

FUNKTION h

Band 5 (Ausgabeband)

ZWISCHENERGEBNIS j

Die Berechnung von f erfolgt in Schritten Nr. m = 0, 1, 2, . . . , die auf Band 2 gez¨ahlt werden und die wie folgt ablaufen: Schritt 0: Band 2 enth¨ alt 0, auf Band 3 wird n1 , . . . , nk−1 (von Band 1) kopiert und g(n1 , . . . , nk−1 ) wird berechnet. Das Ergebnis wird auf Band 5 geschrieben. Schritt m + 1: Falls nk der Inhalt von Band 2 ist, h¨alt die TM. (Band 5 enth¨alt dann das Ergebnis.) Falls nicht, wird auf Band 4 die Eingabe n1 $ . . . $ nk $ m $ j geschrieben. j = f (n1 , . . . , nk−1 , m) ist der Inhalt von Band 5, m der von Band 2. Jetzt wird h(n1 , . . . , nk , m, j) berechnet und das Ergebnis auf Band 5 geschrieben. Der Inhalt von Band 2 wird um eins erh¨ oht. Folgerung 5. Die busy beaver Funktion β ist nicht primitiv rekursiv. Bemerkung 3. Nicht jede partiell berechenbare Funktion ist primitiv-rekursiv. In der Tat sind alle primitiv-rekursiven total (d.h. u ¨berall definiert), und es gibt partielle Turing-berechenbare Funktionen. Aber auch alle totalen berechenbaren Funktionen sind leider nicht primitiv-rekursiv. Das k¨ onnen wir abstrakt wie folgt zeigen: alle primitiv-rekursiven Funktionen k¨onnen wir systematisch aufz¨ ahlen, z.B. setzen wir f0 = K0 , f1 = succ, f2 = π11 . Mit den gegebenen Funktionen f0 , . . . , fi machen wir alle m¨oglichen Verkn¨ upfungen und primitiven Rekursionen. Dabei entstehen fi+1 , . . . , fj , dann ist fj+1 die n¨achste noch nicht eingenommene Projektion, usw. Diese Aufz¨ahlung kann bestimmt eine TM durchf¨ uhren. Dann ist die Funktion P (n) = 1 + fn (n, n, . . . , n) Berechenbar. Aber P ist nicht primitiv-rekursiv: falls n¨amlich P = fn , haben wir P (n) = 1 + fn (n) ≠ fn (n) – ein Widerspruch. Es ist Wilhelm Ackermann 1928 gelungen, ein viel konkreteres Beispiel einer Funktion anzugeben, die nicht primitiv-rekursiv ist, sich aber mit einem einfachen Algorithmus berechnen l¨ aßt. Die Funktion, die man heute Ackermann-Funktion nennt, ist eine von Rozsa Peter sp¨ ater entdeckte Vereinfachung der urspr¨ unglichen Idee:

ctBspAckermannFunktion bspAckermannFunktion

Beispiel 10. Die Ackermann-Funktion A ∶ N2 → N ist wie folgt definiert: A(0, m) = m + 1 A(n + 1, 0) = A(n, 1) und A(n + 1, m + 1) = A(n, A(n + 1, m)). Es gilt also

108KAPITEL 4. CHURCH-TURING-THESE, REKURSIVE FUNKTIONEN UND GRAMMATIKEN A(0, 0) = 1, A(0, 1) = 2, A(1, 0) = A(0, 1) = 2, A(0, 2) = 3, A(1, 1) = A(0, A(1, 0)) = A(0, 2) = 3, A(2, 0) = A(1, 1) = 3, usw. Wir erhalten einen Algorithmus, um jeden Wert A(n, m) zu berechnen: alle m¨ oglichen Paare (n, m) werden so aufgez¨ahlt, dass der Wert A(n, m) direkt aus den vorigen Werten berechnet wird. ⋰2

Beispiel 11. A(4, m) = 22 −3 mit m+2 Exponenten. So dass zum Beispiel A(4, 4) 5000 mehr als 1010 dezimale Ziffern braucht (und es gibt weniger als 1080 Atome im sichtbaren Teil des Universums). Die Formel f¨ ur A(4, m) l¨asst sich einfach per IndukA(1, m) = m + 2 tion beweisen, wobei man erst die folgenden Formeln beweist: A(2, m) = 2m + 3 A(3, m) = 2m+3 − 3 All diese Beweise sind trivial. Satz 2. (Ohne Beweis.) Die Ackermann-Funktion ist nicht primitiv-rekursiv, denn A(n, n) w¨ achst schneller als jede primitiv-rekursive Funktion f (n) (d.h., es gibt eine Konstante n0 mit f (n) < A(n, n) f¨ ur alle n ≥ n0 ). Satz 3. Die Ackermann-Funktion ist berechenbar. Beweis. Gegeben seien n, m. Wir wollen A(n, n) durch eine TM berechnen. Die TM berechnet systematisch alle Werte von A und schreibt sie in der Form $$n0 $m0 $A(n0 , m0 )$$ in einem Speicher: $$0$0$1$$0$i$2$$1$0$0$2$$ . . . ∥ ∥ A(0, 0) A(0, 1) A(1, 0) ∥ A(0, 1) Bei jedem Schritt fragt sie, ob sie schon A(n, n) berechnet hat: n m Band 1 (Eingabeband) Band 2 (Ausgabe)

A(n, m)

Band 3 (Z¨ ahler)

n0 = 0, 1, 2 . . .

Band 4 (Z¨ ahler)

n0 = 0, 1, 2 . . .

Band 5 (Speicher)

$$n0 $m0 $A(n0 , m0 )$$⋯

Am Anfang ist B2 leer, auf B3 und B4 steht 0 und dann f¨angt die Maschine mit den folgenden Schritten an: (a) Ist n0 = n und m0 = m? Wenn ja, schreibe A(n, m) aus B5 auf B2 und halte. (b) Wenn nein, berechne den n¨achsten Wert der Ackermann-Funktion: entweder setze n0 ∶= n0 + 1, berechne A(n0 + 1, m0 ) und schreibe es auf B7, oder setze m0 ∶= m0 + 1, berechne A(n0 , m0 + 1) und schreibe es auf B7. GOTO (a).

4.3

µ-rekursive Funktionen

Die Operationen Verkn¨ upfung und primitive Rekursion sind nicht stark genug, um alle berechenbaren Funktionen zu generieren. Aber wenn der folgenden Operation µ hinzugef¨ ugt wird, gen¨ ugen sie:

4.3. µ-REKURSIVE FUNKTIONEN

109

Definition. Gegeben sei eine partielle Funktion f von k + 1 variablen, definieren wir ihre Minimierung µf als die folgende partielle Funktion von k Variablen: µf (n1 , . . . , nk )) = m wenn m die kleinste zahl ist, so dass f (n1 , . . . , nk , m) = 0. (Und wenn keine solche Zahl existiert, ist µf in den k-Tupel nicht definiert). Notation. Wir schreiben auch µm f um zu betonen, dass die Variable m minimiert wird. Beispiel 1. Die Vorg¨ angerfunktion pred(n) hat die Form µm f f¨ ur f (n, m) = n − m (undefiniert f¨ ur n < m). Beispiel 2. Die Funktion ⎧ ⎪0 f¨ ur n = 0 ̂0 (n) = ⎪ K ⎨ ⎪ undefiniert sonst ⎪ ⎩ hat die Form ̂0 (n) = µm π 1 (n, m). K 1 In der Tat, π11 (n, m) = 0 nur wenn n = 0 und das kleinste m¨ogliche m ist m = 0. Beispiel 3. F¨ ur die Funktion der ganzzahligen Divison: ⎧ ⎪ falls dividierbar ⎪n ∶ m div(n, m) ⎨ ⎪ undefiniert sonst ⎪ ⎩ h¨ atten wir die Tendenz zu schreiben div(n, m) = µk (n − m ∗ k). Denn das kleinste k mit n − m ∗ k = 0 ist k = setzen wir f (n, m, k) = n − succ(pred(m)) ∗ k Dann gilt div(n, m) = µk f (n, m, k)

n . m

Aber dies ergibt 0 ∶ 0 = 0. Deswegen

Definition. Eine Funktion heißt rekursiv (oder µ-rekursiv), wenn sie durch die Basisfunktionen und endlich viele Anwendungen von 1. Verkn¨ upfung, 2. primitiver Rekursion und 3. Minimierung µ definiert werden kann. Beispiel 4. (a) Alle primitiv-rekursive Funktionen sind µ-rekursiv (b) Die Funktion sub(n, m) = n − m f¨ ur n ≥ m ̂0 in Beispiel 2 durch die folgende ist µ-rekursiv: sie ensteht aus der Funktion K primitive Rekursion: ̂0 (m) sub(0, m) = K sub(n + 1, m) = succ(sub(n, m)). D.h., die Bestandteile der primitiven Rekursion sind ̂0 g(m) = K h(n, m, i) = succ(i) = succ(π13 ) beide µ-rekursiv.

110KAPITEL 4. CHURCH-TURING-THESE, REKURSIVE FUNKTIONEN UND GRAMMATIKEN (c) Deswegen ist pred µ-rekursiv, siehe Beispiel 1. Und auch Division ist µ-rekursiv, siehe Beispiel 3.

ursivUndTuringberechenbar

ursivUndTuringberechenbar

Satz 1. Jede µ-rekursive Funktion ist partiell berechenbar. Beweis. Es gen¨ ugt zu den Punkten 1. - 3. aus Satz 1 einen vierten Punkt hinzuzuf¨ ugen: 4. Falls f partiell berechenbar ist, so ist es auch µf . Sei M eine TM, die f berechnet. Wir konstruieren eine 3-Band TM f¨ ur µf wie folgt: n1 $ n2 $ . . . $ nk Band 1 (Eingabeband) Band 2 (Schrittz¨ ahler)

i

Band 3 (simuliert M )

FUNKTION f

Am Anfang wird i = 0 auf Band 2 geschrieben, und dann wird auf Band 3 immer f (n1 , . . . , nk , i) berechnet. Falls das Ergebnis 0 ist, h¨alt die TM, und Band 2 enth¨alt die Ausgabe. Falls das Ergebnis nicht 0 ist, wird Band 2 um 1 erh¨oht (i ∶= i + 1), und f (n1 , . . . , nk , i) wird erneut berechnet, usw.

ingberechenbarUndRekursiv

ingberechenbarUndRekursiv

Satz 2. (Ohne Beweis) Jede partiell berechenbare Funktion ist µ-rekursiv. Bemerkung 1. F¨ ur die totalen berechenbaren Funktionen gibt es einen analogen Satz. Die einzige Differenz ist, dass der Minimierungsoperator µ nur eingeschr¨ankt benutzt wird: Definition. Eine totale Funktion f von k + 1 Variablen heißt minimierbar wenn f¨ ur jeden k-Tupel n1 , . . . , nk es ein m gibt mit f (n1 , . . . , nk , m) = 0. Bemerkung 2. µm f ist dann eine totale Funktion. Satz 3. (Ohne Beweis.) Eine totale Funktion (mehrerer Variablen aus N) ist berechenbar, genau dann, wenn sie aus den Basisfunktionen durch endlich viele Anwendungen von Verkn¨ upfungen, primitive Rekursion und Minimierung von minimierbaren Funktionen definiert werden kann. Beispiel 5. Die Ackermann-Funktion ist µ-rekursiv (mit µ nur auf minimierbare Funktionen angewendet).

4.4

sectDefGrammatik defGrammatik

Grammatiken und Turingmaschinen

In Kapitel 2 sprachen wir von kontextfreien Grammatiken, die es erlauben, eine Variable durch ein Wort zu ersetzen. Das ist ein Spezialfall einer Grammatik (auch unbeschr¨ ankte Grammatik oder Grammatik des Typs 0 genannt), die es allgemein erlaubt, ein Wort durch ein anderes zu ersetzen. Es zeigt sich, dass diese Grammatiken genau die rekursiv aufz¨ahlbaren Sprachen definieren. In diesem Sinn erhalten wir also ein vollkommen neues Modell von Sprachen, die Turing-akzeptierbar sind. Definition. Eine Grammatik G ist ein Quadrupel G = (Σ, V, S, R), wobei Σ das Alphabet aller Terminalsymbole, V das Alphabet aller Variablen (zu Σ disjunkt), S ∈ V das Startsymbol und R eine endliche Menge an Paaren (α, β) von W¨ortern u ¨ber Σ ∪ V mit α ≠ ε ist.

4.4. GRAMMATIKEN UND TURINGMASCHINEN

111

Bemerkung 1. Elemente (α, β) aus R werden mit α→β bezeichnet und werden Produktionen oder Ersetzungsregeln genannt. Die Anwendung einer Regel α → β auf ein Wort w ist genau dann m¨oglich, wenn w die Form w = w′ αw′′ (w′ , w′′ W¨orter u ¨ber Σ ∪ V ) hat. Das Ergebnis der Anwendung ist das Wort w′ βw′′ . Notation. 1. Mit ⇒ bezeichnen wir die Anwendung einer einzigen Regel; also schreiben wir f¨ ur zwei W¨ orter u, w in (Σ ∪ V )∗ u ⇒ v, falls es eine Regel α → β in R und W¨orter u1 , u2 in (Σ ∪ V )∗ gibt, so dass u = u1 αu2 und v = u1 βu2 .

fDurchGErzeugteSprache

fDurchGErzeugteSprache

sectBspAltVierDreiZwei bspAltVierDreiZwei

2. Mit ⇒∗ bezeichnen wir die reflexive und transitive H¨ ulle der Relation ⇒. Definition. F¨ ur jede Grammatik G heißt die Menge aller W¨orter u ¨ber Σ, die vom Startsymbol ableitbar sind, die Sprache L(G) erzeugt durch G. K¨ urzer: L(G) = {w ∈ Σ∗ ; S ⇒∗ w}. Alle oben definierten Begriffe verallgemeinern die in Kapitel 2 eingef¨ uhrten Begriffe f¨ ur kontextfreie Sprachen. Aber die allgemeinen Grammatiken erzeugen Sprachen, die nicht kontextfrei sein m¨ ussen: Beispiel 1. Eine Grammatik f¨ ur die (nicht kontextfreie) Sprache L = {an bn cn ; n ≥ 1}. Sei G = ({a, b, c}, {B, C, S}, S, R) die Grammatik mit den Regeln (1) S → aBC ∣ aSBC (2) CB → BC (3) aB → ab (4) bB → bb (5) bC → bc (6) cC → cc Das Wort an bn cn , n ≥ 1, liegt in L(G), da es sich wie folgt ableiten l¨asst: S ⇒∗ an−1 S(BC)n−1 [Regel S → aSBC, (n − 1)-mal angewendet] ⇒ an (BC)n [Regel S → aBC] ⇒∗ an B n C n [Regel BC → CB, (n − 1)-mal angewendet] ⇒ an bB n−1 C n [Regel aB → ab] ⇒∗ an bn C n [Regel bB → bb, (n − 1)-mal angewendet] ⇒ ⇒∗

an bn cC n−1 an bn cn

[Regel bC → bc] [Regel cC → cc, (n − 1)-mal angewendet]

Umgekehrt beweisen wir, dass nur W¨orter der Form an bn cn ableitbar sind. In der Tat: falls w ein Wort ist, das von S ableitbar ist und keine Variable enth¨alt, beweisen wir das folgende: 1. Die Anzahl von a’s im Wort w ist dieselbe wie die von b’s und dieselbe wie die von c’s . In der Tat, die Regeln (2) - (6) ¨andern die Anzahl der Buchstaben a, b/B oder c/C nicht, und Regel (1) erh¨oht alle drei dieser Zahlen gleichzeitig um 1. 2. Alle a’s stehen links im Wort w, das heißt, w hat die Form w = an v (und v besteht aus n b’s und n c’s ). Keine der Regeln (1) - (6) ¨andert n¨amlich die linke Position von a.

112KAPITEL 4. CHURCH-TURING-THESE, REKURSIVE FUNKTIONEN UND GRAMMATIKEN 3. Das Wort w enth¨ alt nicht die Kombination cb (das heißt, w hat nicht die Form w = ucbv). Um das zu beweisen, betrachten wir die Regeln (3) - (6): diese a ¨ndern weder Anzahl noch Position der Buchstaben a, b/B oder c/C im Wort, sie wandeln nur B → b oder C → c um. Wir k¨onnen daher annehmen, dass in der Ableitung S ⇒∗ w zuerst nur die Regeln (1) und (2) benutzt werden, und dann erst werden die Regeln (3) - (6) angewendet. Genauer: es gibt eine Ableitung: S ⇒ w1 ⇒ w2 ⇒ ⋅ ⋅ ⋅ ⇒ wi ⇒ ⋅ ⋅ ⋅ ⇒ wk = w, wobei f¨ ur S ⇒ ⋅ ⋅ ⋅ ⇒ wi nur die Regeln (1) und (2) angewendet werden und f¨ ur wi ⇒ ⋅ ⋅ ⋅ ⇒ wk nur die Regeln (3) - (6). Dann unterscheiden sich die W¨ orter wi und wk nur dadurch, dass an der Stelle im Wort, an der b steht, wi den Buchstaben B hat und dasselbe gilt analog f¨ ur c/C. Das Wort wi enth¨ alt die Kombination CB nicht, denn keine der Regeln (3) - (6) kann B in b umwandeln, falls vor diesem B entweder C oder c steht. Es folgt, dass das Wort w = wk die Kombination cb nicht enth¨alt. 4. w = an bn cn , denn in 2. haben wir ein Wort v mit n b’s, n c’s und ohne die Kombination cb – das einzige Wort ist v = bn cn . Beispiel 2. Die Sprache aller W¨orter u ¨ber {a, b, c} mit der gleichen Anzahl von a’s, b’s und c’s. Auch diese Sprache ist nicht kontextfrei (beweisen Sie es mithilfe des Pumping-Lemmas!). Hier ist eine Grammatik f¨ ur diese Sprache: (a) Start. Hier darf das Startsymbol einfach verschwinden: S → ABSC∣ε (b) Alle Variablen A, B, C sind untereinander kommutativ AB → BA BA → AB AC → CA CA → AC BC → CB CB → BC (c) Von Variablen zu Eingabesymbolen A→a B→b C → c. Jedes Wort w mit L¨ ange 3n und mit n a’s, b’s sowie c’s l¨asst sich Ableiten: Wir verwenden erst (a) n − 1-mal S ⇒ ABSC ⇒ ABABSCC ⇒ . . . ⇒ (AB)n SC n ⇒ (AB)n C n Zun¨ achst gestalten wir (AB)n C n zum Wort w um, außer dass die Buchstaben groß sind. Dies l¨ asst sich durch Anwendung der Produktionen aus (b) leicht machen. Am Ende benutzen wir (c) um w zu erhalten. Um gekehrt, jedes Wort aus L(G) hat die gleiche Anzahl von a’s, b’s und c’s. in der tat, wir beweisen das folgende: gegeben S ⇒ w mit w u ¨ber {a, b, c, A, B, C, S} ist die Anzahl von a, A gleich der von b, B und gleich der von c, C. Beweis per Induktion in der L¨ange k der Ableitung von w aus S: k=0 Dann w = s: die drei Zahlen sind gleich 0. k + 1: Wir haben S ⇒ w1 ⇒ . . . ⇒ wk ⇒ wk+1 (= w). Nach Induktionsvoraussetzung hat wk dieselbe Anzahl (sagen wir v) von a, A und

4.4. GRAMMATIKEN UND TURINGMASCHINEN

113

b, B und c, C. Das Wort wk+1 entsteht aus wk indem eine der Produktionen oben angewendet wird. Wenn S → ABSC angewendet wurde, hat wk genau i+1 der Symbole a, A sowie b, B und c, C. Alle anderen Produktionen haben die Eigenschaft, dass die Anzahl von a, A auf der rechten und linken Seite gleich ist. Dasselbe gilt f¨ ur b, B und c, C. Deswegen hat auch wk+1 genau i Symbolen a, A sowie b, B und c, C.

sectBspAltVierDreiDrei bspAltVierDreiDrei

Beispiel 3. Simulation einer TM. Wir zeigen jetzt, wie die Arbeit einer TM vollst¨andig von einer Grammatik simuliert werden kann. Erinnern wir uns an das Konzept von Konfigurationen (q, u, a, v) aus Kapitel 3.1: ... ... a ´¹¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¸ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¶ ⇑ ´¹¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¸ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¶ u v q Die Konfigurationen werden jetzt statt (q, uav) durch das Wort [uqav] u ¨ber Σ ∪ Q ∪ {[, ], #} bezeichnet. Also ist die Initialkonfiguration mit Eingabe s1 . . . sn das Wort [q0 s1 . . . sn ]. Die Arbeit der TM wird durch die Relation ⊢ ( Folgekonfiguration“) beschrieben. ” Wir konstruieren jetzt eine Grammatik G, in der f¨ ur zwei Konfigurationen gilt: [uqav] ⊢ [u′ q ′ a′ v ′ ] genau dann, wenn [u′ q ′ a′ v ′ ] ⇒ [uqav]. (Also beschreibt die Ableitung in der Grammatik G die Berechnung r¨ uckw¨arts.) Wir benutzen die Bandsymbole Σ der TM als terminale Symbole und die folgenden Variablen: V = Q ∪ {S, #, [, ]}; wir setzen V ∩ Σ = ∅ wie u ¨blich voraus. Also G = (Σ, V, S, R), und die Produktionen R entsprechen den M¨oglichkeiten von ⊢ (siehe Tabelle 3.1 in Abschnitt 3.1): ¨ 1. F¨ ur jede Ubergangsregel (q, s) → (q ′ , s′ ) der TM mit s′ in Σ ∪ {#} haben wir die Folgekonfigurationen [uqsv] ⊢ [uq ′ s′ v], und wir ben¨otigen also die Produktion (in der Gegenrichtung) (1) q ′ s′ → qs. ¨ 2. F¨ ur jede Ubergangsregel (q, s) → (q ′ , R) der TM haben wir die Folgekonfigurationen [uqsv] ⊢ [usq ′ v] falls v ≠ ε und [uqs] ⊢ [usq ′ #] falls v = ε. Wir ben¨ otigen daf¨ ur die Produktionen (2) sq ′ → qs (3) sq ′ #] → qs] ¨ 3. F¨ ur jede Ubergangsregel (q, s) → (q ′ , L) brauchen wir die Produktionen ′ ′ ′ (4) q s s → s qs ∀s′ ∈ Σ ∪ {#} ′ (5) [q #s → [qs Nehmen wir jetzt an, dass die TM ein Wort s1 . . . sn u ¨ber Σ akzeptiert, und dass sie ihr Eingabeband l¨oscht, bevor sie h¨alt. Dann haben wir eine Berechnung, die mit der Initialkonfiguration [q0 s1 . . . sn ] beginnt und mit der Finalkonfiguration [qF #] endet. Das heißt, aufgrund der Produktionen (1) (5) gibt es eine Ableitung (in der Gegenrichtung!) [qF #] ⇒ . . . ⇒ [q0 s1 . . . sn ].

114KAPITEL 4. CHURCH-TURING-THESE, REKURSIVE FUNKTIONEN UND GRAMMATIKEN Wir f¨ ugen jetzt drei Produktionen hinzu, so dass wir dann vom Startsymbol S das Wort s1 . . . sn ableiten: (6) S → [qF #] (7) [q0 → ε (8) ] → ε Wir haben also die Grammatik GM = (Σ, V ∪ {#, [, ], S}, S, R) mit den Produktionen (1) - (8). Wir beweisen jetzt, dass sie die Sprache L(M ) erzeugt. sectSatzTMDieBandLoescht satzTMDieBandLoescht

Satz 1. Falls M eine TM ist, die ihr Band immer l¨ oscht, bevor sie h¨ alt, dann gilt f¨ ur die obige Grammatik GM , dass L(M ) = L(GM ). Beweis. 1. Jedes Wort w = s1 . . . sn , das M akzeptiert, ist aus GM ableitbar, das heißt, L(M ) ⊆ L(GM ). In der Tat, f¨ ur eine gegebene Berechnung, die in der Konfiguration [q0 s1 . . . sn ] beginnt und in [qF #] endet, seien k0 = [q0 s1 . . . sn ] ⊢ k1 ⊢ . . . ⊢ kM = [qF #] die Konfigurationen der Berechnung. Dann gilt S ⇒ [qF #] ⇒ kM −1 ⇒ kM −2 ⇒ ⋅ ⋅ ⋅ ⇒ k1 ⇒ [q0 s1 . . . sn ] ⇒∗ s1 . . . sn , wobei am Anfang die Produktion (6) und am Ende die Produktionen (7) und (8) verwendet wurden. Also geh¨ort s1 . . . sn zu L(GM ). 2. Sei w = s1 . . . sn ein Wort, das von S ableitbar ist. Wir haben eine Ableitung der Form S ⇒ [qF #] ⇒ w1 ⇒ w2 ⇒ . . . ⇒ wM = s1 . . . sn . Wir d¨ urfen annehmen, dass die Regeln (7) und (8) (die bestimmt angewendet wurden, da w1 die beiden Klammern enth¨alt, aber wM nicht) erst am Ende der Ableitung angewendet wurden, also wM −2 = [q0 s1 . . . sn ]. F¨ ur die Ableitung w1 ⇒∗ wM −2 wurden nur die Regeln (1) - (6) angewendet. Es ist also hinreichend, zu zeigen, dass, falls f¨ ur zwei Konfigurationen w und w′ , w′ ⊢ w aufgrund von (1) - (6) gilt, dann folgt daraus w ⊢ w′ . (a) Falls die Produktion (1) angewendet wurde, gilt w′ = [uq ′ s′ v] und w = ¨ [uqsv], wobei qs → q ′ s′ eine Ubergangsregel ist. Dann ist w′ eine Folgekonfiguration von w. (b) Falls die Produktion (2) angewendet wurde, gilt w′ = [usq ′ v] und w = [uqsv]. Wieder ist w′ eine Folgekonfiguration von w. (c) Falls die Produktion (3) angewendet wurde, gilt w′ = [usq ′ #] und w = [uqs], und auch diesmal ist w′ eine Folgekonfiguration von w. Analog mit den Produktionen (4) und (5). Also f¨ ur w1 = [qF #] und wM −2 = [q0 s1 . . . sn ] folgt aus w1 ⇒∗ wM −2 , dass wM −2 ⊢∗ w1 . Das bedeutet, dass die TM auf die Eingabe s1 . . . sn h¨alt und akzeptiert. Also geh¨ ort s1 . . . sn zu L(M ).

ivaufzaehlbarUndGrammatik

ivaufzaehlbarUndGrammatik

Korollar 1. F¨ ur jede rekursiv-aufz¨ ahlbare Sprache L gibt es eine Grammatik, die L erzeugt.

sectBspAltVierDreiVier bspAltVierDreiVier

sectBspAltVierDreiFuenf

Beweis. Es gibt eine TM, die L akzeptiert. Sei M eine Modifikation dieser TM, die sich nur dadurch unterscheidet, dass M ihr Band l¨oscht, bevor sie h¨alt. Dann gilt L = L(M ) = L(GM ).

4.4. GRAMMATIKEN UND TURINGMASCHINEN bspAltVierDreiFuenf

115

Beispiel 4. Die folgende TM akzeptiert die Sprache aller ungeraden Zahlen (¨ uber Σ = {∣}): M = ({q0 , q1 , q2 }, {∣}, δ, q0 , qF ) ¨ mit Uberg¨ angen (q0 , ∣) → (q1 , #) (q1 , #) → (qF , R) (qF , ∣) → (q2 , #) (q2 , #) → (q0 , R) Dieser TM entspricht die folgende Grammatik GM = ({∣}, {q0 , q1 , q2 , #, [, ], S}, S, R) mit den Produktionen S → [qF #] q1 # → q0 ∣ #qF → q1 # #qF #] → q1 #] q2 # → qF ∣ #q0 → q2 # #q2 #] → q2 #] [q0 →ε ] →ε

UndRekursivaufzaehlbar

UndRekursivaufzaehlbar

Satz 2. Jede von einer Grammatik erzeugte Sprache ist rekursiv-aufz¨ ahlbar. Beweis. Wir wollen zeigen, dass f¨ ur jede Grammatik G die Sprache L(G) von einer TM akzeptiert werden kann. Wir benutzen eine nichtdeterministische 2-Band-TM, die alle Produktionen von G in einem zus¨atzlichen Ged¨achtnis hat. Band 1 ist ein read-only Eingabeband. Auf Band 2 schreibt die TM zu Beginn das Startsymbol S. In jedem Berechnungsschritt zerlegt die TM nichtdeterministisch das Wort w auf Band 2 in drei W¨ orter: w = upv u, p, v ∈ (Σ ∪ V )∗ mit p ≠ ε. Zum Beispiel ist am Anfang die einzige m¨ogliche Zerlegung u = ε, p = S und v = ε. Jetzt w¨ ahlt die TM nichtdeterministisch eine Produktion von G von der Form p → q (falls keine solche Produktion existiert, h¨alt die TM in einem nichtfinalen Zustand). Dann schreibt die TM das Wort w′ = uqv auf Band 2 und vergleicht Band 1 mit Band 2. Falls die Inhalte gleich sind, h¨alt die TM und akzeptiert. Falls sie nicht gleich sind, wird der neue Berechnungsschritt (Zerlegung des Wortes w′ in drei W¨ orter usw.) gestartet. Es ist klar, dass die Eingabe auf Band 1, falls sie von S ableitbar ist, nach endlich vielen Berechnungsschritten (die der Ableitung der Eingabe aus S entsprechen) akzeptiert wird. Falls umgekehrt die Eingabe nicht zu L(G) geh¨ort, ist jede m¨ogliche Berechnung entweder unendlich oder h¨alt und akzeptiert nicht.

116KAPITEL 4. CHURCH-TURING-THESE, REKURSIVE FUNKTIONEN UND GRAMMATIKEN

4.5

Universelle Turingmaschine

sectUnivTM

Wir konstruieren jetzt eine universelle (oder programmierbare“) TM, die bei Ein” gaben der Form (c, w) c – Algorithmus, w – Datei die Datei w entsprechend des Algorithmus c berechnet. Da wir Algorithmen als Turingmaschinen interpretieren, k¨onnen wir genauer sagen: eine universelle Turingmaschine Mu erh¨ alt als Eingabe ein Wort c(M )w, wobei c(M ) eine passende Codierung der (beliebigen) Turingmaschine M und w ein (beliebiges) Eingabewort f¨ ur M ist. Dann berechnet Mu die Eingabe und liefert genau dasselbe Ergebnis, das die Maschine M auf Eingabe w liefert. Das k¨onnen wir entweder in der Akzeptor-Variante interpretieren, also Mu h¨alt genau dann auf c(M )w, wenn M auf w h¨alt, und dann akzeptiert Mu genau dann, wenn M akzeptiert, oder in der Rechner-Variante, also Mu f¨ uhrt f¨ ur c(M )w zu der gleichen Ausgabe wie M f¨ ur w. Es zeigt sich, dass die Maschine Mu , die wir jetzt beschreiben, beide Rollen erf¨ ullt. Wir beschr¨ anken uns auf TM mit dem bin¨aren Bandalphabet Σ = {0, 1}. Also hat die universelle Turingmaschine Mu sowie alle simulierten Maschinen M dieses Eingabealphabet. Codierung c(M ) von Turingmaschinen M : F¨ ur jede TM M = (Q, {0, 1}, δ, q0 , q1 ) deren Zust¨ ande Q = {q0 , q1 , . . . , qn−1 } so durchnummeriert sind, dass q0 der Initialzustand und q1 der Finalzustand ist, definieren wir ein bin¨ ares Codewort c(M ) wie folgt. Wir benutzen 0i um die Zahl i zu codieren und 1 als Trennungssymbol. Das Wort c(M ) hat die folgende Form: Am Anfang steht 0n , das die Anzahl n ¨ aller Zust¨ ande bezeichnet. Dann werden die einzelnen t Ubergangsregeln aus R durch bin¨ are W¨ orter w1 , . . . , wt codiert, wie sp¨ater erkl¨art wird, und durch eine 1 voneinander getrennt. Am Ende schreiben wir 111. Der Code hat also die Form c(M ) = 0n 1w1 1w2 1 . . . 1wt 111. ¨ Um die Ubergangsregeln zu codieren, schreiben wir f¨ ur Zust¨ande 10i+1 statt qi und codieren die Symbole L, R, #, 0, 1 wie folgt Symbol Code

L 10

R 100

# 1000

0 104

1 105

¨ Die Ubergangsregel (qi , 0) → (qj , L) erh¨ alt also den Code w = 10i+1 104 10j+1 10, ¨ die Ubergangsregel (qi , #) → (qj , 0) den Code w = 10i+1 103 10j+1 104 usw.

4.5. UNIVERSELLE TURINGMASCHINE bspTMcode1

117

¨ Beispiel 1. Wir codieren die Maschine M1 mit Zust¨anden q0 , q1 und Ubergangsregeln (q0 , 1) → (q1 , R) (q1 , #) → (q1 , 1) wie folgt: c(M1 ) = 111001w1 1w2 111 wobei w1 der Code f¨ ur (q0 , 1) → (q1 , R) ist: w1 = 10105 100100 und w2 der Code f¨ ur (q1 , #) → (q1 , 1) ist: w2 = 100103 100105 . Insgesamt ergibt sich c(M1 ) = 00110105 1001001100103 100105 111. ¨ Wir bemerken, dass einzelne Ubergangsregeln voneinander durch 11 getrennt werden. Jede Turingmaschine wird durch ihren Code vollst¨andig beschrieben.

bspTMcode2

Beispiel 2. Falls eine Turingmaschine den Code c(M2 ) = 000110105 10103 110103 10101100104 103 100111 hat, muss es die Maschine M2 = ({q0 , q1 , q2 }, {0, 1}, δ, q0 , q1 ) ¨ mit den Ubergangsregeln (q0 , 1) → (q0 , #) (q0 , #) → (q0 , L) (q1 , 0) → (q2 , R) sein. Bemerkung 1. Erinnern wir uns an die in Kapitel 3 eingef¨ uhrte Sprache Lcode = { c(M ) ∣ M ist eine TM, die c(M ) nicht akzeptiert } . Zum Beispiel das Wort c(M1 ) in Beispiel 1 ist ein Codewort einer TM. Akzeptiert diese TM das Wort c(M1 ) ? Der erste Buchstabe von c(M1 ) ist 0 und da kein ¨ Ubergang (q0 , 9) →? definiert ist, h¨alt die TM sofort. Da q0 nicht final ist, akzeptiert das Wort c(M1 ) nicht. Das heißt, c(M1 ) ∈ Lcode . Wie in Abschnitt 3.4 bewiesen, ist die Sprache Lcode nicht rekursiv-aufz¨ahlbar. Das bedeutet, dass kein Algorithmus entscheiden kann, ob eine beliebige TM ihr eigenes Wort akzeptiert oder nicht. Universelle Turingmaschine Mu Wir konstruieren jetzt eine universelle Turingmaschine Mu . Also reagiert sie auf die Eingabe c(M )w, wobei M eine TM mit Eingabe aus {0, 1} und w ein Wort u ¨ber {0, 1} ist, wie folgt:

118KAPITEL 4. CHURCH-TURING-THESE, REKURSIVE FUNKTIONEN UND GRAMMATIKEN 1. Mu h¨ alt genau dann, wenn M auf das Wort w h¨alt, 2. Mu akzeptiert genau dann, wenn M das Wort w akzeptiert 3. falls M gehalten hat, hat Mu auf Band 1 dasselbe Ausgabewort wie M . Die Maschine Mu wird als eine 3-Band TM beschrieben, aber wir wissen, dass das unwichtig ist, weil wir eine 1-Band TM konstruieren k¨onnen, die Mu simuliert. BAND 1

BAND 2

# 0 1 0 ´

...

1 1 1 1 0 1 ... µ³ ¶ ´ µ³ w c(M )

1 # # ¶

...

Enth¨ alt c(M ) 0 0 ... ´ µ³ i+1

BAND 3

0 ¶ Zustand qi

Band 1 enth¨ alt am Anfang die Eingabe c(M )w. Das Ende des Wortes c(M ) wird durch 111 gekennzeichnet und die B¨ander 2 und 3 sind, wie u ¨blich, leer. Zur Vorbereitung auf die Simulation f¨ uhrt Mu die folgenden Schritte aus: 1. c(M ) wird von Band 1 auf Band 2 kopiert und auf Band 1 gel¨oscht, 2. der Kopf von Band 1 wird auf das erste Symbol von w gestellt 3. Auf Band 3 wird 10 geschrieben (Zustand q0 ), und der Kopf wird auf die 1 gestellt.

BAND 1

# 1 0 1 ... ´ µ³ ⇑ c(M )

1 # # ¶

BAND 2

1 1 1 ... 1 1 1 ´ µ³ ¶ ⇑ c(M )

BAND 3

# 1 0 #

...

⇑ Dann wird M in rekursiven Schritten wie folgt simuliert (so dass das Band von M identisch mit dem Band 1 von Mu ist und der Zustand von M gleich qi ist, wobei 0i+1 auf Band 3 von Mu steht): Simulation von M : Der Kopf von Band 1 liest s = #, 0 oder 1, also ein Symbol, das den Code 10p hat, wobei p = 3 (#), p = 4 (0) oder p = 5 (1) gilt. Jetzt beginnt der Kopf auf Band 2 eine systematische Suche nach der Kombination 10i+1 10p ,

4.5. UNIVERSELLE TURINGMASCHINE

119

wobei i + 1 die Zahl der 0’en auf Band 3 ist. Falls die Kombination 10i+1 10p nicht ¨ gefunden wurde, hat die Maschine M keine Ubergangsregel (qi , s) →?, deshalb h¨alt M . Also h¨ alt auch Mu (wenn sie die rechte Gruppe 111 auf Band 2 erreicht hat, ohne die gesuchte Kombination zu finden). Mu akzeptiert genau dann, wenn Band 3 den Inhalt 100 hat, d.h., genau dann, wenn M im Finalzustand q1 gehalten hat. Falls die Kombination 10i+1 10p gefunden wurde, liest der Kopf auf Band 2 weiter bis zur n¨ achsten Gruppe 11. Wir haben jetzt das Wort 10i+1 10p 10j+1 10r 11 . . . ¨ auf Band 2 und das bedeutet, dass eine Ubergangsregel von M die folgende Form besitzt: (qi , s) → (qj , s′ ) s′ hat den Code 10r (r = 1, . . . , 5) Die Maschine Mu ¨ andert den Bandinhalt von Band 3 zu 10j+1 und bewegt den Kopf auf Band 1 nach links oder rechts, falls r = 1 oder 2 ist, oder Mu u ¨berschreibt s mit #(falls r = 3), 0 (r = 4) oder 1 (r = 5). Jetzt ist Mu f¨ ur den n¨ achsten Simulationsschritt vorbereitet. Definition. Die Sprache Lu = L(Mu ) aller bin¨ aren W¨ orter c(M )w wobei die TM, M , das Wort w akzeptiert, heißt die universale Sprache. Folgerung 6. Lu ist rekursiv aufz¨ahlbar. Bemerkung 2. 1. Die obige Codierung kann auch auf nichtdeterministische Turingmaschinen mit dem Bandalphabet {0, 1} angewendet werden. 2. Es ist einfach zu entscheiden, ob ein bin¨ares Wort v der Code einer (deterministischen oder nichtdeterministischen) TM ist. Die Codierungen sind n¨amlich alle von der Form TMcode1

(1)

v = 0n 1w1 1w2 1 . . . 1wt 111,

wobei w1 , . . . , wt verschiedene W¨orter der Form TMcode2

(2)

10i+1 10p 10j+1 10r mit i, j = 0, . . . , n − 1, p = 3, 4, 5 und r = 1, 2, 3, 4, 5

sind. Umgekehrt ist jedes Wort v, das (1) und (2) erf¨ ullt, der Code einer TM. Mit anderen Worten ist die Sprache aller Codierungen von allen nichtdeterministischen TM rekursiv. 3. Auch die Sprache aller Codierungen aller deterministischen TM ist rekursiv: hier muss der Algorithmus nur noch f¨ ur alle Paare k, k ′ = 1, . . . , t von Indizes mit wk = 10i+1 10p 10j+1 10r und



wk′ = 10i + 110p 10j +1 10r u ufen, ob j = j ′ und r = r′ . ¨berpr¨



120KAPITEL 4. CHURCH-TURING-THESE, REKURSIVE FUNKTIONEN UND GRAMMATIKEN

4.6

Das Halteproblem

sectHalt

Gibt es einen Algorithmus, der f¨ ur jedes Paar (Algorithmus c, Datei w) entscheidet, ob c auf die Datei w h¨alt? Aus Abschnitt 4.5 wissen wir, dass es einen Algorithmus gibt, der auf die Eingabe (c, w) das Ergebnis von c auf die Datei w berechnet - das macht die universale Turingmaschine! Dennoch ist die Antwort auf die obige Frage, die als Halteproblem bekannt ist, negativ. Auch dann, wenn wir uns nur auf die Algorithmen beschr¨anken, die von TM mit dem Bandalphabet {0, 1} repr¨ asentiert werden, ist die Antwort negativ. F¨ ur diese Maschinen M haben wir die Codierung c(M ) aus Abschnitt 4.5, und wir k¨onnen das Halteproblem pr¨aziser formulieren: ist die Sprache Lhalt = { v ∣ v = c(M )w f¨ ur ein bin¨ares Wort w und eine Turingmaschine M , die auf Eingabe w h¨alt } rekursiv? Wir beweisen, dass Lhalt nicht rekursiv (also das Halteproblem nicht entscheidbar) ist, sie aber rekursiv-aufz¨ ahlbar ist. Daraus folgt, dass das Komplement Lhalt nicht rekursiv-aufz¨ ahlbar ist. Das bedeutet, dass das Problem, ob ein Algorithmus c auf die Datei w nicht h¨ alt, nicht einmal mehr semi-entscheidbar ist. Bemerken wir, dass in jedem Wort v = c(M )w der Code c(M ) eindeutig bestimmt ist (aufgrund der Trenngruppen 111 am Anfang und Ende von c(M )) und also auch w eindeutig bestimmt ist. Es gibt einen Algorithmus, der u uft, ob u diese Form ¨berpr¨ hat – siehe Bemerkung in Abschnitt 4.5. Bemerkung 1. Viele (auch ungel¨oste!) mathematische Probleme kann man umformulieren zu Fragen, ob eine leicht konstruierbare TM auf eine Eingabe h¨alt. Beispiel 1. Beispiel einer TM mit sehr interessantem Halteproblem. Es ist ziemlich trivial, eine 5-Band-TM zu konstruieren, die auf Band 2 systematisch alle Zahlen n = 3, 4, 5, . . . schreibt und f¨ ur jede Zahl n auf die B¨ander 3 - 5 systematisch alle Zahlen a, b, c ≥ 2 schreibt und dann auf Band 1 die Zahl an + bn − cn berechnet. Falls diese Zahl 0 ist, h¨alt die TM. Falls nicht, berechnet die TM den n¨ achsten Quadrupel (n, a, b, c). Die Entscheidung, ob diese Turingmaschine M auf die leere Eingabe h¨ alt, das heißt, ob c(M ) ∈ Lhalt gilt, ist bestimmt h¨ ochst kompliziert: dies ist ¨aquivalent zum Beweis des ber¨ uhmten Satzes von Fermat! Satz 1. Die Sprache Lhalt ist rekursiv-aufz¨ ahlbar. Beweis. Die folgende Turingmaschine akzeptiert Lhalt : TURINGMASCHINE M0 v

EINGABE / Hat v die Form v = c(M )w f¨ ur eine TM M ? NEIN

JA

/ H¨alt Mu auf Eingabe v?

NEIN



v nicht akzeptiert



v nicht akzeptiert

JA

/ v akzeptiert

4.6. DAS HALTEPROBLEM

121

Also u uft M0 , ob die Eingabe die Form c(M )w hat (siehe Bemerkung in 4.5), ¨berpr¨ und falls das der Fall ist, simuliert sie die universale Turingmaschine Mu . Die Eingabe v wird genau dann von M0 akzeptiert, wenn v = c(M )w und Mu (akzeptierend ¨ oder nicht akzeptierend) auf die Eingabe v h¨alt. Aquivalent dazu ist: genau dann, wenn M auf die Eingabe w h¨ alt. K¨ urzer: L(M0 ) = Lhalt . satzHalt

Satz 2 (Unentscheidbarkeit des Halteproblems). Die Sprache Lhalt ist nicht rekursiv. Beweis. Die Annahme, dass Lhalt rekursiv ist, f¨ uhrt zu einem Widerspruch: es folgt, dass die Sprache Lcode = {w; w = c(M ) f¨ ur eine Turingmaschine M mit w ∉ L(M )} rekursiv-aufz¨ ahlbar ist. Das ist aber falsch, siehe Beispiel 2 in Kapitel 3.4. Sei Mhalt eine TM, die Lhalt akzeptiert und auf jede Eingabe h¨alt. Dann l¨asst sich in der Tat eine TM konstruieren, die die Sprache Lcode akzeptiert: TURINGMASCHINE Mcode w

EINGABE / Hat w die Form w = c(M ) f¨ ur eine TM M ? NEIN



w nicht akzeptiert

JA / Akzeptiert Mhalt Eingabe ww? NEIN

JA / Akzeptiert Mu Eingabe ww?



w akzeptiert

NEIN

JA / w nicht akzeptiert



w akzeptiert

Das heißt, dass die Turingmaschine Mcode eine Eingabe w wie folgt berechnet: 1. Mcode u uft, ob w = c(M ) f¨ ur eine Turingmaschine M gilt (siehe Bemer¨berpr¨ kung in 4.5). 2. Falls ja, wiederholt Mcode die Eingabe und schreibt also ww = c(M )w auf das Band. 3. Jetzt simuliert Mcode die Maschine Mhalt bis sie h¨alt. (a) Falls Mhalt die Eingabe ww nicht akzeptiert, h¨alt Mcode und akzeptiert w. In diesem Fall h¨ alt n¨amlich die Maschine M nicht auf die Eingabe w (denn c(M )w ∉ Lhalt ); also wird w von M nicht akzeptiert – es folgt w ∈ Lcode . (b) Falls Mhalt akzeptiert, simuliert Mcode die universale TM auf dieselbe Eingabe ww. Da c(M )w ∈ Lhalt gilt, h¨alt M auf die Eingabe w, also h¨alt die universale TM auf die Eingabe c(M )w. Mcode akzeptiert genau dann, wenn Mu nicht akzeptiert. Die Turingmaschine Mcode h¨ alt auf jede Eingabe: der erste Schritt h¨alt (denn die Sprache aller Codes ist rekursiv, siehe Bemerkung 2.2 4.5), der zweite h¨alt nach unserer Voraussetzung von Mhalt , und der letzte h¨alt, denn Mu erh¨alt nur solche Eingaben ww, die von Mhalt akzeptiert werden, das heißt Eingaben c(M )w mit w = c(M ), so dass M auf w h¨ alt (oder ¨aquivalent: Mu h¨alt auf die Eingabe c(M )w = ww). Welche Eingaben w akzeptiert Mcode ? Genau die der Form w = c(M ), wobei entweder

122KAPITEL 4. CHURCH-TURING-THESE, REKURSIVE FUNKTIONEN UND GRAMMATIKEN ˆ M auf w nicht h¨ alt, d.h., Mhalt akzeptiert die Eingabe c(M )w nicht, oder ˆ M auf w h¨ alt und nicht akzeptiert, d.h., Mu akzeptiert die Eingabe c(M )w nicht.

Also gilt: w ∈ L(Mcode ) genau dann, wenn w = c(M ) und w ∉ L(M ); oder k¨ urzer: L(Mcode ) = Lcode , ein Widerspruch. Folgerung 7. Das Problem, ob eine TM nicht h¨alt, ist nicht semi-entscheidbar. D.h., die Sprache Lhalt ist nicht rekursiv-aufz¨ahlbar. Beweis. Das folgt aus Satz 2 im Abschnitt 4.5: falls Lhalt und Lhalt rekursivaufz¨ ahlbar w¨ aren, w¨ are Lhalt rekursiv.

4.7

Ein Rechner als Turing-Maschine

Die universelle TM zeigt, dass TM programmierbar sind: wir k¨onnen die Eingabe c(M )w der Maschine Mu als ein Paar von Algorithmen und Datei w, die als c(M ) dargestellt werden, verstehen. Ist aber klar, dass reelle Computer durchaus simuliert werden k¨ onnen? Ja, das wollen wir jetzt (informell, weil ”Computer” ist nicht definiert...) zeigen. (a) Wir nehmen an, dass der Speicher des Computers aus einer Reihe w0 , w1 , w2 , . . . (potentiell unendlich) von W¨ortern oder Bytes besteht, wobei wi die Adresse i hat. (b) In einigen W¨ ortern ist das Programm gespeichert. Jedes Wort repr¨asentiert eine einfache Anweisung entsprechend der Maschinensprache (oder der Assemblersprache). Wir erlauben indirekte Adressierung: Inhalt eines Wortes kann die Adresse sein, wo man die notwendige Datei findet. (c) Die Register, d.h., die W¨ orter mit besonders schnellem Zugriff, k¨onnen als separate B¨ ander der TM genommen werden. Hier nehmen wir an, dass unser Rechner nur ein Register hat, den Akkumulator (in dem z.B. die Arithmetik durchgef¨ uhrt wird). Nehmen wir die einfache Programmiersprache, die nur die folgende Anweisung hat: LEADi Kopiert Wi in den Akkumulator ADDi Addiert Wi + Akkumulator und speichert dies in dem Akkumulator JUMPi Sprung auf Adresse i READi Lese i Bits der Eingabe WRITE Kopiert Akkumulator in die Ausgabe Die TM hat 7 B¨ ander:

Band 1: Speicher

$$0$W0 $1$W1 $10$W2 $

Band 2:

Eingabe des Rechners (read only)

Band 3: Programmregister

101 (Einweisung in W5 durchgef¨ uhrt)

Band 4: Adressregister

111 (Einweisung hat Adresse 7)

Band 5:

Akkumulator

Band 6:

Name der Anweisung

Band 7:

Ausgabe

4.7. EIN RECHNER ALS TURING-MASCHINE

123

Anfang der Simulation Band 1 enth¨alt w$$u wobei w Datei (Eingabe) und u Inhalt des Speichers ist. Auf Band 2 kopieren wir die Eingabedatei aus Band 1 und l¨ oschen sie dort, sodass Band 1 den Speicher des Rechners enth¨alt. Simulation einer Anweisung aus wj schreibe

Auf Band 3 lese j, suche $j $wj $ auf Band 1 und

(a) den Namen der Anweisung (LOAD, ADD, . . .) auf Band 6 und die Adresse i auf Band 4. (b) erh¨ ohe Band 3 um 1 (c) die Anweisung durchf¨ uhren Z.B. falls LOADi in wj steht, suche die TM $i$wi $ auf Band 1 und schreibt wi auf Band 5. Im Fall von WRITEi f¨ uhrt die TM die Addition von Band 5 und wi durch und schreibt das Ergebnis auf Band 5, usw.

124KAPITEL 4. CHURCH-TURING-THESE, REKURSIVE FUNKTIONEN UND GRAMMATIKEN

Kapitel 5

Unentscheidbare Probleme Wir zeigen jetzt weitere Probleme, die nicht entscheidbar sind. Wir benutzen st¨andig die Codierung c(M ) von (deterministischen und nichtdeterministischen) Turingmaschinen M aus Abschnitt 3.5. Auch alle Modifikationen von Turingmaschinen mit Bandalphabet {0, 1} aus Abschnitt 3.2 sind damit codiert. Falls M z.B. eine nichtdeterministische k-Band TM ist, bezeichnen wir mit c(M ) den Code einer 1-BandTM, die M simuliert. Auch f¨ ur jeden Kellerautomaten erhalten wir eine Codierung, in dem Sinne, dass wir ihn mit einer nichtdeterministischen 2-Band TM simulieren (Beispiel 3 in Kapitel 3.3) und den Code der TM verwenden. Wir werden eine TM, die auf jede Eingabe h¨alt und die Sprache L akzeptiert, kurz Algorithmus f¨ ur L nennen.

5.1

Das Akzeptanzproblem

subsectAkzeptanz

Erinnern wir uns an den CYK-Algorithmus (Kapitel 2.9), der f¨ ur jede kontextfreie Grammatik G mit Terminalsymbolen aus {0, 1} und jedes Wort w u ¨ber {0, 1} entscheidet, ob w in L(G) liegt. Daraus folgt, dass das Akzeptanzproblem f¨ ur Kellerautomaten entscheidbar ist; mit anderen Worten haben wir einen Algorithmus, der f¨ ur jeden Kellerautomaten M und jedes Wort w entscheidet, ob M das Wort w akzeptiert. Oder k¨ urzer: die Sprache L(K) ur einen Kellerautomaten M und ein Wort w aus L(M )} acc = {u; u = c(M )w f¨ (K)

ist rekursiv. In der Tat kann ein Algorithmus, der Lacc entscheidet, wie folgt konstruiert werden: 1. Wir u ufen, ob die Eingabe u die Form u = c(M )w, wobei M ein Keller¨berpr¨ automat ist, hat – vergleiche die Bemerkung in 4.5. 2. F¨ ur den gegebenen Kellerautomaten M konstruieren wir eine kontextfreie Grammatik G(M ), die die Sprache L(M ) erzeugt. 3. Der CYK-Algorithmus wird auf G(M ) und w angewendet. (K)

Falls also M0 eine TM ist, die diesen Algorithmus repr¨asentiert, gilt Lacc = L(M0 ). Im Kontrast hierzu zeigen wir jetzt, dass das Akzeptanzproblem f¨ ur Turingmaschinen, also die Frage, ob eine gegebene Turingmaschine ein gegebenes Eingabewort akzeptiert, unentscheidbar ist. K¨ urzer: die Sprache aller c(M )w wobei M das Wort w akzeptiert ist nicht rekursiv: 125

126

KAPITEL 5. UNENTSCHEIDBARE PROBLEME

Definition. Lacc ist die Sprache aller bin¨aren W¨orter c(M )w f¨ ur eine Turingmaschine M und ein Wort w aus L(M ). Satz 1. Die Sprache Lacc ist nicht rekursiv. Beweis. Wir merken erst an, dass es zu jeder Turingmaschine M eine Turingmaschine M gibt, die sich von M nur darin unterscheidet, dass finale und nichtfinale Zust¨ ande ausgetauscht werden. (Genauer: wenn wir in M die finalen und nichtfinalen Zust¨ ande austauschen, erhalten wir eine TM mit mehreren finalen Zust¨anden, ̃ simuliert, siehe Abschnitt 3.2.1) Der Ubergang ¨ von M und M ist eine TM, die M asst sich offensichtlich durch einen (kleinen) Algorithmus implementieren. zu M l¨ ˆ gibt, die auf die Eingabe c(M ) die Das bedeutet, dass es eine Turingmaschine M Ausgabe c(M ) berechnet. Es gilt w ∈ L(M ) genau dann, wenn M auf die Eingabe w h¨alt und nicht akzeptiert. Wir beweisen jetzt, dass die Annahme, dass Lacc rekursiv ist, zu einem Widerspruch f¨ uhrt: wenn Lacc rekursiv w¨ are, w¨ urde folgen, dass Lhalt rekursiv ist. In der Tat: falls Lacc von einer Turingmaschine Macc akzeptiert wird, die auf jede Eingabe h¨alt, k¨ onnen wir die folgende Turingmaschine Mhalt konstruieren, die Lhalt akzeptiert und auf jede Eingabe h¨ alt: TURINGMASCHINE Mhalt u

u nicht akzeptiert

O

EINGABE



Hat u die Form u = c(M )w f¨ ur eine TM M ? NEIN



u nicht akzeptiert

NEIN Akzeptiert JA / NEIN/ c(M ) wird Macc Eingabe ˆ von M c(M )w? berechnet JA



u akzeptiert

Akzeptiert

/ Macc Eingabe c(M )w? JA



u akzeptiert

Diese TM akzeptiert genau die Eingaben u = c(M )w, f¨ ur die gilt, dass ˆ entweder M akzeptiert w (d.h., Macc akzeptiert c(M )w), oder ˆ M akzeptiert w (d.h., Macc akzeptiert c(M )w).

Das heißt, genau die Eingaben c(M )w, f¨ ur die M auf die Eingabe w h¨alt. K¨ urzer: L(Mhalt ) = Lhalt . Dar¨ uber hinaus h¨alt Mhalt auf jede Eingabe – ein Widerspruch zu Satz 2 aus Kapitel 4.6.

5.2

Akzeptanz des leeren Wortes

subsectAkzeptanzEps

Eine noch einfachere Frage ist, ob eine TM die leere Eingabe akzeptiert. Auch diese Frage ist aber unentscheidbar: Definition. Lε ist die SPrache aller bin¨aren W¨orter c(M )w wobei M eine TM ist die ε akzeptiert Satz 1. Die Sprache Lε ist nicht rekursiv.

5.3. IST EINE TM EIN ALGORITHMUS?

127

Wir merken erst an, dass es f¨ ur jede Turingmaschine M und jedes Wort w eine Turingmaschine Mw gibt, die das leere Wort genauso berechnet wie M das Wort w. Mw schreibt erst das Wort w = s1 . . . sn von links nach rechts auf ihr Band (mit Hilfe von n neuen Zust¨ anden q1 , . . . , qn , wobei qn der Initialzustand von Mw ist) und dann geht sie in den Initialzustand q0 der Maschine M u ¨ber und beginnt die Berechnung ¨ wie M . Das bedeutet, dass zu den Ubergangsregeln von M die folgenden Regeln hinzugef¨ ugt werden: (qn , #) → (qn , sn ) (qn , sn ) → (qn−1 , L) (qn−1 , #) → (qn−1 , sn−1 ) (qn−1 , sn−1 ) → (qn−2 , L) ⋮ (q1 , #) → (q1 , s1 ) (q1 , s1 ) → (q0 , s1 ) (Jetzt steht der Kopf im Zustand q0 am Anfang des Wortes w = s1 . . . sn .) ¨ Offensichtlich kann der Ubergang von (M, w) zu Mw durch einen Algorithmus imˆ , die auf die Eingabe c(M )w plementiert werden, d.h., es gibt eine Turingmaschine M die Ausgabe c(Mw ) berechnet. Die Annahme, dass Lε rekursiv ist, f¨ uhrt zu einem Widerspruch: daraus w¨ urde folgen, dass Lacc rekursiv ist. In der Tat haben wir, falls Mε ein Algorithmus f¨ ur Lε ist, den folgenden Algorithmus f¨ ur Lacc : TURINGMASCHINE Macc u

EINGABE / Hat u die Form u = c(M )w f¨ ur eine TM M ? NEIN

JA /

c(Mw ) wird ˆ von M berechnet.

Akzeptiert

/ Mε Eingabe NEIN/ u nicht



u nicht akzeptiert

c(Mw )? JA

akzeptiert



u akzeptiert

Es ist klar, dass Mε die Eingabe u = c(M )w genau dann akzeptiert, wenn Mw das leere Wort akzeptiert und das geschieht genau dann, wenn M das Wort w akzeptiert. Das heißt, genau dann, wenn die Eingabe u = c(M )w in Lacc liegt. K¨ urzer: L(Macc ) = Lacc . Außerdem h¨alt Macc auf jede Eingabe – ein Widerspruch zu 5.1

5.3

Ist eine TM ein Algorithmus?

Auch diese Frage, d.h., das Problem, ob eine gegebene TM auf jede Eingabe h¨alt, ist unentscheidbar. Definition. Lalg ist die Sprache aller bin¨aren W¨orter c(M )w wobei M eine TM ist, die auf jede Eingabe h¨ alt Satz 1. Die Sprache Lalg ist nicht rekursiv. Wir merken erst an, dass es f¨ ur jede Turingmaschine M eine Turingmaschine M ′ gibt, die jede Eingabe so berechnet wie M die Eingabe ε: M ′ l¨oscht erst das Band

128

KAPITEL 5. UNENTSCHEIDBARE PROBLEME

¨ und dann simuliert sie M . Offensichtlich kann der Ubergang von M zu M ′ durch einen Algorithmus durchgef¨ uhrt werden. Die Annahme, dass Lalg rekursiv ist, f¨ uhrt zu einem Widerspruch: daraus w¨ urde folgen, dass Lε rekursiv ist. In der Tat haben wir den folgenden Algorithmus f¨ ur Lε , falls Malg ein Algorithmus f¨ ur die Sprache Lalg ist: TURINGMASCHINE Mε u

u akzeptiert

O

EINGABE

JA



Hat u die Form u = c(M ) f¨ ur eine TM M ? NEIN



JA /

c(M ) wird ˆ von M berechnet.

Akzeptiert

/ Malg Eingabe c(M ′ )?

NEIN



u nicht akzeptiert

JA



u nicht akzeptiert

Akzeptiert Mu

/ die Eingabe c(M ′ )?

NEIN



u nicht akzeptiert

Die Maschine Mε h¨ alt auf jede Eingabe u: nur im letzten Schritt m¨ ussen wir aufpassen, ob Mu auf die Eingabe c(M ′ ) h¨alt (¨aquivalent: ob M ′ auf die Eingabe ε h¨ alt) – das folgt daraus, dass Malg die Eingabe c(M ′ ) akzeptiert. Und eine Eingabe u wird genau dann von Mε akzeptiert, wenn u = c(M ) f¨ ur eine Turingmaschine, f¨ ur die gilt: M ′ h¨ alt auf jede Eingabe und M ′ akzeptiert ε. Das ist ¨aquivalent dazu, dass M auf ε h¨ alt und akzeptiert. Also u ∈ L(Mε ) genau dann, wenn u = c(M ) ∈ Lε . Das steht im Widerspruch zu 5.2

5.4

Das Problem von “hello world” Programmen

Es ist leicht, ein JAVA-Programm zu schreiben, welches auf jede Eingabe “hello world” ausgibt und h¨ alt. Ist es aber so leicht, diese Eigenschaft zu u ufen? ¨berpr¨ Wir wollen ein Programm Phallo schreiben, welches f¨ ur gegebene Eingabedatei w und JAVA Programmcode P entscheidet, ob P mit Eingabe w “hello world” schreibt und h¨ alt. Ist dies m¨ oglich? Nein, so ein Programm kann man nicht schreiben. Oder, ¨aquivalent dazu, die folgende Sprache ist nicht rekursiv: Lhallo = {c(M )w; die TM M auf Eingabe w h¨alt und hat ASCII-Code f¨ ur “hello world” auf dem Band }. Satz 1. Lhallo ist unentscheidbar. Beweis. Angenommen, dass Lhallo entscheidbar ist, leiten wir einen Widerspruch her. Wir haben eine TM, Mhallo , die auf jede Eingabe h¨alt und akzeptiert g.d.w. die ̃hallo , die auf jede Eingabe c(M )w in Lhallo ist. Wir modifizieren sie zu einer TM M Eingabe w = c(M ) funktioniert wie Mhallo auf Eingabe ww. Aber wenn Mhallo h¨alt ̃hallo das Band. Vorausgesetzt Mhallo h¨alt und akzeptierte und akzeptiert, l¨ oscht M ̃ nicht, schreibt Mhallo “hello world” auf das Band. ̃hallo TURINGMASCHINE M

5.5. SATZ VON RICE

129

/ ww

EINGABE / w

/ Mhallo 

akzeptiert

/ Band l¨oschen

akzeptiert nicht

“hello world” am Band

Es gibt zwei M¨ oglichkeiten f¨ ur das Wort w ˜ = c(Mhallo ), beide sind widerspr¨ uchlich: ̃w ̃ liegt in Lhallo . Dann akzeptiert Mhallo das Wort w ̃w. ̃ Deswegen (a) Das Wort w ̃hallo auf Eingabe w ̃ leer. Das aber bedeutet, dass Mhallo ist das Band von M ̃)w ̃=w ̃w ̃ nicht. akzeptiert c(M ̃w ̃ liegt nicht in Lhallo . Dann akzeptiert Mhallo nicht diese Eingabe, (b) Das Wort w ̃hallo auf Eingabe w ̃ “hello world”. Daras folgt, dass Mhallo deswegen schreibt M ̃ ̃=w ̃w. ̃ akzeptiert c(Mhallo )w

5.5

Satz von Rice

Ist es entscheidbar, ob f¨ ur eine Turingmaschine M die akzeptierte Sprache L(M ) ˆ regul¨ ar, ˆ kontextfrei, oder ˆ nichtleer

ist? Alle drei Antworten sind negativ. In der Tat gilt ein u ¨berraschend allgemeiner Satz in diesem Gebiet. Sei S eine beliebige Eigenschaft formaler Sprachen (z.B. regul¨ar, kontextfrei, nicht leer, usw.) Wir fragen, ob es entscheidbar ist, dass eine TM eine Sprache mit der Eigenschaft S akzeptiert. K¨ urzer, ob die Sprache LS = {c(M ); M ist eine TM und L(M ) hat die Eigenschaft S} rekursiv ist. Das ist selbstverst¨ andlich der Fall, falls S trivial ist, d.h., ˆ entweder hat jede Sprache L(M ) die Eigenschaft S, oder ˆ keine Sprache L(M ) hat die Eigenschaft S.

Die drei oben erw¨ ahnten Eigenschaften sind bestimmt nicht trivial. Der folgende Satz ergibt also die negativen Antworten: Satz 1 (Satz von Rice). F¨ ur jede nichttriviale Eigenschaft S von Sprachen ist es unentscheidbar, ob f¨ ur eine Turingmaschine M die Sprache L(M ) die Eigenschaft S hat. K¨ urzer: die Sprache LS ist nicht rekursiv. Beweis. 1. Nehmen wir erst an, dass die leere Sprache ∅ die Eigenschaft S nicht hat. Da S nicht trivial ist, gibt es eine Turingmaschine M0 , so dass gilt L(M0 ) hat die Eigenschaft S. F¨ ur jede Turingmaschine M und jedes Wort w konstruieren wir die folgende Turingmaschine M w :

130

KAPITEL 5. UNENTSCHEIDBARE PROBLEME TURINGMASCHINE M w u

EINGABE / Akzeptiert M0 die Eingabe u? NEIN

JA

/ Akzeptiert M

die Eingabe w? NEIN



u nicht akzeptiert

JA /

u akzeptiert



u nicht akzeptiert

Es gilt ⎧ ⎪ ⎪L(M0 ) L(M w ) = ⎨ ⎪ ∅ ⎪ ⎩

falls M die Eingabe w akzeptiert falls M die Eingabe w nicht akzeptiert

¨ Der Ubergang von (M, w) zu M w kann offensichtlich durch einen Algorithˆ , die auf die mus implementiert werden. Es gibt also eine Turingmaschine M w Eingabe c(M )w die Ausgabe c(M ) berechnet. Die Annahme, dass LS rekursiv ist, f¨ uhrt zu einem Widerspruch: es w¨ urde folgen, dass Lacc (5.1) rekursiv ist. In der Tat erhalten wir, falls MS ein Algorithmus f¨ ur die Sprache LS ist, den folgenden Algorithmus f¨ ur Lacc : TURINGMASCHINE Macc u

u nicht akzeptiert

O

EINGABE

NEIN



Hat u die Form u = c(M )w f¨ ur eine TM M ? NEIN



u nicht akzeptiert

JA /

c(M w ) wird ˆ von M berechnet.

Akzeptiert

/ MS Eingabe c(M w )? JA



u nicht akzeptiert

In der Tat akzeptiert Macc genau die W¨orter c(M )w, f¨ ur die MS die Eingabe c(M w ) akzeptiert, d.h., f¨ ur die die Sprache L(M w ) die Eigenschaft S hat. Es gilt: L(M w ) hat die Eigenschaft S ⇐⇒ M akzeptiert w, denn f¨ ur L(M w ) haben wir nur zwei M¨oglichkeiten: L(M w ) = L(M0 ) und L(M0 ) hat die Eigenschaft S, oder L(M w ) = ∅, und ∅ hat die Eigenschaft S nicht. Also: Macc akzeptiert genau die W¨orter c(M )w, die in Lacc liegen. Da Macc auf jede Eingabe h¨alt, bekommen wir einen Widerspruch zu 5.1. 2. Nehmen wir an, dass die leere Sprache ∅ die Eigenschaft S hat. Sei S die komplement¨ are Eigenschaft (das heißt, die Negation von S), die genau die Sprachen haben, die die Eigenschaft S nicht haben. Speziell hat ∅ also nicht die Eigenschaft S, und S ist sicher nichttrivial. Aus (1) folgt, dass LS nicht rekursiv ist. Daraus folgt, dass die Sprache LS (aller W¨orter, die nicht in LS liegen) nicht rekursiv ist, denn LS ist der Durchschnitt von LS und der Sprache aller Codes {c(M ); M eine TM}. Die letztere Sprache ist rekursiv, siehe Bemerkung in 4.5 Falls also auch LS rekursiv w¨are, m¨ usste LS rekursiv sein. Aus Satz ??? folgt, dass LS nicht rekursiv ist.

5.6. MINIMIERUNG VON TURINGMASCHINEN

5.6

131

Minimierung von Turingmaschinen

Wir zeigen, dass es im Gegensatz zu endlichen Automaten keinen Minimierungsalgorithmus f¨ ur Turingmaschinen gibt. F¨ ur jede TM (die, wie oben, das Bandalphabet {0, 1} hat) bezeichnen wir mit fM die partielle Funktion, die M wie folgt berechnet: falls M die Eingabe n (bin¨ar) hat, und falls M h¨alt, ist fM (n) die Zahl, die auf dem Band steht, wenn alle Blanksymbole und eventuell am Anfang stehende Nullen ignoriert werden. Ein Minimierungsalgorithmus f¨ ur Turingmaschinen ist ein Algorithmus A, der jeder Turingmaschine M eine Turingmaschine A(M ) mit der minimalen Anzahl von Zust¨ anden zuordnet, die dieselbe Funktion berechnet, fM (n) = fA(M ) (n)

f¨ ur alle n.

Beispiel 1. F¨ ur jede Turingmaschine M , die die Identit¨atsfunktion berechnet, d.h., fM (n) = n f¨ ur alle n ∈ N erf¨ ullt, hat die Turingmaschine A(M ) nur einen Zustand. Denn die Identit¨ atsfunktion kann von einer TM mit einem einzigen Zustand und ¨ keiner Ubergangsregel realisiert werden. Satz 1. Es gibt keinen Minimierungsalgorithmus f¨ ur Turingmaschinen. Beweis. Wir merken erst an, dass es f¨ ur jede Turingmaschine M und jedes Wort w m¨ oglich ist, die folgende Turingmaschine M(w) zu konstruieren TURINGMASCHINE M(w) n

EINGABE /

(bin¨ ar)

H¨ alt M auf die NEIN / Eingabe w in M(w) l¨ asst n ausgeben h¨ ochstens n Schritten? JA



M(w) schreibt Ausgabe 0

Also simuliert M(w) die Turingmaschine M auf die Eingabe w f¨ ur k ≤ n Schritte, bis M h¨ alt, und dann schreibt M(w) die Ausgabe 0; falls M in n Schritten nicht ¨ h¨ alt, schreibt M(w) die Ausgabe n. Der Ubergang von M und w zu M(w) kann ˆ ˆ ist eine einfache offensichtlich von einer Turingmaschine M durchgef¨ uhrt werden (M ˆ Modifikation der universalen TM). Also ist M eine TM, die auf die Eingabe c(M )w die Ausgabe c(M(w) ) liefert. Es gilt: fM(w) (n) = n,

falls M auf Eingabe w nicht h¨alt,

d.h., die Machine M(w) berechnet die Identit¨atsfunktion. Also gilt f¨ ur jeden Minimierungsalgorithmus A, A(M(w) ) hat 1 Zustand, falls M auf w nicht h¨alt. Umgekehrt gilt: falls M auf Eingabe w h¨alt, ist fM(w) nicht die Identit¨atsfunktion. Es gilt also: M h¨ alt nicht auf Eingabe w ⇐⇒ A(M(w) ) berechnet die Identit¨atsfunktion. Die Annahme, dass es einen Minimierungsalgorithmus A gibt, f¨ uhrt zu einem Widerspruch: es folgt, dass die Sprache Lhalt rekursiv-aufz¨ahlbar ist (siehe Korollar in 4.6). In der Tat akzeptiert die folgende Turingmaschine M ∗ die Sprache Lhalt :

132

KAPITEL 5. UNENTSCHEIDBARE PROBLEME TURINGMASCHINE M ∗ u

EINGABE / Hat u die Form u = c(M )w f¨ ur eine TM M ? NEIN

JA /

c(M(w) ) wird ˆ von M berechnet.

/

M(w) wird von A minimiert.

/



u nicht akzeptiert

/

Hat A(M(w) ) nur einen Zustand? NEIN



u nicht akzeptiert

JA

/

Berechnet A(M(w) ) die Identit¨ atsfunktion? NEIN

JA /

u akzeptiert



u nicht akzeptiert

(Die letzte Entscheidung, ob eine TM mit nur einem Zustand die Identit¨atsfunktion berechnet, l¨ asst sich bestimmt mit einem kleinen Algorithmus durchf¨ uhren.) Die Maschine M ∗ h¨ alt auf jede Eingabe und akzeptiert alle W¨orter u = c(M )w, wobei M(w) die Identit¨ atsfunktion berechnet. Da fM(w) genau dann die Identit¨atsfunktion ist, wenn M auf die Eingabe w nicht h¨alt, gilt M ∗ akzeptiert c(M )w ⇐⇒ M h¨alt nicht auf w. K¨ urzer: L(M ∗ ) = Lhalt , ein Widerspruch.

Kapitel 6

Komplexit¨ at von Algorithmen Bisher haben wir uns die Frage gestellt, ob ein Problem entscheidbar (d.h. mit Hilfe eines Algorithmus l¨ osbar) ist. Jetzt wollen wir auch die Effizienz von Algorithmen diskutieren. Es gibt wichtige Aufgaben, wie z.B. jeden Graphen mit der kleinstm¨ oglichen Zahl an Farben zu f¨arben (ohne dass eine Kante gleichfarbige Knoten verbindet), f¨ ur die es zwar Algorithmen gibt, aber kein effizienter Algorithmus bekannt ist. Wir f¨ uhren zuerst die Klasse P aller Probleme ein, die effizient l¨osbar sind; z.B. das Problem, jeden Graphen, f¨ ur den es m¨oglich ist, mit zwei Farben zu f¨arben. Effi” zient“ bedeutet: in polynomialer Zeit durchf¨ uhrbar. Genauer: ein Problem geh¨ort der Klasse P an, falls es mit einem Algorithmus l¨osbar ist, f¨ ur den es ein Polynom p(m) gibt, so dass f¨ ur jede Eingabe der Gr¨oße m die L¨osung in p(m) Zeiteinheiten gefunden werden kann. Es zeigt sich, dass die Klasse P nicht von dem Modell der Berechnung abh¨ angt: es kann eine Turingmaschine, eine RAM oder eine moderne Workstation sein. (Nat¨ urlich wird f¨ ur diese drei Modelle das ausgew¨ahlte Polynom p(n) ganz verschieden sein, d.h., der Grad der Effizienz“ h¨angt sehr von der kon” kreten Implementierung ab. Aber die prinzipielle M¨oglichkeit, die Zeit durch ein Polynom zu beschr¨ anken, ist implementierungsunabh¨angig.) ¨ Danach wird die Klasse N P aller Probleme eingef¨ uhrt, f¨ ur die wenigstens die Uberpr¨ ufung, ob eine gegebene Datei das Problem l¨ost, effizient ist. Z.B. das Problem, jeden Graphen, f¨ ur den es m¨ oglich ist, mit drei Farben zu f¨arben: es ist kein effizi¨ enter Algorithmus bekannt, aber die Uberpr¨ ufung, ob eine vorgeschlagene F¨arbung wirklich drei Farben benutzt und keine Kante zwischen gleichfarbigen Knoten ergibt, ist effizient. Leider ist es bis heute nicht bekannt, ob P = N P. Aber es sind viele Probleme bekannt, die N P-vollst¨andig“ sind - f¨ ur diese gilt: w¨are eines dieser ” Probleme effizient l¨ osbar, w¨ aren es alle anderen auch, denn dann folgt P = N P. Das erw¨ ahnte Problem der Dreif¨ arbung von Graphen ist, wie wir beweisen werden, N Pvollst¨ andig. Es scheint sehr unwahrscheinlich, dass dieses Problem effizient l¨osbar ist, aber falls ja, w¨ urde daraus folgen, dass viele andere wichtige Probleme (z.B. Traveling Salesman Problem) effizient l¨osbar w¨aren. Dieses Kapitel hat, wie die vorigen, theoretischen Charakter; z.B. benutzt die Klasse P beliebige Polynome zur Zeiteinschr¨ankung und das ist nicht realistisch“, falls ” das Polynom einen zu großen Exponenten hat. Dennoch hat Komplexit¨atstheorie wichtige praktische Aspekte. Stellen Sie sich vor, dass Ihr Chef Sie damit beauftragt hat, ein Programm zu schreiben, das u uft, ob eine vorgeschlagene Produktspe¨berpr¨ 133

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT

134

zifikation realisierbar ist. Trotz einigen Wochen intensiven Versuchens ist es Ihnen nicht gelungen, das Programm zu schreiben. Was jetzt? Wenn Sie die Produktspezifikation analysieren und feststellen, dass sie sehr allgemein formuliert ist, liegt es vielleicht an der Allgemeinheit und nicht an Ihrer Unf¨ahigkeit. Es w¨are z.B. toll, wenn Sie zeigen k¨ onnen, dass das von Ihnen verlangte Programm eigentlich auch das Halteproblem l¨ osen k¨ onnte – dann k¨onnen Sie Ihrem Chef beweisen, dass er unl¨ osbare Aufgaben erteilt. Das ist aber leider nicht sehr wahrscheinlich, denn das Halteproblem ist doch sehr allgemein. Also versuchen Sie zu zeigen, dass Ihr Programm eines von den hunderten N P-vollst¨andiger Problemen l¨osen w¨ urde – das zeigt nicht, dass die Aufgabe prinzipiell nicht effektiv implementierbar w¨are, aber dass es schon einer Schar ausgezeichneter Programmierer nicht gelungen ist, einen effizienten Algorithmus zu entwickeln.

6.1

Beispiele effizienter Algorithmen

sect-eff-alg

In diesem Abschnitt illustrieren wir eine genaue Analyse der Effizienz von Algorithmen an einigen wichtigen Beispielen von Graphen-Algorithmen. Ein gerichteter Graph G = (V, E), wobei V die Menge aller (n) Knoten und E die Menge aller Kanten (d.h. geordneten Paaren von Knoten) ist, wird gew¨ohnlich durch seine n × n-Adjazenzmatrix (aij ) repr¨ asentiert, wobei ⎧ ⎪ ⎪1 falls (i, j) eine Kante in E ist aij = ⎨ ⎪ 0 sonst ⎪ ⎩ Oder durch Adjazenzlisten, d.h., durch n lineare Listen, wobei die i-te Liste alle Knoten j mit (i, j) ∈ E enth¨ alt und die heads (Listenk¨opfe) in einem Array gespeichert werden. Beispiel: f¨ ur den gerichteten Graphen / 2

1 O





3 _  4

5 o

haben wir die Adjazenzmatrix der Gesamtgr¨oße m = n2 ⎛0 ⎜0 ⎜ ⎜0 ⎜ ⎜0 ⎝1

1 1 0 0 0

0 1 0 1 0

0 1 0 0 0

0⎞ 0⎟ ⎟ 0⎟ ⎟ 1⎟ 0⎠

und die Adjazenzlisten der Gesamtgr¨oße m = n + k

6.1. BEISPIELE EFFIZIENTER ALGORITHMEN

135



1

/ 2

2

/ 2

/ 4

4

/ 5

/ 3

5

/ 1

/ 3



3

bsp-top-sort





Beispiel 1 (Topologisches Sortieren). In Abschnitt 2.8 haben wir den folgenden Algorithmus f¨ ur das topologische Sortieren eines gerichteten Graphen G = (V, E) beschrieben: 1: {(1) Initialisierung} 2: i ∶= 0 3: W ∶= V {W – die Menge der noch nicht bearbeiteten Knoten} 4: {(2) Rekursionsschritt} 5: while ein Knoten x ∈ W ohne Vorg¨ anger existiert do 6: i ∶= i + 1; 7: ord(x) = i; 8: W ∶= W − {x} 9: L¨ oschen des Knotens x aus dem Graphen 10: od Wie lange dauert dieser Algorithmus f¨ ur einen Graphen mit n Knoten? Nehmen wir an, dass eine Eintragung in die Liste ord sowie die Modifikation der Variablen i und W eine konstante Zahl A von Zeiteinheiten dauert. Um einen Knoten x ohne Vorg¨ anger zu finden, suchen wir in der Adjazenzmatrix eine Spalte mit lauter Nullen; das dauert Km2 Zeiteinheiten, wobei K eine Konstante ist und m die aktuelle Knotenzahl ( m = n, n − 1, . . . , 1), und die Entfernung eines Knotens dauert eine konstante Zahl L von Zeiteinheiten. Dann ist die gesamte Zahl von Zeiteinheiten f¨ ur diesen Algorithmus n

T = 2A + ∑ (Km2 + 3A + L) > Cn3

f¨ ur eine Konstante C.

m=1

Dieser Algorithmus kann viel effizienter implementiert werden. Diesmal stellen wir den Graphen mittels Adjazenzlisten dar. Wir bezeichnen f¨ ur jeden Knoten v mit IN [v]

(ein Array, v = 1, . . . , n)

die Zahl aller Kanten mit dem Endknoten v und wir setzen U = {v; v ∈ V und IN [v] = 0}. Algorithmus f¨ ur Topologisches Sortieren Eingabe: Gerichteter Graph G = (V, E) mit n Knoten und k Kanten Ausgabe: Topologische Sortierung ord ∶ V → {1, . . . , n} von G, falls G azyklisch ist 1: {(1) Initialisierung} 2: i ∶= 0 {i – die letzte Zahl, die ord benutzt hat} 3: U ∶= ∅ {U - die Menge aller Knoten v mit IN [v] = 0} 4: IN [1] ∶= 0, . . . , IN [n] ∶= 0 5: for alle Knoten v in V do 6: for alle Knoten w mit einer Kante (v, w) in E do

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT

136 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29:

IN [w] ∶= IN [w] + 1 end for end for for alle Knoten v in V do if IN [w] = 0 then U ∶= U ∪ {v} end if end for {(2) Rekursionsschritt} while U einen Knoten v enth¨alt do U ∶= U − v i ∶= i + 1 ord(v) ∶= i for alle Knoten w mit (v, w) ∈ E do IN [w] ∶= IN [w] − 1 if IN [w] = 0 then U ∶= U ∪ {w} end if end for od {(3) Ausgabe} Falls n = i, ist ord eine topologische Sortierung von G. Falls n > i, ist die Ausgabe ein Code daf¨ ur, dass G nicht azyklisch ist.

ur jeden azyklischen Graphen G ist ord eine topologische Sortierung Korrektheit: F¨ von G. Das folgt daraus, dass jeder azyklische Graph einen Knoten ohne Vorg¨anger hat. Deshalb ist U ≠ ∅, solange nicht alle Knoten sortiert worden sind. F¨ ur jede Kante (v, w) von G gilt: falls in einem Durchgang der Schleife 16–26 der Wert ord(v) ∶= i zugeordnet wird, hat vor diesem Durchgang IN [w] einen Wert ≥ 1. Deswegen wird der Wert ord(w) erst in einem Durchgang i + k, k ≥ 1, zugewiesen und es folgt ord(v) < ord(w). Zeitkomplexit¨ at: Wir wollen die Zahl der Zeiteinheiten bestimmen, die dieser Algorithmus f¨ ur Graphen mit n Knoten und k Kanten braucht. Das h¨angt von der Implementierung ab. Wir nehmen an, dass die mengentheoretischen Operationen (insert, delete) so implementiert werden, dass sie eine konstante Zahl A von Zeiteinheiten brauchen, und auch jede Zuweisung A Zeiteinheiten ben¨otigt. Dann dauert die Initialisierung: Zeile 2. 3. 4. 5.–9. 10.–14.

Zeitkomplexit¨ at A A An n + Ak 2An (3A + 1)n + Ak Zeiteinheiten

Nur die Zeilen 5.–9. ben¨ otigt eine Erkl¨arung: bezeichnen wir mit k(v) die Zahl aller Nachfolger von v. Die Implementierung mit Adjazenzlisten erlaubt eine Durchf¨ uhrung der Schleife 6.–8. in Zeit Ak(v). Die ganze Schleife dauert n + ∑nv=1 Ak(v) = n + Ak Zeiteinheiten. Im Rekursionsschritt dauert 20.–25. 3Ak(v) Schritte. Da die Rekursion n-mal wiederholt wird, ben¨ otigt sie

6.1. BEISPIELE EFFIZIENTER ALGORITHMEN 17. 18. 19. 20.–25.

137

An An An 3Ak 3A(n + k) Zeiteinheiten

Die Zeitkomplexit¨ at des Algorithmus ist also (6A + 1)n + 4Ak Zeiteinheiten. Bemerkung 1. Die Konstante A h¨angt von der konkreten Implementierung ab. Um von solchen Details in unserer Analyse absehen zu k¨onnen, f¨ uhren wir, f¨ ur jede Funktion t(n), die Klasse O(t(n))

(gelesen: O von t(n)“) ”

ein, die aus allen Funktionen f (n) besteht, die nicht schneller als t(n) wachsen (f¨ ur große Werte von n): Definition. O(t(n)) bezeichnet die Klasse aller Funktionen f (n), f¨ ur die es Konstanten n0 und C gibt, so dass f (n) ≤ Ct(n)

f¨ ur alle n ≥ n0 .

Beispiel 2. 1. Der Algorithmus f¨ ur topologische Sortierung hat eine lineare Zeitkomplexit¨ at O(n + k) Es gilt (6A + 1)n + 4Ak ≤ C(n + k), wobei C = 6A + 1, f¨ ur alle n ≥ 0. 2. Jedes quadratische Polynom geh¨ort zur Klasse O(n2 ). In der Tat, f¨ ur f (n) = a + bn + cn2 = (

a b + + c) n2 2 n n

gilt: falls n ≥ max{a, b}, ist f (n)leq(2 + c)n2 . Es gen¨ ugt also, n0 = max{a, b} und C = 2 + c zu setzen. 3. Allgemeiner enth¨ alt die Klasse O(nk ) alle Polynome des Grades k. 4. Die exponentielle Funktion 2n geh¨ort nicht zu der Klasse O(nk ), denn 2n = ∞. n→∞ nk lim

Bemerkung 2. Falls Graphen als Adjazenzmatrizen implementiert werden, ben¨otigt jeder Algorithmus f¨ ur das topologische Sortieren mindestens n2 Schritte 2 In der Tat muss jeder Algorithmus f¨ ur jedes der n2 Paare (i, j) entweder aij oder aji in der Adjazenzmatrix durchsuchen. (Stellen wir uns vor, dass ein Algorithmus

138

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT

A weder aij noch aji durchsucht. F¨ ur den Graphen G mit n Knoten und keiner Kante ergibt A ein topologisches Sortieren. Bezeichnen wir mit G den Graphen, der genau zwei Kanten i → j und j → i enth¨alt. Dann wird G mit dem Algorithmus A genau wie G bearbeitet, obwohl G zyklisch ist. Das ist ein Widerspruch.) Also ist auch bei dieser Implementierung die Zeitkomplexit¨at linear in der Gr¨oße n2 der Eingabe. bsp-2-faerb

¨ Beispiel 3 (2-FARBUNG). Wir wollen einen (ungerichteten) Graphen G mit zwei Farben, z.B. rot und blau, so f¨arben, dass keine zwei benachbarten Knoten gleichfarbig sind. Es ist klar, dass das f¨ ur Graphen, die ein Dreieck enthalten, unm¨oglich ist. Allgemeiner: f¨ ur einen Graphen mit einem Zyklus ungerader L¨ange existiert keine solche F¨ arbung. In dem Fall, dass G keine Zyklen ungerader L¨ange hat, l¨aßt sich ein einfacher Algorithmus wie folgt angeben: wir w¨ahlen einen Knoten v und f¨arben ihn rot. Alle Nachbarn von v werden blau gef¨arbt – da G kein Dreieck enth¨alt, verursacht diese F¨ arbung keine Probleme. Dann werden alle Nachbarn der zuletzt gef¨arbten Knoten rot gef¨ arbt - da G kein Dreieck und keinen Zyklus aus f¨ unf Kanten enth¨alt, verursacht auch dies keine Probleme. So wird fortgefahren, bis die ganze Komponente von v (d.h., alle Knoten, die mit v durch einen ungerichteten Weg verbunden sind) gef¨ arbt ist. Dann w¨ ahlen wir wieder einen beliebigen, noch nicht gef¨arbten, Knoten, der rot gef¨ arbt wird, usw. Wir beschreiben diesen Algorithmus formal. Die Mengen aller (schon) roter oder blauer Knoten werden mit ROT und BLAU bezeichnet, die Menge aller zuletzt gef¨ arbten Knoten mit F . Algorithmus f¨ ur 2-F¨ arbung Eingabe: Ungerichteter Graph G = (V, E) Ausgabe: Eine 2-F¨ arbung V = ROT ∪ BLAU , falls es eine gibt. 1: {1. Initialisierung} 2: ROT ∶= ∅ 3: BLAU ∶= ∅ 4: F ∶= ∅ 5: {2. Rekursionsschritt} 6: while V ≠ ∅ do 7: w¨ ahle v aus V 8: V ∶= V − {v} 9: ROT ∶= ROT ∪ {v} 10: F ∶= F ∪ {v} 11: while F ≠ ∅ do 12: w¨ ahle w in F 13: for alle Knoten u ∈ V mit (u, w) ∈ E do 14: if w ∈ ROT then 15: BLAU ∶= BLAU ∪ {u} 16: else 17: ROT ∶= ROT ∪ {u} 18: end if 19: F ∶= F ∪ {u} 20: V ∶= V − {u} 21: end for 22: F ∶= F − {w} 23: od 24: od 25: {3. Ausgabe} 26: Falls ROT oder BLAU eine Kante aus E enthalten, ist die Ausgabe ein Code

6.1. BEISPIELE EFFIZIENTER ALGORITHMEN

139

daf¨ ur, dass G keine 2-F¨ arbung hat. Falls weder ROT noch BLAU eine Kante enth¨ alt, ist dies die gesuchte 2-F¨arbung. Korrektheit: In jedem Schritt des Algorithmus gilt f¨ ur jeden Knoten v: entweder v ∈ V oder v ∈ ROT oder v ∈ BLAU . Da am Ende V = ∅ gilt, ist also jeder Knoten entweder rot oder blau gef¨ arbt. Falls weder ROT noch BLAU eine Kante enth¨alt, haben wir eine 2-F¨ arbung gefunden. Es bleibt zu zeigen, dass G Zyklen ungerader L¨ange hat, falls ROT eine Kante enth¨ alt (analog f¨ ur BLAU). Sei v der Knoten in 7. Wir beweisen, dass jeder Knoten, der in 17. rot (oder in 15. blau) gef¨arbt wird, einen Weg von gerader (oder ungerader) L¨ ange nach v hat, wobei die L¨ ange des leeren Weges“ von v nach v gleich 0 gesetzt ” wird. Am Anfang der Schleife ab 11. ist das klar, denn der einzige roten Knoten ist v, und blaue gibt es nicht. Jeder Durchgang dieser Schleife erh¨alt diese Eigenschaft: falls w rot ist und also einen Weg der L¨ange 2k nach v hat, wird jeder blau zu f¨ arbende Knoten u (f¨ ur den eine Kante (u, w) gegeben ist) einen Weg der L¨ange 2k + 1 nach v haben. Analoges gilt, falls w blau ist. Sei (u, u′ ) eine Kante in ROT . Wir haben einen Kreis, der mit einen Weg der L¨ ange 2k von u nach v beginnt, dann mit einem Weg der L¨ange 2k ′ von v nach u′ weitergeht und mit der Kante (u′ , u) endet. Dieser Kreis hat die ungerade L¨ange 2k + 2k ′ + 1 und enth¨ alt also einen Zyklus ungerader L¨ange (denn ein Kreis, der nur Zyklen von gerader L¨ ange enth¨ alt, hat selbst gerade L¨ange). Analog l¨aßt sich f¨ ur eine Kante in BLAU argumentieren. Zeitkomplexit¨ at: Falls Graphen als Adjazenzlisten implementiert werden und die mengentheoretischen Operationen konstante Zeit erforden, hat dieser Algorithmus eine lineare Zeitkomplexit¨ at O(n + k) (wobei n die Zahl aller Knoten und k die Zahl aller Kanten ist). In der Tat ben¨ otigt die Initialisierung die Zeit O(1). Die F¨arbung einer Komponente K (die Zeilen 8.–23.), deren Zahl von Kanten k(K) ist, dauert O(k(K)), da jede Kante nur einmal durchsucht wird. Falls der Graph G genau r Komponenten hat, gilt k = k(K1 )+⋅ ⋅ ⋅+k(Kr ) und die r Durchg¨ange der Schleife 6.–24. dauern O(n+k) Schritte. ¨ Die Uberpr¨ ufung, ob ROT oder BLAU eine Kante enthalten, ben¨otigt auch die lineare Zeit O(n + k). Insgesamt wird der Algorithmus also in O(n + k) Schritten durchgef¨ uhrt. ¨ Beispiel 4 (3-FARBUNG). Die analoge Aufgabe, einen gegebenen Graphen mit drei Farben zu f¨ arben, ist viel schwieriger. Kein effizienter Algorithmus ist bekannt – und sp¨ ater werden wir Gr¨ unde daf¨ ur kennenlernen, weshalb es unwahrscheinlich ist, dass ein effizienter Algorithmus existiert. Ineffizient k¨ onnen wir einfach alle m¨oglichen F¨arbungen ausprobieren. Das ist bestimmt ein Algorithmus – aber er braucht O(3n ) Schritte, da es 3n F¨arbungsm¨oglichkeiten gibt. Und das ist sehr aufwendig. bsp-ger-weg

Beispiel 5 (GERICHTETER WEG). F¨ ur zwei Knoten v und w eines gerichteten Graphen ist ein Weg der L¨ ange d von v nach w eine Liste v = v0 , v1 , . . . , v d = w von Knoten, so dass (vi−1 , vi ) eine Kante f¨ ur i = 1, . . . , d ist. Jeder Knoten hat einen (leeren) Weg der L¨ange 0 zu sich selbst.

140

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT

Seien ein gerichteter Graph G und zwei Knoten v und w gegeben, dann entscheiden wir in linearer Zeit O(n + k), ob ein Weg von v nach w f¨ uhrt. Sei M die Menge aller Knoten zu denen ein Weg von v f¨ uhrt. Algorithmus f¨ ur gerichteter Weg Eingabe: Ein gerichteter Graph G = (V, E) und zwei Knoten v und w Augabe: JA, falls ein gerichteter Weg von v nach w f¨ uhrt, ansonsten NEIN 1: {Initialisierung:} 2: M ∶= {v} 3: {Rekursionsschritt:} 4: while eine Kante (x, y) mit x ∈ M und y ∉ M existiert do 5: M ∶= M ∪ {y} 6: E ∶= E − {(x, y)} 7: od 8: {Ausgabe:} 9: JA, falls w ∈ M , NEIN falls w ∈ / M. Zeitkomplexit¨ at: Falls der Graph mit Adjazenzlisten implementiert ist, dauert dieser Algorithmus O(n + k) Schritte, denn jede Liste wird h¨ochstens einmal durchsucht.

6.2

Komplexit¨ atsklasse P

sect-classP

Alle Probleme, die ein Rechner mit polynomialer Zeitkomplexit¨at l¨osen kann, formen die Klasse P. Genauer: ein Entscheidungsproblem geh¨ort zu P, falls es einen Algorithmus gibt, der f¨ ur jede Eingabe der L¨ange n in h¨ochstens p(n) Zeiteinheiten entscheidet, ob die Antwort JA oder NEIN ist, wobei p(n) ein (gegebenes) Polynom ist. Es entsteht die Frage: welche Implementierung haben wir hier im Sinn? Die Antwort ist: die Klasse P ist von der Implementierung unabh¨angig. Verschiedene Implementierungen k¨ onnen nat¨ urlich verschiedene Zeitkomplexit¨aten haben (wie im Fall des TOPOLOGISCHEN SORTIERENS in 6.1 gezeigt wurde); d.h., das Polynom p(n) wird f¨ ur jede Implementierung individuell gew¨ahlt werden. Aber die Existenz eines Polynomes ist unabh¨angig von der Implementierung. Das zeigen wir, indem wir Turingmaschinen als Implementierungsmodell nehmen und dann beweisen, dass dieselbe Klasse P auch z.B. mit RAM als Modell entsteht. Der Beweis f¨ ur andere Berechnungsmodelle folgt analog. Definition. Wir sagen, dass eine deterministische TM eine Zeitkomplexit¨at t(n) hat, wobei t(n) eine Funktion aus der Menge N ist, falls die TM f¨ ur jede Eingabe der L¨ ange n in h¨ ochstens t(n) Schritten h¨alt. kompl-bsp

Beispiel 1. Die Sprache L ⊆ {0, 1}∗ aller W¨orter, die keine zwei benachbarten Einsen enthalten, kann von der folgenden TM akzeptiert werden: M bleibt solange im Initialzustand q0 , wie sie Nullen liest, also (q0 , 0) → (q0, R). Falls M eine 1 liest, geht sie in den Zustand q1 u ¨ber: (q0 , 1) → (q1, R). Falls nach der 1 gleich eine 0 folgt, gehen wir zur¨ uck zum Zustand q0 , falls aber noch eine 1 gelesen wird, h¨alt die Maschine im (nichtfinalen) Zustand q1 . Und falls das Blanksymbol gelesen wird, h¨ alt die Maschine im finalen Zustand qF . Hier ist eine vollst¨andige Beschreibung von M : M = ({q0 , q1 , qF }, {0, 1}, δ, q0 , qF )

¨ 6.2. KOMPLEXITATSKLASSE P

141

¨ wobei δ durch die folgenden Ubergangsregeln bestimmt wird: (q0 , 0) → (q0 , R) (q0 , 1) → (q1 , R) (q0 , #) → (qF , #) (q1 , 0) → (q0 , R) (q1 , #) → (qF , #) Jede Eingabe der L¨ ange n liest die TM von links nach rechts und h¨alt sp¨atestens bei dem Symbol # hinter dem Eingabewort, also nach h¨ochstens n + 1 Schritten. Sie hat also die Zeitkomplexit¨ at t(n) = n + 1. Bemerkung 1. 1. Im Kapitel 3 haben wir verschiedene Varianten von TM eingef¨ uhrt (zum Beispiel mit zus¨atzlichem Ged¨achtnis, mit mehreren B¨andern, usw.). Die Definition der Klasse P (s.u.) ist unabh¨angig davon, welche der Varianten als TM gemeint ist; das beweisen wir exakt im Abschnitt 6.4. 2. Zeitkomplexit¨ at ist nicht eindeutig definiert (denn sie ist nur eine Absch¨atzung f¨ ur die Anzahl der Berechnungsschritte). Genau genommen ist jede Funktion t′ (n) mit t′ (n) ≥ n+1 f¨ ur alle n auch eine Zeitkomplexit¨at der TM aus Beispiel 1. tm-palin

Beispiel 2. Die Sprache aller Palindrome (siehe Abschnitt 2.1, Beispiel 3) wird von der folgenden Turingmaschine M akzeptiert. Die Maschine M hat ein zus¨atzliches Ged¨ achtnis (siehe 3.2.2) f¨ ur die Symbole aus Σ und vier Zust¨ande: q0 , Initialzustand, qR und qL (f¨ ur die Bewegung nach links oder rechts des Kopfes der Turingmaschine) und qF , einen finalen Zustand. Zustand q0 : Falls # gelesen wird, h¨alt die TM und akzeptiert. Falls ein Symbol aus Σ gelesen wird, speichert die TM es im Ged¨achtnis, l¨oscht es und geht zu qR u ¨ber. Zustand qR bewegt den Kopf nach rechts bis er # liest, dann bewegt sich der Kopf einen Schritt nach links. [Problem: nach dem L¨oschen des ersten Symbols steht die TM im Zustand qR auf einem #; daher wird ein spezielles L¨oschsymbol ben¨otigt.] Falls das jetzt gelesene Symbol mit dem Ged¨achtnis u ¨bereinstimmt, wird es gel¨oscht und die TM geht zu qL u ¨ber; falls nicht, h¨alt die TM und akzeptiert nicht. [Problem: zum L¨ oschen am rechten Rand brauchen wir einen weiteren Zustand, etwa qC .] Zustand qL bewegt den Kopf nach links bis er # liest [bzw. das neue L¨oschsymbol], dann bewegt er den Kopf einen Schritt nach rechts und geht zu q0 u ¨ber. ¨ Wie lange dauert die Berechnung einer Eingabe der L¨ange n? Der Ubergang q0 → qR ¨ dauert einen Schritt und der Ubergang qR → qL dauert n + 2 Schritte. Es dauert also 1 + (n + 2) + n = 2n + 3 Schritte, bis wieder q0 erreicht wird. Jetzt beginnt dieselbe Berechnung mit einem Wort der L¨ ange n − 2. Der Zustand q0 wird also in 2(n − 2) + 3 Schritten wieder erreicht. (Wir nehmen immer den schlechtesten Fall an, hier also den Fall, dass die Eingabe wirklich ein Palindrom ist.) Die gesamte Berechnungszeit betr¨agt h¨ochstens t(n) = (2n + 3) + (2n − 1) + ⋅ ⋅ ⋅ + 5 + 1 Schritte. Diese Summe ist gleich n2 + 4n + 4, wie durch Induktion leicht bewiesen werden kann (?). Das bedeutet, dass unsere TM die Zeitkomplexit¨at t(n) = n2 + 4n + 4

142

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT

hat. Bemerkung 2. Wir k¨ onnen f¨ ur die Sprache aller Palindrome eine fast doppelt so schnelle TM konstruieren, indem wir die beiden ersten Buchstaben speichern (und l¨ oschen) und sie mit den beiden letzten vergleichen (und diese dann auch l¨ oschen). Eine noch schnellere TM w¨ urde drei (oder vier usw.) Buchstaben auf einmal vergleichen. Wir k¨ onnen also eine fast k-mal schnellere TM f¨ ur ein beliebig großes k konstruieren. Wir beobachten, dass jede dieser TM eine Zeitkomplexit¨at hat, die von einem quadratischen Polynom repr¨asentiert wird. Den gleichen Beschleunigungsprozess k¨onnen wir mit jeder TM machen, indem wir stets in einem Schritt k Felder gleichzeitig lesen und bearbeiten. Aus diesem Grund ist nicht die Funktion t(n) selbst interessant, nur die Geschwindigkeit des Wachs” tums“ von t(n), also die Klasse O(t(n)). Definition. Wir bezeichnen mit P die Klasse aller formalen Sprachen, die von einer TM mit polynomialer Zeitkomplexit¨ at akzeptiert werden k¨ onnen. Genauer: eine Sprache L geh¨ort zur Klasse P, falls es eine Turingmaschine M und ein Polynom p(n) gibt, so dass L = L(M ) und M h¨ alt auf Eingaben der L¨ange n in h¨ochstens p(n) Schritten. Bemerkung 3. Erinnern wir uns daran, dass Entscheidungsproblem ≡ formale Sprache. Genau genommen m¨ ussen wir ein Entscheidungsproblem erst codieren (z.B. bin¨ar, mit Symbolen 0 und 1). Dann bezeichnet L ⊆ {0, 1}∗ die Sprache aller Codierungen der Eingaben, auf die die Entscheidung JA ist. Weiter nehmen wir immer an, dass die Codierung von Problemen vern¨ unftig“ ist. ” Wenn n¨ amlich jemand freiwillig eine extrem lange Codierung der Eingabe benutzt, kann er auch ein kompliziertes Problem in linearer Zeit p(n) = n, wobei n die unvern¨ unftige“ Codel¨ ange ist, l¨osen. Die folgenden Regeln sind als vern¨ unftig“ ” ” anzusehen: 1. Zahlen werden bin¨ ar oder dezimal repr¨asentiert. (Nicht un¨ar!) 2. Graphen werden durch Adjazenzmatrizen oder Adjazenzlisten dargestellt (siehe Abschnitt 6.1). 3. Mengentheoretische Operationen (Insert, Delete, Vereinigung, Durchschnitt) werden so implementiert, dass ihre Ausf¨ uhrung eine konstante Zahl von Zeiteinheiten dauert. Beispiel 3 (PALINDROM). Die Entscheidung, ob ein Wort ein Palindrom ist, ist ein Problem der Klasse P, denn die TM aus Beispiel 2 hat die Zeitkomplexit¨at O(n2 ). ¨ Beispiel 4 (2-FARBUNG). Das Problem, ob ein Graph mit zwei Farben gef¨arbt werden kann, geh¨ ort zur Klasse P. In Abschnitt 6.1 haben wir daf¨ ur einen Algorithmus mit linearer Zeitkomplexit¨at beschrieben. Es ist nicht kompliziert, den Algorithmus mit einer TM zu implementieren und zu beweisen, dass diese TM polynomiale Zeitkomplexit¨ at hat.

¨ 6.2. KOMPLEXITATSKLASSE P bsp-2-3-SAT

143

¨ ¨ Beispiel 5 (2-ERFULLBARKEIT und 3-ERFULLBARKEIT). Analog zu der Situation der 2-F¨ arbung und 3-F¨arbung haben wir hier ein anderes wichtiges Beispiel der Probleme, deren leichtere Variante zu P geh¨ort und deren schwierige (wahrscheinlich) nicht. Es handelt sich um Boolesche Formeln u ¨ber den Variablen x1 , . . . , xn . Die einfachsten Formeln sind die Variablen xi selbst und ihre Negationen ¬xi - diese Formeln heißen Literale. Die komplizierteren Formeln werden mit Hilfe der u ¨blichen logischen Operationen, z.B. Konjunktion ∧, Disjunktion ∨ und Implikation → erzeugt. Jede Disjunktion von Literalen heißt Klausel . Beispiele: x ∨ y ∨ ¬z

¬x.

und

Jede Boolesche Formel phi hat eine konjunktive Normalform (KNF), d.h., φ = φ1 ∧ φ2 ∧ ⋅ ⋅ ⋅ ∧ φn ist eine Konjunktion der Klauseln φ1 , . . . , φn . Z.B. hat die Formel φ = (x → y ∧ z) ∧ (¬x → ¬z) ¨ die folgende KNF: wir benutzen die Aquivalenz von a→b

und

¬a ∨ b

und erhalten φ = (¬x ∨ (y ∧ z)) ∧ (x ∨ ¬z) Da ¬x ∨ (y ∧ z) ¨ aquivalent zu (¬x ∨ y) ∧ (¬x ∨ z) ist (de Morgansches Gesetz), gilt φ = (¬x ∨ y) ∧ (¬x ∨ z) ∧ (x ∨ ¬z). Das ist also eine Boolesche Formel, deren Klauseln je zwei Literale enthalten. Eine Formel φ heißt erf¨ ullbar , falls die Variablen so mit true oder false belegt werden k¨ onnen, dass φ den Wert true annimmt. Beispiel: die obige Formel ist erf¨ ullbar, denn f¨ ur x = true, y = true, z = true gilt φ = true. Es ist kein effizienter Algorithmus bekannt, der f¨ ur jede Boolesche Formel unter¨ scheidet, ob sie erf¨ ullbar ist. Das Problem m-ERFULLBARKEIT ist: Gegeben, eine Boolesche Formel φ in konjunktiver Normalform, wobei jede Klausel m Literale enth¨ alt, ist φ erf¨ ullbar? Wir definieren die Gr¨oße der Eingabe φ als n + k, wobei n die Anzahl aller Variablen und k die Anzahl aller Klauseln von φ ist. ¨ 2-ERFULLBARKEIT geh¨ ort zur Klasse P. Wir k¨onnten hier einen effizienten Algorithmus angeben, aber einfacher ist es zu zeigen (in Abschnitt 6.3), dass es eine effiziente Reduktion dieses Problems auf ein anderes Problem der Klasse P gibt – ¨ daraus folgt dann indirekt, dass 2-ERFULLBARKEIT zur Klasse P geh¨ort. ¨ 3-ERFULLBARKEIT ist dagegen schwierig: in Abschnitt 6.4 zeigen wir, dass dieses ¨ Problem N P-vollst¨ andig ist, also genauso schwierig wie 3-FARBUNG. bsp-universal

¨ REGULARER ¨ ¨ Beispiel 6 (UNIVERSALITAT AUSDRUCKE). Das ist ein (rares) Beispiel eines leicht zu formulierenden Problems, f¨ ur das bewiesen wurde, dass es nicht effizient l¨ osbar ist. Regul¨are Ausdr¨ ucke haben wir in Kapitel 1 eingef¨ uhrt: sie werden aus Buchstaben des Alphabets Σ, z.B. Σ = {a, b}, und Symbolen ∅ und  mit Hilfe der Operatoren +, ⋅, und ∗ erzeugt. Jetzt arbeiten wir mit komprimierter Notation: statt xx . . . x (n-mal) schreiben wir x ↑ n (n bin¨ar), z.B. xxxxx = x ↑ 101

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT

144 Der regul¨ are Ausdruck

(aaa + b∗ )(aaa + b∗ ) ergibt also in komprimierter Notation (a ↑ 11 + b∗ ) ↑ 10. Ein regul¨ arer Ausdruck u ¨ber dem Alphabet Σ heißt universal , falls die dadurch definierte Sprache die ganze Sprache Σ∗ ist. Z.B. ist der obige regul¨are Ausdruck (¨ uber Σ = {a, b}) nicht universal, aber (a∗ ↑ 11+b∗ ) ↑ 10 ist universal. Jeder regul¨are Ausdruck u ¨ber Σ ist also ein Wort u ¨ber dem Alphabet Σ ∪ {∗, +, (, ), 0, 1, ↑} und die L¨ ange dieses Wortes ist dann die Gr¨oße der Eingabe. Satz 1. Das Problem, zu entscheiden, ob ein gegebener regul¨ arer Ausdruck in komprimierter Notation u ort nicht zu P. ¨ber {a, b} universal ist, geh¨ Den Beweis kann der Leser unter 13.15 im Buch von Hopcroft und Ullman (siehe Einleitung [?]) finden.

6.3

Berechnungsprobleme und Reduzierbarkeit

sect-berechnungsprob

Die Komplexit¨ atsklasse P wurde f¨ ur Entscheidungsprobleme eingef¨ uhrt. Analog k¨ onnen wir f¨ ur Berechnungsprobleme die Klasse FP einf¨ uhren, die alle in polynomialer Zeit l¨osbaren Probleme enth¨alt. ¨ Beispiel 1. 2-FARBUNG ist das Problem, zu jedem 2-f¨arbbaren Graphen eine 2-F¨ arbung zu berechnen. Darunter verstehen wir, wie u ¨blich, eine Funktion f ∶ {0, 1}∗ → {0, 1}∗ , die jedem bin¨ aren Code w = c(G) eines Graphen G einen bin¨aren Code f (w) seiner 2-F¨ arbung zuordnet, falls G eine 2-F¨arbung hat. So eine Funktion kann in linearer Zeit berechnet werden, siehe Beispiel 3 in 6.1. Wir verwenden wieder TM als Berechnungsmodell. Wir sagen, dass eine TM eine Funktion f ∶ Σ∗ → Γ∗ (Σ, Γ zwei Alphabete) berechnet, falls die TM f¨ ur jede Eingabe s1 s2 . . . sn (aus Σ∗ ) nach endlich vielen Schritten mit dem Wort f (s1 . . . sn ) (aus Γ∗ ) auf dem Band h¨alt, siehe Abschnitt ?? Definition. Wir bezeichnen mit FP die Klasse aller Funktionen f ∶ Σ∗ → Γ∗ , die von einer TM in polynomialer Zeit berechnet werden k¨onnen. D.h., f¨ ur die eine Turingmaschine M und ein Polynom p(n) existieren, so dass M auf jede Eingabe s1 . . . sn aus Σ∗ in h¨ ochstens p(n) Schritten h¨alt und f (s1 . . . sn ) auf das Band schreibt.

6.3. BERECHNUNGSPROBLEME UND REDUZIERBARKEIT bsp-starke-komp

arke-komp-formen-graph

145

Beispiel 2 (STARKE KOMPONENTEN). Zwei Knoten eines gerichteten Graphen G k¨ onnen genau dann in beiden Richtungen durch einen gerichteten Weg verbunden werden, wenn sie in einem Kreis des Graphen liegen. Wir sagen dann, dass die beiden Knoten in derselben starken Komponente liegen. Genauer: eine starke Komponente von G ist eine maximale Menge von Knoten, die durch gerichtete Wege (in beiden Richtungen) miteinander verbunden werden k¨ onnen. Beispiel: der folgende Graph 0

● a

r

● ●

b

ru ¨ber L(a, b), mit k < 0

6.5. GEOMETRISCHE ALGORITHMEN UND REELLE RAM

153

Falls die Linie L(a, b) die Gleichung y = kx + q hat, liegt r genau dann u ¨ber dieser Linie, wenn ry > krx + q. Auch diese Entscheidung dauert O(1) Schritte. Beispiel 3 (DAS INNERE EINES POLYGONS). Eingabe: Ein konvexes Polygon P und ein Punkt r. Ausgabe: Entscheidung, ob r im Inneren von P liegt. Bemerkung 1. Ein Polygon P ist eine Liste von Punkten, die als die Ecken von P bezeichnet werden. Ein Polygon P = (v0 , v1 , . . . , vn−1 ) heißt simple, falls sich die Strecken L(vi , vi+1 ) (wobei i + 1 modulo n berechnet wird) nur in den erwarteten“ ” Ecken schneiden, d.h., der Durchschnitt von L(vi , vi+1 ) und L(vj , vj+1 ) mit i ≠ j ist vi , falls j +1 = i, oder vj , falls i+1 = j, und ansonsten leer. Falls wir aus der Ebene die Strecken eines simplen Polygons P entfernen, erhalten wir zwei zusammenh¨angende Teile, einen gebundenen, der das Innere von P genannt wird, und einen weiteren, ¨ der als das Außere von P bezeichnet wird. Ein simples Polygon P heißt konvex , falls sein Inneres jede Strecke enth¨alt, deren Endpunkte es enth¨ alt. Beispiele: ●

● ●





● Konvexes Polygon

● ●

















● Nichtkonvexes Polygon

Nichtsimples Polygon

Ein konvexes Polygon wird als eine Liste v0 , v1 , . . . , vn−1 von Punkten angegeben, wobei wir annehmen, dass die Orientierung im Uhrzeigersinn erfolgt und keine zwei benachbarten Ecken auf der gleichen Linie liegen: v1 ● v0 ● vn−1 ● ● vn−2

● v2











Um unseren Algorithmus zu vereinfachen, nehmen wir zus¨atzlich an, dass die xKoordinaten der Punkte v0 , . . . , vn−1 voneinander verschieden sind. Algorithmus f¨ ur das INNERE EINES POLYGONS 1. Wir w¨ ahlen einen Punkt p im Inneren von P . 2. Die Halblinien von p zu den Ecken v0 , . . . , vn−1 teilen die Ebene in n Sektoren. Wir bestimmen den Sektor, in dem sich der gegebene Punkt r befindet, in O(log n) Schritten wie folgt.

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT

154

v0 vi+1







● a



v1 ●

p

vi



Wir suchen also i0 = 0, . . . , n − 1, so dass r im Sektor (vi0 , p, vi0 +1 ) liegt (hier wird i0 + 1 modulo n berechnet, d.h., (n − 1) + 1 = 0). Wir wenden bin¨ares Suchen an: falls wir, f¨ ur jedes i = 0, . . . , n − 1, in konstanter Schrittzahl O(1) entscheiden, ob i0 kleiner, gleich oder gr¨oßer als i ist, berechnen wir i0 in O(log n) Schritten. Falls r rechts von p liegt (rx ≥ px ) brauchen wir nur die Ecken rechts von p betrachten. Sei also vi eine solche Ecke:

vi 0





r

● vi0 +1

● vi



Falls r u ¨ber L(p, vi ) liegt, gilt i0 > i. Falls r unter L(p, vi ), aber u ¨ber L(p, vi+1 ) liegt, gilt i0 = i . Und falls r unter L(p, vi+1 ) liegt, gilt i0 < i. Diese Entscheidung ben¨ otigt eine konstante Zahl von Schritten. Analoges gilt f¨ ur a links von p (rx ≤ px ). 3. Falls der Sektor (vi , p, vi+1 ), in dem r liegt, berechnet worden ist, gilt: r liegt genau dann im Inneren des Polygons P , wenn es im Inneren des Dreiecks (vi , p, vi+1 ) liegt. Dies bestimmen wir in konstanter Zahl O(1) von Schritten. (Sei αx + βy + γ = 0 die Gleichung der Linie L(vi , vi+1 ). Dann liegt r genau dann im Inneren des Dreiecks, wenn αx + βy + γ dieselben Zeichen f¨ ur die Koordinaten von r und p hat.) Zeitkomplexit¨ at Der Algorithmus wird in O(1) + O(log n) + O(1) = O(log n) Schritten durchgef¨ uhrt. ¨ Beispiel 4 (KONVEXE HULLE). Eingabe: Punkte v1 , . . . , vn in der Ebene mit paarweise verschiedenen x-Koordinaten. Ausgabe: Konvexe H¨ ulle, d.h., das kleinste Polygon, das alle Punkte enth¨alt. Bemerkung 2. Jede Ecke der konvexen H¨ ulle ist einer der gegebenen Punkte. Das kann man sich leicht am Gummiband-Modell klarmachen: stellen wir uns ein elastisches Gummiband vor, das so gestreckt wird, dass es alle gegebenen Punkte enth¨ alt, und anschließend losgelassen wird. Es formt dann die konvexe H¨ ulle.

6.5. GEOMETRISCHE ALGORITHMEN UND REELLE RAM

155

Die Ausgabe des folgenden Algorithmus ist also eine Liste mit Punkten vi (f¨ ur einige i = 1, . . . , n), die die konvexe H¨ ulle, im Uhrzeigersinn orientiert, repr¨asentiert. ¨ Algorithmus f¨ ur die KONVEXE HULLE 1. Sortieren Wir sortieren die gegebenen Punkte nach ihren x-Koordinaten. Weiter nehmen wir also an, dass vi f¨ ur alle i = 1, . . . , n links von vi+1 steht. 2. Berechnung der oberen H¨ ulle Der Punkt v1 liegt links von allen anderen Punkten und der Punkt vn liegt rechts – also sind v1 und vn bestimmt in der konvexen H¨ ulle enthalten. Die konvexe H¨ ulle besteht aus (a) einer Liste mit Punkten von v1 zu vn , die wir die obere H¨ ulle nennen und (b) einer Liste mit Punkten von vn zu v1 , der unteren H¨ ulle. In dem folgenden Beispiel

v4

v1 ● ●

v8 ● ●

v2



v6 ●

v10 ●

● v5 ● v7

● v3

v12

● v11



obere H¨ ulle v14

untere H¨ ulle ●

v13

● v9

ist die obere H¨ ulle v1 , v4 , v8 , v12 , v14 und die untere H¨ ulle ist v14 , v13 , v9 , v3 , v1 .

Die Berechnung der oberen H¨ ulle verfolgt die folgende divide-and-conquer Strategie: 2a Die Punkte v1 , . . . , vn werden in zwei ungef¨ahr gleich große Teile aufgeteilt. Nehmen wir an, dass n gerade ist, dann arbeiten wir mit der linken H¨alfte“ ” v1, . . . , vn/2 und der rechten H¨alfte“ vn/2+1 , . . . , vn . F¨ ur beide H¨alften bestim” men wir rekursiv die obere H¨ ulle.

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT

156

pi0 ●

. .. ● p2 ● ● v1 = p 1

. .. ●

●⋱ ●



qj0 ●

q2 ●





● ps q1 ●

obere H¨ ulle f¨ ur v1 , . . . , vn/2

●⋱ ●

● ●

● ● q t = vn

obere H¨ ulle f¨ ur vn/2+1 , . . . , vn

Wir bezeichnen die obere H¨ ulle von v1 , . . . , vn/2 mit p1 , p2 , . . . , p s und die obere H¨ ulle f¨ ur vn/2+1 , . . . , vn mit q1 , q2 , . . . , q t . 2b Wir berechnen die obere Tangente der beiden gefundenen oberen H¨ ullen: das ist das Segment L(pi0 , qj0 ), so dass alle Punkte p1 , . . . , ps , q1 , . . . , qt unter ihm liegen. 2c Die obere H¨ ulle der Punkte v1 , . . . , vn ist p1 , p2 , . . . , pi0 , qj0 , qj0 +1 , . . . , qt . 3. Berechnung der unteren H¨ ulle Dies geschieht analog zu (2). 4. Die konvexe H¨ ulle ergibt sich aus der oberen H¨ ulle gefolgt von der unteren H¨ ulle. Zeitkomplexit¨ at: Schritt (1) hat die Zeitkomplexit¨at O(n log n). Wir zeigen jetzt, dass auch Schritt (2) diese Zeitkomplexit¨at hat; analoges gilt f¨ ur Schritt (3). Da (4) in n Zeiteinheiten geschrieben werden kann, ist damit bewiesen, dass der ganze Algorithmus die Zeitkomplexit¨at O(n log n) hat. Wir zeigen sp¨ ater, dass dies optimal ist. Zeitkomplexit¨ at von Schritt (2): Sie h¨angt von der Zeitkomplexit¨at von (2b) ab. Wir zeigen, dass die obere Tangente in O(log n) Schritten gefunden werden kann. Dann folgt, falls Schritt (2) in t(n) Zeiteinheiten berechnet wird, dass die Schritte (2a) - (2c) die folgende Zeitkomplexit¨at haben: (2a) (2b) (2c)

2t( n2 ) O(log n) O(n)

Zeiteinheiten Zeiteinheiten Zeiteinheiten

Es gibt also Konstanten n0 und K, so dass n f¨ ur alle n ≥ n0 gilt t(n) ≤ 2t( ) + K. 2

6.5. GEOMETRISCHE ALGORITHMEN UND REELLE RAM

157

Da die Gleichung t(n) = 2t( n2 ) + K ⋅ n die L¨osung t(n) = K ⋅ n ⋅ log n hat, ist damit bewiesen, dass Schritt 2 die Zeitkomplexit¨at O(n log n) hat. Wie wird die obere Tangente berechnet? Wir zeigen zuerst, wie man f¨ ur jeden Punkt pi (i = 1, . . . , s) in der Zeit O(log t) die obere Tangente von pi zu den Punkten q1 , . . . , qt berechnet, also wie man den Index j(i) findet, so dass alle Punkte q1 , . . . , qs unter der Linie L(pi , qj(i) ) liegen.

● ●









qj(i)



● qj+1

pi ●



● ●

qj

● qj−1



Das k¨ onnen wir in der Zeit O(log t) durch bin¨ares Suchen zwischen j = 1, . . . , t berechnen, falls wir f¨ ur jedes j in konstanter Zeit O(1) bestimmen, ob j(i) gr¨oßer, gleich oder kleiner als j ist. In der Tat: ˆ falls qj−1 und qj+1 unter L(pi , qj ) liegen gilt j = j(i), ˆ falls qj−1 u ¨ber L(pi , qj ) liegt gilt j > j(i), ˆ falls qj+1 u ¨ber L(pi , qj ) liegt gilt j < j(i).

Analog kann man zeigen, dass in der Zeit O(log n) die globale obere Tangente L(pi0 , qj0 ) berechnet werden kann. Hier m¨ ussen wir f¨ ur jedes Paar (i, j) entscheiden, welcher der 9 F¨ alle (i = i0 , j = j0 oder i = i0 , j < j0 usw.) zutrifft. Jetzt bestimmen wir i0 durch bin¨ ares Suchen zwischen i = 1, . . . , s: f¨ ur jedes i ben¨otigen wir die Zeit O(log t), um j(i) zu berechnen, und dann nur konstante Zeit, um zu entscheiden, ob i0 gr¨ oßer, gleich oder kleiner als i ist: q j0 ● pi0 ● ● ● ● ●

pi+1



● pi

qj(i)

● ●

pi−1 ● ●

● ●

● ●

ˆ falls pi−1 und pi+1 unter L(pi , qj(i) ) liegen, gilt i = i0 , ˆ falls pi−1 u ¨ber L(pi , qj(i) ) liegt, gilt i < i0 , ˆ falls pi+1 u ¨ber L(pi , qj(i) ) liegt, gilt i > i0 .



158

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT

Daraus folgt, dass wir mit bin¨arem Suchen i0 in der Zeit O((log t)(log s)) = O(log(t + s)) = O(log n) finden k¨ onnen. Es gilt j0 = j(i0 ). ¨ Bemerkung 3. Der obige Algorithmus f¨ ur die KONVEXE HULLE ist optimal. Wir ¨ k¨ onnen n¨ amlich SORTIEREN auf KONVEXE HULLE in linearer Zeit reduzieren – deshalb kann kein Algorithmus schneller als Ω(n log n) sein. In der Tat formen wir mit gegebenen Zahlen x1 , . . . , xn in linearer Zeit die n Punkte v1 , . . . , vn der Kurve y = x2 mit den gegebenen x-Koordinaten:

y = x2

x3

x1 x4 x2

Da die Kurve y = x2 konvex ist, enth¨alt die konvexe H¨ ulle der Punkte v1 , . . . , vn jeden dieser Punkte. Also antwortet jeder Algorithmus A, der das Problem KONVEXE ¨ HULLE l¨ ost, auf die Eingabe v1 , . . . , vn mit der Ausgabe vi1 , vi2 , . . . , vin , die eine Orientierung der gegebenen Punkte im Uhrzeigersinn repr¨asentiert. Sei k der Index, f¨ ur den vik der letzte Punkt (nach rechts) ist, dann gilt xik > xik+1 > ⋅ ⋅ ⋅ > xin > xi1 > xi2 > ⋅ ⋅ ⋅ > xik−1 Wir k¨ onnen k in linearer Zeit O(n) bestimmen und also in der Zeit n + t(n) + n sortieren, wobei t(n) die Zeit ist, die A ben¨otigt, um die konvexe H¨ ulle zu berechnen. Es gilt also t(n) = Ω(n log n). ¨ Beispiel 5 (PLANARE 3-FARBBARKEIT). Eingabe: Ein planarer Graph (das heißt, ein Graph, dessen Knoten Punkte der Ebene sind, und dessen Kanten Linien sind, die sich nur in den Knoten schneiden). Ausgabe: Entscheidung, ob der Graph mit drei Farben gef¨arbt werde kann. ¨ Bemerkung 4. 1. Wir wissen, dass f¨ ur Graphen im allgemeinen 2-FARBBAR¨ KEIT leicht“ und 3-FARBBARKEIT sehr schwierig“ ist, wie genau sp¨ater ” ” ¨ bewiesen wird. Es folgt, dass zum Beispiel 4-FARBBARKEIT auch sehr ” schwierig“ sein muß: eine triviale Reduktion ¨ ¨ 3-FARBBARKEIT ◁ 4-FARBBARKEIT

6.5. GEOMETRISCHE ALGORITHMEN UND REELLE RAM

159

erfolgt, wenn zu dem gegebenen Graphen G ein neuer Knoten a hinzugef¨ ugt und mit allen alten Knoten verbunden wird. Der neue Graph G ist genau dann ●

a

● ●



● ●

G

Graph G 4-f¨ arbbar, wenn G 3-f¨ arbbar ist (denn a muß eine andere Farbe haben als jeder Knoten x ≠ a). Und die Konstruktion von G verlangt nur lineare Zeit. ¨ 2. F¨ ur planare Graphen ist 2-FARBBARKEIT leicht“ (denn das gilt f¨ ur alle ” ¨ Graphen) und 4-FARBBARKEIT noch leichter: nach dem ber¨ uhmten Satz ist jeder planare Graph 4-f¨ arbbar! Um so erstaunlicher ist die folgende Reduktion, ¨ die zeigt, dass PLANARE 3-FARBBARKEIT mindestens so schwierig ist wie ¨ allgemeine 3-FARBBARKEIT: ¨ ¨ Reduktion: 3-FARBBARKEIT ◁ PLANARE 3-FARBBARKEIT Eingabe: ein beliebiger Graph G. Den k¨ onnen wir immer in polynomialer Zeit in der Ebene repr¨asentieren (ohne zu verlangen, dass die Kanten sich nicht u ¨berschneiden). Genauer: 1. f¨ ur die n Knoten von G w¨ ahlen wir (beliebig) n verschiedene Punkte der Ebene und 2. die Kante (u, v) von G wird durch eine Linie von Punkt u nach v repr¨asentiert, so dass kein Knoten außer u, v auf der Linie liegt, und falls sich zwei Linien außer einem Knoten schneiden, liegt der Schnittpunkt auf keiner weiteren Linie des Graphen. Ein Beispiel einer solchen Repr¨ asentation ist im Bild 6.1 gezeigt. Ausgabe: ein planarer Graph G∗ , der genau dann 3-f¨arbbar ist, wenn G 3-f¨arbbar ist. F¨ ur die Konstruktion des Graphen G∗ benutzen wir den Hilfsgraphen H in Abbildung 6.2. Dieser Graph ist 3-f¨ arbbar, Abbildung 6.3 zeigt drei Beispiele von F¨arbungen mit den Farben 1, 2, 3. Lemma 1. Jede 3-F¨ arbung von H f¨ arbt N und S mit denselben Farben, analog f¨ ur O und W . Beweis. Nehmen wir an, dass N mit 1 und S mit 2 gef¨arbt wird. Wie wird der Mittelpunkt M gef¨ arbt? Farbe 1: w¨ ahlt man f¨ ur die vertikalen Nachbarn von M die Farben 2 (oben) und 3 (unten), dann bleibt f¨ ur die horizontalen Nachbarn keine Farbe u ¨brig (Bild (6.4a)). F¨ arbt man dagegen beide vertikalen Nachbarn mit Farbe 3, so muß der rechte horizontale Nachbar die Farbe 2 erhalten, w¨ahrend der Knoten zwischen S und O die Farbe 1 erhalten muß. Dies erzwingt die Farbe 2 f¨ ur den Knoten O. Aber nun kann der Knoten zwischen N und O nicht mehr gef¨arbt werden (Bild (6.4b)).

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT

160

⎡0 ⎢ ⎢0 ⎢ ⎢0 ⎢ ⎢ ⎢1 ⎢ ⎢1 ⎢ ⎢1 ⎣

(6.1a) Adjazenzmatrix

0 0 0 1 1 1

0 0 0 1 1 1

1 1 1 0 0 0

1 1 1 0 0 0

























1⎤⎥ 1⎥⎥ 1⎥⎥ ⎥ 0⎥⎥ 0⎥⎥ 0⎥⎦

(6.1b) Erste Repr¨asentation

(6.1c) Zweite Repr¨asentation

Abbildung 6.1: Zwei Repr¨asentationen eines (nichtplanaren) Graphen N ● W



M

● ●

S

rep-np-g

● ●













O



Abbildung 6.2: Graph H 1

1



2



2



3 (6.3a)



● 1

2

● 3







3





1



3 2 2



1 1



3



2



3 (6.3b)



3

● ●

3

graph-h

1







1





2



3 2 3



1 1



2



3



2 (6.3c)



● ●

2

1



2





3

1





2

3





1

Abbildung 6.3: 3-F¨arbungen von H Farbe 2 entf¨ allt aus demselben Grund. Farbe 3 - hier haben die vertikalen Nachbarn von M die Farben 2, 1 (Bild (6.4b), was f¨ ur die horizontalen Nachbarn keine Farbe u ¨brigl¨aßt. Konstruktion von Graphen G∗ Gegeben ist ein Graph G, repr¨asentiert durch Punkte und Linien in der Ebene. Auf jeder Kante (u, v), die durch andere Kanten geschnitten wird (Bild 6.5a) f¨ uge neue Knoten hinzu, von u aus hinter jedem Schnittpunkt, wie in Bild 6.5b angedeutet; der letzte erh¨alt das Label O. F¨ ur die Linien

faerb-h

6.5. GEOMETRISCHE ALGORITHMEN UND REELLE RAM

1 ● ●

?

● ●

(6.4a)

● 1

1

● 2







3





2



● ●

?





● (6.4b)

1

1

● ●

161

3



?





2

3





1

2



● ●



3

?

● ●

(6.4c)

● ●

3

2







1





2





?

Abbildung 6.4: F¨arbungsversuche des Graphen H

graph-h-lemma

von u′ nach v ′ , die (u, v) schneiden, wird jeweils ein Knoten mit dem Label S hinzugef¨ ugt, von u′ aus hinter dem Schnitt mit (u, v).



v



v



v

(6.5a) u



u′

u′

● O ●

(6.5b) u



● ●

S v



● ●





u′



O ● S



v′





O ● S v′



(6.5c) u=W



O ● =W ●

O●

O ● =W ●



Abbildung 6.5: Konstruktion von G∗

¨ Daraufhin werden die Uberschneidungen durch eine Kette von Hilfsgraphen H, verbunden an den Knoten O bzw. W , ersetzt, wie in Bild 6.5c angedeutet. Konkretes Beispiel: f¨ ur den Graphen in 6.1c) haben wir erst den folgenden Graphen

konstr-gs

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT

162



u











● S

v

N ●

W

und dann den planaren Graphen G∗







u =O ●





● S







●N







v



● ● W

Eigenschaften von G∗ 1. G∗ ist planar. In der Tat, alle Schnittpunkte von Linien wurden durch Kopien von H u uckt und es entstehen keine neuen. ¨berbr¨ 2. Falls G∗ 3-f¨ arbbar ist, ist auch G 3-f¨arbbar. Man benutzt dieselben Farben der Knoten wie in G∗ . Falls eine Linie (u, v) von G keinen Schnittpunkt in G aufweist, dann ist (u, v) auch eine Linie von G∗ und deswegen haben u, v verschiedene Farben. Andernfalls schneidet (u, v) andere Linien, was wie in Bild 6.5 durch H eliminiert wird. Dann hat u(= W ) dieselbe Farbe wie jeder OKnoten von 6.5b, siehe Lemma oben. Da v und der benachbarte O-Knoten von G∗ verschiedene Farben haben, sind auch die Farben von u und v verschieden. Ganz analog verf¨ ahrt man mit Linien (u′ , v ′ ), die (u, v) schneiden: u′ hat dieselbe Farbe wie S, die sich von der Farbe von v ′ unterscheiden muß (dies gilt auch, wenn eine entlang der Knoten N und S verbundene Kette von Kopien von H entlang von (u′ , v ′ ) auftritt. 3. Falls G 3-f¨ arbbar ist, ist auch G∗ 3-f¨arbbar. Wir f¨arben in G∗ erst die alten“ ” Knoten von G mit den Farben 1, 2, 3. Danach werden f¨ ur eine G-Kante (u, v) in 6.5b alle O-Knoten mit denselben Farben wie u gef¨arbt. Als letztes f¨arben wir die Knoten des angeklebten Graphen H wie folgt. Die Farbe von 0 und W ist schon gegeben, zum Beispiel Farbe 1. Die anderen Farben h¨ angen von der F¨arbung des Anfangsknotens u′ = N der Linie (u′ , v ′ ) ¨ ab, deren Uberbr¨ uckung H pr¨asentiert (Bild 6.6).

¨ 6.6. KOMPLEXITATSKLASSE NP

u ● 1



1●

u′



● ● 1 ● 1 ● 1 ● 3● ′ v (6.6a)

1 ●



v

163

u ● 1



2●

u′



● ● 2 ● 1 ● 1 ● 3● ′ v (6.6b)

1 ●



v

Abbildung 6.6: F¨ arbung einer Kopie des Graphen H (a) Falls u′ Farbe 1 hat (siehe 6.6a), benutzen wir die F¨arbung von Bild 6.3a. (b) Falls u′ die Farbe 2 oder 3 hat, (siehe 6.6b), benutzen wir die F¨arbung von Bild 6.3b bzw. 6.3c. 4. Die Konstruktion von G∗ aus G dauert O(k 2 ) Schritte, wobei k die Zahl aller Kanten von G ist (falls G schon in der Ebene repr¨asentiert wird, was auch in polynomialer Zeit durchgef¨ uhrt wird). In der Tat m¨ ussen wir f¨ ur jede Kante h¨ ochstens k Schneidungen u ucken, und das dauert (da eine ¨berbr¨ ¨ Uberbr¨ uckung in konstanter Zeit O(1) durchgef¨ uhrt wird) O(k) Schritte pro Kante.

6.6

Komplexit¨ atsklasse N P

sect-classNP

Probleme, die grunds¨ atzlich schwieriger zu l¨osen sind als die der Klasse P, die sich aber trotzdem in polynomialer Zeit von einer nichtdeterministischen TM l¨osen lassen, formen die Komplexit¨ atsklasse N P. Intuitiv kann man N P wie folgt erkl¨aren: falls ein Entscheidungsproblem die Eigenschaft hat, dass man in polynomialer Zeit u ufen kann, ob eine angebotene“ L¨osung wirklich die Aufgabe l¨ost, geh¨ort ¨berpr¨ ” das Problem zu N P. Bevor wir N P formal definieren, zeigen wir diese intuitive Erkl¨ arung an einem Beispiel. bsp-zerlegbarkeit

Beispiel 1 (ZERLEGBARKEIT). Wir sollen entscheiden, ob f¨ ur eine Zahl n (Eingabe) eine Zerlegung in ein Produkt n = pq zweier kleinerer Zahlen existiert. Obwohl das ein Problem ist, dass in der Mathematik seit tausenden von Jahren behandelt wurde, gibt es keinen effizienten Algorithmus daf¨ ur. Wir wissen also nicht, ob ZERLEGBARKEIT zu P geh¨ ort. Aber dieses Problem geh¨ort offensichtlich zu N P: falls uns jemand Zahlen p und q nennt, k¨onnen wir effizient u ufen, ob sie eine ¨berpr¨ L¨ osung bilden, d.h., ob das Produkt pq der Eingabe gleicht. Das letzte kann mit einer nichtdeterministischen TM wie folgt gel¨ost werden: Band 1 ist das Eingabeband. Auf Band 2 wird nichtdeterministisch eine Zahl p geschrieben und auf Band 3 nichtdeterministisch eine Zahl q. Die NTM multipliziert p mit q und vergleicht pq mit Band 1: falls pq auf Band 1 steht, h¨alt die NTM und akzeptiert, falls nicht, h¨ alt sie und akzeptiert nicht. F¨ ur jede Zahl n, die zerlegbar ist, gibt es eine Berechnung, die n in linearer Zeit akzeptiert. Definition. Wir sagen, dass eine nichtdeterministische Turingmaschine M die Zeitkomplexit¨ at p(n) hat, falls es f¨ ur jede Eingabe der L¨ange n, die M akzeptiert, eine akzeptierende Berechnung gibt, die h¨ochstens p(n) Berechnungsschritte ben¨ otigt. Mit N P bezeichnen wir die Klasse aller Sprachen (oder Entscheidungsprobleme), die von einer NTM mit polynomialer Zeitkomplexit¨at akzeptiert (oder gel¨ost) werden k¨ onnen. Genauer: eine Sprache L geh¨ort zu N P, falls es eine NTM und ein Polynom p(n) gibt, so dass die NTM die Zeitkomplexit¨at p(n) hat und L akzeptiert.

faerb-kop-h

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT

164 bsp-np

Beispiel 2.

1. Jedes Problem der Klasse P geh¨ort zu N P.

2. ZERLEGBARKEIT ist ein Problem der Klasse N P; es ist nicht bekannt, ob es zur Klasse P geh¨ ort. bsp-np-SAT

bsp-np-TSP

¨ 3. ERFULLBARKEIT (siehe Beispiel 5 in 6.2) ist ein Problem der Klasse N P: f¨ ur jede Boolesche Formel f (x1 , . . . , xn ) und jede potentielle L¨osung“, d.h. ” jede (beliebig berechnete) Belegung aller Variablen x1 , . . . , xn , k¨onnen wir effizient entscheiden, ob der Wert von f true oder false ist. Es ist einfach, eine NTM mit polynomialer Zeitkomplexit¨at zu konstruieren, die das Problem ¨ ERFULLBARKEIT l¨ ost: Band 1 ist ein Eingabeband, auf dem ein Code der Formel f (x1 , . . . , xn ) gespeichert wird. Auf Band 2 erzeugt die NTM nichtdeterministisch n Werte 0 oder 1. Dann berechnet sie den Wert von f mit diesen n Variablenwerten (mit 1 = true und 0 = false). 4. TRAVELING SALESMAN PROBLEM (TSP) ist ein Problem der Klasse N P mit großer praktischer Relevanz. Die Eingabe ist eine Liste S1 , . . . , Sn von St¨ adten und eine Matrix von Zahlen d(i, j) ≥ 0 f¨ ur i, j = 1, . . . , n die die Distanz von Si zu Sj repr¨asentieren (oder die Kosten der Reise von Si nach Sj ). Die Aufgabe ist, zu entscheiden, ob alle St¨adte besucht werden k¨ onnen, ohne dass die gesamten Kosten eine gegebene Zahl k u ¨berschreiten. Das heißt: die Eingabe besteht aus Zahlen k und dij f¨ ur i, j = 1, . . . , n. Die L¨ osung ist eine Rundfahrt, d.h. eine Permutation (i1 , i2 , . . . , in ) der Zahlen 1, . . . , n, so dass

eq-tsp-def

d(i1 , i2 ) + d(i2 , i3 ) + ⋅ ⋅ ⋅ + d(in−1 , in ) + d(in , i1 ) ≤ k.

(∗)

Auch f¨ ur dieses Problem gibt es keinen effizienten Algorithmus. Aber das Problem geh¨ ort sicher zu N P: falls eine Permutation gegeben wird, ben¨otigt ¨ die Uberpr¨ ufung der Ungleichung (∗) nur lineare Zeit. Satz 1. Jede NTM mit der Zeitkomplexit¨ at p(n) kann von einer TM mit der Zeitkomplexit¨ at O(K p(n) ) wobei K eine Konstante ist simuliert werden. Beweis. Im Beweis des Satzes 1 in 3.3 haben wir eine Simulation einer nichtdeterministischen Turingmaschine M durch eine deterministische 3-Band Turingmaschine M gezeigt. Wir beweisen, dass M die Zeitkomplexit¨at O(r2p(n) ) f¨ ur eine Konstante r hat, falls M die Zeitkomplexit¨at p(n) hat. Danach simulieren wir M mit einer (1-Band) TM, deren Komplexit¨at O(n2 + (r2p(n) )2 ) ist, siehe Satz 1 in 6.4. Da (r2p(n) )2 = r4p(n) , setzen wir K = r4 : die Funktion n2 + r4p(n) geh¨ort zu O(K p(n) ). ¨ Sei, wie im Beweis des Satzes 1 in 3.3, eine Numerierung der Uberg¨ ange (q, s) → (qi , si ) f¨ ur i = 1, . . . , r gegeben. F¨ ur jede Eingabe der L¨ange n brauchen wir nur die ersten p(n) Berechnungsschritte der Maschine M zu simulieren. Die Maschine M erzeugt systematisch alle Listen aus Zahlen i1 i2 . . . ik

mit k ≤ p(n) (und 1 ≤ is ≤ r f¨ ur s = 1, . . . , k)

auf Band 2 – die Anzahl dieser Listen ist r + r2 + r3 + ⋅ ⋅ ⋅ + rp(n) ∈ O(rp(n) ). F¨ ur jede Liste wird M (in k ≤ p(n) Schritten) simuliert, also dauert die ganze Simulation einer Eingabe h¨ ochstens O(p(n)rp(n) ) Schritte. Es gilt p(n)rp(n) ∈ O(r2p(n) ).

¨ 6.7. N P-VOLLSTANDIGKEIT

165

Korollar 1. Jedes Problem der Klasse N P kann von einem Algorithmus mit exponentieller Zeitkomplexit¨ at K p(n)

K – Konstante, p(n) – Polynom

gel¨ ost werden.

6.7

N P-Vollst¨ andigkeit

Wir haben oben erw¨ ahnt, dass kein effizienter Algorithmus f¨ ur Probleme wie ZERLEGBARKEIT oder TSP bekannt ist. Mit anderen Worten ist es nicht bekannt, ob diese Probleme in der Klasse P liegen. Eigentlich ist auch die folgende allgemeine Frage bisher unbeantwortet: Offenes Problem: Gilt P = N P? Trotz intensiver Bem¨ uhungen vieler Wissenschaftler und trotz vieler Nebenergebnisse zu diesem Thema ist die Antwort noch nicht bekannt. Es gibt aber Probleme, die in der Klasse N P eine besondere Stellung haben: wenn man f¨ ur eines dieser Probleme feststellen w¨ urde, dass es zu P geh¨ore, so w¨ urde jedes Problem der Klasse N P zu P geh¨ oren – also w¨ are die Antwort auf die obige Frage positiv. Solche Probleme (zu denen z.B. TSP geh¨ort) heißen N P-vollst¨andig. Erinnern wir uns an den Begriff der Reduktion in polynomialer Zeit (6.3): Definition. Eine Sprache L heißt N P-hart, falls es f¨ ur jede Sprache L′ der Klasse N P eine Reduktion auf L in polynomialer Zeit gibt, oder k¨ urzer: L′ ∈ N P Ô⇒ L′ ◁ L. Eine Sprache, die N P-hart ist und zu N P geh¨ort, heißt N P-vollst¨ andig . Satz 1. Falls eine N P-harte Sprache in P liegt, gilt P = N P. Beweis. Sei L eine N P-harte Sprache in P. F¨ ur jede Sprache L′ in N P gibt es eine Reduktion auf L in polynomialer Zeit. Aus L ∈ P folgt also L′ ∈ P (Satz 1 in 6.3). Damit ist P = N P bewiesen. ¨ Satz 2 (Cookscher Satz.). ERFULLBARKEIT ist N P-vollst¨ andig. ¨ Beweis. 1. ERFULLBARKEIT ist ein Problem der Klasse NP: siehe Beispiel 2 Nr. 3 in Abschnitt 6.6. ¨ 2. F¨ ur jede Sprache L in N P zeigen wir, dass L auf ERFULLBARKEIT in polynomialer Zeit reduzierbar ist. Wir haben eine Turingmaschine M mit polynomialer Zeitkomplexit¨at p(n), die L akzeptiert. Wir k¨onnen f¨ ur M , ohne Beschr¨ ankung der Allgemeinheit, das folgende annehmen: (a) Die Zust¨ ande von M sind wie folgt durchnumeriert: q0 (initial), q1 (final), q2 , . . . , qm . Der finale Zustand q1 ist ein Haltezustand. def

(b) Die Bandsymbole von M sind s1 , . . . , sk und s0 = #. (c) Die Zellen des Bandes sind mit ganzen Zahlen durchnumeriert. Die Eingabe steht in den Zellen 1, . . . , n.

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT

166

Zelle Nr.: −2

−1

0

1

2

...

#

#

si1

si2

#

n ...

sin

n+1 n+2 n+3 #

#

#

...

⇑ q0 Initialkonfiguration ¨ (d) Die Uberg¨ ange sind mit y = 1, 2, . . . , d durchnumeriert und wie folgt in eine Tabelle geschrieben: ¨ Nr. y y Ubergang 1 (qi(1) , sj(1) ) → (qi′ (1) , sj ′ (1) ) 2 (qi(2) , sj(2) ) → (qi′ (2) , sj ′ (2) ) ⋮ ⋮ d (qi(d) , sj(d) ) → (qi′ (d) , sj ′ (d) ) Hier ist sj(y) ein Bandsymbol und sj ′ (y) ist entweder L, R oder ein Bandsymbol. Bemerkung 1. In der Zeit p(n) kann die TM h¨ochstens p(n) Felder beschriften, also gen¨ ugt es, die Bandzellen Nr. −p(n), −p(n) + 1, . . . , 0, 1, . . . , p(n) zu betrachten. ¨ Die Reduktion der Sprache L auf ERFULLBARKEIT bedeutet, dass f¨ ur jedes Wort w u ¨ber Σ eine Boolesche Formel φw konstruiert wird, so dass φw ist erf¨ ullbar ⇐⇒ w ∈ L und dass die Konstruktion in polynomialer Zeit durchgef¨ uhrt wird. Die Aussage w ∈ L bedeutet, dass es eine Berechnung des Wortes w durch M gibt, die im Zustand q1 h¨ alt. Eine solche Berechnung k¨onnen wir durch eine Formel φw eindeutig beschreiben, wenn wir die folgenden Booleschen Variablen einf¨ uhren: NAME BEDEUTUNG: ist true belegt genau dann, wenn UMFANG qit Zur Zeit t hat M den Zustand qi . t = 0, . . . , p(n) i = 0, . . . , m krt Zur Zeit t steht der Kopf im Feld r t = 0, . . . , p(n) r = −p(n), . . . , p(n) stj,r Zur Zeit t steht im Feld r das Symbol sj t = 0, . . . , p(n) j = 0, . . . , k r = −p(n), . . . , p(n) ¨ uty Zur Zeit t wird der Ubergang Nr. y durchgef¨ uhrt t = 0, . . . , p(n) − 1 y = 1, . . . , d Mit Hilfe dieser Variablen k¨onnen wir alle Bedingungen einer akzeptierenden Berechnung von w formal darstellen: (a) Initialisierung. Zur Zeit t = 0 ist die folgende Belegung true: q00 k10 s0i1 ,1 , . . . , s0in ,n s00,b

(Initialzustand q0) (initiale Kopfposition 1) (die gegebene Eingabe w = si1 . . . sin in Feldern 1, . . . , n) f¨ ur alle b = −p(n), . . . , p(n) außer b = 1, . . . , n (das Symbol s0 = # in allen Zellen des Bandes außer der Eingabe)

¨ 6.7. N P-VOLLSTANDIGKEIT

167

Jede von diesen Variablen formt eine Klausel von φw , also ist der Anfang von φw : eq-phiw1

(1)

n

p(n)

b=1

b=−p(n) b≠1,...,n

φw = q00 ∧ k10 ∧ ⋀ s0ib ,b ∧



s00,b ∧ . . .

(b) Akzeptanz von w. Eine weitere Klausel von φw gew¨ahrleistet, dass w zum Zeitpunkt t = 1, . . . , p(n) akzeptiert wird, d.h., der Zustand ist q1 (finaler Haltezustand). Das ist die Klausel eq-phiw2

p(n)

q11 ∨ q12 ∨ ⋅ ⋅ ⋅ ∨ q1

(2)

(die genau dann true ist, wenn q1t f¨ ur einen Zeitpunkt t true ist). (c) Randbedingungen. Wir m¨ ussen auch sicherstellen, dass zu jedem Zeitpunkt t die TM i. ii. iii. iv.

genau einen Zustand hat, in jedem Feld genau ein Symbol steht, der Kopf genau eine Position hat und ¨ genau ein Ubergang (falls es sich um keine Haltekonfiguration handelt) durchgef¨ uhrt wird.

Z.B. verlangt (i), dass φw f¨ ur jeden Zeitpunkt t = 0, 1, . . . , p(n) die folgende Klausel hat: m

eq-phiw3

(3)

t t t t ⋁ qi = q0 ∨ q1 ∨ ⋅ ⋅ ⋅ ∨ qm

i=0

(also: es gibt einen Zustand zum Zeitpunkt t), sowie die Klauseln eq-phiw4

(4)

qit → ¬qit′

f¨ ur alle i ≠ i′

(also: zwei Zust¨ ande qi und qi′ k¨onnen nicht gleichzeitig vorhanden sein). Analoges gilt f¨ ur (ii)–(iv). ¨ ¨ (d) Uberg¨ ange. Nehmen wir an, dass die Zeile y der Ubergangstabelle die Bewegung des Kopfes nach links darstellt: ZEILE y: (qi(y) , sj(y) ) → (qi′ (y) , L) ¨ (Bewegung nach rechts oder Uberschreibung des Bandsymbols werden analog behandelt). Dann m¨ ussen wir zu der Konjunktion von φw Klauseln hinzuf¨ ugen, die gew¨ahrleisten, dass uty die erwartete Auswirkung zum Zeitpunkt t hat: Falls der Kopf im Feld r steht, wird er als n¨achstes im Feld r − 1 stehen: eq-phiw5

(5)

t+1 (uty ∧ krt ) → kr−1

f¨ ur alle r = −p(n) + 1, . . . , p(n).

Der Zustand zum Zeitpunkt t muß qi(y) sein und der zum Zeitpunkt t + 1 muß qi′ (y) sein, also hat φw zwei Klauseln eq-phiw6

(6)

t uty → qi(y)

und

uty → qit′ (y)

Falls der Kopf im Feld r steht, muß das Symbol im Feld r gleich sj(y) sein: eq-phiw7

(7)

(uty ∧ krt ) → stj(y),r

f¨ ur alle r = -p(n), . . . , p(n)

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT

168

Alle Bandsymbole bleiben unver¨andert: eq-phiw8

(8)

(uty ∧ stj,r ) → st+1 j,r

f¨ ur alle j = 0, . . . , k und alle r = −p(n), . . . , p(n) − 1.

Wenn alle Klauseln (5)–(8) zu φw hinzugef¨ ugt worden sind, wird der ¨ Ubergang Nr. y korrekt ausgef¨ uhrt. Damit ist die Konstruktion von φw vollst¨ andig. Es gilt: φw ist erf¨ ullbar ⇐⇒ M akzeptiert die Eingabe w. In der Tat ergibt jede akzeptierende Berechnung von w eine Belegung der Variablen von φw f¨ ur die alle Teile der Konjunktion true sind, also w = true: wir setzen qit = true, falls die Berechnung M zur Zeit t den Zustand qi hatte, ana¨ log mit krt und stj,r ; wir setzen uty = true, falls der Ubergang Nr. y im Schritt t durchgef¨ uhrt wurde. Umgekehrt beschreibt jede Belegung der Variablen von φw , f¨ ur die alle Teile der Konjunktion von φw true sind, eine akzeptierende Berechnung von w. Wie viel Zeit ben¨ otigen wir, um φw zu konstruieren? Der Teil (1) braucht O(p(n)) Symbole (also O(p(n)) Zeiteinheiten), dasselbe gilt f¨ ur den Teil (2). Es l¨aßt sich leicht zeigen, dass die Randbedingungen nur ¨ O(p(n)2 ) Symbole ben¨ otigen. Der letzte Teil, der die d Uberg¨ ange repr¨asentiert, braucht O(p(n)) O(1) O(p(n)) O(p(n))

Symbole Symbole Symbole Symbole

f¨ ur f¨ ur f¨ ur f¨ ur

(5) (6) (7) und (8),

und da d eine Konstante ist, brauchen wir f¨ ur den letzten Teil O(p(n)) Symbole. Also reichen insgesamt O(p(n)2 ) Symbole. Es folgt, dass die Konstruktion von φw h¨ochstens O(p(n)2 ) Schritte verlangt. Bemerkung 2. Die Idee, dass eine Sprache L genau dann zu N P geh¨ort, wenn angebotene L¨ osungen in polynomialer Zeit u uft werden k¨onnen, l¨aßt sich sich ¨berpr¨ ¨ durch den Begriff Zertifikat formalisieren. Z.B. ist f¨ ur 3-FARBUNG ein Zertifikat eines ungeordneten Graphen eine F¨arbung (korrekt oder nicht) seiner Knoten mit drei Farben. Wir formen die Sprache Lcheck aller W¨orter wz, wobei w ein Code eines Graphen ist und z ein Code seines Zertifikates, das korrekt ist. Diese Sprache geh¨ ort der Klasse P an, denn f¨ ur jeden Graphen und jede F¨arbung ist die Korrektheit effizient u ufbar. Wichtig ist hier, dass die angebotenen L¨osungen nicht ¨berpr¨ komplizierter“ zu codieren sind als die Eingaben selbst. Genauer: f¨ ur die W¨orter ” wz (w – Eingabe, z - Zertifikat) nehmen wir an, dass die L¨ange ∣z∣ des Wortes z durch p(∣w∣), wobei p(n) ein Polynom ist, begrenzt werden kann: Definition. F¨ ur eine Sprache L ⊆ Σ∗ heißt eine Sprache Lcheck eine Zertifikatensprache, falls 1. Lcheck in P liegt und 2. es gibt ein Polynom p(n), so dass f¨ ur jedes Wort w u ¨ber Σ der L¨ange n gilt: w ∈ L ⇐⇒ wz ∈ Lcheck f¨ ur irgendein Wort z der L¨ange ≤ p(n).

¨ 6.7. N P-VOLLSTANDIGKEIT

169

Satz 3. Eine Sprache geh¨ ort genau dann zur Klasse N P, wenn sie eine Zertifikatensprache hat. Beweis. 1. Gegeben eine Zertifikatensprache Lcheck ⊆ Γ∗ f¨ ur L ⊆ Σ∗ *, wir beweisen, dass L ∈ N P. Sei M eine Turingmaschine mit polynomialer Zeitkomplexit¨at q(n), die Lcheck akzeptiert. Dann haben wir die folgende nichtdeterministische Turingmaschine M ∗ , die L akzeptiert: Band 1 Eingabeband

w1 w2

...

wn

Band 2 Erzeugung von z

z1

z2

...

zk

Band 3 Simulation von M

w1 w2

...

wn z1

f¨ ur k ≤ p(n)

z2

...

zk

Auf Band 1 steht die Eigabe w der L¨ange n. Auf Band 2 wird nichtdeterministisch ein Wort z u ¨ber der L¨ange k ≤ p(n) geschrieben. Dann werden w und danach z auf Band 3 kopiert, und die Maschine M wird simuliert; falls M h¨ alt und akzeptiert, h¨alt auch M ∗ und akzeptiert. Es folgt also, ∗ dass M genau die W¨ orter w akzeptiert, f¨ ur die es ein Wort z der L¨ange ≤ p(n) mit wz ∈ Lcheck gibt – also akzeptiert M ∗ die Sprache L. Die Erzeugung von z dauert 2k ∈ O(p(n)) Schritte und die Simulation von M dauert q(n+k) ∈ O(q(p(n))) Schritte, also hat M ∗ eine polynomiale Zeitkomplexit¨at. 2. F¨ ur jede Sprache L ⊆ Σ∗ der Klasse N P konstruieren wir eine Zertifikatensprache. Wir haben eine nichtdeterministische Turingmaschine M mit polynomialer Zeitkomplexit¨ at p(n), die L akzeptiert. F¨ ur jedes Wort w ∈ L der L¨ange n gibt es eine Boolesche Formel φw der L¨ange O(p2 (n)), die die Berechnung von w vollst¨ andig beschreibt – siehe den obigen Beweis des Cookschen Satzes. Da φw eine Formel in KNF ist, ist sie ein Wort aus den Symbolen ∨, ∧, (, ), x0, x1, x10, . . . , xi

(i ≤ p(n)2 )

wobei i bin¨ ar dargestellt wird, also ein Wort u ¨ber Γ = {∨, ∧, (, ), x, 0, 1}. Das Wort w hat die L¨ ange O(p2 (n)). Genauer gibt es nur eine Konstante K, so dass f¨ ur jedes Wort w ∈ L der L¨ange n die Berechnung von w durch eine Formel φw der L¨ ange ≤ Kp2 (n) repr¨asentiert wird. Nehmen wir der Einfachheit halber an, dass Γ ∩ Σ = ∅. Dann ist die folgende Sprache Lcheck u ¨ber Σ ∪ Γ eine Zertifikatensprache f¨ ur L: Lcheck besteht aus allen W¨ortern wφ, wobei w ein Wort u ange n) ist und φ eine Boolesche Formel der L¨ange ≤ ¨ber Σ (der L¨ Kp2 (n), die eine akzeptierende Berechnung von w beschreibt, ist. (a) Lcheck geh¨ ort zu P. In der Tat, f¨ ur jedes Wort u der L¨ange m u ufen wir, ¨ber Σ ∪ Γ u ¨berpr¨ i. ob u = wφ f¨ ur w ∈ Σ∗ und φ ∈ Γ∗ , wobei w die L¨ange n und φ die L¨ ange ≤ Kp2 (n) hat und ii. falls ja, ob φ = φw die Formel aus dem Beweis des Cookschen Satzes ist.

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT

170

Das kann in linearer Zeit O(m) u uft werden. ¨berpr¨ (b) w ∈ L ⇐⇒ es gibt ein Wort wφ ∈ Lcheck , so dass φ die L¨ange ≤ Kp2 (n) hat, wobei n die L¨ange von w ist. Das folgt aus der Konstruktion von Lcheck.

6.8

Weitere N P-vollst¨ andige Probleme

Satz 1. Sei L eine N P-vollst¨ andige Sprache. Dann ist jede Sprache in N P, auf die L in polynomialer Zeit reduziert werden kann, auch N P-vollst¨ andig. Beweis. Sei L0 ⊆ Γ∗ eine Sprache der Klasse N P, und sei f ∶ Σ∗ → Γ∗ eine Reduktion von L ⊆ Σ∗ auf L0 in polynomialer Zeit. Wir beweisen, dass L0 N Pvollst¨ andig ist. F¨ ur jede Sprache L′ ⊆ (Σ′ )∗ der Klasse N P gibt es eine Reduktion g ∶ (Σ′ )∗ → Σ∗ von L′ nach L in polynomialer Zeit. Es gen¨ ugt zu zeigen, dass die zusammengesetzte Abbildung f (g(x)) von (Σ′ )∗ nach Γ∗ eine Reduktion in polynomialer Zeit von L′ nach L0 ist. Damit ist die N P-Vollst¨andigkeit von L0 bewiesen. F¨ ur jedes Wort x u ¨ber Σ gilt x ∈ L′ ⇐⇒ g(x) ∈ L ⇐⇒ f (g(x)) ∈ L0 , also m¨ ussen wir nur zeigen, dass f (g(x)) eine Funktion der Klasse FP ist. Sei M eine TM, die f berechnet und die polynomiale Zeitkomplexit¨at p(n) hat, und sei M eine TM, die g berechnet und die polynomiale Zeitkomplexit¨at q(n) hat. Dann haben wir eine 2-Band Maschine M ∗ , die auf Band 1 die Maschine M simuliert (in q(n) Schritten) und das Ergebnis auf Band 2 kopiert, wo sie die Maschine M simuliert (in p(q(n)) Schritten). Das Ergebnis von M ∗ auf Band 2 ist das Wort f (g(x)), das in O(p(q(n))) Schritten berechnet wurde. ¨ ¨ Beispiel 1 (3-ERFULLBARKEIT). Wir wissen, dass 2-ERFULLBARKEIT zu P ¨ geh¨ ort. Trotzdem ist 3-ERFULLBARKEIT, d.h., das Problem der Erf¨ ullbarkeit f¨ ur Formeln, die in KNF h¨ ochstens drei Literale je Klausel enthalten, NP-vollst¨andig: ¨ 1. 3-ERFULLBARKEIT geh¨ort zu N P – klar. ¨ 2. F¨ ur ERFULLBARKEIT existiert eine Reduktion in polynomialer Zeit auf ¨ 3-ERFULLBARKEIT: In der Tat kann jede Klausel aus vier Literalen a1 ∨ a2 ∨ a3 ∨ a4 mit zwei Klauseln aus je drei Literalen (a1 ∨ a2 ∨ b) ∧ (¬b ∨ a3 ∨ a4 ) ersetzt werden. Es ist klar, dass a1 ∨ a2 ∨ a3 ∨ a4 genau dann erf¨ ullt ist, wenn die letzte Formel mit b = true oder b = false erf¨ ullt. Analog wird a1 ∨ a2 ∨ a3 ∨ a4 ∨ a5 mit drei Klauseln ersetzt: (a1 ∨ a2 ∨ b) ∧ (¬b ∨ a3 ∨ c) ∧ (¬c ∨ a4 ∨ a5 ) ¨ usw. Diese Ubersetzung dauert lineare Zeit O(n), denn f¨ ur jede Klausel der L¨ange n ben¨ otigen wir n − 2 Klauseln der L¨ange 3.

¨ 6.8. WEITERE N P-VOLLSTANDIGE PROBLEME

171

¨ Beispiel 2 (3-FARBUNG.). Dies ist das Problem, ob ein gegebener Graph mit ¨ drei Farben gef¨ arbt werden kann. W¨ahrend 2-FARBUNG zu P geh¨ort (Beispiel ¨ 3 in 6.1), zeigen wir jetzt, dass 3-FARBUNG N P-vollst¨andig ist. Also gilt auch ¨ hier: falls jemand einen effizienten Algorithmus f¨ ur 3-FARBUNG findet, beweist er P = N P! ¨ 1. 3-FARBUNG ist in N P. Falls eine 3-F¨arbung der Knoten vorgeschlagen wird, k¨ onnen wir in linearer Zeit entscheiden, ob sie korrekt ist. ¨ ¨ 2. 3-ERFULLBARKEIT l¨ aßt sich in polynomialer Zeit auf 3-FARBUNG reduzieren. Um den zweiten Teil zu beweisen, benutzen wir den folgenden Hilfsgraphen b ●

c ●





a ●





● ● d Hilfsgraph

Wenn seine Knoten mit drei Farben, z.B. weiß, schwarz, blau gef¨arbt werden gilt: eq-d-schwarz

(1)

Falls a, b und c schwarz sind, muß d auch schwarz sein.

(Das ist leicht zu u ufen, denn falls b und c schwarz sind, ist keiner der beiden ¨berpr¨ Knoten direkt unter b und c schwarz und die Spitze des rechten Dreiecks muß also schwarz sein. Dasselbe gilt dann f¨ ur das linke Dreieck.) eq-d-weiss

(2)

Falls a oder b oder c weiß ist, darf d weiß sein.

Genauer: f¨ arben wir a, b, c so mit den drei Farben, so dass mindestens einmal weiß benutzt wird, dann l¨ aßt sich der ganze Hilfsgraph so f¨arben, dass d weiß wird. (Das ist auch leicht zu u ufen). ¨berpr¨ Wir konstruieren jetzt f¨ ur jede Boolesche Formel φ mit Klauseln aus drei Literalen einen Graphen Gφ , so dass φ ist erf¨ ullbar ⇐⇒ Gφ ist 3-f¨arbbar. Der Graph Gφ hat drei verschiedene Typen von Knoten. Typ 1 sind drei Knoten, die mit den drei Farben markiert werden und ein Dreieck formen: S ●

●B ● W

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT

172

Typ 2: f¨ ur jede Variable x der Formel φ wird ein extra Dreieck an den Knoten B angeh¨ angt. Die beiden freien Knoten dieses Dreiecks werden mit x und ¬x markiert. Z.B. erhalten wir, falls φ nur die Variablen x, y, z hat, den folgenden Graphen: x ●

y ●

z ¬z ● ●

S ●

¬x ●

¬y ●

●B ● W

Typ 3: f¨ ur jede Klausel α ∨ β ∨ γ der Formel φ nehmen wir den obigen Hilfsgraphen: β ●

γ ●





α ●





● ● W

und die vier Knoten, die mit α, β, γ, W markiert sind, werden mit den gerade markierten Knoten des Typs 2 identifiziert. Beispiel: f¨ ur φ = y ∨ ¬x ∨ ¬z

(1 Klausel)

erhalten wir den Graphen ¬x ●

x ● y ●

¬z ●

z ● S ●



●B



● W Wir beweisen zuerst: φ erf¨ ullbar Ô⇒ Gφ ist 3-f¨arbbar.

¬y ●

● ●



¨ 6.8. WEITERE N P-VOLLSTANDIGE PROBLEME

173

F¨ ur die gegebene Belegung der Variablen mit φ = true f¨arben wir wie folgt: 1. S, B und W wie angedeutet (schwarz, blau, weiß), 2. Knoten des Typs 2 sind weiß, falls ihr Wert true ist, und schwarz, falls der Wert false ist, 3. in jedem der Hilfsgraphen ist mindestens einer der Knoten a, b, c weiß gef¨arbt, deshalb k¨ onnen wir eine F¨arbung finden, die auch d weiß f¨arbt finden, siehe (2) oben. Umgekehrt beweisen wir: Gφ 3-f¨arbbar Ô⇒ φ erf¨ ullbar. Wir k¨ onnen, ohne Beschr¨ ankung der Allgemeinheit, annehmen, dass die gegebene F¨ arbung die Knoten des Typs 1 wie angedeutet f¨arbt. Wir setzen dann x = true ⇐⇒ der x-Knoten des Typs 2 ist weiß. Wir beweisen, dass φ = true, d.h., dass in jeder Klausel α ∨ β ∨ γ von φ eines der Literale α, β, γ true ist. Da kein Knoten des Typs 2 blau gef¨arbt werden kann (wegen der Kante zu B), sind sie schwarz oder weiß. Aufgrund der Eigenschaft (1) des Hilfsgraphen k¨ onnen nicht α, β, γ gleichzeitig schwarz sein – also ist α, β oder γ true. Es ist klar, dass f¨ ur eine Formel φ der Gr¨oße n = Anzahl aller Variablen + Anzahl aller Klauseln die Konstruktion des Graphen Gφ in linearer Zeit O(n) durchf¨ uhrbar ist. ¨ Beispiel 3. k-FARBUNG ist NP-vollst¨andig f¨ ur jedes k ≥ 3. Wir k¨onnen z.B. 3¨ ¨ FARBUNG auf 4-FARBUNG in polynomialer Zeit wie folgt reduzieren: ein Graph G ist genau dann 3-f¨ arbbar, wenn der folgende Graph ● Neuer Knoten













G

4-f¨ arbbar ist. Bemerkung 1. Ein Graph ist planar , falls er so in der Ebene gezeichnet werden kann, dass die Kanten sich nicht u ur planare ¨berkreuzen. Das k-F¨arbungsproblem f¨ Graphen ist 1. trivial f¨ ur k ≥ 4, denn jeder planare Graph ist 4-f¨arbbar, aber trotzdem 2. N P-vollst¨ andig f¨ ur k = 3 (vergl. Bemerkung 4 in Abschnitt 6.5). Wir erinnern daran, dass ein Hamiltonscher Kreis in einem ungerichteten Graphen ein Kreis ist, der jeden Knoten genau einmal besucht. Das Problem HAMILTONSCHER KREIS hat als Eingabe einen Graphen G und wir sollen entscheiden, ob G einen Hamiltonschen Kreis hat.

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT

174

Beispiel 4. (ohne Beweis) HAMILTONSCHER KREIS ist ein N P-vollst¨andiges Problem. Beispiel 5. TSP ist N P-vollst¨andig. Wir haben in Beispiel 2 Nr. 4 in Abschnitt 6.6 bemerkt, dass TSP zur Klasse N P geh¨ort. Es ist also genug, eine Reduktion von HAMILTONSCHER KREIS auf TSP in polynomialer Zeit zu finden. Das ist trivial: f¨ ur jeden Graphen G mit Knoten 1, . . . , n setzen wir ⎧ ⎪ ⎪1 dij = ⎨ ⎪ 2 ⎪ ⎩

falls (i, j) eine Kante ist sonst

Dann hat dieses TSP genau dann eine L¨osung mit Gesamtkosten n, wenn G einen Hamiltonschen Kreis hat. ur hunderte von Problemen (einschließlich praktisch sehr wichSchlußbemerkung: F¨ ¨ tiger wir z.B. TSP oder 3-FARBUNBG) ist heute bekannt, dass sie N P-vollst¨andig sind. Das Problem ZERLEGBARKEIT (Beispiel 1) ist eines der wenigen Probleme, f¨ ur die nicht bekannt ist, ob sie N P-vollst¨andig sind. Es gilt aber, falls P ≠ N P, dass in N P Probleme existieren, die nicht N P-vollst¨andig sind (ohne Beweis).

6.9

Komplexit¨ atsklasse coN P

Definition. Mit coN P bezeichnen wir die Klasse aller Sprachen L, f¨ ur die gilt: die komplement¨ are Sprache liegt in N P: L ∈ coN P ⇐⇒ L ∈ N P Beispiel 1 (PRIMZAHL). Eingabe: Zahl n Ausgabe: JA genau dann, wenn n eine Primzahl ist. Dies ist also komplemaent¨ ar zu ZERLEGBARKEIT, deswegen PRIMZAHL ∈ coN P. ¨ Beispiel 2 (GULTIGKEIT). Eingabe: Boolsche Formal φ in KNF. Ausgabe: JA genau dann, wenn φ g¨ ultig ist, d.h. f¨ ur jede Belegung der Variablen gilt φ = true. Dies ist ein Problem in coN P, denn eine Belegung mit φ = false ist ein Zertifikat f¨ ur die komplement¨ are Sprache! Bemerkung 1.

1. P ⊆ coN P.

In der Tat, bei einer deterministischen TM gen¨ ugt es, die finalen und nichtfinalen Zust¨ ande zu vertauschen. 2. coN P ist unter Reduktion abgeschlossen: L0 ∈ coN P, L ◁ L0 Ô⇒ L ∈ coN P Es gilt n¨ amlich L ◁ L0 : wir haben doch f ∶ Γ∗ → Σ∗ in FP, so dass w ∈ L ⇐⇒ f (w) ∈ L0 , und dies bedeutet w ∈ L ⇐⇒ f (w) ∈ L0 .

¨ 6.9. KOMPLEXITATSKLASSE CON P

175

Definition. Eine Sprache L0 heißt coN P-vollst¨ andig , falls sie in coN P liegt und L ∈ coN P Ô⇒ L ◁ L0 . ¨ Beispiel 3. GULTIGKEIT ist coN P-vollst¨andig. in der Tat, gegeben L ∈ coN P, dann gibt es weil L ∈ N P, eine Reduktion in ¨ polynomialer Zeit von L auf ERFULLBARKEIT. Sei f diese Reduktion: jedem Wort w wird eine Formel f (w) zugeordnet mit w ∈ L ⇐⇒ f (w) erf¨ ullbar. Eine Formel φ ist genau dann g¨ ultig, wenn ¬φ immer false, d.h. unerf¨ ullbar ist. Sei jetzt g die folgende Funktion: g(w) = ¬f (w) Aus f ∈ FP folgt bestimmt g ∈ FP. Und w ∈ L ⇐⇒ w ∉ L ⇐⇒ f (w) nicht erf¨ ullbar ⇐⇒ g(w) g¨ ultig ¨ Offenes Problem: Gilt N P = coN P ? Die Antwort ist ja, falls GULTIGKEIT in N P liegt: Satz 1. Falls N P ≠ coN P, endh¨ alt N P keine coN P-vollst¨ andige Sprache. Beweis. Sei L0 coN P-vollst¨ andig. Wir beweisen, dass L0 ∈ N P Ô⇒ L ∈ N P f¨ ur alle L ∈ coN P d.h., falls L0 ∈ N P, gilt coN P ⊆ N P): Es gibt Reduktion f in polynomialer Zeit von L nach L0 (da L ∈ coN P). Gegeben eine NTM M , die L0 in polynomialer Zeit akzeptiert, die Kombination Band 1

f berechnet

Band 2

M simuliert

ergibt eine NTM, die L in polynomialer Zeit akzeptiert, also L ∈ N P. Und L0 ∈ N P Ô⇒ L ∈ coN P f¨ ur alle L ∈ N P (d.h., N P ⊆ coN P): hier existiert eine Reduktion f von L auf L0 , und die obige NTM akzeptiert in polynomialer Zeit die Sprache L, das beweist L ∈ N P, also L ∈ coN P. Bemerkung 2. F¨ ur PRIMZAHL gilt auch PRIMZAHL ∈ N P, aber dies ist ein nichttriviales Ergebnis, dessen Beweis hier nicht durchgef¨ uhrt wird. Die Klasse N P ∩ coN P aller Probleme, die effektives Zertifikat f¨ ur Antwort JA sowie f¨ ur Antwort NEIN habe, enth¨ alt also interssante Probleme. Wir wissen, dass sie P enth¨alt. Offenes Problem Gilt P = N P ∩ coN P?

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT

176

6.10

Komplexit¨ at von Optimierungsproblemen

sec:compopti

Viele Probleme sind weder als Entscheidungsprobleme, noch als Berechnungsprobleme zu verstehen, sondern als Probleme, die f¨ ur einen maximalen (oder minimalen) Wert eines Parameters eine Konstruktion verlangen. Solche Maximierungs- oder Minimierungsprobleme heißen Optimierungsprobleme. ¨ Beispiel 1 (MINIMALE FARBUNG). Eingabe: Ungerichteter Graph G Ausgabe: Eine F¨ arbung von G mit minimaler Zahl von Farben. Gibt es eine effiziente L¨ osung dieses Problems? Bestimmt nicht (falls P ≠ N P), denn ¨ ¨ jeder Algorithmus f¨ ur MINIMALE FARBUNG kann nat¨ urlich 3-FARBUNG l¨osen. F¨ ur jedes Minimierungsproblem M haben wir das zugrunde liegende Entscheidungsproblem, dessen Eingabe ein Paar (x, y) ist, wobei x die Eingabe von M und y eine Zahl ist. Die Entscheidung lautet: hat P eine L¨osung der Eingabe x mit einem Parameter ≤ y? Es ist klar, dass ein Minimierungsproblem, das eine effiziente L¨ osung hat, die Eigenschaft hat, dass das zugrunde liegende Entscheidungsproblem zu P geh¨ ort. Analoges gilt f¨ ur Maximierungsprobleme. Beispiel 2 (MAXIMALES MATCHING). Eingabe: Ungerichteter Graph G Ausgabe: Eine maximale Menge von Kanten, die voneinander disjunkt sind. Dies ist ein Optimierungsproblem mit vielen praktischen Anwendungen. Der Name stammt von der Anwendung, wobei eine Gruppe von M¨annern und Frauen die Knotenmenge von G formen und eine Kante einen Mann x mit einer Frau y genau dann verbindet, wenn sie ein potentielles Paar formen. Die Aufgabe ist dann, die gr¨ oßte Menge von aktuellen Paaren zu bilden, f¨ ur die kein(e) Teilnehmer(in) mehrmals auftritt. Dieser Graph ist offensichtlich 2-f¨arbbar; oft wird das MAXIMALE MATCHING Problem nur f¨ ur 2-f¨arbbare Graphen untersucht. Es gibt einen effizienten Algorithmus, der MAXIMALES MATCHING l¨ost. Die Grundidee ist, dass jedes Matching M durch einen erweiternden Weg verbessert werden kann. F¨ ur das gegebene Matching M heißt eine Kante des Graphen G frei , falls sie nicht in M liegt, und ein Knoten heißt frei, falls er kein Endknoten einer Kante in M ist. Definition. F¨ ur ein Matching M im Graphen G heißt ein Weg in G erweiternd , falls seine Endknoten frei sind und seine Kanten abwechselnd frei und unfrei sind. Beispiel 3. Im Graphen G

hat das Matching M :

x1 ●

● y1

x2 ●

● y2

x3 ●

● y3

x4 ●

● y4

x5 ●

● y5

¨ VON OPTIMIERUNGSPROBLEMEN 6.10. KOMPLEXITAT

x1 ●

● y1

x2 ●

● y2

x3 ●

● y3

x4 ●

● y4

x5 ●

● y5

177

den folgenden erweiternden Weg: x4 , y1 , x1 , y2 , x2 , y3 , x3 , y4 . erw-weg-matching

Satz 1. Falls ein Matching M einen erweiternden Weg W hat, gibt es ein gr¨ oßeres Matching M ′ , das aus M dadurch ensteht, dass die freien und unfreien Kanten von W ausgetauscht werden. Beweis. M ′ ist ein Matching, denn f¨ ur die inneren Knoten x des Weges W gibt es genau eine Kante in M , auf der x liegt, und die wird in M ′ mit genau einer Kante von W ausgetauscht. F¨ ur die beiden Endknoten von W (die in M frei sind) gibt es auch genau eine Kante in M ′ . Da beide Endknoten des Weges W frei sind, hat W mehr freie als unfreie Kanten, also hat M ′ mehr Kanten als M . Im obigen Beispiel erhalten wir das Matching x1 ●

● y1

x2 ●

● y2

x3 ●

● y3

x4 ●

● y4

x5 ●

● y5

Dieses Matching hat immer noch erweiternden Wege, etwa x5 , y2 , x1 , y5 , oder auch x5 , y3 , x2 , y2 , x1 , y5 . Diese liefern die neuen Matchings x1 ●

● y1

x1 ●

● y1

x2 ●

● y2

x2 ●

● y2

x3 ●

● y3

x3 ●

● y3

x4 ●

● y4

x4 ●

● y4

x5 ●

● y5

x5 ●

● y5

bzw.

f¨ ur die es keine erweiternden Wege mehr gibt – deshalb sind sie maximal:

178 matching-max

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT

Satz 2. Jedes Matching, f¨ ur das es keinen erweiternden Weg gibt, ist maximal. Beweis. Mit anderen Worten sollen wir f¨ ur jedes Matching M zeigen, dass, falls es ein gr¨ oßeres Matching M ∗ gibt, M einen erweiternden Weg hat. Sei G der Graph, dessen Knoten die Knoten von G sind und dessen Kanten alle Kanten in (M − M ∗ ) ∪ (M ∗ − M ) sind, d.h. alle Kanten, die in genau einem der Matchings M und M ∗ liegen. Jeder Knoten von G liegt auf h¨ ochstens zwei Kanten. Das bedeutet, dass G eine disjunkte Vereinigung von Zyklen und (maximalen) Wegen ist. Da sich in jedem Zyklus die Kanten von M und M ∗ abwechseln, gilt: in jedem Zyklus ist die Zahl von Kanten aus M gleich der Zahl der Kanten aus M ∗ . Andererseits hat G mehr Kanten aus M ∗ als aus M , da M ∗ mehr Elemente als M enth¨alt. Es gibt also einen maximalen Weg W in G, auf dem mehr Kanten aus M ∗ als aus M liegen. Das bedeutet, dass beide Endkanten von W in M ∗ liegen. Da der Weg W maximal ist, sind seine Endknoten frei im Matching M . Also ist W ein erweiternder Weg f¨ ur M. Algorithmus f¨ ur MAXIMALES MATCHING Eingabe: Ungerichteter Graph G = (V, E) Ausgabe: Maximales Matching M ⊆ E 1: Initialisierung M ∶= ∅ 2: while ein erweiternder Weg W f¨ ur M existiert do 3: M ∶= M ′ f¨ ur M ′ aus Satz 1 4: od Korrektheit: folgt aus Satz 1 und 2. Am Ende des while-Zyklus (der aufgrund von Satz 1 konvergiert) hat M keinen erweiternden Weg und ist also maximal. Zeitkomplexit¨ at: h¨ angt nat¨ urlich von der Zeitkomplexit¨at des Suchen des erweiternden Weges in Zeile 2 ab. Es sind Algorithmen bekannt, die f¨ ur Graphen mit n Knoten und k Kanten die Zeitkomplexit¨at O(nk) haben. Dann hat der ganze Algorithmus oben Zeitkomplexit¨at O(nk).

bsp:maxflow

Beispiel 4 (MAXFLOW). Das Problem MAXIMALES MATCHING ist ein Spezialfall des MAXFLOW Problems: gegeben seien ein gerichteter Graph G und zwei Knoten s (source) und t (target), wir suchen den maximalen Fluß Kanten-disjunkter Wege von s nach t. (Die Wege d¨ urfen also gemeinsame Knoten haben, aber keine gemeinsamen Kanten.) Auch hier wird die L¨osung mit Hilfe von erweiternden Wegen berechnet. Gegeben ein Fluß H mit Wegen von s nach t, eine Kante von G heißt frei , falls sie auf keinem Weg von H liegt. Ein erweiternder Weg f¨ ur H ist eine Liste s = v0 , v1 , . . . , vn−1 , vn = t von Knoten von G, so dass f¨ ur jedes i = 1, . . . , n gilt ˆ entweder ist (vi−1 , vi ) eine freie Kante von G, oder ˆ (vi , vi−1 ) ist eine unfreie Kante von G.

Wir erweitern H, indem alle freien Kanten (vi−1 , vi ) unfrei werden und alle unfreien Kanten (vi , vi−1 ) frei werden. Beispiel: Sei G der Graph und H der mit dickeren Linien gekennzeichneter Fluß wie folgt:

¨ VON OPTIMIERUNGSPROBLEMEN 6.10. KOMPLEXITAT

x s● z

●?

0●G x

y ●/

y′ ●

●

.●

179



●.> t

z′

Der folgende erweiternde Weg s, y, z ′ , z, x′ , x, y ′ , t f¨ uhrt zum folgenden Fluß: x s● z

●?

/●F x

y /●

y′ !●

●

/●



!.=●

t

z′

Auch f¨ ur MAXFLOW gibt es einen Algorithmus, der aufrund erweiternder Wege in der Zeit O(nk) das Problem l¨ ost. Um das Konzept eines Optimierungsproblems zu formalisieren, nehmen wir an, dass die Eingabe sowie potentielle L¨ osungen in demselben Alphabet Σ codiert werden. ¨ Z.B. nehmen wir f¨ ur MINIMALE FARBUNG an, dass die Eingabe G bin¨ar (z.B. als Adjazenzmatrix) codiert wird, also u ¨ber Σ = {0, 1}. Jede F¨arbung mit k Farben 1, 2, . . . , k kann auch u ¨ber Σ codiert werden, z.B. als das Wort 0i1 10i2 1 . . . 10in 1, wobei der Knoten 1 mit der Farbe i1 gef¨arbt wird, der Knoten 2 mit der Farbe i2 , usw. Wir haben eine Relation L auf der Menge Σ∗ aller W¨orter, wobei vLw bedeutet, dass die Instanz v des Problems durch w gel¨ost wird. D.h., dass v einen Graphen G codiert, w eine F¨ arbung codiert und diese F¨arbung f¨ ur G korrekt ist. Schließlich haben wir einen Parameter c(v, w), den wir optimieren wollen, und der von der Eingabe v und der L¨ osung w abh¨angen kann. Wir betrachten also eine Funktion c∶L→N ¨ F¨ ur MINIMALE FARBUNG ist c(v, w) = Anzahl der in w verwendeten Farben. Allgemein: Definition. bei

1. Ein Optimierungsproblem ist ein 5-Tupel (Σ, E, A, L, c), wo-

Σ ein Alphabet ist (in dem Eingaben und L¨osungen codiert werden), E eine Sprache u ¨ber Σ ist (aller m¨oglichen Eingaben), A eine Sprache u ¨ber Σ ist (aller m¨oglichen L¨osungen oder Ausgaben)

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT

180

L ⊆ E × A ist eine Relation auf der Menge Σ∗ (insbesondere folgt aus vLw sofort v ∈ E und w ∈ A) und c eine Funktion (Kostenfunktion) ist, die jedem Paar (v, w) ∈ L die Kosten c(v, w) ∈ N der L¨ osung w zur Eingabe v zuordnet. 2. Eine Turingmaschine l¨ ost das Minimierungsproblem (Maximierungsproblem) (Σ, E, A, L, c), falls sie f¨ ur jede Eingabe v ∈ E mit einer Ausgabe w ∈ A h¨ alt, f¨ ur die gilt (a) vLw und (b) c(v, w) ≤ c(v, w′ ) (c(v, w) ≥ c(v, w′ )) f¨ ur alle w′ ∈ A mit vLw′ . Die Relation L kann auch mit ihrer charakteristischen Funktion χL ∶ E × A → {true, false} identifiziert werden. Beispiel: die TM, die den oberen Algorithmus f¨ ur MAXIMALES MATCHING implementiert, ist eine L¨ osung des Problems. Wie erw¨ahnt, hat diese TM eine polynomiale Zeitkomplexit¨ at. Deswegen geh¨ort MAXIMALES MATCHING zur folgenden Klasse: Definition. Die Klasse PO besteht aus allen Optimierungsproblemen (das heißt, allen Minimierungs- und Maximierungsproblemen) (Σ, E, A, L, c), f¨ ur die gilt: 1. E und A sind Sprachen der Klasse P (d.h., wir haben eine effiziente Prozedur, die entscheidet, ob ein Wort eine Ein- oder Ausgabe codiert) 2. es gibt ein Polynom p(x), so daß jedes Paar (u, v) ∈ L der Bedingung ∣v∣ ≤ p(∣u∣) gen¨ ugt (d.h., zu einer Eingabe kann es nur “kurze” L¨osungen geben); 3. χL ∶ E × A → {true, false} ist eine Funktion der Klasse FP 4. c ist eine Funktion der Klasse FP und 5. es gibt eine TM mit polynomialer Zeitkomplexit¨at, die das Optimierungsproblem l¨ ost. ¨ Beispiel 5. MINMALE FARBUNG geh¨ort nicht zu PO, falls P ≠ N P, denn 3¨ FARBUNG ist ein N P-vollst¨andiges Problem. Beispiel 6. MAXIMALES MATCHING geh¨ort zu PO. In der Tat 1. gibt es Algorithmen, die in linearer Zeit entscheiden, ob ein bin¨ares Wort einen Graphen oder ein Matching codiert 2. ist jedes Matching als Teilmenge der Kantenmenge linear in der Eingabegr¨oße beschr¨ ankt 3. gibt es einen Algorithmus, der in linearer Zeit entscheidet, ob eine Menge von Knoten ein Matching ist 4. kann die Bewertung der Zahl c(w, v) aller Knoten des Matching v in linearer Zeit durchgef¨ uhrt werden und 5. haben wir einen effizienten Algorithmus f¨ ur die L¨osung von MAXIMALES MATCHING oben gezeigt.

q-entscheidungsproblem

6.11. APPROXIMATION VON OPTIMIERUNGSPROBLEMEN

181

Bemerkung 1. F¨ ur jedes Minimierungsproblem (Σ, E, A, L, c) definieren wir das zugrunde liegende Entscheidungsproblem: gegeben ein Paar (w, n) mit w ∈ E und n ∈ N, gibt es eine L¨osung v ∈ A, so dass (∗)

vLw

und

c(w, v) ≤ n?

F¨ ur jedes Minimierungsproblem der Klasse PO geh¨ort das zugrunde liegende Entscheidungsproblem zur Klasse P. In der Tat k¨onnen wir f¨ ur jede Eingabe (w, n) in polynomialer Zeit die entsprechende minimale L¨osung v finden, berechnen wir in polynomialer Zeit den Wert c(w, v) und schließlich entscheiden wir in der Zeit O(log n), ob dieser Wert kleiner gleich n ist. Analog f¨ ur Maximierungsprobleme: hier wird die Ungleichung von (∗) umgedreht. Umgekehrt gilt also: falls P ≠ N P, enth¨alt PO kein Optimierungsproblem, dessen zugrunde liegendes Entscheidungsproblem N P-vollst¨andig ist. Beispiel 7 (MINIMALES TSP). (siehe 6.6, Beispiel 2 Nr. 4) Eingabe: w = (di,j )i,j=1,...,n , wobei di,j ∈ N die Kosten des Weges von Stadt i zu Stadt j sind. Ausgabe: Permutation v = (i1 , i2 , . . . , in ), die die Kosten c(w, v) = di1 ,i2 + di2 ,i3 + ⋅ ⋅ ⋅ + din−1 ,in + din ,i1 minimiert. Diese Aufgabe geh¨ ort nicht zu PO, falls P ≠ N P, denn wir wissen, dass das zugrunde liegende Entscheidungsproblem N P-vollst¨andig ist.

6.11

Approximation von Optimierungsproblemen

Falls es f¨ ur ein Optimierungsproblem keinen effizienten Algorithmus gibt, der die optimale L¨ osung findet, k¨ onnen wir versuchen, eine suboptimale L¨osung effizient zu konstruieren. ¨ Beispiel 1. MINIMALE KNOTEN-UBERDECKUNG Eingabe: Ungerichteter Graph Ausgabe: Minimale Menge D an Knoten, so dass jede Kante einen Knoten aus D enth¨ alt. Es ist bekannt, dass das zugrunde liegende Entscheidungsproblem (ob eine Knotendeckung mit h¨ ochstens n Knoten existiert) N P-vollst¨andig ist. Eine suboptimale L¨ osung kann wie folgt beschrieben werden: ¨ Algorithmus f¨ ur KNOTEN-UBERDECKUNG Eingabe: Ungerichteter Graph G Ausgabe: Eine Knoten¨ uberdeckung D 1: D ∶= ∅ 2: V ∶= die Menge aller Knoten von G 3: E ∶= die Menge aller Kanten von G 4: while E eine Kante (x, y) enth¨ alt do 5: D ∶= D ∪ {x, y}

182 6: 7:

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT E ∶= E − {v ∶ v eine Kante mit Endknoten x oder y} od

Korrektheit: Wir konstruieren hier eine Menge D von Knoten mit der Eigenschaft, dass jede im Schritt 6 entfernte Kante einen Endknoten in D hat. Da am Ende alle Kanten entfernt worden sind, ist D eine Knoten¨ uberdeckung. Zeitkomplexit¨ at ist linear, denn jede Kante des Graphen wird von dem Algorithmus nur einmal besucht. Beziehung zum Optimum: Bezeichnen wir f¨ ur jeden Graphen G mit opt(G) die mi¨ ¨ nimale Gr¨ oße einer Knoten-Uberdeckung und mit c(G) die Gr¨oße der Uberdeckung, die unser Algorithmus konstruiert. Es gilt c(G) ≤ 2opt(G). In der Tat hat der Algorithmus die folgende Eigenschaft: D wird mittels paarweise ¨ disjunkter Kanten des Graphen G konstruiert. Jede Uberdeckung D0 muß wenigsten einen Endknoten von jeder dieser Kanten enthalten, also muß D0 mindestens halbsoviele Elemente wie D haben. Definition. Sei (Σ, E, A, L, c) ein Optimierungsproblem. Ein ε-approximierender Algorithmus (ε ≥ 0 eine reelle Zahl) ist ein Algorithmus der Klasse P, der f¨ ur jede Eingabe w ∈ E eine Ausgabe v ∈ A mit vLw berechnet, so dass der relative Fehler von c(w, v) im Vergleich zum optimalen Wert opt(w) kleiner gleich ε ist; d.h., es gilt ∥c(w, v) − opt(w)∥ ≤ ε. opt(w) ¨ Beispiel 2. F¨ ur MINIMALE KNOTEN-UBERDECKUNG haben wir einen 1approximierenden Algorithmus gefunden: es gilt c(w, v) ≤ 2opt(v), also ∥c(w, v) − opt(w)∥ ≤ 1. opt(w) Dieser Algorithmus ist nicht ε-approximierend f¨ ur ε < 1, denn schon f¨ ur den Graphen mit zwei Knoten und einer Kante gilt opt = 1, c(w, v) = 2. bsp-sit

Beispiel 3 (SIT (Scheduling Independent Tasks)). Es sollen Aufgaben W1 , . . . , Wn mit gegebener zeitlicher Dauer t1 , . . . , tn durch k Maschinen bew¨altigt werden. Wir nehmen an, dass jede Maschine unabh¨angig von den anderen jede Aufgabe bearbeiten kann. Unsere Ziel ist es, einen Plan (schedule) zu erstellen, d.h. jeder Arbeit Wi (i = 1, . . . , n) eine Maschine S(i) = 1, . . . , k zuzuordnen, so dass der Zeitbedarf T zur Erledigung aller Aufgaben minimal ist. Die Laufzeit der Maschine m(= 1, . . . , k) betr¨ agt ∑ ti , wobei u ¨ber alle i mit S(i) = m summiert wird. Der Zeitbedarf ist somit T = max{ ∑ ti , . . . , ∑ ti }. S(i)=1

S(i)=k

Da die Zahl k der Maschinen konstant ist, bezeichnen wir das Problem als SIT(k). Wir haben also: Eingabe von SIT(k): Zahlen t1 , . . . , tn . Ausgabe von SIT(k): eine Funktion S ∶ {1, . . . , n} → {1, . . . , k},

6.11. APPROXIMATION VON OPTIMIERUNGSPROBLEMEN

183

f¨ ur die die Zahl T = max{ ∑ ti , . . . , ∑ ti } S(i)=1

S(i)=k

minimal ist. Ein 1/3-approximierender Algorithmus A f¨ ur SIT(k) Der folgende Algorithmus erledigt erst die l¨angsten Arbeiten und erst dann die k¨ urzeren. Außerdem zieht er die am wenigsten benutzten Maschinen vor. Wir benutzen die Hilfsvariable Tm = die Zeit, die Maschine m bisher gearbeitet hat Eingabe: Zahlen t1 , . . . , tk Ausgabe: Funktion S ∶ {1, . . . , n} → {1, . . . , k} 1: sortiere die gegebenen Zeiten, so dass t1 ≥ t2 ≥ ⋅ ⋅ ⋅ ≥ tn 2: for m = 1 to k do 3: Tm ∶= 0 4: end for 5: for i = 1 to n do 6: m ∶= ein Index mit Tm = min{T1 , . . . , Tk } 7: S(i) ∶= m 8: Tm ∶= Tm + ti 9: end for Korrektheit: In der zweiten Schleife ab Zeile 5 wird jede Aufgabe Wi einer Maschine S(i) zugeordnet. Zeitkomplexit¨ at: Das Sortieren in Zeile 1 dauert O(n⋅log n) Zeiteinheiten, die Initialisierung in Zeilen 2–4 dauert O(1) Einheiten, jeder der n Durchl¨aufe der Schleife ab Zeile 5 dauert O(1) Zeiteinheiten (insbesondere besitzt die Menge, deren Minimum in Zeile 6 zu bestimmen ist, immer k Elemente). Insgesamt wird der Zeitbedarf des Algorithmus durch das Sortieren in Zeile 1 dominiert und betragt O(n log n). Dies ist also ein Algorithmus der Klasse P. Approximierung: Dieser Algorithmus ist 1/3-approximierend. Anstatt dies hier zu beweisen, zeigen wir (f¨ ur ein beliebig kleines ε > 0) einen ε-approximierenden Algorithmus f¨ ur SIT(k). Beispiel 4 (Ein ε-approximierender Algorithmus f¨ ur SIT(k)). Die Idee ist einfach: wir w¨ ahlen eine geeignete“ Konstante und verteilen die ersten r (l¨angsten) Aufga” ben optimal – z.B. suchen wir aus allen k r m¨oglichen Zuordnungen die beste aus. Den Rest berechnen wir mit dem Algorithmus aus Beispiel 3. Wir werden zeigen, dass jede Wahl eq-sit1

(1)

r>

k−1 ε

einen ε-approximierbaren Algorithmus ergibt. F¨ ur eine ausgew¨ahlte Konstante r beschreiben wir also den entsprechenden Algorithmus. Approximierender Algorithmus Ar f¨ ur SIT(k): 1: sortiere t1 ≥ t2 ≥ ⋅ ⋅ ⋅ ≥ tn 2: finde f¨ ur die Eingabe t1 , . . . , tr die optimale Planung Sopt ∶ {1, . . . , r} → {1, . . . , k} 3: for m = 1 to k do

184

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT

Tm ∶= ∑Sopt (i)=m ti end for for i = r + 1 to n do m ∶= ein Index mit Tm = min{T1 , . . . , Tk } S(i) ∶= m 9: Tm ∶= Tm + ti 10: end for 4: 5: 6: 7: 8:

Korrektheit: klar ur jede Konstante r hat dieser Algorithmus dieselbe ZeitkomZeitkomplexit¨ at: F¨ plexit¨ at O(n ⋅ log n) wie oben in Beispiel 3. Genauer: der Algorithmus braucht die Zeit O(n log n + k r+1 ). F¨ ur jede Konstante r ist dies einfach O(n log n). Wenn aber ε in (1) gegen Null geht, w¨ achst r und die Zeitkomplexit¨at steigt exponentiell. In der Tat kann die optimale Zuordnung in Zeile 2 wie folgt gefunden werden: wir durchsuchen alle k r m¨ oglichen Zurodnungen: f¨ ur jede Zuordnung S berechnen wir in der Zeit O(k) die gesamte Bearbeitungszeit T (S), die die m Arbeiten unter der Planung S dauern, und dann finden wir in der Zeit O(k r ) das Minimum aller T (S). Schritt 2 dauert also O(k ⋅ k r ) Zeiteinheiten. O(k k/ε ) Zeiteinheiten und der Algorithmus hat also die Zeitkomplexit¨at O(n ⋅ log n + k M +1 ). Approximierung: Wir beweisen, dass unser Algorithmus ε-approximierbar ist, falls (1) gilt: eq-sit2

(2)

aus r ≥

T − Topt k folgt ≤ε ε Topt

Beweis. T sei der Zeitbedarf der Zuordnung, die unser Algorithmus findet. Es muß mindestens eine Aufgabe Wi geben, die genau zur Zeit T beendet wird. Falls i ≤ r, ist Wi eine der optimal zugeordneten Aufgaben W1 , . . . , Wr – also stimmt der Zeitbedarf T (zuf¨ allig) mit dem (optimalen) Zeitbedarf f¨ ur die ersten r Aufgaben u ¨berein und ist folglich selber optimal, T = Topt , was (2) beweist. Wir k¨onnen also eq-sit3

i>r

(3)

annehmen. Also erfolgt die Zuordnung der Aufgabe Wi durch den obigen Algorithmus A. Die Aufgabe Wi beginnt zur Zeit T − ti . Daraus folgt, dass alle k Maschinen im Zeitraum [0, T − ti ) durchg¨ angig besch¨aftigt sind. Falls es n¨amlich eine Maschine geben sollte, deren T¨ atigkeit zur Zeit T0 < T − ti aufh¨ort, w¨ urde der Algorithmus A die Aufgabe Wi auf dieser Maschine zum Zeitpunkt T0 beginnen lassen (denn A bevorzugt die weniger besch¨aftigten Maschinen) und somit w¨ urde Wi nicht zur Zeit T enden. Die Gesamtarbeitszeit aller k Maschinen im Zeitraum [0, T − ti ), also einem Intervall der L¨ ange T − ti , betr¨agt also k(T − ti ). Aber der Algorithmus A verplant nur Aufgaben Wj mit j < i in diesem Zeitraum (da Wi selbst erst zur Zeit T − ti anf¨ angt). Im Intervall [0, T − ti ) werden also nur die Aufgaben W1 , . . . , Wi−1 bearbeitet. Die Gesamtarbeitszeit k(T − ti ) ist also h¨ochstens so groß wie die Zeit t1 + ⋅ ⋅ ⋅ + ti−1 , die die Bearbeitung der Aufgaben W1 , . . . , Wi−1 verlangt: eq-sit4

(4)

k(T − ti ) ≤ t1 + ⋅ ⋅ ⋅ + ti−1 .

Es gilt also eq-sit5

(5)

T≤

t1 + ⋅ ⋅ ⋅ + ti−1 + ti . k

6.11. APPROXIMATION VON OPTIMIERUNGSPROBLEMEN

185

Anderseits dauern alle n Aufgaben insgesamt t1 +⋅ ⋅ ⋅+tn Zeiteinheiten. Die optimale Zuordnung ergibt einen Zeitbedarf von Topt Zeiteinheiten, dabei sind die k Maschinen maximal kTopt Zeiteinheiten aktiv (falls alle die ganze Zeit besch¨aftigt sind). Daraus folgt eq-sit6

kTopt ≥ t1 + ⋅ ⋅ ⋅ + tn .

(6) Dann gilt

eq-sit7

Topt ≥

(7)

t1 + ⋅ ⋅ ⋅ + tn t1 + ⋅ ⋅ ⋅ + ti−1 ≥ . k k

Die Kombination von (5) und (7) ergibt T − Topt ≤

t1 + ⋅ ⋅ ⋅ + ti−1 t1 + ⋅ ⋅ ⋅ + ti−1 + ti − = ti k k

Aus (2) wissen wir, dass ti ≤ tr (denn i > r), also eq-sit8

T − Topt ≤ tr .

(8)

Jetzt benutzen wir (6) nochmals: da t1 ≥ t2 ⋅ ⋅ ⋅ ≥ tn , gilt Topt ≥

t1 + ⋅ ⋅ ⋅ + tn t1 + ⋅ ⋅ ⋅ + tr r ⋅ tr ≥ ≥ k k k

und kombiniert mit (8), bekommen wir eq-sit9

T − Topt tr k ≤ r⋅tr = . Topt r k

(9) Da r ≥

k ε

ist, folgt

k r

≤ ε, also ist (9) die gew¨ unschte Ungleichung.

Satz 1. F¨ ur kein ε > 0 gibt es einen ε-approximierenden Algorithmus f¨ ur TSP, falls P ≠ N P. Beweis. Wir wissen, dass HAMILTONSCHER KREIS ein N P-vollst¨andiges Problem ist. Wir beweisen, dass wir einen Algorithmus A der Klasse P f¨ ur HAMILTONSCHER KREIS finden k¨ onnen, falls ein ε-approximierender Algorithmus Aε f¨ ur TSP gegeben ist – es folgt, dass P = N P. Ein ungerichteter Graph G als Eingabe wird von A wie folgt bearbeitet: Der Algorithmus Aε wird auf das TSP angewendet mit n St¨adten und ⎧ ⎪ falls (i, j) eine Kante von G ist ⎪1 di,j = ⎨ ⎪ 2 + ⌈εn⌉ falls nicht, ⎪ ⎩ wobei ⌈εn⌉ die kleinste ganze Zahl ≥ εn ist. Bezeichnen wir mit c die Kosten der Tour, die Aε findet. Der Algorithmus A liefert die Antwort JA genau dann, wenn c ≤ (1 + ε)n. Korrektheit des Algorithmus A: wir beweisen G hat einen Hamiltonschen Kreis ⇐⇒ c ≤ (1 + ε)n. In der Tat:

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT

186

1. Jeder Hamiltonsche Kreis von G besteht aus n Kanten, also betragen die Kosten copt = n. Da Aε ε-approximierend ist, gilt also c−n ≤ε n und somit c ≤ (ε + 1)n. 2. Falls die gefundene Rundreise der Bedingung c ≤ (1 + ε)n gen¨ ugt, zeigen wir, dass sie nur Kanten aus G enth¨alt, also einen Hamiltonschen Kreis in G bildet. Dazu reicht es, c < 2 + ⌈εn⌉ + (n − 1) zu beweisen, denn jede Rundreise, die mindestens einmal die Kanten von G verl¨aßt, kostet mindestens 2 + ⌈εn⌉ (= Kosten einer Kante außerhalb von G) plus n−1 (die untere Grenze der Kosten der anderen n − 1 Kanten). Wegen εn < ⌈εn⌉ + 1 folgt c ≤ (ε + 1)n < n + ⌈εn⌉ + 1 = 2 + ⌈εn⌉ + (n − 1). ur den Algorithmus Aε existiert ein Polynom Zeitkomplexit¨ at des Algorithmus A: f¨ p(n), so dass Aε die Rundreise in der Zeit p(n) findet. Dann dauert die Bearbeitung des Graphen G h¨ ochstens O(n2 ) Schritte f¨ ur die Konstruktion von TSP und dann p(n) Schritte f¨ ur Aε , insgesamt also O(n2 + p(n)) Schritte. Das bedeutet, dass A in der Klasse P liegt – im Widerspruch zur N P-Vollst¨andigkeit von HAMILTONSCHEM KREIS. Zusammenfassung: F¨ ur Optimierungsprobleme, f¨ ur die wir keinen effizienten Algorithmus finden k¨ onnen, k¨ onnen wir versuchen, approximierbare Algorithmen zu finden. Es gibt Aufgaben, die sogar f¨ ur jedes ε einen ε-approximierbaren Algorithmus besitzen, z.B. SIT(k). Leider gibt es aber wichtige Optimierungsaufgaben, die keinen ε-approximierbaren Algorithmus erlauben, z.B. TSP.

6.12

Raumkomplexit¨ at

Bisher haben wir einen Algorithmus als effizient betrachtet, falls er wenig Zeit braucht. Ein anderer wichtiger Gesichtspunkt ist der Speicherbedarf eines Algorithmus. Wie die Zeitkomplexit¨at ist auch die Raumkomplexit¨at prinzipiell von der Implementation unabh¨ angig, falls wir nur die Frage stellen, ob polynomial großer Speicher gen¨ ugt. Deswegen k¨onnen wir wieder Turingmaschinen als Berechnungsmodell verwenden. Wir sagen, dass eine TM die Raumkomplexit¨ at s(n) hat, wobei s(n) eine Funktion u urlichen Zahlen ist, falls f¨ ur ¨ber der Menge N aller nat¨ jede Eingabe w der L¨ ange n die TM h¨alt und der Kopf h¨ochstens s(n) Bandfelder durchgegangen ist. Definition. Wir bezeichnen mit PSPACE die Klasse aller formalen Sprachen, die von einer TM mit polynomialer Raumkomplexit¨ at akzeptiert werden k¨onnen. Genauer: eine Sprache L geh¨ort zur Klasse PSPACE, falls es eine Turingmaschine M und ein Polynom p(n) gibt, so dass L = L(M ) und M hat die Raumkomplexit¨at p(n). bem-pspace

Bemerkung 1.

1. Die vorher eingef¨ uhrten Klassen P und N P werden oft PT IME und N PT IME

bezeichnet, um sie von PSPACE zu unterscheiden.

¨ 6.12. RAUMKOMPLEXITAT bem-time-in-space

187

2. Es gilt PT IME ⊆ PSPACE denn in einem Schritt kann eine TM nur ein Bandfeld besuchen. Es folgt, dass ¨ ¨ Probleme wie 2-FARBUNG, 2-ERFULLBARKEIT usw. in PSPACE liegen. ¨ REGULARER ¨ ¨ 3. Das Problem der UNIVERSALITAT AUSDRUCKE (Beispiel 6 in 6.2) geh¨ ort nicht zur Klasse PSPACE. 4. Die Klasse N PSPACE“, die zu N PT IME analog w¨are, brauchen wir nicht ” einzuf¨ uhren: Satz 1 (Savitch-Satz). Jede nichtdeterministische Turingmaschine mit polynomialer Raumkomplexit¨ at kann durch eine (deterministische) Turingmaschine mit polynomialer Raumkomplexit¨ at simuliert werden. Beweis. Sei M eine NTM mit Raumkomplexit¨at p(n) > n, dann konstruieren wir eine (deterministische) Turingmaschine M ∗ , mit der Raumkomplexit¨at O(p2 (n)), die dieselbe Sprache akzeptiert. Wir k¨onnen annehmen, dass M das Band l¨oscht, bevor sie im finalen Zustand h¨ alt. Dann ist (qF , #) die einzige akzeptierende Konfiguration. Es gibt eine Konstante C, so dass die Berechnung eines Wortes der L¨ange n h¨ochstens 2Cp(n) Konfigurationen durchl¨ auft. In der Tat haben die Konfigurationen die Form (q, s1 . . . si . . . sp(n) ), wobei q ein Zustand ist, s1 . . . sp(n) ist der Inhalt des Bandes und i ist die Kopfposition. Falls die Maschine r Zust¨ande und m Symbole in Σ ∪ {#} hat, ist die Zahl der Konfigurationen gleich r (f¨ ur Zust¨ande q) mal p(n) (f¨ ur Kopfpositionen i) mal der Zahl mp(n) aller W¨orter s1 . . . sp(n) u ¨ber Σ ∪ {#}. Es gilt rp(n)mp(n) < rmp(n) mp(n) = rm2p(n) < 2Cp(n) f¨ ur eine geeignete Konstante C. Es folgt, dass f¨ ur jedes von M akzeptierte Wort s1 . . . sn sn eine akzeptierende Berechnung von h¨ ochstens 2Cp(n) Schritten existiert. In der Tat, nehmen wir die k¨ urzeste akzeptierende Berechnung von s1 . . . sn , dann wird keine der 2C p(n) Konfigurationen wiederholt. Es gilt: M akzeptiert s1 . . . sn genau dann, wenn (q0 , s1 . . . sn ) ⊢∗ (qF , #). Und das k¨ onnen wir durch die Begrenzung 2Cp(n) der Zahl der Schritte wie folgt versch¨ arfen: F¨ ur zwei Konfigurationen K und K ′ schreiben wir REACH(K, K ′ , i) = true

188

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT

falls in h¨ ochstens 2i Berechnungsschritten aus der Konfiguration K die Konfiguration K ′ erreicht werden kann. (Z.B. bedeutet REACH(K, K ′ , 0), dass die Konfiguration K ′ in h¨ ochstens einem Schritt aus Konfiguration K erreicht werden kann – d.h., entweder K = K ′ oder K ′ ist eine Folgekonfiguration von K.). Es gilt M akzeptiert s1 . . . sn genau dann, wenn REACH(K, K ′ , Cp(n)) = true f¨ ur K = (q0 , s1 . . . sn ), K ′ = (qF , #) Es gen¨ ugt also, einen Algorithmus zu finden, der die Antwort REACH(K, K ′ , i) mit polynomialer Raumkomplexit¨ at f¨ ur alle Paare K, K ′ von Konfigurationen und alle ¨ Zahlen i = 0, . . . , Cp(n) berechnet. Die Idee ist, dass es f¨ ur i = 0 nur die Uberpr¨ ufung ′ ist, ob K eine der Folgekonfigurationen ist, die in O(1) Zeiteinheiten berechnet wird, und aus dem Fall REACH(−, −, i) k¨onnen wir REACH(−, −, i + 1) wie folgt berechnen: Seien K, K ′ Konfigurationen, f¨ ur die REACH(K, K ′ , i + 1) = true ist. i+1 i Also gibt es eine Berechnung in 2 = 2⋅2 Schritten; sei K die Konfiguration, die aus K in dieser Berechnung in 2i Schritten erreicht wird – dann gilt REACH(K, K, i) = true und REACH(K, K ′ , i) = true. Umgekehrt: falls es eine Konfiguration K gibt mit REACH(K, K, i) = true = REACH(K, K ′ , i), gilt bestimmt REACH(K, K ′ , i + 1). Die Antwort REACH(K, K ′ , i) kann f¨ ur i = 0, . . . , Cp(n) also rekursiv durch den folgenden deterministischen Algorithmus berechnet werden: i = 0 ∶ Antwort true genau dann, wenn K = K ′ oder K ⊢ K ′ . i + 1 ∶ Antwort true genau dann, wenn es eine Konfiguration K gibt mit REACH(K, K, i) ∧ REACH(K, K ′ , i) = true. F¨ ur i = 0 muß dieser Algorithmus nur die zwei Konfigurationen K, K ′ (W¨orter der L¨ ange p(n) + 1) speichern, also ist der Raumbedarf O(p(n)). F¨ ur i + 1 m¨ ussen wir, f¨ ur den rekursiven Ablauf, i speichern, und neben den Eingaben K und K ′ wird die lokale Variable K gespeichert. Dann wird REACH(K, K, i) u uft. ¨berpr¨ Falls die Antwort true ist, k¨onnen wir denselben Raum (!) wieder benutzen, um REACH(K, K ′ , i) zu u ufen. Da i ≤ Cp(n) und K, K ′ , K W¨orter der L¨ange ¨berpr¨ p(n) + 1 sind, wird in einem Schritt der Rekursion Raum O(p(n)) gen¨ ugen. Die Rekursion hat Cp(n) Schritte, also brauchen wir insgesamt Raum O(Cp2 (n)). Korollar 1. N PT IME ⊆ PSPACE Beweis. In der Tat sagt uns der Savitch-Satz, dass PSPACE = N PSPACE. Und N PT IME ⊆ N PSPACE ist analog zur Bemerkung 1 Nr. 2 oben. Bemerkung 2. Die Klasse PSPACE enth¨alt also alle Probleme, f¨ ur die es (Zeit-) effizient entscheidbar ist, ob eine angebotene L¨osung wirklich das Problem l¨ost. Z. ¨ B. TSP, 3-FARBBARKEIT usw. Es ist nicht bekannt, ob N PT IME = PSPACE gilt. Wir zeigen jetzt ein interessantes Beispiel eines Prolems, f¨ ur das nicht klar ist, ob es zu N PT IME geh¨ ort, da es keinen vern¨ unftigen Begriff von angebotener L¨osung“ ” gibt, das aber zu PSPACE geh¨ort. Beispiel 1 (QUANTIFIZIERTE BOOLESCHE FORMELN). Eingabe: Eine quantifizierte Boolesche Formel φ ohne freie Variablen. Ausgabe: JA genau dann, wenn φ den Wert true hat.

¨ 6.12. RAUMKOMPLEXITAT

189

Bisher sprachen wir nur u ¨ber Boolesche Formeln ohne Quantoren (∀x), (∃x). Die quantifizierten Booleschen Formeln, QBF, in Variablen xi (i = 1, . . . , n) k¨onnen wie folgt definiert werden: 1. Jede Variable xi ist eine QBF 2. Die Konstanten true und false sind QBF 3. Falls E1 , E2 zwei QBF sind, sind auch E1 ∨ E2 , E1 ∧ E2 , E1 → E2 und ¬E2 QBF’n. 4. Falls E eine QBF ist, sind auch (∀x)E und (∃x)E (f¨ ur jede Variable x) QBF’n. Das heißt: die Menge aller QBF ist die kleinste Menge, f¨ ur die 1 – 4 gilt. Beispiel: E = (∀x)(∃y)(x → ((∀x)(¬y ∨ x))). Dies ist eine geschlossene QBF, dass heißt, alle Variablen werden quantifiziert (der innere Quantor (∀x) wirkt u ¨ber die Formel (¬y ∨ x), der ¨außere u ¨ber (∃y)(x → ((∀x)(¬y ∨ x))) ). Jede geschlossene Formel hat einen Wert, den wir bekommen, indem wir f¨ ur jede quantifizierte Variable die Belegung mit true oder false betrachten. Zum Beispiel in E m¨ ussen wir, aufgrund des ¨außeren (∀x), die zwei Formeln E1 = (∃y)(true → ((∀x)(¬y ∨ x))) und E2 = (∃y)(false → ((∀x)(¬y ∨ x))) bewerten: falls beide Werte true sind, ist E true (sonst false). Also W ERT (E) = W ERT (E1) ∧ W ERT (E2) Um den Wert von E1 zu bewerten, m¨ ussen wir die Werte von E11 = true → ((∀x)(¬true ∨ x)) und E12 = true → ((∀x)(¬false ∨ x)) kennen: falls einer der Werte true ist, ist E1 true (sonst false), also W ERT (E1 ) = W ERT (E11 ) ∨ W ERT (E12 ). Der Wert von E11 ist false: betrachten wir die Belegung x = true. Aber der Wert von E12 ist true, da ¬false ∨ x = true ∨ x den Wert true hat f¨ ur x = false, true. Also W ERT (E1 ) = false ∨ true = true. Analog kann man zeigen, dass W ERT (E2 ) = true, also W ERT (E) = true.

¨ VON ALGORITHMEN KAPITEL 6. KOMPLEXITAT

190

Im allgemeinen definieren wir die Menge V ar(E) aller freien Variablen einer QBF wie folgt: V ar(xi ) = {xi } V ar(true) = V ar(false) = ∅ V ar(E1 ∨ E2 ) = V ar(E1 ) ∪ V ar(E2 ), analog mit ∧, → V ar(¬E) = V ar(E) V ar((∀x)E) = V ar((∃x)E) = V ar(E) − {x} Eine QBF heißt geschlossen, falls sie keine freien Variablen hat, falls also V ar(E) = ∅. Den Wert W ERT (E) einer geschlossenen QBF definieren wir wie folgt: W ERT (true) = true W ERT (false) = false W ERT (E1 ∨ E2 ) = W ERT (E1 ) ∨ W ERT (E2), analog mit ∧, → W ERT (¬E) = ¬W ERT (E) W ERT ((∀x)E) = W ERT (E(true/x)) ∧ W ERT (E(false/x)) W ERT ((∃x)E) = W ERT (E(true/x)) ∨ W ERT (E(false/x)) Hier ist E(true/x) die QBF, die wir aus E bekommen, indem alle freien Vorkommen der Variablen x durch true ersetzt werden, analog E(false/x). Bemerkung 3. Das Problem QBF geh¨ort zur Klasse PSPACE. In der Tat existiert ein Algorithmus mit Raumkomplexit¨at O(n2 ), wobei n die L¨ ange des Wortes E ist, der entscheidet, ob E true ist. Hier bezeichnet E eine geschlossene Boolesche Formel. Den Wert W ERT (E) = true oder false berechnen wir rekursiv wie folgt ˆ falls E = true, ist W ERT (E) = true ˆ falls E = false, ist W ERT (E) = false ˆ falls E = ∀xi (E ′ ) oder E = ∃xi (E ′ ), berechnen wir erst (rekursiv) den Wert von E(true/xi ) Dann speichern wir das Ergebnis (in 1 Bit) und auf demselben Raum (!) berechnen wir E(false/xi ), speichern das Ergebnis (wieder 1 Bit) und entscheiden, ohne zus¨atzlichen Raum, den Wert von E aufgrund dieser zwei Werte.

Algorithmus f¨ ur QBF Eingabe: E, eine QBF ohne freie Variablen. Ausgabe: der Wert von E, W ERT (E), rekursiv berechnet: W ERT (true) ∶= true; W ERT (false) ∶= false; W ERT (∀xi (E)) ∶= W ERT (E(true/xi )) ∧ W ERT (E(false/xi )); W ERT (∃xi (E)) ∶= W ERT (E(true/xi )) ∨ W ERT (E(false/xi ));

¨ 6.12. RAUMKOMPLEXITAT

191

Korrektheit: Jede QBF kann in die Form mit Quantoren nach außen gebracht werden. Falls die Formel in dieser Form keine freien Variablen besitzt, muß sie eine der 4 Typen oben sein. Die Rekursion erfolgt nach der Zahl k aller Quantoren von E. F¨ ur k = 0 ist E = true oder E = false, falls k > 0 ist, gilt E = ∀xi (E) oder E = ∃xi (E), wobei f¨ ur E die Zahl aller Quantoren k − 1 ist. Nach k Rekursionsschritten wird also W ERT (E) berechnet sein. Raumkomplexit¨ at: Sei E eine QBF der L¨ange n. Die Zahl k aller Quantoren in E erf¨ ullt k < n. Die Rekursion hat also Tiefe n und in jedem rekursiven Schritt brauchen wir, wie oben erkl¨ art wurde, nur Raum um 2 Bit gr¨oßer als der Raum des n¨ achsten Schrittes. Das Wort E hat L¨ange n, also haben die in der Rekursion gespeicherten W¨ orter L¨ ange O(n), was mit n rekursiven Schritten Raum O(n2 ) verlangt. Offenes Problem: Liegt QBF in N PT IME? In der Tat scheint dies unwahrscheinlich, denn QBF ist PSPACE-vollst¨ andig , das heißt f¨ ur jedes Problem der Klasse PSPACE gibt es eine Reduktion auf QBF in polynomialer Zeit (!). Falls also QBF ∈ N PT IME ist, folgt N PT IME = PSPACE.