Skript - Professur für Theoretische Informatik

Werbung
Skript zur Vorlesung
„Theoretische Informatik 2“
Prof. Dr. Georg Schnitger
Sommersemester 2015
Hinweise auf Fehler und Anregungen zum Skript bitte an
sorin@cs.uni-frankfurt.de
Mit einem Stern gekennzeichnete Abschnitte werden in der Vorlesung nur kurz angesprochen.
Inhaltsverzeichnis
I
Einführung
5
1 Grundlagen
1.1
7
Begriffe und Notationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8
1.1.1
Aussagenlogik, Mengen, Relationen und Funktionen . . . . . . . . . .
8
1.1.2
Summen, Produkte, Vereinigungen und Durchschnitte . . . . . . . . .
9
1.1.3
Bäume und Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10
Was ist ein korrektes Argument? . . . . . . . . . . . . . . . . . . . . . . . . .
13
1.2.1
Direkte Beweise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
1.2.2
Beweis durch Kontraposition . . . . . . . . . . . . . . . . . . . . . . .
15
1.2.3
Beweis durch Widerspruch
. . . . . . . . . . . . . . . . . . . . . . . .
15
1.2.4
Vollständige Induktion . . . . . . . . . . . . . . . . . . . . . . . . . . .
16
Schatztruhe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
27
1.3.1
Geschlossene Ausdrücke für Summen . . . . . . . . . . . . . . . . . . .
27
1.3.2
Größe von endlichen Mengen . . . . . . . . . . . . . . . . . . . . . . .
27
1.4
Einige Grundlagen aus der Stochastik . . . . . . . . . . . . . . . . . . . . . .
30
1.5
Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
33
1.2
1.3
2 Komplexitätsklassen
2.1
35
Worte und Sprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
35
2.1.1
Das Wortproblem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
38
2.2
Turingmaschinen und die Churchsche These . . . . . . . . . . . . . . . . . . .
41
2.3
Sprachklassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
43
2.3.1
Formale Sprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
44
2.3.2
Zeit-Komplexitätsklassen . . . . . . . . . . . . . . . . . . . . . . . . .
46
2.3.3
Speicherplatz-Komplexitätsklassen . . . . . . . . . . . . . . . . . . . .
47
2.3.4
Die Komplexität paralleler Berechnungen . . . . . . . . . . . . . . . .
49
1
2
II
INHALTSVERZEICHNIS
Formale Sprachen
53
3 Endliche Automaten und reguläre Sprachen
3.1
55
Minimierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
61
3.1.1
Äquivalenzrelationen . . . . . . . . . . . . . . . . . . . . . . . . . . . .
62
3.1.2
Die Verschmelzungsrelation . . . . . . . . . . . . . . . . . . . . . . . .
63
3.1.3
Der Äquivalenzklassenautomat . . . . . . . . . . . . . . . . . . . . . .
65
3.1.4
Der Minimierungsalgorithmus . . . . . . . . . . . . . . . . . . . . . . .
68
3.1.5
Die Myhill-Nerode Relation . . . . . . . . . . . . . . . . . . . . . . . .
73
3.1.5.1
Der Äquivalenzklassenautomat ist minimal . . . . . . . . . .
75
3.1.5.2
Der Myhill-Nerode Automat . . . . . . . . . . . . . . . . . .
78
Reguläre Sprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
79
3.2.1
Der Satz von Myhill und Nerode . . . . . . . . . . . . . . . . . . . . .
79
3.2.2
Das Pumping-Lemma . . . . . . . . . . . . . . . . . . . . . . . . . . .
82
Endliche Automaten und Nichtdeterminismus . . . . . . . . . . . . . . . . . .
85
3.3.1
Nichtdeterministische endliche Automaten: NFAs . . . . . . . . . . . .
85
3.3.1.1
Minimierung von NFAs . . . . . . . . . . . . . . . . . . . . .
91
3.3.1.2
NFAs mit -Übergängen . . . . . . . . . . . . . . . . . . . . .
92
3.3.2
Abschlusseigenschaften . . . . . . . . . . . . . . . . . . . . . . . . . . .
92
3.3.3
Zweiwege Automaten
. . . . . . . . . . . . . . . . . . . . . . . . . . .
93
3.3.3.1
Determinismus gegen Nichtdeterminismus . . . . . . . . . . .
96
3.3.3.2
Ein Kommunikationsargument . . . . . . . . . . . . . . . . .
98
3.4
Endliche Automaten und Probabilismus . . . . . . . . . . . . . . . . . . . . .
100
3.5
Reguläre Ausdrücke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
104
3.5.1
Die Länge regulärer Ausdrücke . . . . . . . . . . . . . . . . . . . . . .
106
3.6
Grammatiken und reguläre Grammatiken . . . . . . . . . . . . . . . . . . . .
108
3.7
Entscheidungsprobleme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
110
3.8
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
111
3.2
3.3
4 Kontextfreie Sprachen
113
4.1
Ableitungsbäume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
114
4.2
Die Chomsky-Normalform und das Wortproblem . . . . . . . . . . . . . . . .
118
4.3
Das Pumping Lemma und Ogden’s Lemma . . . . . . . . . . . . . . . . . . .
127
4.3.1
Abschlusseigenschaften kontextfreier Sprachen . . . . . . . . . . . . .
131
Kellerautomaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
132
4.4.1
Deterministisch kontextfreie Sprachen . . . . . . . . . . . . . . . . . .
138
4.4.2
Abschlusseigenschaften deterministisch kontextfreier Sprachen . . . . .
140
Entscheidungsprobleme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
142
4.4
4.5
INHALTSVERZEICHNIS
4.6
4.5.1
Das Postsche Korrespondenzproblem . . . . . . . . . . . . . . . . . . .
143
4.5.2
Unentscheidbare Probleme für kontextfreie Sprachen . . . . . . . . . .
145
4.5.3
Das Äquivalenzproblem für Finite State Transducer . . . . . . . . . .
147
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
148
5 XML und reguläre Baumgrammatiken∗
149
5.1
XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
149
5.2
DTDs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
152
5.2.1
Ein Parser für DTDs . . . . . . . . . . . . . . . . . . . . . . . . . . . .
154
Reguläre Baumsprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
154
5.3.1
Baumsprachen mit eindeutigen Typen . . . . . . . . . . . . . . . . . .
157
5.3.2
Reguläre Baumgrammatiken und Baumautomaten . . . . . . . . . . .
159
XPath und XQuery . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
163
5.4.1
XPath: Navigation in XML-Dokumenten . . . . . . . . . . . . . . . . .
163
5.4.2
XQuery: Eine Anfragesprache für XML-Datenbanken . . . . . . . . . .
164
5.3
5.4
III
3
Komplexitätsklassen
6 Speicherplatz-Komplexität
167
169
6.1
Eine Platzhierarchie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
169
6.2
Sub-Logarithmischer Speicherplatz . . . . . . . . . . . . . . . . . . . . . . . .
170
6.3
Logarithmischer Speicherplatz . . . . . . . . . . . . . . . . . . . . . . . . . . .
171
6.3.1
DL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
171
6.3.2
NL und NL-Vollständigkeit . . . . . . . . . . . . . . . . . . . . . . . . .
174
6.3.3
Der Satz von Savitch . . . . . . . . . . . . . . . . . . . . . . . . . . . .
176
6.3.4
Der Satz von Immerman und Szlepscenyi . . . . . . . . . . . . . . . .
178
PSPACE-Vollständigkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
181
6.4.1
QBF: Quantifizierte Boolesche Formeln . . . . . . . . . . . . . . . . .
182
6.4.2
Das Geographie-Spiel . . . . . . . . . . . . . . . . . . . . . . . . . . .
184
6.4.3
NFA’s und reguläre Ausdrücke . . . . . . . . . . . . . . . . . . . . . .
185
6.5
Komplexitätsklassen und die Chomsky Hierarchie . . . . . . . . . . . . . . . .
187
6.6
Probabilistische Turingmaschinen und Quantenrechner . . . . . . . . . . . . .
192
6.7
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
196
6.4
4
INHALTSVERZEICHNIS
7 Parallelität
197
7.1
Parallele Rechenzeit versus Speicherplatz
. . . . . . . . . . . . . . . . . . . .
198
7.2
P-Vollständigkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
200
7.2.1
Das Circuit Value Problem . . . . . . . . . . . . . . . . . . . . . . . .
201
7.2.2
Die Lineare Programmierung . . . . . . . . . . . . . . . . . . . . . . .
204
7.2.3
Parallelisierung von Greedy-Algorithmen
. . . . . . . . . . . . . . . .
205
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
207
7.3
Teil I
Einführung
5
Kapitel 1
Grundlagen
Die Vorlesung „Theoretische Informatik 2“ beschließt den Grundstudiumszyklus der theoretischen Informatik.
- In der Veranstaltung „Diskrete Modellierung“ werden fundamentale diskrete Modellierungsmethoden zur Verfügung gestellt. Behandelt werden Aussagen- und Prädikatenlogik, Bäume und Graphen, Markovketten sowie eine Einführung in endliche Automaten
und kontextfreie Grammatiken.
- Die Veranstaltungen „Datenstrukturen“ und „Theoretische Informatik 1“ sind vor Allem der Beschreibung von Datenstrukturen, Standardalgorithmen und Entwurfsmethoden sowie der Effizienzmessung von Algorithmen gewidmet. Desweiteren wird mit den
Konzepten der NP-Vollständigkeit und der Entscheidbarkeit die Möglichkeit gegeben,
die Komplexität algorithmischer Probleme zu bestimmen. Die Vorlesungsinhalte bilden
das Rüstzeug für den Entwurf effizienter Algorithmen und das Erkennen schwieriger
algorithmischer Probleme.
Im ersten Teil dieser Vorlesung wird unser Hauptaugenmerk dem Wortproblem gelten, nämlich der Frage, ob ein vorgelegtes Programm einer höheren Programmiersprache syntaktisch
korrekt ist, und wir werden Typ Checking für XML-Dokumente durchführen. Dazu werden
wir bereits aus der „diskreten Modellierung“ bekannte Konzepte wie endliche Automaten
und kontextfreie Grammatiken wieder aufgreifen und vertiefen sowie neue Konzepte wie unbeschränkte (konventionelle) Grammatiken und Baumgrammatiken untersuchen.
Im zweiten Teil fragen wir uns, wieviel Ressourcen benötigt werden, um das Wortproblem
für wichtige Klassen formaler Sprachen –wie etwa reguläre, kontextfreie oder kontextsensitive
Sprachen– zu lösen: Im Wortproblem für eine Sprache, also für eine Menge von Worten, ist
festzustellen, ob ein Eingabewort zur Sprache gehört oder nicht.
Neben den schon aus der Theoretischen Informatik 1 bekannten Komplexitätsklassen P und NP
spielen auch Komplexitätsklassen eine wichtige Rolle, die den notwendigen Speicherverbrauch
messen: Wir werden auf die Komplexitätsklassen DL und NL wie auch auf die Klasse PSPACE
geführt. Diese Klassen sind nicht nur für das Verständnis formaler Sprachen wichtig, sondern
auch für das Verständnis nicht-klassischer Berechnungen wie randomisierte Berechnungen
oder Quantenberechnungen. Als Nebenprodukt werden wir auch zum Beispiel sehen, dass das
Entscheidungsproblem „Besitzt der ziehende Spieler einen Gewinnzug?“ für viele nicht-triviale
Zweipersonenspiele zu den schwierigsten Problemen der Klasse PSPACE gehört: Man kann
deshalb die Klasse PSPACE auch zur Klassifikation der Schwierigkeit von Spielen benutzen!
7
8
KAPITEL 1. GRUNDLAGEN
Welche Probleme erlauben ultra-schnelle parallele Algorithmen? Wir betrachten zur Beantwortung dieser Frage die Klasse NC aller parallelisierbaren Entscheidungsprobleme: Ein Entscheidungsproblem L gehört genau dann zu NC, wenn L rasant schnelle Algorithmen besitzt,
die mit nicht zu vielen Prozessoren arbeiten. Wir fragen uns dann, welche Probleme in P nicht
parallelisierbar sind und führen zur Beantwortung dieser Frage die LOGSPACE-Reduktion
und den Begriff der P-Vollständigkeit ein. Wir stellen fest, dass P = NC genau dann gilt, wenn
eine P-vollständige Sprache parallelisierbar ist: Die P-vollständigen Sprachen sind also die
im Hinblick auf Parallelisierbarkeit schwierigsten Sprachen in P. Schließlich werden wir auf
einen sehr engen Zusammenhang zwischen Parallelisierbarkeit und Speicherplatz-Komplexität
geführt, wenn wir die Anzahl der Prozessoren außer Acht lassen.
1.1
Begriffe und Notationen
Wir stellen Begriffe und Schreibweisen aus der Aussagenlogik, für Mengen, Relationen und
Funktonen, Bäume und Graphen zusammen. Ausführlicher gehen wir auf die Konzepte der
Worte und Sprachen ein.
1.1.1
Aussagenlogik, Mengen, Relationen und Funktionen
0. Notation aus der Logik:
¬φ ist die Negation der Formel φ. Für Formeln φ und ψ ist φ ∧ ψ, φ ∨ ψ und φ ⊕ ψ
die Konjunktion, Disjunktion, bzw. das exklusive Oder (XOR) von φ und ψ. Die
Formeln φ → ψ und φ ↔ ψ bezeichnen die Implikation und die Äquivalenz.
Man schreibt φ ≡ ψ, falls die Formel ψ genau dann wahr ist, wenn φ wahr ist. Beachte
(φ → ψ) ≡ (¬φ ∨ ψ) und (φ ↔ ψ) ≡ ((φ → ψ) ∧ (ψ → φ)).
1. Wir erinnern an die Mengennotationen aus Abschnitt ??: Die Beschreibung x ∈ M
bedeutet, dass x ein Element der Menge M ist, x 6∈ M hingegen bedeutet, dass x
kein Element von M ist. Die Schreibweise
M 0 := {x ∈ M : x hat Eigenschaft E }
drückt aus, dass wir die Menge M 0 als die Menge aller Elemente x ∈ M definieren, die
die Eigenschaft E besitzen. Alternativ schreiben wir auch
M 0 := {x : x ∈ M und x hat Eigenschaft E }.
– Für Mengen M1 , M2 bedeutet M1 ⊆ M2 , bzw. M2 ⊇ M1 dass M1 eine Teilmenge
von M2 ist. P(M ) := { M 0 : M 0 ⊆ M } ist die Potenzmenge von M und ∅ ist
die leere Menge. Beachte, dass die leere Menge Teilmenge jeder Menge ist.
– Wir erinnern an die Mengenoperationen
Durchschnitt M1 ∩ M2 := {x : x ∈ M1 und x ∈ M2 },
Vereinigung M1 ∪ M2 := {x : x ∈ M1 oder x ∈ M2 },
Mengendifferenz M1 \ M2 := M1 − M2 := {x : x ∈ M1 und x 6∈ M2 }.
2. Natürliche, ganze, rationale und reelle Zahlen:
1.1. BEGRIFFE UND NOTATIONEN
9
N
:=
Menge der natürlichen Zahlen := {0, 1, 2, 3, ...}
N>0
:=
Menge der positiven natürlichen Zahlen := {1, 2, 3, ...}
Z
:=
Menge der ganzen Zahlen := {0, 1, −1, 2, −2, 3, −3, ...}
Q
:=
Menge der rationalen Zahlen := { ab : a, b ∈ Z b 6= 0}
R
:=
Menge der reellen Zahlen
Für eine reelle Zahl x ∈ R ist bxc die größte ganze Zahl kleiner oder gleich x und dxe
die kleinste ganze Zahl größer oder gleich x.
3. Das kartesische Produkt der Mengen M1 , . . . , Mk ist die Menge
M1 × · · · × Mk = { (m1 , . . . , mk ) : m1 ∈ M1 , . . . , mk ∈ Mk }.
4. Graphen werden durch Paare G = (V, E) bezeichnet, wobei V die Menge der Knoten
und E die Menge der Kanten ist. Wenn G ungerichtet ist, dann ist E ⊆ { {u, v} :
u, v ∈ V und u 6= v}. Wenn G ein gerichteter Graph ist, dann ist stets E ⊆ V × V .
5. Um eine Funktion (oder Abbildung) f zu beschreiben, benutzen wir den Formalismus
f : A → B um anzugeben, dass die Funktion genau auf allen Elementen x ∈ A des
Definitionsbereichs A definiert ist. Der Wert von f für das Argument x ∈ A wird
durch f (x) bezeichnet; beachte, dass f (x) ein Element des Bildbereichs B ist, es gilt
also f (x) ∈ B.
– f ist injektiv, falls es für jedes Element b ∈ B des Bildbereichs höchstens ein
Element a des Definitionsbereichs mit f (a) = b gibt.
– f ist surjektiv, falls es für jedes Element b ∈ B des Bildbereichs mindestens ein
Element a des Definitionsbereichs mit f (a) = b gibt.
– f ist bijektiv, falls es für jedes Element b ∈ B des Bildbereichs genau ein Element
a des Definitionsbereichs mit f (a) = b gibt.
Die Funktionen f : A → B und g : B → C lassen sich hintereinander ausführen:
Zuerst wende f auf das Argument x an, dann wende g auf das Zwischenergebnis f (x) an,
um das Endergebnis g(f (x)) zu erhalten. Man bezeichnet die Hintereinanderausführung
auch als Komposition und benutzt die Notation g ◦ f .
1.1.2
Summen, Produkte, Vereinigungen und Durchschnitte
Summen- und Produktsymbole haben sich für Summen und Produkte mit vielen Operanden
eingebürgert.
(a) Ist k ∈ N>0 und sind z1 , . . . , zk (natürliche, ganze, rationale, reelle oder komplexe)
Zahlen, so schreiben wir
k
X
zi
bzw.
i=1
X
zi
i∈{1,...,k}
um die Summe der Zahlen z1 , . . . , zk zu bezeichnen (d.h. die Zahl z1 + · · · + zk ).
Wir schreiben
k
Y
i=1
zi
bzw.
Y
zi
i∈{1,...,k}
um das Produkt der Zahlen z1 , . . . , zk zu bezeichnen (d.h. die Zahl z1 · · · · · zk ).
10
KAPITEL 1. GRUNDLAGEN
(b) Sind M1 , . . . , Mk Mengen, so schreiben wir
k
[
Mi
bzw.
i=1
[
Mi
i∈{1,...,k}
um die Vereinigung der Mengen M1 , . . . , Mk zu bezeichnen (d.h. die Menge M1 ∪ · · · ∪
Mk ).
Wir schreiben
k
\
Mi
bzw.
i=1
\
Mi
i∈{1,...,k}
um den Durchschnitt der Mengen M1 , . . . , Mk zu bezeichnen (d.h. die Menge M1 ∩ · · · ∩
Mk ).
(c) Ist K eine Menge, deren Elemente Teilmengen einer Menge U sind (d.h.: K ⊆ P(U )),
so ist
[
M
:=
{x ∈ U : es existiert eine Menge M ∈ K, so dass x ∈ M }
M ∈K
die Vereinigung aller Mengen M ∈ K (d.h. die Menge aller Elemente x, die in mindestens
einer Menge M ∈ K liegen). Analog ist
\
M
:=
{x ∈ U : für alle M ∈ K gilt x ∈ M }
M ∈K
der Durchschnitt aller Mengen M ∈ K (d.h. die Menge aller Elemente x, die in jeder
Menge M ∈ K liegen).
1.1.3
Bäume und Graphen
Ein ungerichteter Graph ist ein Paar G = (V, E), das aus einer Knotenmenge V und
einer Kantenmenge E besteht, wobei alle Kanten Teilmengen von V der Größe zwei, also
Paarmengen sind: Für jede Kante e ∈ E gibt es Knoten u, v ∈ V mit u 6= v und
e = {u, v}.
Wir sagen, dass u und v Endknoten von e sind, bzw. dass e die Knoten u und v verbindet.
Die Knoten u, v ∈ V heißen benachbart (bzw. adjazent), wenn {u, v} eine Kante von G
ist. Die Anzahl der Nachbarn eines Knotens u ist der Grad von u. Der Grad eines Graphen
ist der maximale Grad eines Knotens.
In einem gerichteten Graphen sind Kanten geordnete Paare, d.h. es gilt stets E ⊆ V × V .
Die Kante
e = (u, v)
besitzt den Ausgangsknoten u und den Endknoten v; der Knoten v heißt auch ein direkter Nachfolger von u und u heißt direkter Vorgänger von v. Der Ausgangsgrad AusGradG (u) von Knoten u in G (Englisch: outdegree) ist die Anzahl der direkten Nachfolger
von u, also
Aus-GradG (u) = { v ∈ V : (u, v) ∈ V }.
Der Eingangsgrad Ein-GradG (v) von Knoten v in G (Englisch: indegree) ist die Anzahl der
direkten Vorgänger von u, also
Ein-GradG (v) = { u ∈ V : (u, v) ∈ V }.
1.1. BEGRIFFE UND NOTATIONEN
11
Während Kanten für ungerichte Graphen stets zwei verschiedene Knoten verbinden, sind
„Schleifen“ (u, u) für gerichtete Graphen erlaubt.
Wir sagen (für ungerichtete wie auch gerichtete Graphen), dass die Knoten u und v mit der
Kante e inzident sind, wenn u und v Endknoten von e sind, bzw. Anfangs- und Endknoten
von e sind. Schließlich heißt G1 = (V, E1 ) ein Teilgraph von G2 = (V, E2 ), wenn E1 ⊆ E2 ,
wenn also jede Kante von G1 auch eine Kante von G2 ist.
Ein Weg der Länge k in G ist ein Tupel
(v0 , v1 . . . , vk )
von Knoten, so dass {vi−1 , vi } ∈ E, bzw. (vi−1 , vi ) ∈ E. Ein Weg ohne wiederholte Knoten ist
ein einfacher Weg. Die Distanz zwischen zwei Knoten ist die minimale Länge eines Weges
zwischen den beiden Knoten.
Ein Kreis der Länge k ist ein Weg (v0 , . . . , vk ) der Länge k mit v0 = vk und der Eigenschaft,
dass (v0 , . . . , vk−1 ) ein Weg ist. Ein Kreis (v0 , . . . , vk−1 , v0 ) heißt einfach, wenn (v0 , . . . , vk−1 )
ein einfacher Weg ist.
Abbildung 1.1: Der erste Graph ist ein Kreis der Länge 5. Der zweite Graph besteht aus zwei
Kreisen der Länge 3.
Ein Hamilton-Weg ist ein einfacher Weg, der jeden Knoten genau einmal durchläuft, ein
Hamilton-Kreis ist ein einfacher Kreis, der jeden Knoten genau einmal durchläuft, Ein
Euler-Weg ist ein Weg, der jede Kante genau einmal durchläuft, ein Euler-Kreis ist ein
Kreis, der jede Kante genau einmal durchläuft.
Nenne einen Graphen G azyklisch, wenn G keinen einfachen Kreis besitzt. Ein gerichteter
Graph heißt stark zusammenhängend, wenn es für je zwei Knoten u und v einen Weg von
u nach v gibt.
Eine Knotenmenge in einem ungerichteten Graphen ist zusammenhängend, wenn je zwei
Knoten der Menge durch einen Weg verbunden sind. Eine Zusammenhangskomponente
ist eine größte zusammenhängende Knotenmenge. Sei G = (V, E) ein ungerichteter Graph.
Ein Knoten u ∈ V besitzt offenbar genau eine Zusammenhangskomponente, nämlich die
Knotenmenge
ZH(u) = {v ∈ V : es gibt einen Weg von u nach v }.
Beachte, dass damit die Knotenmenge V eine disjunkte Vereinigung der Zusammenhangskomponenten von G ist. Warum? Angenommen, es ist w ∈ ZH(u) ∩ ZH(v). Damit wissen wir, dass
∗
∗
es Wege u → w von u nach w und v → w von v nach w gibt. Ein beliebiger Knoten v 0 ∈ ZH(v)
∗
kann somit durch einen Weg w → v 0 erreicht werden, wenn wir zuerst von w („rückwärts“)
∗
∗
nach v laufen und von dort aus nach v 0 . Also erhalten wir auch einen Weg u → w → v 0 von
u nach v 0 und ZH(v) ⊆ ZH(u) folgt. Analog zeigt man ZH(u) ⊆ ZH(v) und die Gleichheit
ZH(u) = ZH(v) folgt, wann immer ZH(u) und ZH(v) gemeinsame Knoten besitzen.
Ein Wald ist ein ungerichteter Graph ohne einfache Kreise. Ein Baum ist ein zusammenhängender Wald. (Mit anderen Worten, ein Wald ist eine knoten-disjunkte Vereinigung von Bäumen.) Die Knoten mit Grad höchstens Eins heißen Blätter. Ein Wald W heißt ein Spannwald für einen ungerichteten Graphen G, wenn W ein Teilgraph von G ist und wenn G und
12
KAPITEL 1. GRUNDLAGEN
W dieselbe Knotenmenge besitzen; ist W sogar ein Baum, so heißt W ein Spannbaum von
G.
Abbildung 1.2: Ein Wald, der aus drei Bäumen besteht.
Wir erhalten einen gewurzelten Baum T = (V, E) aus einem Baum T 0 = (V, E 0 ), indem
wir einen Knoten r ∈ V als Wurzel auszeichnen und alle Kanten von T 0 „von der Wurzel
weg“ richten.
Genauer, ein gerichteter Graph T = (V, E) ist ein gewurzelter Baum, falls T die folgenden
Eigenschaften besitzt:
1. Es gibt genau einen Knoten r ∈ V mit Ein-GradT (r) = 0: Die Wurzel hat keine eingehenden Kanten.
2. Für jeden Knoten v ∈ V gibt es einen in r beginnenden und in v endenden Weg.
3. Für jeden von der Wurzel verschiedenen Knoten v ∈ V ist Ein-GradT (v) = 1: Bis auf
die Wurzel hat jeder Knoten genau einen Elternknoten.
Sei also T = (V, E) ein gewurzelter Baum. Für jede Kante e = (u, v) ∈ E heißt v ein Kind
von u und u der Elternknoten von v. Ist neben der Kante (u, v) auch (u, w) eine Kante von
B, dann nennen wir w einen Geschwisterknoten von v. Gibt es einen Weg von Knoten u
nach Knoten v, dann heißt u Vorfahre von v und v Nachfahre von u. Knoten vom Grad 1
heißen Blätter. Ein Knoten v ∈ V heißt ein innerer Knoten von T , wenn v kein Blatt ist
und von der Wurzel verschieden ist.
Die Tiefe des Knotens v ist die Länge des Weges von der Wurzel nach v, die Höhe von v ist
die größte Länge eines in v beginnenden Weges. Die Tiefe eines Baums ist die größte Tiefe
eines Blatts, die Höhe eines Baums ist die Höhe der Wurzel.
Ein gewurzelter Baum T = (V, E) heißt binär, wenn Aus-GradT (v) ≤ 2 für jeden Knoten
v ∈ V gilt. Ein vollständiger binärer Baum der Tiefe t ist ein binärer Baum, in dem alle
Blätter die Tiefe t besitzen und alle inneren Knoten wie auch die Wurzel den Aus-Grad genau
2 besitzen.
Ein vollständiger Graph oder eine Clique ist ein ungerichteter Graph, in dem je zwei Knoten benachbart sind. Eine unabhängige Menge ist eine Knotenmenge, in der je zwei Knoten
nicht durch eine Kante verbunden sind. Ein Graph ist bipartit, wenn seine Knotenmenge in
zwei unabhängige Mengen zerlegt werden kann.
Eine konfliktfreie Färbung eines ungerichteten Graphen G = (V, E) ist eine Farbzuweisung
an die Knoten, so dass benachbarte Knoten verschiedene Farben erhalten. Eine konfliktfreie
Färbung zerlegt somit die Knotenmenge in unabhängige Mengen. Die minimale Farbenzahl,
die für die Färbung eines Graphen G benötigt wird, heißt die chromatische Zahl χ(G) von
G.
1.2. WAS IST EIN KORREKTES ARGUMENT?
13
Aufgabe 1
(a) Zeige, dass die Tiefe eines binären Baums mit n Blättern mindestens dlog2 ne beträgt.
(b) Sei B ein binärer Baum mit N Blättern und sei Ti die Tiefe des iten Blatts. Zeige die sogenannte Kraft’sche
Ungleichung
n
X
2−Ti ≤ 1.
i=1
Hinweis: Assoziere einen binären String mit jedem Blatt.
1.2
Was ist ein korrektes Argument?
(Teile dieses Abschnitts orientieren sich an den Abschnitten 2.5 und 2.6 des Skripts „Diskrete
Modellierung“ von Nicole Schweikardt.)
Die theoretische Informatik arbeitet mit mathematischen Methoden, um unumstößliche Aussagen machen zu können. In dieser Veranstaltung möchten wir zum Beispiel zweifelsfreie
Aussagen über das Verhalten von Algorithmen und Datenstrukturen zur Lösung eines algorithmischen Problems angeben. Typische Aussagen sind von der folgenden Form:
Der Algorithmus löst das Problem für alle Eingaben, und für alle Eingaben der
Länge n garantieren die eingesetzten Datenstrukturen eine Laufzeit von höchstens
t(n) Schritten.
Kompliziertere Analysen unterteilen wir in Zwischenbehauptungen, die wir „Lemmas“ nennen und die abschließende Behauptung, die in einem „Satz“ festgehalten wird. Die Zwischenbehauptungen wie auch die abschließende Behauptung müssen natürlich in jeder Situation
richtig sein und durch jeweils einen „Beweis“ untermauert sein. Der Beweis einer Behauptung
darf verwenden:
• etwaige Voraussetzungen der Behauptung,
• Definitionen und bereits bekannte Tatsachen und Sätze,
• im Beweis selbst oder anderswo bereits als wahr bewiesene Aussagen,
• und darf diese Fakten durch logische Schlussregeln verknüpfen.
Das hört sich alles sehr kompliziert an, ist aber höchst einfach: Der Beweis muss aus einer
Folge von einfach nachvollziehbaren Schritten bestehen, die selbst der „Metzger um die Ecke“
nachvollziehen kann und überzeugend findet.
Ziel dieses Abschnitts ist ein kurzer Überblick über die folgenden grundlegenden Beweistechniken, insbesondere:
• direkter Beweis
• Beweis durch Kontraposition
• Beweis durch Widerspruch (indirekter Beweis)
• und vollständige Induktion.
14
KAPITEL 1. GRUNDLAGEN
1.2.1
Direkte Beweise
Bei einem direkten Beweis wird die Behauptung eines Satzes „direkt“, d.h. ohne „Umwege“,
bewiesen. Ein erstes Beispiel ist der Nachweis, dass das arithmetische Mittel stets mindestens
so groß wie das geometrische Mittel ist. Im Verlauf der Vorlesung werden wir viele weitere
Beispiele kennenlernen.
Satz 1.1 Für alle reellen Zahlen a, b ≥ 0 gilt
a+b √
≥ a · b.
2
Zuerst versuchen wir eine Beweisidee zu erhalten.
1. Die Wurzel stört und wir quadrieren:
• Statt
a+b
2
≥
√
2
a · b zeige die Ungleichung ( a+b
2 ) ≥ a · b.
2. Wir multiplizieren aus und erhalten die Ungleichung
a2 +2a·b+b2
4
≥ a · b.
3. Wir multiplizieren mit 4 und erhalten a2 + 2a · b + b2 ≥ 4a · b.
4. Wenn wir 4a · b nach links „bringen“, ist a2 − 2a · b + b2 ≥ 0 zu zeigen.
• a2 − 2a · b + b2 = (a − b)2 gilt.
• Jedes Quadrat ist nicht-negativ und die Ungleichung stimmt!?!
√
a · b eine wahre Aussage
Das ist leider kein Beweis, weil wir aus der Ungleichung a+b
2 ≥
folgern. Hoffentlich haben wir nur mit äquivalenten Umformungen gearbeitet.
Beweis:
1. a2 − 2a · b + b2 = (a − b)2 gilt und a2 − 2a · b + b2 ≥ 0 folgt.
2. Wir addieren 4a · b auf beide Seiten: a2 + 2a · b + b2 ≥ 4a · b gilt ebenfalls.
3. Die linke Seite der Ungleichung stimmt mit (a + b)2 überein: Es gilt also
(a + b)2 ≥ 4a · b.
4. Wir dividieren beide Seiten durch 4 und ziehen die Wurzel:
a+b √
≥ ab
2
folgt und das war zu zeigen.
1.2. WAS IST EIN KORREKTES ARGUMENT?
1.2.2
15
Beweis durch Kontraposition
Der Beweis durch Kontraposition beruht auf der Äquivalenz der beiden Implikationen
wenn Aussage A wahr ist, dann ist auch Aussage B wahr
und
wenn Aussage B falsch ist, dann ist auch Aussage A falsch.
Hier ist ein erstes Beispiel für einen Beweis durch Kontraposition.
Satz 1.2
Für jedes n ∈ N gilt: Falls n2 eine ungerade Zahl ist, so ist auch n eine ungerade Zahl.
Beweis: Durch Kontraposition. Sei n ∈ N beliebig. Falls n ungerade ist, so ist nichts weiter
zu beweisen.
Wir zeigen: Falls n keine ungerade Zahl ist, so ist auch n2 keine ungerade Zahl.
Beachte: Nach Definition ist eine natürliche Zahl m genau dann gerade, wenn es ein k ∈ N
gibt, s.d. m = 2 · k. Daher gilt:
n ist gerade ⇒ es existiert k ∈ N s.d. n = 2 · k
2
(denn n ist gerade)
⇒ es existiert k ∈ N s.d. n = 4 · k = 2 · (2 · k 2 )
⇒ n2 ist gerade
2
(nach Definition gerader Zahlen).
Somit ist n2 gerade, d.h. n2 ist keine ungerade Zahl.
1.2.3
Beweis durch Widerspruch
Man beweist einen Satz der Form
„Falls die Voraussetzungen A erfüllt sind, so gilt Aussage B“
durch Widerspruch dadurch, dass man
• annimmt, dass die Voraussetzungen A erfüllt sind, aber die Aussage B nicht gilt und
• daraus einen Widerspruch herleitet.
Nicht nur Implikationen lassen sich durch Widerspruch beweisen. Möchten wir zum Beispiel
die Aussage B durch Widerspruch beweisen, dann stellen wir uns vor, dass die Implikation
„Wenn 1 = 1, dann gilt Aussage B“ zu zeigen ist: Nimm an, dass die Aussage B nicht gilt
und leite daraus einen Widerspruch her.
Als ein erstes Beispiel für einen Beweis durch Widerspruch betrachten wir folgenden Satz:
Satz 1.3
√
2 ist irrational, also keine rationale Zahl.
16
KAPITEL 1. GRUNDLAGEN
√
Beweis: Durch Widerspruch. Wir nehmen an, dass 2 eine rationale Zahl ist und müssen
einen Widerspruch herleiten.
√
Wenn 2 eine rationale Zahl ist, dann gibt es teilerfremde Zahlen p, q ∈ N mit
√
p
2= .
q
Wir quadrieren und erhalten die Gleichung
p2 = 2 · q 2 .
Also ist p2 eine gerade Zahl. Wir haben aber in Satz 1.2 gezeigt, dass dann auch p gerade
ist. Wenn aber p = 2r, dann folgt p2 = 4r2 = 2q 2 und damit 2r2 = q 2 . Dann ist aber q 2
gerade. Wir wenden wieder Satz 1.2 an und erhalten, dass auch q gerade ist: Die Zahlen p
und q haben den gemeinsamen Teiler 2 im Widerspruch zur Teilerfremdheit
Der griechische Mathematiker Euklid (300 v. Chr.) hat gezeigt, dass es unendliche viele Primzahlen1 gibt. Dieses Resultat ist Grundlage für viele Verfahren der Public-Key Kryptographie.
Mehr über die Public-Key Kryptographie erfahren Sie in der Veranstaltung „Mathematik 2“.
Satz 1.4 (Satz von Euklid) Es gibt unendlich viele Primzahlen.
Beweis: Wir benutzen, dass sich jede natürliche Zahl als Produkt von Primzahlen schreiben
lässt.
Wir nehmen an, dass es nur endlich viele Primzahlen gibt und dass dies die Primzahlen
p1 , . . . , pn sind. Definiere die Zahl
N = p1 · · · pn + 1.
Dann ist N − 1 durch alle Primzahlen teilbar und N kann durch keine Primzahl teilbar sein,
denn Zahlen mit einem gemeinsamen Teiler größer als Eins haben einen Abstand größer als
Eins.
1.2.4
Vollständige Induktion
(Teile dieses Abschnitts orientieren sich am Skript „Diskrete Modellierung“ von Nicole Schweikardt.)
Wir möchten die Aussage A(n) für alle natürlichen Zahlen n zeigen. Dazu ist es ausreichend,
wenn wir
1. im Induktionsanfang die Aussage A(0) zeigen und
2. im Induktionsschritt die Implikation
(A(0) ∧ A(1) ∧ · · · ∧ A(n)) → A(n + 1)
für jedes n ∈ N nachweisen.
1
ist.
Eine Primzahl ist eine natürliche Zahl größer als Eins, die nur durch sich selbst und durch die Eins teilbar
1.2. WAS IST EIN KORREKTES ARGUMENT?
17
Typischerweise, wie auch in Beispiel 1.1, nimmt man „nur“ die Aussage A(n) in der Induktionsannahme an und weist die Aussage A(n + 1) nach. In Beispiel 1.2 müssen wir aber
zum Beispiel die stärkere Induktionsannahme A(n − 1) ∧ A(n) benutzen, um A(n + 1) zeigen
zu können. Um aber diese stärkere Induktionsannahme abrufen zu können, müssen wir im
Induktionsanfang mehr tun und die Aussagen A(1) und A(2) zeigen.
Manchmal gilt eine Aussage A(n) nur für alle Zahlen n ∈ N ab einer Zahl n0 . In einem solchen
Fall zeigt man die Aussage A(n0 ) im Induktionsanfang und behält die Vorgehensweise des
Induktionsschritts bei.
Beispiel 1.1 (Es ist richtig dunkel)
Wir befinden uns in einem stockdunklem Gang, der nach einer Seite unbeschränkt lang ist.
Den Gang können wir nur über die andere Seite verlassen. Was tun, wir kennen noch nicht
einmal die Länge N des Weges bis zum Ende des Ganges? Wie können wir mit möglichst
wenigen Schritten den Gang verlassen?
Wie wär’s mit: Ein Schritt nach „vorn“, zwei zurück, drei nach vorn, vier zurück,
...
Und wieviele Schritte benötigen wir dann, um den Gang zu verlassen? Wir nehmen an, dass
der erste Schritt in die falsche Richtung führt. Nach 2k Wiederholungen sind wir dann insgesamt (−1+2)+(−3+4)+· · ·+(−(2k −1)+2k) = k Schritte in die richtige Richtung gegangen.
Wir müssen N Schritte gehen, um den Gang zu verlassen und müssen deshalb insgesamt
(1 + 2) + (3 + 4) + · · · + (2N − 1 + 2N ) =
2N
X
i
i=1
Schritte zurücklegen. Wir werden mächtig erschöpft sein, denn das sind quadratisch viele
Schritte:
Satz 1.5
n
X
i = 1 + 2 + ... + n =
i=1
n · (n + 1)
.
2
Beweis: Wir geben zwei Argumente und beginnen mit der vollständigen Induktion nach n:
(a) Induktionsanfang für n = 0: Es ist
P0
i=1 i
= 0 und
0·(0+1)
2
= 0. X
(b) Induktionsschritt von n auf n + 1:
n·(n+1)
voraussetzen.
2
Ind.ann. n·(n+1)
=
+ (n + 1) = n·(n+1)+2·(n+1)
= (n+2)·(n+1)
2
2
2
– Wir können die Induktionsannahme
–
Pn+1
Pn
i=1 i + (n + 1)
i=1 i =
(n+1)·(n+2)
.X
2
Pn
i=1 i
=
=
Unser zweites Argument ist ein direkter Beweis: Wir betrachten ein Gitter mit n Zeilen
P
und n Spalten. Das Gitter hat n2 Gitterpunkte. Die Summe ni=1 i stimmt überein mit der
Anzahl der Gitterpunkte unterhalb der Hauptdiagonale und auf der Hauptdiagonale. Die
Hauptdiagonale besitzt n Gitterpunkte und unterhalb der Hauptdiagonale befindet sich die
Hälfte der verbleibenden n2 − n Gitterpunkte. Also folgt
n
X
i=1
i=n+
n · (n + 1)
n2 − n
=
X
2
2
18
KAPITEL 1. GRUNDLAGEN
und auch dieses Argument ist abgeschlossen.
Sind quadratisch viele Schritte wirklich notwendig? Alles auf eine Karte zu setzen, also nur
in eine Richtung zu marschieren, ist Unfug. Aber können wir etwas mutiger sein, als immer
nur einen weiteren Schritt zu wagen?
Zum Beispiel, Ein Schritt nach vorn, zwei zurück, vier nach vorn, acht zurück,
...,
Und wieviele Schritte benötigen wir diesmal, um den Gang zu verlassen? Wir nehmen auch
diesmal an, dass der erste Schritt in die falsche Richtung führt. Nach 2k Wiederholungen sind
wir
(−1 + 2) + (−4 + 8) + · · · + (−22k−2 + 22k−1 )
= −(1 + 4 + · · · + 22k−2 ) + 2 · (1 + 4 + · · · + 22k−2 )
= (1 + 4 + · · · + 22k−2 ) =
k−1
X
4i
i=0
Schritte in die richtige Richtung gegangen und haben insgesamt
(1 + 2) + (4 + 8) + · · · + (22k−2 + 22k−1 ) = (1 + 4 + · · · + 22k−2 ) + 2 · (1 + 4 + · · · + 22k−2 )
= 3 · (1 + 4 + · · · + 22k−2 ) = 3 ·
k−1
X
4i
i=0
Schritte zurückgelegt.
k−1 i
4 < N gelten, da wir
Um den Gang nach 2k + 2 Wiederholungen zu verlassen, muss i=0
sonst den Gang schon nach 2k Wiederholungen verlassen hätten. In der letzten Wiederholung
gehen wir 22k Schritte in die falsche Richtung, kehren mit derselben Schrittzahl wieder um
und gehen die letzten maximal N Schritte. Insgesamt sind wir
P
3·
k−1
X
4i + 2 · 22k + N < 3 ·
i=0
k−1
X
4i + 2 · 4k + N ≤ (3 + 2 · 4) ·
k−1
X
4i + N < 12 · N
i=0
i=0
Schritte gelaufen. Können wir die Analyse verbessern?
Satz 1.6 (Die geometrische Reihe) Für alle n ∈ N gilt
n
X
ai =
i=0
an+1 − 1
,
a−1
falls a 6= 1 eine reelle Zahl ist.
Beweis: Wir geben wieder zwei Argumente und beginnen mit der vollständigen Induktion
nach n:
(a) Induktionsanfang für n = 0:
P0
i=1 a
i
= 1 und
a0+1 −1
a−1
= 1. X
(b) Induktionsschritt von n auf n + 1:
– Wir können die Induktionsannahme
Pn
i
i=1 a
=
an+1 −1
a−1
voraussetzen. Dann ist
1.2. WAS IST EIN KORREKTES ARGUMENT?
–
19
Pn+1 i
Pn
n+1
n+1
n+2 −an+1
n+2
i
n+1 Ind.ann
= a a−1−1 + an+1 = a −1+a
= a a−1−1 X
i=1 a + a
i=1 a =
a−1
Auch hier ist unser zweites Argument ein direkter Beweis:
(a − 1) ·
Pn
i=0 a
i
= a · ni=0 ai − ni=0 ai
Pn+1 i Pn
i
n+1 − a0 = an+1 − 1 .
=
i=0 a = a
i=1 a −
P
P
Jetzt dividiere durch a − 1 und die Behauptung ist gezeigt. X
k−1 i
Wir können unsere Analyse tatsächlich verbessern. Dazu beachte zuerst, dass i=0
4 =
P
k
k
k−1 i
4 −1
4 −1
k
k
k
i=0 4 + 2 · 4 = 3 · 4−1 + 2 · 4 =
4−1 < N und damit 4 − 1 < 3 · N gilt. Deshalb ist 3 ·
P
k−1
3 · (4k − 1) + 2 ≤ 9 · N + 2. Die Gesamtzahl 3 · i=0 4i + 2 · 4k + N der Schritte ist also durch
10 · N + 2 beschränkt.
P
Ende Beispiel 1.1
Vorher quadratisch viele Schritte, jetzt linear viele!
Beispiel 1.2 (Die Fibonacci-Folge)
Ein Bauer züchtet Kaninchen. Jedes weibliche Kaninchen bringt im Alter von zwei Monaten
ein weibliches Kaninchen zur Welt und danach jeden Monat ein weiteres. Wie viele weibliche
Kaninchen hat der Bauer am Ende des n-ten Monats, wenn er mit einem neu geborenen
weiblichen Kaninchen startet? Diese Anzahl bezeichnen wir mit fib(n).
Wie schnell wächst fib(n)? Können wir sogar einen expliziten Ausdruck für fib(n) bestimmen?
Um diese Fragen beantworten zu können, geben wir zuerst eine rekursive Definition, benutzen
also die Grundidee der vollständigen Induktion, um die Folge fib(n) besser zu verstehen.
• Rekursionsanfang für n = 1 und n = 2: Es ist fib(1) := 1 und fib(2) := 1.
• Rekursionsschritt von n − 1 und n nach n + 1: Es ist fib(n + 1) := fib(n) + fib(n − 1)
für alle n ∈ N mit n ≥ 2.
Warum? Genau die fib(n − 1) Kaninchen, die sich im Monat n − 1 im Besitz des Bauern
befinden, haben jeweils einen Nachkommen im Monat n + 1. Des Weiteren besitzt der
Bauer fib(n) Kaninchen im Monat n und diese Kaninchen bleiben auch im Monat n + 1
in seinem Besitz.
Somit gilt:
n
fib(n)
1
1
2
1
3
2
4
3
5
5
6
8
7
13
8
21
9
34
10
55
11
89
12
144
Die Folge fib(n) wird auch Fibonacci-Folge genannt; sie ist benannt nach dem italienischen
Mathematiker Leonardo Fibonacci (13. Jh.). Die Zahl fib(n) heißt auch n-te FibonacciZahl. Wir zeigen, dass
2n/2 ≤ fib(n) ≤ 2n
für alle n ≥ 6 gilt.
Satz 1.7
(a) Für alle natürlichen Zahlen n ≥ 1 gilt fib(n) ≤ 2n .
20
KAPITEL 1. GRUNDLAGEN
(b) Für alle natürlichen Zahlen n ≥ 6 gilt 2n/2 ≤ fib(n).
Beweis: Wir zeigen Teil (a) durch Induktion nach n.
Induktionsanfang: Betrachte n = 1 und n = 2.
Behauptung: fib(1) ≤ 21 und fib(2) ≤ 22 .
Def.
Def.
Beweis: Es gilt: fib(1) = 1 ≤ 2 = 21 und fib(2) = 1 ≤ 4 = 22 . X
Induktionsschritt: n → n + 1
Sei n ∈ N mit n ≥ 2 beliebig.
Induktionsannahme: Für alle natürlichen Zahlen i mit 1 ≤ i ≤ n gilt fib(i) ≤ 2i .
Behauptung: fib(n + 1) ≤ 2n+1 .
Def.
Beweis: fib(n + 1) = fib(n) + fib(n − 1)
Ind.ann.
≤
2n + 2n−1 ≤ 2 · 2n = 2n+1 .
Analog zeigt man auch die Aussage in Teil (b). Allerdings muss man diesmal im Induktionsanfang 2n/2 ≤ fib(n) für n = 6 und n = 7 zeigen.
Aufgabe 2
Zeige: Für alle natürlichen Zahlen n ≥ 6 gilt 2n/2 ≤ fib(n).
Bemerkung 1.1 Es gibt auch einen expliziten Ausdruck für die n-te Fibonacci-Zahl. Für alle
n ∈ N mit n ≥ 1 gilt nämlich:
fib(n) =
1
√ ·
5
√ !n
1+ 5
−
2
√ !n !
1− 5
.
2
(1.1)
Aufgabe 3
Zeige Darstellung (1.1) durch vollständige Induktion nach n.
Hinweis:
√
1+ 5
2
und
√
1− 5
2
erfüllen die quadratische Gleichung x2 = x + 1.
Aufgabe 4
Ein einfaches Polygon ist ein von einem geschlossenen, sich nicht schneidenden, Streckenzug begrenztes, ebenes
geometrisches Objekt. Hier ein Beispiel für ein einfaches Polygon G mit n = 8 Ecken.
r
r
cc
rhhhh
c
hhr
c
cr
r `
G
r `
```
```
`r
Wir möchten ein einfaches Polygon triangulieren, das heißt in disjunkte Dreiecke zerlegen. Dazu können nicht
überschneidende Diagonalen in das einfache Polygon eingefügt werden, wobei eine Diagonale eine im Polygon
verlaufende Strecke ist, die zwei Eckpunkte verbindet. Hier ist ein Beispiel einer möglichen Triangulation des
obigen einfachen Polygons:
1.2. WAS IST EIN KORREKTES ARGUMENT?
21
r
r
Dcc
D c
rhhhh
h
h
r
D
c
cr
C D
r `
G
Dr C
`
```
``` C `Cr
(a) Beweise, dass sich jedes einfache Polygon G mit n Ecken durch n − 3 Diagonalen triangulieren lässt
und, dass dabei n − 2 Dreiecke entstehen.
(b) Beschreibe für allgemeine Eckenzahl n ein einfaches Polygon, bei dem diese Zerlegung eindeutig ist, d.h.
jede Triangulierung besitzt dieselbe Menge von Diagonalen. Aus deiner Beschreibung soll erkennbar sein,
wie man für gegebenes n ein solches einfaches Polygon konstruiert. Argumentiere, warum die Zerlegung
deiner einfachen Polygone eindeutig ist.
Allerdings müssen induktive Beweise sorgfältig geführt werden. Wo steckt der Fehler in den
beiden folgenden Argumenten?
Aufgabe 5
(a) Wir zeigen, dass je zwei natürliche Zahlen a und b gleich sind. Dazu setzen wir k = max{a, b} und führen
eine Induktion nach k. Im Basisschritt haben wir k = 0 und deshalb ist a = 0 = b und das war zu zeigen.
Im Induktionsschritt ist max{a, b} = k + 1, und wir können die Induktionsbehauptung auf a − 1 und b − 1
anwenden, denn max{a − 1, b − 1} = k. Also ist a − 1 = b − 1 und die Behauptung a = b folgt.
(b) Wir zeigen, dass alle Pferde die gleiche Farbe besitzen und führen einen Beweis durch Induktion über
die Zahl k aller Pferde. Im Basisschritt ist k = 1 und die Behauptung ist offensichtlich richtig. Für den
Induktionsschritt nehmen wir an, dass es k + 1 Pferde p1 , . . . , pk+1 gibt. Dann haben aber nach Induktionsvoraussetzung sowohl p1 , p2 , . . . , pk die Farbe von p2 wie auch p2 , . . . , pk+1 ebenfalls die Farbe von p2 : Wir haben
die Behauptung gezeigt.
Analyse rekursiver Programme
Wir untersuchen ein rekursives Programm R(~
p) (mit den Parametern p~) und legen eine Eingabe x fest. Während der Abarbeitung von R(~
p) werden rekursive Aufrufe getätigt, die ihrerseits
weitere rekursive Aufrufe starten und so weiter. Der Rekursionsbaum B modelliert die Struktur all dieser rekursiven Aufrufe. B wird nach den folgenden Regeln gebaut.
1. Beschrifte die Wurzel von B mit den Parametern p~ des Erstaufrufs.
• Wenn innerhalb von R(~
p) keine rekursiven Aufrufe getätigt werden, dann wird die
Wurzel zu einem Blatt.
• Ansonsten erhält die Wurzel für jeden rekursiven Aufruf innerhalb R(~
p) ein neues
Kind, das mit den Parametern des rekursiven Aufrufs beschriftet wird.
2. Wenn ein Knoten v von B mit den Parametern ~q beschriftet ist, gehen wir mit v genauso
wie mit der Wurzel vor.
• Wenn innerhalb von R(~q) keine rekursiven Aufrufe getätigt werden, wird v zu
einem Blatt.
• Ansonsten erhält v für jeden rekursiven Aufruf innerhalb von R(~q) ein neues Kind,
das mit den Parametern des rekursiven Aufrufs beschriftet wird.
Die Anzahl der Knoten von B stimmt überein mit der Anzahl aller rekursiven Aufrufe für
Eingabe x.
22
KAPITEL 1. GRUNDLAGEN
Beispiel 1.3 (Berechnung der nten Fibonacci-Zahl)
Wir möchten die nte Fibonacci-Zahl fib(n) für eine natürliche Zahl n ≥ 1 berechnen und tun
dies mit zwei verschiedenen Algorithmen. Welcher Algorithmus ist schneller?
Algo1(n):
(a) Falls n = 1, dann gib Algo1(1) := 1 als Ergebnis zurück.
(b) Falls n = 2, dann gib Algo1(2) := 1 als Ergebnis zurück.
(c) Falls n ≥ 3, dann gib Algo1(n) := Algo1(n − 1) + Algo1(n − 2) als Ergebnis
zurück.
Wenn wir jede Addition, jeden Vergleich, und jedes Zurückgeben eines Ergebnisses als einen
Schritt zählen, dann benötigt dieser rekursive Algorithmus bei Eingabe einer Zahl n genau
g1 (n) Schritte, wobei
g1 (1) = 2 und
g1 (2) = 3
und
g1 (n) = 3 + g1 (n − 1) + g1 (n − 2) + 2
= 5 + g1 (n − 1) + g2 (n − 2)
für alle n ∈ N mit n ≥ 3.
Ein anderer Algorithmus, der für eine natürliche Zahl n ≥ 1 den Wert fib(n) berechnet, ist:
Algo2(n):
(a) Falls n = 1 oder n = 2, dann gib 1 als Ergebnis zurück.
(b) Seien a0 := 0, a1 := 1 und a2 := 1.
(c) Wiederhole für alle i von 3 bis n:
(d)
Ersetze a0 durch a1 und a1 durch a2 .
(e)
Ersetze a2 durch a0 + a1 .
(f) Gib den Wert a2 als Ergebnis zurück.
Dieser Algorithmus benötigt bei Eingabe n ≥ 1 genau g2 (n) := 6+5·(n−2) Schritte. (Ähnlich
wie oben zählen wir jeden Vergleich, jedes Zurückgeben eines Werts und jedes Setzen eines
Werts als einen Schritt. Für jeden Schleifendurchlauf berechnen wir zusätzlich zwei Schritte,
um den Wert von i um eins zu erhöhen und zu testen, ob das Ergebnis kleiner oder gleich n
ist).
1. Frage: Welchen Algorithmus nehmen wir?
Offensichtlich gilt g1 (n) ≥ fib(n). Wir wissen aber schon aus Beispiel 1.2, dass fib(n) ≥ 2n/2
für n ≥ 6 gilt. Der elegante rekursive Algo1 besitzt eine exponentielle Laufzeit und ist absolut
gräßlich, während sein unscheinbarer Kollege Algo2 mit „linearer Laufzeit“ glänzt.
2. Frage: Wie sehen die Rekursionsbäume für Algo1 und Algo2 aus?
Der Rekursionsbaum für Algo1(n) ist ein markierter binärer Baum der wie folgt rekursiv
definiert ist. Die Rekursionsbäume für n = 1 und n = 2 bestehen nur aus einem einzigen
Knoten der jeweils mit „1“, bzw. „2“ markiert ist. Kennen wir die Rekursionsbäume Bn−2
für n − 2 und Bn−1 für n − 1, dann erhalten wir den Rekursionsbaum Bn für n, indem wir
1.2. WAS IST EIN KORREKTES ARGUMENT?
23
n
n−1
n−2
Bn−2
n−3
n−2
Bn−3
Bn−2
Abbildung 1.3: Die rekursive Definition des Baums Bn
1
2
3
1 2
4
2
5
3
1 2
3
1 2 2
6
4
5
4
3
1 2
2
3
3
1 2 1 2 2
4
3
1 2
Abbildung 1.4: Die „Fibonacci-Bäume“ B1 , B2 , B3 , B4 , B5 und B6 .
die Wurzel r von Bn mit n markieren, die Wurzel von Bn−2 zum linken Kind und die Wurzel
von Bn−1 zum rechten Kind von r machen.
Der Baum Bn hat „beinahe“ die Graph-Struktur eines vollständigen Binärbaums, aber der
linke Baum Bn−2 ist nicht so tief wie der rechte Baum Bn−1 . Die Wurzel „berechnet“ fib(n),
das linke Kind fib(n−2) und das rechte Kind fib(n−1). Und jetzt wird auch offensichtlich wie
idiotisch sich Algo2 verhält, denn um fib(n − 1) im rechten Kind der Wurzel zu berechnen,
wird fib(n−3) aber auch fib(n−2) neu berechnet, obwohl fib(n−2) im linken Kind der Wurzel
bereits berechnet wurde. Als ein weiteres Beispiel: Die Fibonacci-Zahl fib(2) tritt 5-mal in B6
auf!
Diesen Fehler macht Algo2 nicht, denn jede Fibonacci-Zahl wird genau einmal berechnet.
Algo2 ist ein iteratives Programm und besitzt deshalb natürlich keinen Rekursionsbaum,
seine Vorgehensweise wird aber am besten durch einen Weg n → n − 1 → n − 2 → · · · → 2
wiedergegeben. Dieser Weg ist nur ein „klitzekleiner“ Teilbaum von Bn , die restlichen Knoten
von Bn führen alle unnötige Neuberechnungen bereits bekannter Fibonacci-Zahlen durch.
Beispiel 1.4 (Binärsuche)
Ein Array A = (A[1], . . . , A[n]) von n Zahlen und eine Zahl x ist gegeben. Wir möchten
wissen, ob und wenn ja wo die Zahl x in A vorkommt.
Wenn A nicht sortiert ist, dann bleibt uns nichts anderes übrig als uns alle Zellen von A auf
der Suche nach x anzuschauen. Wir führen eine lineare Suche durch, die im schlimmsten
Fall alle n Zellen des Arrays inspizieren muss. Wenn das Array aber aufsteigend sortiert ist,
dann können wir Binärsuche anwenden.
void Binärsuche( int unten, int oben){
24
KAPITEL 1. GRUNDLAGEN
if (oben < unten)
std::cout « x « “ wurde nicht gefunden.“
« std::endl;
int mitte = (unten+oben)/2;
if (A[mitte] == x)
std::cout « x « “ wurde in Position “ « mitte « “ gefunden.“ « std::endl;
else {
if (x < A[mitte])
Binärsuche(unten, mitte-1);
else
Binärsuche(mitte+1,oben);}}
1. Frage: Ist Binärsuche korrekt?
Es sei n = oben − unten + 1. Wir geben einen Beweis mit vollständiger Induktion nach n.
(a) Induktionsanfang für n = 0: Es ist n = oben − unten + 1 = 0 und oben < unten
folgt. In diesem Fall wird Binärsuche(unten, oben) richtigerweise mit der Antwort „x
wurde nicht gefunden“ abbrechen. X
(b) Induktionsschritt n → n + 1: Es ist oben − unten + 1 = n + 1. Wenn A(mitte) mit
x übereinstimmt, dann wird richtigerweise mit Erfolgsmeldung abgebrochen.
Ansonsten sucht Binärsuche richtigerweise in der linken Hälfte, wenn x < A[mitte],
und sonst in der rechten Hälfte. Die rekursive Suche in der linken bzw. rechten Hälfte
verläuft aber nach Induktionsannahme korrekt. X
Wir fordern n = 2k − 1 für eine Zahl k ∈ N. Sei T (n) die maximale Anzahl von Zellen, die
Binärsuche für ein sortiertes Array von n Zahlen inspiziert.
2. Frage: Wie groß ist T (n)?
Hier ist eine rekursive Definition von T (n):
(a) Rekursionsanfang: T (0) = 0.
(b) Rekursionsschritt: T (n) = T ( n−1
2 ) + 1.
k
2 −2
Wir haben n = 2k − 1 gefordert. Beachte, dass n−1
= 2k−1 − 1 gilt. Nach jedem
2 =
2
rekursiven Aufruf wird der Exponent k also um 1 erniedrigt und T (2k − 1) = k „sollte“
folgen. Wir zeigen T (2k − 1) = k mit vollständiger Induktion nach k.
(a) Induktionsanfang: T (20 − 1) = T (0) = 0. X
(b) Induktionsschritt: T (2k+1 − 1) = T (2k − 1) + 1
Induktionsannahme
=
k + 1. X
1.2. WAS IST EIN KORREKTES ARGUMENT?
25
Und was bedeutet das jetzt? Binärsuche muss höchstens k Zahlen inspizieren gegenüber bis zu
2k −1 Zahlen für die lineare Suche: Die lineare Suche ist exponentiell langsamer als Binärsuche.
3. Frage: Wie sieht der Rekursionsbaum B für ein Array A und einen Schlüssel y aus, der
nicht in A vorkommt?
Wir nehmen wieder an, dass das Array A genau n = 2k − 1 Schlüssel für eine Zahl k ∈ N
besitzt. Beachte, dass ein Knoten von B entweder ein Blatt ist oder genau einen rekursiven
Aufruf verursacht. Der Rekursionsbaum B besitzt also den Aus-Grad Eins.
Wir wissen bereits, dass Binärsuche im schlimmsten Fall k Zellen inspiziert. Da der Schlüssel
y nicht in A vorkommt, tritt der schlimmste Fall ein und es werden genau k Zellen inspiziert.
In jedem rekursiven Aufruf der Binärsuche wird nur eine Zelle des Arrays inspiziert, nämlich
die mittlere Zelle des Array-Abschnitts in dem gegenwärtig gesucht wird.
Der Rekursionsbaum B ist also ein markierter Weg der Länge k.
Binärsuche ist schnell, weil stets höchstens ein rekursiver Aufruf getätigt wird und weil die
Länge des Array-Abschnitts in dem gesucht wird, mindestens halbiert wird.
Beispiel 1.5 (Türme von Hanoi)
Wir haben drei Stäbe mit den Nummern 1, 2 und 3. Ursprünglich liegen N Ringe auf Stab
1, wobei die Ringe in absteigender Größe auf dem Stab aufgereiht sind: Der größte Ring von
Stab 1 ist also der unterste Ring. Die Stäbe 2 und 3 sind zu Anfang leer.
In einem Zug können wir einen zuoberst liegenden Ring von einem Stab auf einen anderen
bewegen. Der Zug ist nur dann erlaubt, wenn der Ring auf einen größeren Ring gelegt wird
oder wenn der Stab leer ist. Alle Ringe sollen am Ende auf Stab 2 liegen.
Stab 1
Stab 2
Stab 3
Stab 1
Stab 2
Stab 3
Das folgende in Pseudocode geschriebene rekursive Programm soll dieses Ziel für N ≥ 1
erreichen.
void Hanoi( int N, int stab1, int stab2, int stab3)
// Annahmen: Auf allen Stäben sind die Ringe der Größe nach geordnet.
// Jeder der oberen N Ringe auf Stab „stab1“ passt auf Stab „stab2“ und „stab3“.
// Die Folge (stab1,stab2,stab3) ist eine Permutation der Zahlen 1,2 und 3.
{if (N==1)
bewege den obersten Ring von Stab „stab1“ nach Stab „stab2“;
else {
Hanoi(N-1,stab1,stab3,stab2);
bewege den obersten Ring von Stab „stab1“ nach Stab „stab2“;
Hanoi(N-1,stab3,stab2,stab1); }}
26
KAPITEL 1. GRUNDLAGEN
1. Frage: Ist Hanoi(N-1,stab1,stab2, stab3) korrekt?
Wir zeigen mit vollständiger Induktion nach N : Für jede Permutation (stab1,stab2,stab3) der
drei Stäbe wird „Hanoi (N, stab1, stab2, stab3)“ die obersten N Ringe von stab1 auf stab2
bewegen ohne andere Ringe anzufassen. Vorausgesetzt wird, dass jeder der obersten N Ringe
von stab1 auf die beiden anderen Stäbe passt.
Beachte, dass wir eine stärkere Aussage behaupten als auf den ersten Blick notwendig zu
sein scheint: Wir behaupten nämlich die Richtigkeit für alle(!) Permutationen der drei Stäbe.
Diese verschärfte Behauptung ist auch notwendig, um Aussagen über die beiden rekursiven
Aufrufe machen zu können. Die Formulierung einer verschärften Aussage ist charakteristisch
für viele Induktionsbeweise.
Induktionsanfang für N = 1. Richtigerweise wird der eine zuoberst liegende Ring von
„stab1“ nach „stab2“ bewegt.
Induktionsschritt von N auf N + 1: Wir können in der Induktionsannahme voraussetzen,
dass „Hanoi(N, stab1, stab2,stab3)“ – für jede Permutation (stab1,stab2,stab3) der drei Stäbe
– die N obersten Ringe von „stab1“ nach „stab2“ bewegt ohne andere Ringe anzufassen.
Im ersten rekursiven Aufruf wird „Hanoi(N, stab1, stab3,stab2)“, nach Induktionsannahme,
die obersten N Ringe von „stab1“ nach „stab3“ bewegen. Der jetzt zuoberst liegende Ring
von „stab1“ wird auf „stab2“ gelegt: Nach Annahme passt dieser Ring auf „stab2“.
Da dieser Ring der größte der ursprünglichen N + 1 obersten Ringe von „stab1“ ist, passen
alle jetzt auf „stab3“ hinzu gepackten Ringe auf „stab1“ und „stab2“. Der zweite und letzte rekursive Aufruf „Hanoi(N, stab3, stab2,stab1)“ wird deshalb nach Induktionsannahme
alle durch den ersten rekursiven Aufruf auf „stab3“ bewegten Ringe erfolgreich auf „stab2“
bewegen: Damit liegen die ursprünglich obersten N + 1 Ringe von „stab1“ jetzt auf „stab2“.
2. Frage: Wieviele Ringbewegungen führt Hanoi(N-1,stab1,stab2, stab3) aus?
Sei T(N) die Anzahl der Ringbewegungen nach Aufruf des Programms Hanoi(N,stab1,stab2,stab3).
(Beachte, dass diese Anzahl nicht von der Permutation (stab1,stab2,stab3) abhängt.) Wir geben eine rekursive Definition von T(N) an.
(a) Rekursionsanfang: Es ist T (1) = 1 und
(b) Rekursionsschritt: Es ist T (N ) = 2 · T (N − 1) + 1.
Und wie sieht ein expliziter Ausdruck für T (N ) aus? Es ist T (1) = 1, T (2) = 3, T (3) =
7, T (4) = 15 und das sieht ganz so aus als ob T (N ) = 2N − 1 gilt. Wir verifizieren unsere
Vermutung mit vollständiger Induktion nach N .
(a) Induktionsanfang für N = 1: Unser Programm bewegt einen Ring und 1 = 21 − 1. X
(b) Induktionsschritt von N auf N + 1: Wir können in der Induktionsannahme voraussetzen, dass T (N ) = 2N − 1 gilt. Dann folgt
T (N + 1) = 2 · T (N ) + 1
und das war zu zeigen. X
Ind.ann
=
2 · (2n − 1) + 1 = 2N +1 − 1
1.3. SCHATZTRUHE
27
3. Frage: Wie sieht der Rekursionsbaum B für Hanoi(N,1,2,3) aus?
Es werden zwei rekursive Aufrufe mit dem Parameter N − 1 getätigt. Der Rekursionsbaum
B hat also die Graph-Struktur eines Binärbaums.
Mit vollständiger Induktion über N zeigt man, das B die Graph-Struktur eines vollständigen
Binärbaums der Höhe N − 1 besitzt: Trifft diese Aussage für die beiden rekursiven Aufrufe
zu, dann gilt sie auch für den „Master-Aufruf“. Die Anzahl der Ringbewegungen ist so groß,
weil für N > 1 stets zwei rekursive Aufrufe getätigt werden, wobei der Parameter N nur um
Eins reduziert wird:
B ist ein vollständiger Binärbaum der Höhe N − 1 und besitzt 2N +1 − 1 Knoten.
1.3
Schatztruhe
Wir geben geschlossene Ausdrücke für Summen an und bestimmen die Größe häufig auftretender Mengen.
1.3.1
Geschlossene Ausdrücke für Summen
Lemma 1.8 (Summenformeln) Für alle natürlichen Zahlen n ≥ 0 gilt:
(a)
n
X
i=
i=0
(b)
n
X
n · (n + 1)
2
i2 =
i=0
(c)
n
X
(
i
a =
i=0
(d)
∞
X
i=0
1
· n · (n + 1) · (2n + 1).
6
ai =
an+1 −1
a−1
n+1
falls a 6= 1
sonst
1
für eine reelle Zahl a mit −1 < a < 1.
1−a
Beweis: Teil (a) wird in Satz 1.5 und Teil (c) in Satz 1.6 gezeigt. Teil (d) folgt aus Teil (c),
da
an+1 − 1
1
=
.
lim
n→∞ a − 1
1−a
Teil (c) zeigt man mit vollständiger Induktion nach n.
1.3.2
Größe von endlichen Mengen
Zur Erinnerung: Für eine endliche Menge M bezeichnen wir die Anzahl der Elemente von M
mit |M |. Seien A und B endliche Mengen. Dann gilt:
|A| = |B| ⇔ es gibt eine bijektive Funktion von A nach B.
28
KAPITEL 1. GRUNDLAGEN
Der Binomialkoeffizient
setzen wir
n
k
ist für natürliche Zahlen n, k mit 0 ≤ k ≤ n definiert und zwar
n
k
!
=
n!
,
k! · (n − k)!
wobei 0! := 1 und r! := 1 · 2 · · · r für alle natürlichen Zahlen r ≥ 1.
Binomialkoeffizienten treten im binomischen Lehrsatz beim
Ausmultiplizieren der Potenz (a+
b)n auf. Desweiteren werden wir gleich sehen, dass nk mit der Anzahl von k-elementigen
Teilmengen einer n-elementigen Menge übereinstimmt.
Lemma 1.9 (Binomialkoeffizienten) Für alle natürlichen Zahlen n, k ∈ N mit k ≤ n
gilt:
!
(a)
n
k
!
(b)
n
k
!
(c)
n
k
!
!
=
n−1
n−1
+
, falls k ≥ 1
k
k−1
=
n
n−k
=
n−1
n
·
falls k ≥ 1.
k−1
k
!
und
!
(d) Binomischer Lehrsatz: Es gilt
n
(a + b) =
n
X
k=0
!
n k n−k
a b
.
k
Beweis: Die Aussagen (a), (b) und (c) lassen sich mit einem direkten Beweis verifizieren. Der
binomische Lehrsatz kann mit vollständiger Induktion nach n gezeigt werden.
Aufgabe 6
Beweise den binomischen Lehrsatz. Nimm dazu die Teile (a), (b) und (c) aus Lemma 1.9 an.
Satz 1.10 Die Kardinalität wichtiger Mengen
(a) Sei M eine Menge von n Elementen.
1. M hat genau
n
k
Teilmengen der Größe k
2. und es ist |P(M )| = 2n , M hat also genau 2n Teilmengen.
(b) Sei k ∈ N>0 und seien M1 , . . . , Mk endliche Mengen. Dann gilt:
| M1 × · · · × Mk | =
k
Y
|Mi |.
i=1
(c) A und B seien endliche Mengen. Dann gibt es genau |B||A| Funktionen f : A → B:
|Abb(A, B)| = |B||A| .
1.3. SCHATZTRUHE
29
Beweis: (a1) Ohne Beschränkung der Allgemeinheit nehmen wir S = {1, . . . , n} an und
führen einen Beweis durch vollständige Induktion nach n.
Für den Induktionsanfang n= 1 ist nur zu beobachten, dass es genau eine Menge mit keinen
Elementen gibt und es ist 10 = 1. Desweiteren gibt es genau eine Menge mit einem Element,
nämlich die Menge selbst und es ist 11 = 1.
Für den Induktionsschritt unterscheiden wir, ob eine k-elementige Teilmenge T ⊆ S das
Element n enthält oder nicht. Wenn ja, dann ist T \ {n} eine (k − 1)-elementige
Teilmenge
von {1, . . . , n − 1} und nach Induktionsvoraussetzung gibt es genau n−1
(k
−
1)-elementige
k−1 Teilmengen von {1, . . . , n − 1}. Wenn nein, dann verbleiben genau n−1
Teilmengen, denn
k
wir müssen die k-elementigen Teilmengen
von
{1,
.
.
.
,
n
−
1}
zählen.
Die
Behauptung folgt
n−1
n−1
n
jetzt aus Teil (b), denn es ist k−1 + k = k .
(a2) Wir
wenden den binomischen Lehrsatz für a = b = 1 an und erhalten nk=0 nk = 2n .
n
Aber k stimmt überein mit der Anzahl der Teilmengen von M der Mächtigkeit k und
Pn
n
k=0 k ist die Anzahl der Teilmengen von M .
P
(b) Wende vollständige Induktion nach k an.
(c) Wir konstruieren eine bijektive Funktion
b : Abb(A, B) → B |A| ,
von der Menge aller Abbildungen f : A → B in das |A|-fache Potenz der Menge B: Definiere
nämlich b(f ) als die Funktionstabelle von f , die in „Position“ a ∈ A den Funktionswert f (a)
vermerkt. Funktionstabellen sind |A|-Tupel mit Komponenten in B, da für jedes Argument
a ∈ A der Funktionswert f (a) ∈ B vermerkt wird.
Warum ist b bijektiv? Weil Funktionstabellen nur eine andere Darstellung der Funktionen
sind. Die Behauptung folgt jetzt aus Teil (b).
Beispiel 1.6 (Die Fakultät) n Teilnehmer nehmen an einem Rennen teil. Wieviele verschiedene Reihenfolgen gibt es für den Zieleinlauf? Wir beschreiben die Anzahl
fak(n)
der verschiedenen Reihenfolgen mit einer rekursiven Definition.
• Rekursionsanfang für n = 1: Es ist fak(1) := 1.
• Wir überlegen uns zuerst, dass es bei n+1 Teilnehmern genau n+1 verschiedene Gewinner des Rennens geben kann. Wenn wir aber den Gewinner kennen, dann gibt es genau
fak(n) verschiedene Reihenfolgen für den Zieleinlauf der verbleibenden n Teilnehmer.
Rekursionsschritt von n auf n + 1: Es ist fak(n + 1) := (n + 1) · fak(n).
Wir behaupten, dass
fak(n) = n · (n − 1) · (n − 2) · · · · · 2 · 1 =
n
Y
i
i=1
gilt und beweisen diese Behauptung mit vollständiger Induktion. Der Induktionsanfang
für n = 1 ist klar, denn nach Definition ist fak(1) = 1.
30
KAPITEL 1. GRUNDLAGEN
Der Induktionsschritt von n auf n + 1 ist auch klar, denn es ist fak(n) = n · (n −
1) · (n − 2) · · · · · 2 · 1 nach Induktionsannahme und die Behauptung fak(n + 1) =
(n + 1) · n · (n − 1) · (n − 2) · · · · · 2 · 1 folgt aus der Definition fak(n + 1) := (n + 1) · fak(n).
Notation: Die Funktion fak : N>0 → N wird Fakultät genannt. Meistens schreibt man n!
statt fak(n) und spricht n! als „n Fakultät“ aus.
Ende Beispiel 1.6
Definition 1.1 M sei eine endliche Mengen. Eine bijektive Funktion f : M → M wird auch
eine Permutation der Menge M genannt.
Wieviele Permutationen besitzt eine endliche Menge M ?
Satz 1.11 M, M1 , M2 seien Mengen mit n Elementen.
(a) Es gibt genau n! bijektive Funktionen f : M1 → M2 .
(b) Die Menge M besitzt genau n! Permutationen.
Wenn M1 die Menge der n Teilnehmer eines Rennens ist, dann entspricht eine bijektive Funktion f : M1 → {1, . . . , n} einer möglichen Reihenfolge im Zieleinlauf. Teil (a) verallgemeinert
also unser Ergebnis über die Anzahl verschiedener Zieleinläufe. Beachte, dass auch Teil (b)
eine Konsequenz von Teil (a) ist, wenn wir nämlich M1 := M und M2 := M setzen.
Beweis: Wir können unsere Argumentation für die Anzahl der verschiedenen Reihenfolgen
beim Zieleinlauf übernehmen, denn die Anzahl b(n) der bijektiven Funktionen zwischen zwei
n-elementigen Mengen besitzt die rekursive Definition
b(1) := 1, b(n + 1) := (n + 1) · b(n)
und diese rekursive Definition stimmt mit der rekursiven Definition der Fakultät überein. Aufgabe 7
Ein Handlungsreisender muss jede von n Städten genau einmal besuchen. Gesucht ist eine Rundreise minimaler
Länge. Wieviele verschiedene Rundreisen gibt es?
1.4
Einige Grundlagen aus der Stochastik
Wir werden in dieser Vorlesung meistens die pessimistische Sicht des Worst-Case-Szenarios
analysieren. Das heißt, wir werden uns bei der Analyse von Lösungsstrategien fragen, was
schlimmstenfalls geschehen könnte. Manchmal verzerrt dieser Blick aber die wahren Gegebenheiten zu stark, und eine Betrachtung dessen, was man vernünftigerweise erwarten sollte,
ist geboten. Insbesondere verliert die Worst-Case-Analyse drastisch an Wert, wenn der WorstCase extrem unwahrscheinlich ist.
Eine kurze Wiederholung elementarer Begriffe der Stochastik ist daher angebracht. Wir
konzentrieren uns auf endliche Wahrscheinlichkeitsräume. Also ist eine endliche Menge Ω von Elementarereignissen gegeben sowie eine Wahrscheinlichkeitsverteilung p,
die jedem Elementarereignis e ∈ Ω die Wahrscheinlichkeit p(e) zuweist. Desweiteren muss
P
p(e) ≥ 0 für alle e ∈ Ω gelten. Ein Ereignis E ist eine Teilmenge von Ω
e∈Ω p(e) = 1 und
P
und prob[E] = e∈E p(e) ist die Wahrscheinlichkeit von E.
1.4. EINIGE GRUNDLAGEN AUS DER STOCHASTIK
31
Beispiel 1.7 Wir wählen die Menge der 37 Fächer eines Roulettspiels als unsere Menge von
Elementarereignissen. Die Ereignisse gerade, ungerade, rot oder schwarz können dann als Vereinigung von Elementarereignissen beschrieben werden. Die Wahrscheinlichkeit eines solchen
Ereignisses ergibt sich aus der Summe der jeweiligen Elementarereignisse.
Lemma 1.12 (Rechnen mit Wahrscheinlichkeiten) Seien A und B Ereignisse über dem
endlichen Wahrscheinlichkeitsraum Ω = {e1 , . . . , en } und sei p = (p1 , . . . , pn ) eine Wahrscheinlichkeitsverteilung.
(a) prob[A ∩ B] =
P
(b) prob[A ∪ B] =
P
e∈A∩B
e∈A∪B
p(e). Insbesondere ist 0 ≤ prob[A ∩ B] ≤ min{prob[A], prob[B]}.
p(e). Insbesondere ist
max{prob[A], prob[B]} ≤ prob[A ∪ B]
= prob[A] + prob[B] − prob[A ∩ B] ≤ prob[A] + prob[B].
(c) prob[¬A] =
P
e∈A
/ p(e)
= 1 − prob[A].
Erwartungswerte spielen bei der Analyse von erwarteten Laufzeiten eine zentrale Rolle. Die
allgemeine Definition ist wie folgt.
Definition 1.2 (a) Die Menge A ⊆ R sei gegeben. Eine Zufallsvariable X : Ω → A wird
durch eine Wahrscheinlichkeitsverteilung (q(a) : a ∈ A) spezifiziert. Wir sagen, dass q(a) die
Wahrscheinlichkeit des Ereignisses X = a ist.
(b) Sei X eine Zufallsvariable und sei q(a) die Wahrscheinlichkeit für das Ereignis X = a.
Dann wird der Erwartungswert von X durch
E[X] =
X
a · q(a)
a∈A
definiert.
Die möglichen Ausgänge a der Zufallsvariable werden also mit ihrer Wahrscheinlichkeit gewichtet und addiert. Eine zentrale Eigenschaft des Erwartungswerts ist seine Additivität.
Lemma 1.13 Für alle Zufallsvariablen X und Y ist E[X + Y ] = E[X] + E[Y ].
Der Informationsgehalt eines Erwartungswertes hängt dabei vom konkreten Experiment ab.
Dass man bei einem handelsüblichen Würfel eine 3.5 erwartet ist eine wenig nützliche Information. Dass der erwartete Gewinn bei einem Einsatz von 10 Euro auf rot am Roulettetisch
19
18
37 · 20Euro + 37 · 0Euro = 9.73Euro ist, hat dagegen die nützliche Botschaft: Finger weg.
Aufgabe 8
Wir betrachten die Menge Ω = {1, 2, . . . , n}. In einem ersten Experiment bestimmen wir eine Menge A ⊆ Ω,
indem wir jedes Element aus Ω mit Wahrscheinlichkeit pA in A aufnehmen. Wir wiederholen das Experiment
und bilden eine Menge B, wobei wir jedes Element aus Ω mit Wahrscheinlichkeit pB in B aufnehmen.
(a) Bestimme E(|A ∩ B|), den Erwartungswert der Mächtigkeit der Schnittmenge.
(b) Bestimme E(|A ∪ B|), den Erwartungswert der Mächtigkeit der Vereinigungsmenge.
32
KAPITEL 1. GRUNDLAGEN
Aufgabe 9
Wir spielen ein Spiel gegen einen Gegner. Der Gegner denkt sich zwei Zahlen aus und schreibt sie für uns nicht
sichtbar auf je einen Zettel. Wir wählen zufällig einen Zettel und lesen die darauf stehende Zahl. Sodann haben
wir die Möglichkeit, diese Zahl zu behalten oder sie gegen die uns unbekannt gebliebene Zahl zu tauschen. Sei
x die Zahl, die wir am Ende haben, und y die andere. Dann ist unser (möglicherweise negativer) Gewinn x − y.
- Wir betrachten Strategien St der Form „Gib Zahlen < t zurück und behalte diejenigen ≥ t“. Analysiere
den Erwartungswert Ex,y (Gewinn(St )) des Gewinns dieser Strategie in Abhängigkeit von t, x und y.
- Gib eine randomisierte Strategie an, die für beliebige x 6= y einen positiven erwarteten Gewinn für uns
aufweist.
Häufig untersuchen wir wiederholte Zufallsexperimente. Wenn die Wiederholungen unabhängig voneinander sind, hilft die Binomialverteilung weiter.
Lemma 1.14 (Binomialverteilung) Sei A ein Ereignis, welches mit Wahrscheinlichkeit p
auftritt. Wir führen n Wiederholungen des betreffenden Experimentes durch und zählen, wie
häufig ein Erfolg eintritt, das heißt wie häufig A eingetreten ist. Die Zufallsvariable X möge
genau dann den Wert k annehmen, wenn k Erfolge vorliegen.
(a) Die Wahrscheinlichkeit für k Erfolge ist gegeben durch
!
prob[X = k] =
n
· pk · (1 − p)n−k .
k
(b) Die Wahrscheinlichkeit, dass die Anzahl der Erfolge im Intervall [a, b] liegt ist also
prob[X ∈ [a, b] ] =
b
X
k=a
!
n
· pk · (1 − p)n−k .
k
(c) E[X] = n · p ist die erwartete Anzahl der Erfolge.
Damit haben wir den Erwartungswert einer binomialverteilten Zufallsvariable berechnet. Zufallsvariablen mit prinzipiell unendlich vielen Ausgängen werden uns zum Beispiel immer dann
begegnen, wenn wir uns fragen, wie lange man auf das Eintreten eines bestimmten Ereignisses
warten muss. Warten wir zum Beispiel am Roulettetisch auf die erste 0 des Abends, so gibt es
keine Anzahl von Runden, so dass die erste 0 innerhalb dieser Rundenzahl gefallen sein muss.
Natürlich wird aber anhaltendes Ausbleiben immer unwahrscheinlicher und deswegen ergibt
sich trotzdem ein endlicher Erwartungswert. Wir haben damit die geometrische Verteilung
beschrieben.
Lemma 1.15 (geometrische Verteilung) Sei A ein Ereignis mit Wahrscheinlichkeit p.
Die Zufallsvariable X beschreibe die Anzahl der Wiederholungen des Experimentes bis zum
ersten Eintreten von A.
(a) Die Wahrscheinlichkeit, dass X den Wert k annimmt ist
prob[X = k] = (1 − p)k−1 · p.
(b) Der Erwartungswert ist E(X) = p1 .
1.5. LITERATUR
33
Aufgabe 10
Wir nehmen in einem Casino an einem Spiel mit Gewinnwahrscheinlichkeit p = 1/2 teil. Wir können einen
beliebigen Betrag einsetzen. Geht das Spiel zu unseren Gunsten aus, erhalten wir den Einsatz zurück und
zusätzlich denselben Betrag aus der Bank. Endet das Spiel ungünstig, verfällt unser Einsatz. Wir betrachten
die folgende Strategie:
i:=0
REPEAT
setze 2i $
i:=i+1
UNTIL(ich gewinne zum ersten mal)
Bestimme den erwarteten Gewinn dieser Strategie und die erwartete notwendige Liquidität (also den Geldbetrag, den man zur Verfügung haben muss, um diese Strategie ausführen zu können).
1.5
Literatur
Die folgenden Textbücher sind besonders empfehlenswert.
- M. Sipser, Introduction to the Theory of Computation, Paperback 3rd edition, Cengage
Learning, 2012.
- U. Schöning, Theoretische Informatik - kurzgefasst, Spektrum 2008.
- Sanjeev Arora und Boaz Barak, Computational Complexity, a modern approach, Cambridge University Press 2009.
- I. Wegener, Theoretische Informatik: Eine algorithmenorientierte Einführung, B.G. Teubner 1999 (2. Auflage).
- J. Shallit, A second course in Formal Languages and Automata Theory, Cambridge
University Press, 2008.
- J.E. Hopcroft, J.D. Ullman, R. Motwani, Introduction to Automata Theory, Languages
and Computation, Addison-Wesley, 2013.
Die Inhalte der Veranstaltungen „Diskrete Modellierung“, „Datenstrukturen“ und Theoretische Informatik 1“ werden in den folgenden Skripten behandelt. Bitte jeweils die aktuelle
Version benutzen.
- N. Schweikardt, Diskrete Modellierung, eine Einführung in grundlegende Begriffe und Methoden der Theoretischen Infomatik.
- G. Schnitger, Datenstrukturen.
- G. Schnitger, Theoretische Informatik 1.
34
KAPITEL 1. GRUNDLAGEN
Kapitel 2
Komplexitätsklassen
2.1
Worte und Sprachen
An der Lösung welcher Probleme sollten wir interessiert sein? Wir formalisieren den Begriff
eines Problems durch den Begriff einer Sprache.
Definition 2.1 (Alphabete, Worte und Sprachen)
(a) Ein Alphabet Σ ist eine endliche, nicht-leere Menge. Die Elemente von Σ werden
Buchstaben genannt.
(b) Ein Wort w über Σ ist ein Tupel w = (a1 , . . . , am ). Wir sagen, dass w die Länge |w| = m
besitzt. Wir schreiben im folgenden a1 · · · an statt (a1 , . . . , an ).
(c) Das leere Wort () bezeichnen wir mit .
(d) Σn = {(a1 , . . . , an ) | ai ∈ Σ} ist die Menge aller Worte der Länge n über Σ. Dementsprechend besteht Σ0 = {} nur aus dem leeren Wort.
∗
Σ =
∞
[
Σn
n=0
ist die Menge aller Worte über dem Alphabet Σ,
Σ+ =
∞
[
Σn
n=1
ist die Menge aller nicht-leeren Worte über Σ.
(e) Eine Sprache L (über Σ) ist eine Teilmenge von Σ∗ .
Als nächstes besprechen wir die wichtigsten Begriffe im Umgang mit Sprachen.
Definition 2.2 Sei Σ ein Alphabet, u und v seien Worte über Σ.
(a) Es sei u = u1 · · · un und v = v1 · · · vm . Dann bezeichnet
u · v = u1 · · · un · v1 · · · vm
die Konkatenation von u und v. (Beachte, dass u · = · u = u). Wir schreiben auch
uv statt u · v.
35
36
KAPITEL 2. KOMPLEXITÄTSKLASSEN
(b) u heißt genau dann ein Teilwort von v wenn es Worte u1 und u2 über Σ gibt mit
v = u1 u u2 .
(c) u heißt genau dann Präfix von v wenn es ein Wort u1 über Σ mitv = u u1 gibt.
u heißt genau dann ein Suffix, wenn es ein Wort u1 über Σ mit v = u1 u gibt.
(d) Für Sprachen L1 , L2 über Σ bezeichnet
L1 ◦ L2 = {uv | u ∈ L1 , v ∈ L2 }
die Konkatenation von L1 und L2 .
(e) Für eine Sprache L über Σ ist
Ln = {u1 · · · un | u1 , . . . , un sind Worte der Sprache L}
L∗ =
L+ =
∞
[
n=0
∞
[
Ln
(mit L0 = {})
Ln .
n=1
L∗ heißt die Kleene Hülle von L.
Die Operationen bieten die Möglichkeit, Sprachen kompakt zu beschreiben.
Beispiel 2.1
(a) {A, B, C, D, E, F, G, H} ◦ {1, 2, 3, 4, 5, 6, 7, 8} ist die Menge aller Felder eines Schachbretts.
(b) {♣, ♦, ♥, ♠} ◦ {7, 8, 9, 10, Bube, Dame, K önig, Ass} ist die Menge der Karten eines
Skatblatts.
(c) {1} ◦ {0, 1}∗ ist die Menge der Binärdarstellungen der natürlichen Zahlen größer Null.
(d)
4
S
{·, −}i ist die Menge der Morsezeichen für die 26 Buchstaben, ä, ö, ü und ch.
i=1
(e) ({2} ◦ {0, 1, 2, 3} ∪ {, 1} ◦ {0, 1, . . . , 9}) ◦ {:} ◦ {0, 1, . . . , 5} ◦ {0, 1, . . . , 9} ist die Menge
der Uhrzeiten eines Tages.
(f) ({1} ◦ {0, 1, 2} ∪ {1, . . . , 9}) ◦ {:} ◦ {0, 1, . . . , 5} ◦ {0, 1, . . . , 9} ◦ {am, pm} ist die amerikanische Entsprechung.
Als nächstes spielen wir ein wenig mit der Konkatenation und mit dem Sternoperator, also
mit der Kleene Hülle.
Beispiel 2.2 Wir behaupten, dass das Wort abcd ein Element der Sprache
({a}∗ ◦ {b}∗ ◦ {d}∗ ◦ {c}∗ )∗ = L
2.1. WORTE UND SPRACHEN
37
ist. Dazu betrachten wir zuerst die Sprache
K = {a}∗ ◦ {b}∗ ◦ {d}∗ ◦ {c}∗ .
Dann ist
K = {an bm dk cl | n, m, k, l ∈ N}
und das Wort abcd gehört nicht zu K. Beachte aber, dass
L = K∗
und
abcd ∈ K 2 ,
denn abc ∈ K und d ∈ K. Somit ist also abcd ∈ L. Die Sprache L können wir aber einfacher
charakterisieren. Wir behaupten nämlich, dass
L = {a, b, c, d}∗ .
Wir zeigen zuerst L ⊆ {a, b, c, d}∗ . Dies ist offensichtlich, da L nur aus Worten über dem
Alphabet {a, b, c, d} besteht, und da {a, b, c, d}∗ die Menge aller Worte über {a, b, c, d} ist.
Zuletzt ist die umgekehrte Inklusion
{a, b, c, d}∗ ⊆ L
nachzuweisen. Sei w ein beliebiges Wort über dem Alphabet {a, b, c, d}. Wir müssen zeigen,
dass w auch ein Element von L ist. Wenn w = w1 · · · wn mit w1 , . . . , wn ∈ {a, b, c, d}, dann
ist natürlich w1 , . . . , wn ∈ K: jeder Buchstabe von w gehört zur Sprache K. Dann muß aber
w1 · · · wn ∈ K n
gelten und somit ist w = w1 · · · wn ∈ L.
Einige Sprachen L lassen sich rekursiv wie folgt definieren: L ist die kleinste Menge von
Worten über dem Alphabet Σ mit den Eigenschaften
(a) Worte w1 , . . . , wk ∈ Σ∗ gehören zu L.
(b) Wenn u1 , . . . , us zu L gehören, dann gehören auch bestimmte weitere, aus u1 , . . . , us
aufgebaute Worte zu L.
Hier ist ein erstes Beispiel.
Beispiel 2.3 Die Sprache L sei die kleinste Sprache über dem Alphabet Σ = {0, 1} mit den
folgenden Eigenschaften
(a) ∈ L
(b) wenn u ∈ L, dann 0u ∈ L und u1 ∈ L.
38
KAPITEL 2. KOMPLEXITÄTSKLASSEN
Wie sieht L aus? Wir geben eine einfache, nicht rekursive Beschreibung, nämlich
L = {0}∗ {1}∗ .
Beweis: Erst zeigen wir {0}∗ {1}∗ ⊆ L. Sei w ∈ {0}∗ {1}∗ und demgemäß w = 0n 1m . Wir
wissen, dass ∈ L und deshalb ist
0 · , 0 · 0 · , . . . , 0n · ∈ L.
Mit 0n = 0n ist aber auch
0n · 1, 0n · 1 · 1, · · · , 0n 1m ∈ L,
und deshalb ist w ∈ L.
Es bleibt zu zeigen, dass L ⊆ {0}∗ {1}∗ . Dazu genügt es zu bemerken, dass die Sprache
{0}∗ {1}∗ die Eigenschaften (1) und (2) in der Definition von L erfüllt. (Warum ist dies
ausreichend? L ist die kleinste Sprache mit den Eigenschaften (1) und (2)!).
Aufgabe 11
Die Sprache L ist die kleinste Sprache von Worten über dem Alphabet Σ = {(, )} mit den Eigenschaften:
(a) ∈ L.
(b) Wenn u, v ∈ L, dann u · v ∈ L und (u) ∈ L.
Beschreibe L umgangssprachlich.
Aufgabe 12
Die Sprache L ist die kleinste Sprache von Worten über dem Alphabet Σ = {a, b)} mit den Eigenschaften:
(a) ∈ L.
(b) Wenn u ∈ L, dann aua, bub ∈ L.
Gib eine Beschreibung der Form L = { w ∈ Σ∗ : w hat Eigenschaft E }. Was ist die Eigenschaft E?
2.1.1
Das Wortproblem
Das Wortproblem für eine Sprache L ist denkbar einfach zu beschreiben:
Es ist zu entscheiden, ob ein gegebenes Wort w in L liegt.
Das Wortproblem hat viele Anwendungen, alle algorithmischen Entscheidungsprobleme lassen
sich zum Beipiel als Wortprobleme auffassen.
Die Lösung des Wortproblems für L besteht in der Angabe eines möglichst effizienten Algorithmus. Dass das Wortproblem im Schwierigkeitsgrad stark schwankt, ist schnell überlegt.
Beispiel 2.4 Das Wortproblem für die Sprache
L = { Frühling, Sommer, Herbst, Winter }
ist leicht, da zu jedem Wort w schnell festgestellt werden kann, ob es eines der vier enthaltenen
ist.
2.1. WORTE UND SPRACHEN
39
Beispiel 2.5 Nehmen wir als anderes Beispiel die Sprache L, die über dem ASCII Zeichensatz
als Alphabet Σ definiert sei und alle syntaktisch korrekten C-Programme enthalten soll, die
für jede Eingabe halten. Wie ist es mit diesem Kandidaten w:
main(int n)
int i;
{
i=n;
while(NOT(prim(i)&&prim(i+2)))
i++;
}
boolean prim(int n)
int i;
{
for(i=2;i<n;i++)
if(n % i == 0) return(false);
return(true);
}
Was tut dieses Programm? Es beginnt bei der Zahl n aufsteigend nach Primzahlzwillingen zu
suchen und hört nur auf, wenn es fündig wird. Die Frage, ob dieses Programm w in unsere
Sprache L gehört, ist also gleichbedeutend mit der Frage, ob es unendlich viele Primzahlzwillinge gibt. Das Programm hält nämlich genau dann für Eingabe n, wenn es zu n ein Paar von
größeren Primzahlzwillingen gibt. Ob das so ist, ist ein offenes Forschungsproblem.
Beispiel 2.6 Einen ungerichteten Graphen G = (V, E) können wir durch seine Adjazenzmatrix repräsentieren. Die Adjazenzmatrix wiederum lässt sich durch zeilenweises Hintereinandersetzen als ein binärer String auffassen. Wir können damit das Problem der Hamiltonschen
Kreise formulieren:
L = {w ∈ {0, 1}∗ | w beschreibt einen Graphen mit Hamiltonischen Kreis}
Das Wortproblem wird so zum Entscheidungsproblem „Hat ein durch seine Kodierung gegebener Graph einen Hamiltonischen Kreis, also einen Kreis, der jeden Knoten genau einmal
durchläuft?“
(a) Das Wort w1 = 0011001111001100 gehört zur Sprache L, da das Wort den Graphen
1
2
Q
Q Q
Q
Q
Q
3
4
beschreibt, der einen Hamiltonischen Kreis besitzt.
(b) Das Wort w2 = 0011001011011010 gehört nicht zur Sprache L, da das Wort den Graphen
1
2
c
#
c #
#
c
# c
#
c
3
4
40
KAPITEL 2. KOMPLEXITÄTSKLASSEN
beschreibt, der keinen Hamiltonischen Kreis besitzt.
(c) Das Wort w3 = 0010101101 gehört nicht zur Sprache L, da das Wort keinen Graphen
beschreibt: |w3 | ist keine Quadratzahl.
(d) Das Wort w4 = 0001000000000000 gehört nicht zur Sprache L, da der String keiner
Adjazenzmatrix entspricht.
Beispiel 2.7 Wir können über dem Alphabet Σ = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, } Folgen natürlicher Zahlen, durch getrennt, kodieren. So können wir die Sprache





w beschreibt eine Zahlenfolge, so dass eine

∗
L = w ∈ Σ aufsteigende Teilfolge existiert, die mindestens




halb so lang ist wie die Gesamtfolge
definieren.
(a) Das Wort w1 = 9 15 21 4 11 gehört zur Sprache L, da die Zahlenfolge 9,15,21,4,11
repräsentiert wird, und die Teilfolge 9,15,21 mindestens halb so lang ist wie die Gesamtfolge.
(b) Das Wort w2 = 17 10 21 5 19 gehört nicht zur Sprache L, da die repräsentierte
Zahlenfolge 17, 10, 21, 5, 19 keine aufsteigende Teilfolge mit Länge größer als 2 besitzt.
(c) Das Wort w3 = 005 33 gehört nicht zur Sprache, da es keine Zahlenfolge kodiert.
Die Komplexitätstheorie beschäftigt sich mit der Frage, welche Ressourcen ein Algorithmus
benötigt, der ein vorgelegtes Entscheidungsproblem lösen soll.
- Das Problem des Hamiltonischen Kreises (siehe Beispiel 2.6) gehört zu den NP-vollständigen Problemen. In der Veranstaltung „Theoretische Informatik 1“ wird gezeigt, dass
die Existenz eines effizienten Algorithmus, also eines Algorithmus mit polynomieller
Laufzeit, für irgendein NP-vollständiges Problem eine Sensation darstellen würde.
- Das Zahlenfolgenproblem (siehe Beispiel 2.7) kann mit dynamischer Programmierung
in polynomieller Zeit gelöst werden. Das Zahlenfolgenproblem liegt damit in der Klasse
P, der in polynomieller Zeit lösbaren Entscheidungsprobleme.
- Die Frage, ob ein C-Programm immer hält, ist nicht entscheidbar, kann also selbst
durch Algorithmen ohne Zeitbeschränkung nicht gelöst werden. Diese absolute Grenze
algorithmischer Berechnungskraft wird in der „Theoretischen Informatik 1“ nachgewiesen.
Das Wortproblem hat auch Implikationen über Entscheidungsprobleme, wie die hier dargestellten, hinaus. Das aus der „Theoretischen Informatik 1“ bekannte Rucksackproblem ist
zum Beispiel ein Optimierungsproblem. Die Frage ist, wieviel Wert kann in einem Rucksack
transportiert werden, wenn n Objekte mit den Einzelwerten w1 , w2 , . . . , wn und den Gewichten g1 , . . . , gn zur Verfügung stehen, die ganz oder gar nicht mitgenommen werden können,
und die Kapazität C nicht überschritten werden darf. In dieser Formulierung ist die Antwort
offenbar nicht Ja oder Nein, sondern eine Zahl, nämlich der Wert einer optimalen Bepackung.
Zur Formulierung als Entscheidungsproblem führen wir noch einen Sollwert S ein. Die Frage
lautet nun, ob bei gegebenen Objekten und gegebener Kapazität der Wert S erreicht oder
2.2. TURINGMASCHINEN UND DIE CHURCHSCHE THESE
41
übertroffen werden kann. Nun haben wir ein Entscheidungsproblem, dessen Instanzen wir in
eine Zeichenkette kodieren können. Etwa:
w1 g1 w2 g2 . . . wn gn C S
Nehmen wir nun an, wir könnten dieses Wortproblem in Zeit f (n) lösen, so können wir wie
folgt vorgehen, um das Ausgangsproblem zu lösen.
1. Setze l auf 0 und r auf die Summe aller Werte.
2. Solange l < r
a) Setze m = d(l + r)/2e.
b) Löse die Entscheidungsversion mit S = m.
c) Falls Antwort positiv, setze l = m anderenfalls r = m − 1.
3. Gib l als Lösung aus.
Eine simple Binärsuche löst also das Optimierungsproblem mit Hilfe des Entscheidungsproblems. Wie lange dauert die Suche? Wenn W die Summe aller Werte ist, dann wird die
Schleife höchstens O(log2 (W )) mal durchlaufen. Der Aufwand innerhalb einer Iteration ist
im wesentlichen der Aufwand des Entscheidungsproblems und wir erhalten
O(f (n) · log2 W )
als Gesamtlaufzeit, denn wir haben angenommen, dass sich das Wortproblem in Zeit f (n)
lösen lässt. Man beachte, dass log2 W aber nicht größer als die Länge der Binärdarstellungen
der Werte und somit ist log2 W nicht größer als die Eingabelänge n.
Interessieren wir uns also nur dafür, ob ein Optimierungsproblem in polynomieller Zeit gelöst
werden kann oder nicht, so wird uns die Entscheidungsversion bereits die richtige Antwort
liefern. In den Übungen werden wir sehen, dass auch das Problem des Auffindens der optimalen Bepackung selbst – im Gegensatz zum Wert – in derselben komplexitätstheoretischen
Preisklasse anzusiedeln ist.
2.2
Turingmaschinen und die Churchsche These
Was genau ist ein Rechner? Betrachten wir die wesentlichen Anforderungen an ein vernünftiges
Rechnermodell:
Ein Rechner muss jderzeit auf die Eingabe zugreifen können und Rechnungen ohne
Beschränkung von Rechenzeit und Speicherplatz ausführen können.
Natürlich ist nicht klar, was es heißt „Rechnungen ausführen zu können“: Wir führen deshalb
zur Formalisierung ein sehr einfaches Rechnermodell, nämlich die Turingmaschine ein.
Eine (1-Band) Turingmaschine besitzt ein nach links und nach rechts unendliches, lineares
Band, das in Zellen unterteilt ist; die Zellen besitzen Zahlen aus Z als Adressen. Anfänglich
ist die Eingabe w = w1 · · · wn in den Zellen mit den Adressen 1 . . . , n abgelegt, wobei Zelle i
(mit 1 ≤ i ≤ n) den Buchstaben wi speichert; alle verbleibenden Zellen speichern das Blanksymbol B. Die Turingmaschine manipuliert ihr Band mit Hilfe eines Lese-/Schreibkopfes,
der sich zu Beginn der Rechnung auf der Zelle 1 befindet. Während zu Anfang also alle
42
KAPITEL 2. KOMPLEXITÄTSKLASSEN
Buchstaben entweder aus dem Eingabealphabet Σ stammen oder mit dem Blanksymbol
übereinstimmen, darf die Turingmaschine im Verlauf der Rechnung Zellen mit Buchstaben
eines Arbeitsalphabets Γ mit Σ ∪ {B} ⊆ Γ beschriften.
Wie rechnet eine Turingmaschine? Das Programm einer Turingmaschine wird durch eine
Zustandsüberführungsfunktion δ mit
δ : Q × Γ → Q × Γ × {links, bleib, rechts}
beschrieben. Die endliche Menge Q heißt Zustandsmenge, wobei wir annehmen, dass die
Maschine im Anfangszustand q0 ∈ Q startet. Wenn sich die Maschine im Zustand q ∈ Q
befindet und den Buchstaben γ ∈ Γ liest, dann ist der „Befehl“ δ(q, γ) anzuwenden. Falls
δ(q, γ) = (q 0 , γ 0 , Richtung)
gilt, dann wird γ 0 gedruckt (und damit wird γ überdruckt), die Maschine wechselt in den
Zustand q 0 und der Kopf wechselt zur linken Nachbarzelle (Richtung = links), zur rechten
Nachbarzelle (Richtung = rechts) oder bleibt stehen (Richtung = bleib).
Wir sagen, dass die Maschine hält, wenn sie „auf der Stelle tritt“, d.h. wenn sich die Maschine
im Zustand q ∈ Q befindet, den Buchstaben γ ∈ Γ liest und wenn δ(q, γ) = (q, γ, bleib) gilt.
Schließlich zeichnen wir eine Teilmenge F ⊆ Q als Menge der akzeptierenden Zustände
aus und sagen, dass die Maschine die Eingabe w akzeptiert, wenn sie in einem Zustand aus
F hält.
Zusammengefaßt: Eine Turingmaschine M wird durch das 6-Tupel
M = (Σ, Γ, Q, δ, q0 , F)
beschrieben. Wir sagen, dass die Turingmaschine M die Sprache
L(M ) = {w | M akzeptiert w}
akzeptiert. Schließlich messen wir die Laufzeit und definieren timeM (w) als die Anzahl der
Schritte von M auf Eingabe w ∈ Σ∗ . Die worst-case Laufzeit von M auf Eingaben der Länge
n ist dann
timeM (n) = max {timeM (w) | w ∈ Σn } .
Polynomialzeit
Ist uns eine wirklich überzeugende Definition eines Rechnermodells gelungen? Der erste Eindruck ist negativ, denn eine Turingmaschine erinnert eher an eine Nähmaschine als an die
Modellierung eines modernen Rechners. Tatsächlich können Nähmaschinen modernste Rechner und sogar Parallelrechner ohne Probleme simulieren können, solange die Rechenzeit der
Nähmaschine polynomiell größer sein darf als die Rechenzeit des simulierten Rechners. Diese
Aussage setzt aber voraus, dass wir von deterministischen Rechnern reden, also von Rechnern für die die nächste auszuführende Anweisung durch die gegenwärtige Konfiguration von
Befehlszähler und Speicherinhalt bestimmt ist.
So ist es bis heute nicht klar, ob deterministische Turingmaschinen in Polynomial-Zeit probabilistische Rechner simulieren können, obwohl vieles dafür spricht, wenn nur mit einem
kleinen Fehler gerechnet werden darf. Auf der anderen Seite ist es auch „wahrscheinlich“, dass
Quanten-Turingmaschinen in Polynomialzeit mächtiger als deterministische Turingmaschinen
in Polynomialzeit sind.
2.3. SPRACHKLASSEN
43
Der Berechnungsmodus, also Determinismus, Nichtdeterminismus, Probabilismus oder
Quantenberechnungen „macht den Unterschied aus“, nicht aber die auf den ersten Blick eher
mickrige Architektur einer Turingmaschine, die es tatsächlich nach polynomiellem Mehraufwand mit den mächtigsten modernen Architekturen aufnehmen kann.
Wir benutzen deshalb Turingmaschinen in Abschnitt 2.3.2, um die von modernen Rechnern
benötigte Zeit „innerhalb eines Polynoms“ verlässlich vorauszusagen.
Die Churchsche These
Hängt die Klasse der von einem Rechnertyp lösbaren Probleme von dem benutzten Berechnungsmodus ab? Natürlich kann man eine solche Frage erst dann abschließend beantworten,
wenn es klar ist welche Berechnungsmodi in Frage kommen. Allerdings spricht vieles dafür,
dass jeder „vernünftige“ Berechnungsmodus von deterministisch arbeitenden Turingmaschinen simulierbar ist, solange die Berechnungsressourcen „Zeit“ und „Speicherplatz“ nicht eingeschränkt werden.
Genau dies besagt die Churchsche These: Die Klasse der von einem vernünftigen Rechnermodell lösbaren Probleme stimmt überein mit der Klasse der Probleme, die durch deterministische Turingmaschinen lösbar sind.
Ist die Churchsche These wahr, und dies wird man nie bestätigen, möglicherweise aber wirderlegen können, dann hat man den Begriff eines „algorithmisch lösbaren Problems“ ein und
für alle Mal, ohne Bezug auf irgendwelche Rechnergenerationen, festzurren können. Toll, nicht
wahr?
Algorithmisch lösbare Probleme nennt man entscheidbar, nicht lösbare Probleme heißen unentscheidbar.
Definition 2.3 Eine Sprache L heißt entscheidbar, wenn es eine stets haltende Turingmaschine M gibt mit
L = L(M ).
Eine nicht entscheidbare Sprache heißt unentscheidbar.
hM i bezeichne eine „leicht kodierbare“ Beschreibung einer Turingmaschine M als binäres
Wort. Dann werden die folgenden Sprachen in der Vorlesung „Theoretische Informatik 1“ als
unenscheidbar nachgewiesen:
Das Halteproblem := { hM iw : M hält für Eingabe w }
die universelle Sprache := { hM iw : M akzeptiert Eingabe w }.
Wir lernen weitere unentscheidbare Probleme als Konsequenz des Postschen Korrespondenzproblems kennen (siehe Abschnitt 4.5.1): Satz 4.14 nennt unentscheidbare Probleme im Zusammenhang mit kontextfreien Grammatiken, in Korollar 4.15 wird die Unentscheidbarkeit
des Äquivalenzproblems für Finite State Transducer abgeleitet.
2.3
Sprachklassen
Wir können die Schwierigkeit des Wortproblems natürlich nicht für jede betrachtete Sprache
L individuell analysieren. Wir werden uns stattdessen im ersten Teil der Vorlesung auf „formale Sprachen“ und insbesondere auf reguläre und kontextfreie Sprachen beschränken. Diese
44
KAPITEL 2. KOMPLEXITÄTSKLASSEN
Sprachklassen sind syntaktisch durch Grammatiken, bzw. durch besonders einfache Rechnermodelle charakterisierbar. Das Wortproblem wird uns als so genanntes Compilerproblem
begegnen: Ist eine vorgelegte Zeichenkette ein syntaktisch korrektes Programm und was ist
die Bedeutung dieses Programms?
Im zweiten Teil betrachten wir Sprach- oder Problemklassen zu deren Lösung ein bestimmter Ressourcenverbrauch ausreichend ist. Nachdem wir in der „Theoretischen Informatik 1“
Laufzeitklassen wir Pund NPuntersucht haben, beschränken wir uns hier vor allem auf den
Speicherplatzverbrauch. Diese Speicherplatzklassen haben vielfältige Anwendungen.
(a) Im Bereich der formalen Sprachen:
• Reguläre Sprachen lassen sich exakt über ihren Speicherplatzverbrauch charakterisieren, für kontextfreie Sprachen gelingt eine approximative Charakterisierung.
• Selbst einfach klingende Entscheidungsprobleme wie etwa
Sind zwei nichtdeterministische endliche Automaten äquivalent?
gehören bereits zu den schwierigsten Problemen, die mit polynomiellem Speicherplatz lösbar sind. Wir werden auch eine neue Klasse formaler Sprachen, die Klasse
der kontextsensitiven Sprachen kennenlernen: Diese Sprachklasse wird sich mit
Hilfe der Speicherplatzkomplexität exakt charakterisieren lassen.
(b) Welche Probleme lassen sich sehr schnell mit parallelen Algorithmen lösen? Diese Frage
lässt sich durch einen überraschend starken Zusammenhang zwischen „Parallelisierbarkeit“ und „Berechenbarkeit mit kleinem Speicherplatzverbrauch“ beantworten.
(c) Randomisierte Algorithmen und sogar Quantenalgorithmen, die „nur“ polynomielle Zeit
benötigen, können durch konventionelle deterministische Algorithmen mit polynomiellem Speicherplatzverbrauch simuliert werden. Dieses Ergebnis hilft in der Einschätzung
der Berechnungskraft von Randomisierung wie auch von Quantenberechnungen.
(d) Hat der ziehende Spieler (in einem nicht-trivialen Zwei-Personen-Spiel) einen Gewinnzug? Für viele interessante Spiele führt diese Frage auf Berechnungen, die höchstwahrscheinlich nicht in polynomieller Laufzeit, wohl aber mit polynomiellen Speicherplatz
gelingen.
Aufgabe 13
Überflüssige Programmteile: Wir fragen, ob zum Compilierungszeitpunkt algorithmisch festgestellt werden
kann, ob ein gegebenes C-Programm eine Anweisung enthält, die für keine Eingabe zur Ausführung kommt.
In der Regel würde die Existenz einer solchen Anweisung auf einen Programmierfehler hindeuten.
Beurteile die Komplexität dieses Problems und belege Deine Einschätzung möglichst schlüssig.
2.3.1
Formale Sprachen
Zuerst betrachten wir reguläre Sprachen als die einfachste Klasse formaler Sprachen und werden Charakterisierungen aus verschiedensten Perspektiven erhalten, nämlich über deterministische oder nichtdeterministische Automaten (DFAs oder NFAs), über reguläre Grammatiken oder über reguläre Ausdrücke. Allerdings sind regulären Sprachen enge Grenzen gesetzt.
Nehmen wir etwa als Beispiel die Sprache L der legalen Klammerausdrücke, die wir wie folgt
rekursiv definieren.
(a) ∈ L
2.3. SPRACHKLASSEN
45
(b) u, v ∈ L → u ◦ v ∈ L
(c) w ∈ L → {[} ◦ w ◦ {]} ∈ L
(d) L ist die kleinste Sprache, die diese Bedingungen erfüllt.
Diese Sprache ist nicht regulär, mit rekursiven Definitionen, die sich selbst referenzieren dürfen, haben wir aber kein Problem:
KLAM M ER =
{} ∪ (KLAM M ER ◦ KLAM M ER) ∪ ({[} ◦ KLAM M ER ◦ {]}).
Man spricht hier von einer kontextfreien Ableitungsvorschrift. Die entsprechende Sprachklasse
der kontextfreien Sprachen werden wir im Kapitel 4 untersuchen.
In der Definition von Programmiersprachen findet man viele Beispiele rekursiv definierter
Anweisungen. Man denke an die erweiterte Backus Naur Form oder an Syntaxdiagramme.
Eine IF Anweisung in C ist beispielsweise definiert als:
IF
= {if} ◦ {(} ◦ EXP RESSION ◦ {)} ◦ ST AT EM EN T ◦
( {} ∪ ({else} ◦ ST AT EM EN T )) .
Eine IF-Anweisung ist also ein if gefolgt von einem geklammerten Ausdruck. Eine Anweisung
folgt. Daran kann, muss aber nicht, sich ein Paar von Schlüsselwort else und einer Anweisung
anschließen.
Für Ausdrücke bietet C eine Fülle von Formen
EXP RESSION = CON ST AN T ∪ T ERM
∪ EXP RESSION ◦ BIN OP ◦ EXP RESSION
∪ T ERM ◦ ASGN OP ◦ EXP RESSION
∪ EXP RESSION ◦ {?} ◦ EXP RESSION ◦ {:} ◦ EXP RESSION
∪ {&, ++, −−} ◦ T ERM
∪ T ERM ◦ {++, −−}
∪ {−, !, ∼} ◦ EXP RESSION
∪ {(} ◦ T Y P EN AM E ◦ {)} ◦ EXP RESSION
∪ {(} ◦ EXP RESSION ◦ {)}.
Dies läßt sich bis zu den Zeichen des Zeichensatzes herunterbrechen. BIN OP , also ein binary
Operator, ist wie folgt definiert,
BIN OP
= BIN OP _A ∪ BIN OP _B
BIN OP _A = {∗, /, %, +, −, , , >, <, <=, >=, ==, ! =, &, ˆ, |}
BIN OP _B = {&&, ||, , }.
Es lassen sich allerdings nicht alle Anforderungen, die eine Programmiersprache an einen
Quellcode stellt, auf diese Weise beschreiben. Wir können zwar erzwingen, dass auf jede
öffnende Klammer eine schließende folgt, dass kein else ohne vorheriges if auftritt, aber wir
können beispielsweise nicht artikulieren, dass eine Variable deklariert sein muss, bevor man
sie verwendet.
46
KAPITEL 2. KOMPLEXITÄTSKLASSEN
Wir werden sehen, dass bei kontextfreien Sprachen schärfere Geschütze aufgefahren werden
müssen, um das Wortproblem in den Griff zu bekommen. Der Algorithmus von Cocke, Younger und Kasami wird das Wortproblem für kontextfreie Sprachen in Zeit Θ(n3 ) für Eingaben
der Länge n lösen. Damit sind wir zwar im polynomiellen Bereich, aber für praktische Anwendungen ist das zu langsam. Die Einschränkung auf deterministisch kontextfreie Sprachen wird
hier helfen, einen guten Ausgleich zwischen Ausdrucksstärke der Sprachen und der Effizienz
ihrer Compilierung zu finden.
Für beide Klassen, reguläre und kontextfreie Sprachen, werden wir Techniken herleiten, um
formal nachzuweisen, dass eine gegebene Sprache nicht regulär bzw. nicht kontextfrei ist.
2.3.2
Zeit-Komplexitätsklassen
Wir wählen Turingmaschinen als Rechnermodell. Die Architektur einer Turingmaschine M
besteht aus einem nach links und rechts unbeschränktem, eindimensionalem Band. Das Band
ist in Zellen unterteilt und der Zelleinhalt wird von einem Lese-Schreibkopf modifiziert.
Eine Eingabe w = (w1 , . . . , wn ) ∈ Σ∗ , für das Eingabealphabet Σ, wird so abgespeichert, dass
Zelle i (1 ≤ i ≤ n) mit dem Buchstaben i beschriftet ist. Alle anderen Zellen enthalten das
Blanksymbol B. Der Kopf des Lesebands befindet sich zu Anfang der Berechnung auf Zelle
1. Während der Berechnung darf der Kopf den Inhalt der gegenwärtig besuchten Zelle (mit
einem Buchstaben des Bandalphabets Γ) überdrucken und in einem Schritt zur linken oder
rechten Nachbarzelle wandern.
Wenn die Maschine M auf Eingabe w hält, dann ist die Ausgabe M (w) der Berechnung die
Konkatenation der Zelleninhalte vom linkesten Nicht-Blank bis zum rechtesten Nicht-Blank.
Wenn die Maschine M für jede Eingabe nur die Symbole 0 oder 1 als Ausgabe produziert,
dann sagen wir, dass die Eingabe w akzeptiert (Ausgabe 1) bzw. verworfen wird (Ausgabe 0)
und definieren
L(M ) = {w ∈ Σ∗ | M akzeptiert w }
als die von M erkannte Sprache.
Definition 2.4 Sei Σ ein Alphabet , also eine endliche Menge von Buchstaben.
(a) Wenn die deterministische Turingmaschine M für Eingabe w ∈ Σ∗ genau timeM (w)
Schritte ausführt, dann definieren wir
timeM (n) = max{timeM (w) | w ∈ Σn }
als die Laufzeit von M für Eingabelänge n.
(b) Für die Funktion t : N → N definieren wir
Dtime(t) = {L ⊆ Σ∗ | es gibt eine deterministische Turingmaschine M
mit L(M ) = L und timeM = O(t) }.
(c) Die Komplexitätsklasse P besteht aus den mit polynomieller Laufzeit erkennbaren Sprachen,
[
P=
Dtime(nk ).
k∈N
2.3. SPRACHKLASSEN
47
?
Die Frage P = NP ist eine nicht nur für die theoretische Informatik zentrale Frage, und sie wird
auch in dieser Veranstaltung eine prominente Rolle einnehmen. Wir sind deshalb natürlichen
auch an nichtdeterministischen Turingmaschinen und ihren Komplexitätsklassen interessiert.
Eine nichtdeterministische Turingmaschine M führt unter Umständen viele Berechnungen für
eine Eingabe aus. Wir sagen, dass M eine Eingabe w akzeptiert, wenn w von mindestens einer
Berechnung akzeptiert wird und definieren
L(M ) = {w | es gibt eine Berechnung von M , die w akzeptiert }.
Definition 2.5 Sei Σ ein Alphabet. Die Funktion t : N → N sei gegeben.
(a) Wir sagen, dass eine nichtdeterministische Turingmaschine M höchstens Zeit t(n) benötigt, wenn alle Berechnungen von M für Eingaben der Länge n höchstens t(n) Schritte
benötigen.
(b) Wir setzen
Ntime(t) = {L ⊆ Σ∗ | es gibt eine nichtdeterministische Turingmaschine M
mit L(M ) = L und L benötigt höchstens O(t) Schritte }.
(c) Die Komplexitätsklasse NP besteht aus den mit polynomieller Laufzeit erkennbaren Sprachen,
[
Ntime(nk ).
NP =
k∈N
Aufgabe 14
Zeige: Wenn Dtime(n log n) = Ntime(n log n), dann gilt P = NP.
Aufgabe 15
Eine Sprache L gehört genau dann zur Komplexitätsklasse NP, wenn es eine Sprache K ∈ P und eine Konstante
k ∈ N gibt, so dass für alle Eingaben w
w ∈ L ⇔ ∃ y ∈ {0, 1}∗ ( |y| ≤ |x|k ∧ (x, y) ∈ K ).
2.3.3
Speicherplatz-Komplexitätsklassen
Wir wählen deterministische I-O (input-output) Turingmaschinen als Rechnermodell. Eine
I-O Turingmaschine M besitzt drei, nach links und rechts unbeschränkte ein-dimensionale
Bänder mit jeweils einem Lese-Schreibkopf, wobei jeder Kopf in einem Schritt (höchstens) zur
jeweiligen linken oder rechten Nachbarzelle der gegenwärtig besuchten Zelle wandern darf.
(1) Das erste Band ist das Leseband. Wenn Σ1 das Eingabealphabet bezeichnet, dann wird
die Eingabe w = (w1 , . . . , wn ) ∈ Σ∗1 auf den Zellen 0, . . . , n + 1 wie folgt abgespeichert:
Die Zellen 0 und n + 1 enthalten das Begrenzersymbol #, während Zelle i (1 ≤ i ≤ n)
mit dem Buchstaben wi beschriftet ist. Der Kopf des Lesebands befindet sich zu Anfang
der Berechnung auf Zelle 0 und darf während der Berechnung weder den durch die
Begrenzer beschriebenen Bereich verlassen noch einen Zelleninhalt überschreiben. Der
Kopf verhält sich somit wie ein Lesekopf.
48
KAPITEL 2. KOMPLEXITÄTSKLASSEN
(2) Das zweite Band ist das Arbeitsband, dessen Zellen gelesen aber auch mit den Buchstaben des Arbeitsalphabets Γ, beschrieben werden dürfen. Zu Anfang der Berechnung
sind alle Zellen mit dem Blanksymbol B beschriftet.
(3) Das dritte Band ist das Ausgabeband, dessen Zellen zu Anfang der Berechnung ebenfalls
mit dem Blanksymbol beschriftet sind. Der Kopf darf das Ausgabeband mit Buchstaben
eines Ausgabealphabets Σ2 beschreiben, wobei aber in einem Schritt nur die rechte
Nachbarzelle aufgesucht werden darf. Der Kopf verhält sich also wie ein links-nachrechts wandernder Schreibkopf.
Wenn die Maschine M auf Eingabe w hält, dann ist die Konkatenation der Inhalte der
Zellen 0, . . . m die Ausgabe M (w) der Berechnung. (Die Zelle 0 ist die zu Anfang besuchte
Zelle und die Zelle m ist die im letzten Schritt besuchte Zelle des Ausgabebands.)
Wenn die Maschine M für jede Eingabe nur die erste Zelle des Ausgabebands modifiziert und dabei nur die Symbole 0 oder 1 druckt, dann sagen wir, dass die Eingabe w
akzeptiert (Ausgabe 1) bzw. verworfen wird (Ausgabe 0). Wir definieren
L(M ) = {w ∈ Σ∗1 | M akzeptiert w }
als die von M erkannte Sprache.
I-O Turingmaschinen erlauben die Definition des Speicherplatzbedarfs durch Messung der
Anzahl während der Berechnung besuchter Zellen des Arbeitsbands. Hätten wir nur 1-Band
Turingmaschinen betrachtet, dann wäre der Speicherplatzbedarf stets mindestens so groß wie
das Maximum von Ein- und Ausgabelänge, und wir hätten den teuren Arbeitsspeicher mit
billigen Hintergrundspeichern (für die Ein- und Ausgabe) gleichgesetzt.
Definition 2.6 Sei Σ ein Alphabet.
(a) Die I-O Turingmaschine M besuche für jede Eingabe w ∈ Σ∗ genau DspaceM (w) viele
verschiedene Zellen des Arbeitsbands. Wir definieren
DspaceM (n) = max{DspaceM (w) | w ∈ Σn }
als den Speicherplatzbedarf von M für Eingabelänge n.
(b) Sei s : N → N gegeben. Dann definieren wir die Klasse aller mit Platzverbrauch höchstens O(s(n)) lösbaren Entscheidungsprobleme durch
Dspace(s) = {L ⊆ Σ∗ | L(M ) = L für eine I-O TM M mit DspaceM = O(s) }.
(c) Die Komplexitätsklasse DL besteht aus allen mit logarithmischem Speicherplatzbedarf
erkennbaren Sprachen, also
DL = Dspace(log2 n).
(d) Die Komplexitätsklasse PSPACE besteht aus allen mit polynomiellem Speicherplatzbedarf
erkennbaren Sprachen, also
PSPACE =
[
Dspace(nk ).
k∈N
Man beachte, dass wir die Speicherplatzkomplexität in Teil (b) asymptotisch definiert haben.
Dieses Vorgehen wird durch das folgende “Kompressionslemma” geradezu erzwungen.
2.3. SPRACHKLASSEN
49
Lemma 2.1 Die I-O Turingmaschine M erkenne die Sprache L mit Speicherplatzbedarf
höchstens s(n). Dann gibt es eine I-O Turingmaschine M 0 , die L mit Speicherplatzbedarf
höchstens d s(n)
2 e erkennt.
Beweisskizze: Sei Γ das Arbeitsalphabet von M . Die Maschine M 0 verhält sich genau wie
M , benutzt aber das Arbeitsalphabet Γ2 .
Wie ist der Speicherplatzbedarf von nichtdeterministischen Turingmaschinen zu definieren?
Offensichtlich ist auch hier die Betrachtung von (nichtdeterministischen) I-O Turingmaschinen
M angesagt. Wir definieren den Speicherplatzbedarf nspaceM (w) für eine Eingabe w durch
den maximalen Speicherplatzbedarf einer Berechnung für w.
Definition 2.7 Sei Σ ein Alphabet.
(a) Wir definieren
nspaceM (n) = max{nspaceM (w) | w ∈ Σn }
als den Speicherplatzbedarf von M für Eingabelänge n.
(b) Sei s : N → N gegeben. Dann definieren wir
NSPACE(s) = {L ⊆ Σ∗ | es gibt eine nichtdeterministische I-O TM
M mit L(M ) = L und nspaceM = O(s) }.
(c) Die Komplexitätsklasse NL besteht aus allen nichtdeterministisch, mit logarithmischem
Speicherplatzbedarf erkennbaren Sprachen, also
NL = NSPACE(log2 n).
(d) Die Komplexitätsklasse NPSPACE besteht aus allen nichtdeterministisch, mit polynomiellem Speicherplatzbedarf erkennbaren Sprachen, also
NPSPACE =
[
NSPACE(nk ).
k∈N
2.3.4
Die Komplexität paralleler Berechnungen
Wann ist ein algorithmisches Problem parallelisierbar? Was soll „parallelisierbar“ überhaupt
bedeuten? Informell gesprochen sollten wir fordern, dass Berechnungen rasant schnell ablaufen
und mit nicht zu vielen Prozessoren arbeiten. Um diese Begriffe weiter zu klären, wählen wir
Schaltkreise als unserj paralleles Rechnermodell.
Definition 2.8 Ein Schaltkreis S wird durch den Vektor
S = (G, Q, R, gatter, n, eingabe)
beschrieben.
• G = (V, E) ist ein gerichteter, azyklischer Graph.
• Q ist die Menge der Quellen (Knoten mit nur ausgehenden Kanten) und R die Menge
der Senken (Knoten mit nur eingehenden Kanten) von G.
50
KAPITEL 2. KOMPLEXITÄTSKLASSEN
• Die Funktion eingabe: Q → {1, . . . , n} weist jeder Quelle die Position des entsprechenden Eingabebits zu.
• Die Funktion gatter: V \Q → {¬, ∨, ∧} weist jedem inneren Knoten von G eine Boolesche
Funktion zu, wobei einem Knoten v die Negation nur zugewiesen werden darf, wenn v
genau eine eingehende Kante besitzt.
Der Schaltkreis berechnet die Boolesche Funktion fS : {0, 1}n → {0, 1}|R| , indem die n Eingabebits an die Quellen in G angelegt werden, und jeder Knoten das Ergebnis seiner Gatterfunktion weiterleitet. Das Resultat wird an den Senken von G (in einer vorher fixierten
Reihenfolge) abgelesen.
Als nächstes führen wir die Komplexitätsmaße Tiefe, Größe und Fanin ein. Während die Tiefe
die parallele Rechenzeit wiedergibt, misst die Größe die Prozessoranzahl, bzw. in gewissem
Sinne die sequentielle Rechenzeit.
Definition 2.9
(a) Sei S = (G, Q, R, gatter, n, eingabe) ein Schaltkreis. Wir sagen, dass
(a) die Tiefe von S die Länge des längsten Weges in G ist,
(b) die Größe von S die Anzahl der Knoten von G ist, wobei wir keine Quellen zählen,
(c) und der Fanin von S das Maximum, über alle Knoten v, der Anzahl eingehender
Kanten von v ist.
(b) Für eine Boolesche Funktion f : {0, 1}n → {0, 1} definieren wir die minimale Tiefe
DEPTH(f ) = min{ d | Es gibt einen Schaltkreis der Tiefe d für f }
und die minimale Größe
SIZE(f ) = min{ s | Es gibt einen Schaltkreis der Größe s für f },
wobei wir jeweils nur Schaltkreise mit den Gattern ∧, ∨, ¬ vom Fanin zwei betrachten.
Aufgabe 16
Zeige, dass das Problem, die Summe von n Bits modulo 2 zu bestimmen, nicht von Schaltkreisen mit unbeschränktem Fanin und Tiefe 2 gelöst werden kann, wenn polynomielle Größe in n gefordert wird.
Aufgabe 17
a) Bestimme die Anzahl der Funktionen f : {0, 1}n → {0, 1}.
b) Gib eine möglichst gute obere Schranke für die Anzahl der Schaltkreise aus m Gattern mit Fanin 2 und n
Eingaben an.
c) Zeige: Es gibt eine Funktion f : {0, 1}n → {0, 1}, zu deren Berechnung Schaltkreise die Größe mindestens
Ω(2n /n) benötigen.
Schaltkreise berechnen nur Funktionen mit einer festen Anzahl von Eingabebits. Um Funktionen von unbeschränkt vielen Eingabebits berechnen zu können, benötigen wir das Konzept
einer uniformen Schaltkreisfamilie.
Definition 2.10 (a) Eine Schaltkreisfamilie ist eine Folge (Sn )n∈N von Schaltkreisen, so
dass Sn eine Boolesche Funktion auf genau n Eingaben berechnet. Eine Schaltkreisfamilie (Sn )n∈N berechnet eine Funktion f : {0, 1}∗ → {0, 1} genau dann, wenn Sn für
jedes n die Funktion f , eingeschränkt auf {0, 1}n , berechnet.
2.3. SPRACHKLASSEN
51
(b) Eine Schaltkreisfamilie (Sn )n∈N ist uniform, wenn es eine log2 (Größe (Sn ) + n)-platzbeschränkte, deterministische Turingmaschine gibt, die für Eingabe 1n
- alle Knoten von Sn aufzählt,
- jedem inneren Knoten seine Funktion, also eine Funktion aus {¬, ∨, ∧}, zuweist,
- sämtliche Kanten von Sn aufzählt und
- jeder Quelle von Sn eine Bitposition zuweist.
(c) Seien d, s : N → N gegeben. Definiere
DEPTHuniform (d)
als die Klasse aller Sprachen L, die durch eine uniforme Schaltkreisfamilie in Tiefe
O(d(n)) und mit Fanin zwei berechnet werden.
SIZEuniform (s)
ist die Klasse aller Sprachen L, die durch eine uniforme Schaltkreisfamilie mit Größe
O(s(n)) und mit Fanin zwei berechnet werden. Schließlich besteht
DEPTH−SIZEuniform (d, s) = DEPTHuniform (d) ∩ SIZEuniform (s)
aus allen Sprachen, die sowohl in Tiefe O(d) wie auch in Größe O(s) durch eine uniforme
Schaltkreisfamilie vom Fanin zwei berechnet werden.
Mit anderen Worten: Wir verlangen, dass eine uniforme Schaltkreisfamilie Sn einfach, nämlich
durch eine logarithmisch-bandbeschränkte Turingmaschine, konstruierbar sein muss. Warum
haben wir die Uniformität oder Einfachheit von Schaltkreisen gefordert?
Sei n die Gödelnummer der Turingmaschine M . Wenn M auf dem leeren Wort hält, dann
definieren wir Sn so, dass alle Eingaben akzeptiert werden. Wenn hingegen M auf dem leeren
Wort nicht hält, dann definiere Sn so, dass alle Eingaben verworfen werden. Mit anderen Worten, das spezielle Halteproblem (für die Unärkodierung von Gödelnummern) kann mit einer
Schaltkreisfamilie berechnet werden, die nur aus Schaltkreisen mit einem Gatter bestehen.
Die beschriebene Schaltkreisfamilie (Sn )n∈N ist nicht uniform und ihre Konstruktion ist sogar
nicht berechenbar.
In uniformen Schaltkreisfamilien wird die wesentliche Arbeit von den Schaltkreisen geleistet
und nicht von der Beschreibung der Familie.
Aufgabe 18
a) Zeige: Für jede Funktion f : {0, 1}∗ → {0, 1} gibt es eine Schaltkreisfamilie der Tiefe O(n), die f berechnet.
b) Zeige: Es gibt eine berechenbare Funktion f : {0, 1}∗ → {0, 1}, die nicht von einer uniformen Schaltkreisfamilie polynomieller Tiefe berechnet werden kann.
Wir sind an rasant schnellen, parallelen Algorithmen interessiert, die mit einer vernünftigen
Größe auskommen. Die Begriffe „rasant schnell“ und „vernünftige Größe“ präzisieren wir
durch poly-logarithmische Rechenzeit und polynomielle Größe.
52
KAPITEL 2. KOMPLEXITÄTSKLASSEN
Definition 2.11 Für jedes k ∈ N definiere die Komplexitätsklassen:
k
NC
:=
∞
[
DEPTH − SIZEuniform (logk2 n, nl )
l=0
NC :=
[
NCk
k∈N
k
AC
AC :=
ist wie NCk definiert, allerdings beschränken wir den Fanin nicht.
[
ACk .
k∈N
Die Komplexitätsklasse NC ist unsere Definition der Klasse parallelisierbarer Probleme. NC
steht für „Nick’s Class“ (nach ihrem Autor Nick Pippenger). AC steht für „Alternating Circuits“, d.h. Schaltkreise die alternierend aus Schichten von UND- bzw. ODER-Gattern aufgebaut sind.
Teil II
Formale Sprachen
53
Kapitel 3
Endliche Automaten und reguläre
Sprachen
Unser erstes Ziel ist die Definition endlicher Automaten (oder DFAs), eines Maschinenmodells, das seine Eingabe von links nach rechs liest und ohne Speicher auskommen muss. Die
Beschreibung eines endlichen Automaten besteht aus den folgenden Komponenten:
• dem Eingabealphabet Σ,
• der endlichen Menge Q der Zustände,
• dem Anfangszustand q0 ∈ Q,
• der Menge F der akzeptierenden Zustände
• sowie dem Programm (bzw. der Zustandsüberführungsfunktion) δ : Q × Σ → Q.
Wie rechnet ein endlicher Automat? Beginnend mit einem Startzustand q0 wird die Eingabe
Buchstabe für Buchstabe eingelesen und bewirkt Zustandsänderungen. Die Eingabe wird
akzeptiert, wenn der zuletzt erhaltene Zustand akzeptierend ist.
Definition 3.1 Sei A = (Σ, Q, δ, q0 , F ) ein DFA.
(a) A liest ein Wort w ∈ Σ∗ von links nach rechts und wechselt seine Zustände gemäß dem
Programm δ. Formal:
Wir setzen δ auf Worte in Σ∗ fort und definieren
δ : Q × Σ∗ → Q
durch
δ(q, ) = q,
δ(q, w1 · · · wn+1 ) = δ δ(q, w1 · · · wn ), wn+1
Beachte, dass δ(q, w1 · · · wn ) den Zustand bezeichnet, den A nach Lesen der Eingabe
w1 · · · wn erreicht, wenn im Zustand q begonnen wird.
(b) A akzeptiert w ∈ Σ∗ genau dann, wenn δ(q0 , w) ∈ F .
55
56
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
(c) Die von A akzeptierte (oder erkannte) Sprache ist
L(A) = {w ∈ Σ∗ | A akzeptiert w}.
(d) Eine Sprache L ⊆ Σ∗ heißt regulär, wenn es einen endlichen Automaten A mit L =
L(A) gibt.
Aufgabe 19
Zeige, dass eine Sprache L genau dann regulär ist, wenn L durch eine Turingmaschine erkannt wird, die keine
Schreiboperationen ausführt.
Das Programm eines endlichen Automaten läßt sich am besten durch ein Zustandsdiagramm veranschaulichen, das aus Knoten und beschrifteten Kanten besteht. Die Knoten
entsprechen den Zuständen; für jeden Befehl der Form δ(q, a) = q 0 wird eine mit a beschriftete Kante eingesetzt, die vom Knoten q zum Knoten q 0 verläuft.
Den Anfangszustand markieren wir durch einen Pfeil, akzeptierende Zustände werden doppelt
umrandet.
Die Berechnung von A auf Eingabe w = w1 · · · wn beschreibt somit einen Weg im Zustandsgraphen, der
- im Knoten q0 beginnt und
- jeweils die mit w1 , w2 , . . . , wn beschrifteten Kanten wählt.
Beispiel 3.1 Wir behaupten, dass die Sprache
n
o
PARITÄT = w ∈ {0, 1}∗ | w hat gerade viele Einsen
regulär ist. PARITÄT wird von einem endlichen Automaten mit
• Zustandsmenge Q = {gerade, ungerade},
• Anfangszustand gerade,
• F = {gerade} und
• dem Programm δ akzeptiert, wobei
δ(gerade, 0) = gerade,
δ(gerade, 1) = ungerade,
δ(ungerade, 0) = ungerade, δ(ungerade, 1) = gerade.
Das Zustandsdiagramm hat die Form
0
0
1
q0
q1
1
57
Beispiel 3.2 Üben wir uns in der Modellierung und betrachten das folgende Problem. Die
Kindersicherung eines Fernsehers funktioniert so, dass über die Fernbedienung ein dreistelliger Code korrekt eingegeben werden muss, damit der Fernseher eingeschaltet werden kann.
Dafür sind die Tasten von 0 bis 9 relevant. Es gibt eine BACK Taste, die es uns erlaubt, die
letzteingegebene Zahl zurückzunehmen, außerdem gibt es die Taste CODE. Sie muss vor der
Eingabe des Codes gedrückt werden. Wird sie während der Codeeingabe noch mal gedrückt,
so wird die Eingabe neu begonnen.
Ein Automat bietet sich für die Modellierung an, da die Eingabe, die Folge der Tastenbetätigungen, ohnehin nur von links nach rechts (in der zeitlichen Abfolge) zur Verfügung steht.
Wir geben zunächst die Komponenten des Automaten an.
• Das Eingabealphabet sind die relevanten Tasten
Σ = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, BACK, CODE}.
• Die Zustände müssen widerspiegeln, wie weit die Eingabe bereits fortgeschritten ist.
Wie weit ist der Code richtig eingegeben worden? Folgen nach einem richtigen Anfang
vielleicht falsche Zeichen, die mit BACK wieder zurückgenommen werden könnten? All
diese Fragen müssen in den Zuständen beantwortet sein.
• Der Anfangszustand q0 entspricht dem Zustand, in dem noch nichts eingegeben wurde.
• Die Menge der akzeptierenden Zustände hat nur ein Element: den Zustand, der nach
erfolgreicher Codeeingabe angenommen wird.
• Die Übergangsfunktion δ wird die Zustände sinnvoll verbinden.
Ist der Code zum Entsperren des Fernsehers etwa 999, so erhalten wir den folgenden Automaten.
BACK
CODE
CODE
9
9
ready
BACK
CODE
CODE
0,...,8
9
0,...,8
BACK
CODE
CODE
BACK
99
BACK
0,...,8
x
CODE
9x
0,...,9
0,...,9
BACK
xx
0,...,9
OFF
0,...,9
BACK
9
ON
58
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
Bei der Erstellung dieses Automaten haben wir gesunden Menschenverstand eingesetzt. Wir
haben erkannt, dass es nicht nötig ist zu unterscheiden, welche falsche Zahl getippt wurde.
Auch haben wir ausgenutzt, dass es egal ist, ob man die zweite Zahl richtig eintippt, nachdem die erste falsch war. Sehr wohl spielt es aber eine Rolle, ob einer falschen zweiten Zahl
eine richtige erste vorausging. Ist dieser Automat aber kleinstmöglich oder könnte man die
Anforderungen kompakter, das heißt mit weniger Zuständen, formulieren?
Warum betrachten wir endliche Automaten? Endliche Automaten erlauben eine Beschreibung
von Handlungsabläufen:
Wie ändert sich ein Systemzustand in Abhängigkeit von veränderten Umgebungsbedingungen?
Dementsprechend ist das Einsatzgebiet endlicher Automaten vielfältig: Endliche Automaten
finden Verwendung
- in der Entwicklung digitaler Schaltungen,
- in der Softwaretechnik (zum Beispiel in der Modellierung des Applikationsverhaltens),
- im Algorithmenentwurf für String Probleme
- oder in der Abstraktion tatsächlicher Automaten (wie Bank- und Getränkeautomaten)
Aufgabe 20
Ein Mann (M) steht mit einem Wolf (W), einer Ziege (Z) und einem Kohlkopf (K) am linken Ufer eines Flusses,
den er überqueren will. Er hat ein Bot, das groß genug ist, ihn und ein weiteres Objekt zu transportieren, so
dass er immer nur einen der drei mit sich hinübernehmen kann. Falls der Mann allerdings den Wolf und die
Ziege unbewacht an einem der Ufer zurückläßt, so wird der Wolf sicherlich die Ziege fressen. Genauso wird,
wenn die Ziege und der Kohlkopf unbewacht zurückbleiben, die Ziege den Kohlkopf fressen.
Eine Überführung ist ein Wort w über Σ = {M, W, Z, K}, wobei wi ∈ {W, Z, K}, wenn der Mann mit Objekt
wi zum Zeitpunkt i das Boot benutzt und wi = M , wenn der Mann das Bot alleine benutzt. Eine Überführung
w = w1 · · · wn ist erfolgreich, falls nach der letzten Aktion wn der Mann und alle drei Objekte das rechte Ufer
erreicht haben.
Gebe einen möglichst kleinen Automaten an, der alle erfolgreichen Überführungen beschreibt.
Wir werden später sehen, dass die folgenden algorithmischen Probleme effiziente Lösungen
besitzen:
- Das Äquivalenzproblem: Gegeben seien endliche Automaten A und B. Sind A und B
äquivalent, d.h. gilt L(A) = L(B)?
- Das Minimierungsproblem: Gegeben sei ein endlicher Automat A. Bestimme einen äquivalenten endlichen Automaten B mit der kleinsten Anzahl von Zuständen.
Als Konsequenz des Minimierungsproblem kann man damit automatisch kleinste endliche
Automaten für reguläre Sprachen entwerfen. Es stellt sich heraus, dass die Klasse der regulären
Automaten zu den größten Sprachenklassen gehört, für die optimale Programme effizient
bestimmt werden können.
In der Praxis werden häufig nichtdeterministische Automaten benutzt. Wir zeigen, dass überraschenderweise jeder nichtdeterminische Automat einen äquivalenten deterministischen Automat besitzt. Im Abschnitt 2.1 haben wir bereits reguläre Ausdrücke kennengelernt und es
59
stellt sich heraus, dass eine Sprache genau dann regulär ist, wenn die Sprache durch einen regulären Ausdruck dargestellt werden kann. Schliellich werden formale Sprachen häufig durch
Grammatiken beschrieben: Deshalb werden wir reguläre Grammatiken einführen und zeigen,
dass eine Sprache genau dann regulär ist, wenn sie eine reguläre Grammatik besitzt.
Reguläre Sprachen besitzen also eine Vielzahl äquivalenter Charakterisierungen. Neben diesen
Eigenschaften des Maschinenmodells, bzw der Sprachenklasse, haben endliche Automaten
trotz ihrer Einfachheit auch Anwendungen im Algorithmenentwurf. Hier besprechen wir zuerst
kurz die lexikalische Analyse und untersuchen das Pattern Matching Problem in Beispiel ??.
Beispiel 3.3 Lexikalische Analyse.
Die lexikalische Analyse ist meistens die erste Phase bei der Compilierung eines vorgegebenen Programms. Das Programm wird dabei Anweisung nach Anweisung gelesen und in Tokenklassen aufgebrochen. (Beispiele für Tokenklassen sind Keywords, Konstanten, Variablen,
arithmetische Operatoren, Vergleichsoperatoren, Klammern, Kommentare etc.) Zum Beispiel
wird in der lexikalischen Analyse eine Anweisung der Form
if distance >= rate * (end - start) then distance = maxdistance;
aufgebrochen in die Tokenklassen
- Keywords (für if und then)
- Variablen (für distance, rate, end, start, maxdistance)
- Operatoren (für *, -, =)
- Vergleichsoperatoren (für >=)
- Klammern (für ( und ))
- Semikolon (für ;)
Weitere Phasen des Compilers bauen dann auf der Ausgabe der lexikalischen Analyse, also
der Zuweisung von Tokenklassen, auf. Die lexikalische Analyse wird meist durch endliche Automaten implementiert, da die Erkennung von Tokenklassen durch „links-nach-rechts“ Lesen
des Programms möglich ist.
Neben den Eigenschaften des Maschinenmodells, bzw. der Sprachenklasse und den allerdings
nur eingeschränkten algorithmischen Anwendungen sind endliche Automaten in der Modellierung wesentlich. Wir haben ein erstes Beispiel bereits in der Kindersicherung eines Fernsehers
kennengelernt. Hier ist ein zweites Beispiel.
Beispiel 3.4 Modellierung sequentieller Schaltungen.
Bei einer sequentiellen Schaltung, im Gegensatz zu einer kombinatorischen Schaltung, hängt
der Wert am Ausgang der Schaltung nicht nur von den aktuellen Eingangswerten ab, sondern
auch von der Vorgeschichte, die sich im Inhalt der speichernden Bauteile niedergeschlagen
hat. Der systematische Aufbau einer solchen Schaltung ist dabei wie folgt:
60
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
kombinatorisch
Speicher
Takt
Wir modellieren die Schaltung durch einen Mealy Automaten. (Ein Mealy Automat ist ein
endlicher Automat, der für jeden Zustandsübergang eine Ausgabe ausgibt.) Wir wählen als
Eingabealphabet die Menge {0, 1}n , wenn n die Zahl der primären Eingänge ist. Wenn der
Speicher s Bits speichert, dann benutzen wir die Zustandsmenge
Q = {qb1 ···bs | b1 , . . . , bs ∈ {0, 1} }.
Angenommen der Inhalt des Speichers ist b und eine Eingabe x ∈ {0, 1}n liegt an. Wenn
die Schaltung den neuen Speicher c sowie die Ausgabe y produziert, dann wählen wir den
x
Zustandsübergang qb → qc und weisen diesem Zustandsübergang die Ausgabe y zu.
Eine Zustandsminimierung des Mealy Automaten führt zu einer Verkleinerung des Speichers,
denn die Speichergröße ist logarithmisch in der Zustandszahl. Man beachte allerdings, dass
diese Modellierung für großes n nicht praktikabel ist und man wird diesen Ansatz, bzw.
Erweiterungen wie OBDD’s (ordered binary decision diagrams) nur für kleine Teilschaltungen
anwenden können.
Wir werden das Minimierungsproblem im nächsten Kapitel angehen und lösen. Weitere Fragen, die wir in nachfolgenden Abschnitten besprechen, sind:
- Wann ist eine Sprache nicht regulär?
- Welche Sprachen werden von nichtdeterministischen endlichen Automaten akzeptiert?
- Welche — endliche Automaten betreffende — Fragen lassen sich effizient beantworten?
Letztendlich lernen wir alternative Charakterisierungen regulärer Sprachen mit regulären
Grammatiken und regulären Ausdrücken kennen.
Aufgabe 21
Entwirf für folgende Sprachen deterministische endliche Automaten mit möglichst wenigen Zuständen:
(a) Ln = {w| w ∈ {0, 1}∗ und w hat mindestens n Einsen }.
(b) Ln = {ww| w ∈ {0, 1}n }.
(c) L = {w| w ∈ {0, 1}∗ und die Anzahl der Einsen in w ist durch 7 teilbar}.
Aufgabe 22
Entwirf einen deterministischen endlichen Automaten für folgende Sprachen:
L1 =
L2 =
n
w|w ∈ {0, 1, 2, 3, 4}∗ und 3 teilt
n
w|w ∈ {0, 1, 2, 3, 4}∗ und 3 teilt
P|w|
i=1
P|w|
o
wi 5i−1 .
w 5|w|−i .
i=1 i
o
3.1. MINIMIERUNG
61
Aufgabe 23
Die Sprache (IF − ST AT EM EN T ) wird wie folgt rekursiv definiert:
IF − ST AT EM EN T = {if } ◦ EXP RESSION ◦ {then} ◦ ST AT EM EN T
EXP RESSION definieren wir als:
EXP RESSION = {A, . . . Z}+ ◦ {≥ 0}
und ST AT EM EN T wird wie folgt definiert:
ST AT EM EN T = IF − ST AT EM EN T ∪ {A, . . . , Z}+ ◦ {= 0}
Zeige, dass die Sprache IF − ST AT EM EN T regulär ist.
Gibt es Schwierigkeiten im Nachweis der Regularität, wenn wir die rekursive Definition wie folgt verändern
IF − ST AT EM EN T = {if } ◦ EXP RESSION ◦ {then} ◦ ST AT EM EN T ◦ {; }
Aufgabe 24
Beweise oder widerlege:
(a) Zu jeder regulären Sprache L gibt es einen endlichen Automat A mit genau einem akzeptierendem
Zustand und L = L(A).
(b) Falls L0 ⊆ L und L regulär ist, dann ist auch L0 regulär.
3.1
Minimierung
Definition 3.2 A = (Σ, QA , δ A , q0A , F A ) und B = (Σ, QB , δ B , q0B , F B ) seien DFAs.
(a) Wir nennen A und B äquivalent, wenn gilt
L(A) = L(B).
(b) A heißt minimal wenn kein mit A äquivalenter DFA eine kleinere Zustandszahl besitzt.
Äquivalente DFAs haben dasselbe Ausgabeverhalten, können aber völlig unterschiedliche Zustandszahlen besitzen. Für einen gegebenen DFA A = (Σ, Q, δ, q0 , F ) suchen wir einen
„kleinsten“ mit A äquivalenten DFA. Das Tolle ist die genial einfache Idee der Minimierung:
Wir sollten doch zwei Zustände p, q ∈ Q zu einem einzigen Zustand verschmelzen
dürfen, wenn p und q „äquivalent“ sind,
also dasselbe Ausgabeverhalten besitzen.
Aber was bedeutet das, dasselbe Ausgabeverhalten zu besitzen?
Definition 3.3 Der DFA A = (Σ, Q, δ, q0 , F ) sei gegeben. Die Verschmelzungsrelation
≡A ist eine 2-stellige Relation über der Zustandsmenge Q. Wir sagen, dass Zustände p, q ∈ Q
äquivalent bzgl. A sind (kurz p ≡A q), wenn
für alle Worte w ∈ Σ∗ : δ(p, w) ∈ F ⇔ δ(q, w) ∈ F.
Wir nennen ≡A Verschmelzungsrelation, da wir bzgl. ≡A äquivalente Zustände in einen Zustand verschmelzen möchten. Die Verschmelzungsrelation hat eine sehr schöne Eigenschaft,
sie ist nämlich eine Äquivalenzrelation.
62
3.1.1
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
Äquivalenzrelationen
Definition 3.4
Sei E eine 2-stellige Relation über einer Menge M .
(a) E heißt reflexiv, falls (v, v) ∈ E für alle v ∈ M gilt.
(b) E heißt symmetrisch, falls für alle v, w ∈ M gilt:
Wenn (v, w) ∈ E, dann auch (w, v) ∈ E.
(c) E heißt transitiv, falls für alle v, w, u ∈ M gilt:
Ist (v, w) ∈ E und (w, u) ∈ E, so auch (v, u) ∈ E.
(d) Eine Äquivalenzrelation ist eine 2-stellige Relation, die reflexiv, transitiv und symmetrisch ist.
Beispiel 3.5 „Gleichheit“, also die Relation
E := { (m, m) : m ∈ M }
ist für jede Menge M eine Äquivalenzrelation. Die Aussage „(x, y) ∈ E“ entspricht gerade der
Aussage „x = y“.
Sei E eine Äquivalenzrelation über einer Menge M . Für jedes v ∈ M bezeichnet
[v]E := { v 0 ∈ M : (v, v 0 ) ∈ E }
die Äquivalenzklasse von v bezüglich E. D.h.: Die Äquivalenzklasse [v]E besteht aus allen
Elementen von V , die laut E „äquivalent“ zu v sind. Eine Menge W ⊆ V heißt Äquivalenzklasse (bzgl. E), falls es ein v ∈ M mit W = [v]E gibt. Das Element v wird dann ein
Vertreter, bzw. Repräsentant seiner Äquivalenzklasse W genannt.
Wir kommen zu der herausragenden Eigenschaft einer Äquivalenzrelation (bzgl. E).
Satz 3.1 E sei eine Äquivalenzrelation über der Menge M und [v]E , [w]E seien zwei beliebige
Äquivalenzklassen.
Die beiden Äquivalenzklassen stimmen entweder überein (d.h. [v]E = [w]E ) oder die Klassen
sind disjunkt (d.h. [v]E ∩ [w]E = ∅).
Beweis: Wir nehmen an, dass die Äquivalenzklassen [v]E und [w]E ein gemeinsames Element
u besitzen. Dann gilt
1. (v, u) ∈ E und (w, u) ∈ E nach Definition der Äquivalenzklassen,
2. Es folgt (u, w) ∈ E, denn E ist symmetrisch.
3. Wir benutzen, dass E transitiv ist und erhalten (v, w) ∈ E aus (v, u) ∈ E und (u, w) ∈ E.
4. Mit dem gleichen Argument folgt für ein beliebiges mit v äquivalentes Element x aus
(v, x) ∈ E (d.h. (x, v) ∈ E) und (v, w) ∈ E auch (x, w) ∈ E, bzw. (w, x) ∈ E. Wir erhalten
[v]E ⊆ [w]E .
3.1. MINIMIERUNG
63
5. Ebenso erhalten wir [v]E ⊆ [w]E und wir haben die Gleichheit [v]E = [w]E nachgewiesen.
Die Äquivalenzklassen sind also disjunkt. Da jedes Element v ∈ M seiner Äquivalenzklasse
[v]E angehört, ist M eine disjunkte Vereinigung seiner verschiedenen Äquivalenzklassen.
Die Zahl der verschiedenen Äquivalenzklassen wird auch Index von E genannt.
Sei A = (Σ, Q, δ, q0 , F ) ein DFA. Wir erinnern an die Definition der Verschmelzungsrelation:
Zwei Zustände p, q ∈ Q sind äquivalent, kurz p ≡A q, wenn
für alle Worte w ∈ Σ∗ : δ(p, w) ∈ F ⇔ δ(q, w) ∈ F.
(3.1)
Satz 3.2 Sei A ein DFA. Dann ist die Verschmelzungsrelation ≡A eine Äquivalenzrelation.
Insbesondere ist die Zustandsmenge Q eine disjunkte Vereinigung von Äquivalenzklassen und
unsere Idee, äquivalente Zustände zu einem einzigen Zustand zu verschmelzen, erscheint sinnvoll. Wenn alles klappt, wenn wir also die Zustandsübergänge nach Verschmelzung „vernünftig“ setzen können, dann ist der „Äquivalenzklassenautomat“, also der DFA nach Verschmelzung mit A äquivalent. Natürlich stimmt die Anzahl seiner Zustände mit dem Index der
Verschmelzungsrelation überein. Ach wär das toll, wenn der Index die minimale Zustandszahl
wäre.
Beweis von Satz 3.2: Wenn wir q = p in (3.1) annehmen, erhalten wir p ≡A p als Konsequenz und die Verschmelzungsrelation ist reflexiv. Die Symmetrie folgt auch sofort, denn aus
p ≡A q, d.h
für alle Worte w ∈ Σ∗ : δ(p, w) ∈ F ⇔ δ(q, w) ∈ F
folgt q ≡A p, d.h.
für alle Worte w ∈ Σ∗ : δ(q, w) ∈ F ⇔ δ(p, w) ∈ F.
Seien p, q, r beliebige Zustände. Um die Transitivität nachzuweisen, müssen wir p ≡A q, q ≡A r
annehmen und dann p ≡A r zeigen. Nach Annahme gilt also
für alle Worte w ∈ Σ∗ : δ(p, w) ∈ F ⇔ δ(q, w) ∈ F ∧ δ(q, w) ∈ F ⇔ δ(r, w) ∈ F .
und damit folgt
für alle Worte w ∈ Σ∗ : δ(p, w) ∈ F ⇔ δ(r, w) ∈ F.
Wir haben die Behauptung p ≡A r gezeigt.
3.1.2
Die Verschmelzungsrelation
Der DFA A = (Σ, Q, δ, q0 , F ) sei gegeben. Um die Zustandszahl von A zu reduzieren, führen
wir die folgenden Schritte durch:
1. Zuerst bestimmen wir die Äquivalenzklassen der Verschmelzungsrelation ≡A .
64
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
2. Für jede Äquivalenzklasse von ≡A verschmelzen wir alle Zustände der Klasse zu einem
einzigen Zustand und fügen „entsprechende“ Übergänge ein. Den neuen Automaten nennen
wir A0 und bezeichnen ihn als den Äquivalenzklassenautomaten von A.
• Wie sollen wir die Zustandsübergänge von A0 definieren, so dass A und A0 dieselbe
Sprache berechnen?
Wenn der Index von ≡A , und damit die Zustandszahl von A0 , mit der minimalen Zustandszahl
übereinstimmt, dann ist A0 minimal! Natürlich müssen wir uns auch fragen, ob wir ≡A und
A0 effizient berechnen können.
Wie können wir die Äquivalenzklassen der Verschmelzungsrelation berechnen?
Wir bestimmen alle Paare nicht-äquivalenter Zustände.
Definition 3.5 Der DFA A = (Σ, Q, δ, q0 , F ) mit Zuständen p, q ∈ Q sei gegeben.
Wir sagen, dass das Wort w ∈ Σ∗ die Zustände p und q trennt, bzw. ein Zeuge für die
Inäquivalenz von p und q ist, wenn
δ(p, w) ∈ F ∧ δ(q, w) 6∈ F ∨ δ(p, w) 6∈ F ∧ δ(q, w) ∈ F .
Um alle Paare nicht-äquivalenter Zustände zu bestimmen, wenden wir den Verschmelzungsalgorithmus an.
1. Markiere alle Paarmengen {p, q} mit p ∈ F und q 6∈ F (als nicht-äquivalent).
• Es ist δ(p, ) ∈ F und δ(q, ) 6∈ F .
• w = ist Zeuge für die Nicht-Äquivalenz von p und q.
2. Wenn die Paarmenge {p, q} bereits markiert wurde und
wenn δ(r, a) = p sowie δ(s, a) = q
für ein a ∈ Σ, dann markiere {r, s}.
• Da p 6≡A q, gibt es einen Zeugen w mit
δ(p, w) ∈ F und δ(q, w) 6∈ F oder δ(p, w) 6∈ F und δ(q, w) ∈ F .
• Das Wort aw bezeugt, dass r und s nicht-äquivalent sind.
3. Halte, wenn keine neuen Paarmengen {r, s} markiert werden können.
• Unsere Hoffnung ist, dass p 6≡A q genau dann gilt, wenn die Paarmenge {p, q} markiert
wurde.
Der Verschmelzungsalgorithmus funktioniert!
Satz 3.3 Der Verschmelzungsalgorithmus findet alle Paare inäquivalenter Zustände.
3.1. MINIMIERUNG
65
Beweis: Sei P die Menge aller Paare {r, s} nicht-äquivalenter Zustände, die aber von unserem
Verfahren nicht gefunden werden. Wir müssen zeigen, dass P leer ist! Wir führen einen Beweis
durch Widespruch und nehmen an, dass P nicht-leer ist. {p, q} ∈ P habe unter allen Paaren
in P einen kürzesten Zeugen w.
Fall 1: Wenn w = , dann ist
• δ(p, ) ∈ F und δ(q, ) 6∈ F oder δ(p, ) 6∈ F und δ(q, ) ∈ F ,
• bzw. p ∈ F und q 6∈ F oder p 6∈ F und q ∈ F .
Aber dann haben wir {p, q} im Schritt 1. markiert.
Fall 2: Wenn w = au für den Buchstaben a ∈ Σ, dann ist
• δ(p, au) ∈ F und δ(q, au) 6∈ F oder δ(p, au) 6∈ F und δ(q, au) ∈ F ,
• bzw.
δ(δ(p, a), u) ∈ F und δ(δ(q, a), u) 6∈ F oder δ(δ(p, a), u) 6∈ F und δ(δ(q, a), u) ∈
F .
Dann gilt δ(p, a) 6≡A δ(q, a) mit dem kürzeren Zeugen u: Aber {δ(p, a), δ(q, a)} muss nach
Annahme bereits markiert sein, und wir werden darauffolgend {p, q} markieren.
Ist unser Algorithmus effizient? Die Anzahl aller Zustandspaare ist durch |Q|2 nach oben
beschränkt. Wir werden deshalb höchstens |Q|2 Markierungsschritten benötigen.
Wir haben die Verschmelzungsrelation erfolgreich berechnet und bestimmen jetzt den Äquivalenzklassenautomaten.
3.1.3
Der Äquivalenzklassenautomat
Für Zustand p ∈ Q bezeichnet
[p]A := q ∈ Q | p ≡A q
die Äquivalenzklasse von p. Der Äquivalenzklassenautomat
A0 = (Σ, Q0 , δ 0 , q00 , F 0 )
für den DFA A = (Σ, Q, δ, q0 , F ) besitzt
• die Zustandsmenge
Q0 := [p]A | p ∈ Q ,
• den Anfangszustand q00 := [q0 ]A ,
• die Menge F 0 := [p]A | p ∈ F
der akzeptierenden Zustände und
• das Programm δ 0 mit
δ 0 ([p]A , a) := [ δ(p, a) ]A
für alle q ∈ Q und a ∈ Σ.
66
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
Wir haben alle Zustände einer Äquivalenzklasse [p]A zu einem einzigen Zustand zusammengefasst und haben diesen Zustand [p]A genannt. Folgerichtig arbeiten wir deshalb mit der
Menge Q0 aller Äquivalenzklassen von ≡A .
Als Menge der akzeptierenden Zustände des Äquivalenzklassenautomaten haben wir alle mit
einem akzpetierenden Zustand von A äquivalenten Zustände gewählt: Das scheint vernünftig,
aber ist denn wirklich jeder mit einem akzeptierenden Zustand von A äquivalenter Zustand
auch selbst akzeptierend?
Um die Übergangsfunktion δ 0 für eine Äquivalenzklasse [p]A und einen Buchstaben a ∈ Σ zu
definieren, sind wir fast gezwungen, die Äquivalenzklasse des Zustands δ(p, a) zu wählen, und
genau das haben wir getan. Aber vorsichtig, gilt denn δ(p, a) ≡A δ(q, a) für je zwei äquivalente
Zustände p, q? Wenn nicht, dann wäre unsere Definition von δ 0 abhängig vom Vertreter der
Äquivalenzklasse, und das würde nichts Gutes verheißen!
Wir zeigen zuerst, dass die Definition von δ 0 unabhängig vom Vertreter der Äquivalenzklasse
ist. Danach können wir beweisen, dass A und A0 äquivalente DFAs sind.
Satz 3.4 A = (Σ, Q, δ, q0 , F ) sei ein DFA. Für alle Zustände p, q ∈ Q mit [p]A = [q]A gilt
δ(p, a) ≡A δ(q, a).
Beweis: Seien also p, q ∈ Q äquivalente Zustände, d.h. es gilt p ≡A q . Dann folgt:
p ≡A q =⇒ für alle w0 ∈ Σ∗ gilt: δ(p, w0 ) ∈ F ⇐⇒ δ(q, w0 ) ∈ F
=⇒ für alle w ∈ Σ∗ gilt: δ(p, aw) ∈ F ⇐⇒ δ(q, aw) ∈ F.
(3.2)
Für die letzte Implikation haben wir die Aussage der ersten Implikation auf alle w0 der Form
w0 = aw eingeschränkt. Jetzt beachte δ(p, aw) = δ(δ(p, a), w) und δ(q, aw) = δ(δ(q, a), w):
(3.2) =⇒ für alle w ∈ Σ∗ gilt: δ δ(p, a), w ∈ F ⇐⇒ δ δ(q, a), w ∈ F
=⇒ δ(p, a) ≡A δ(q, a).
Somit hängt die Definition von δ 0 nicht ab von der speziellen Wahl eines Vertreters der Äquivalenzklasse.
Wir können jetzt nachweisen, dass A und A0 äquivalente DFAs sind!
Satz 3.5 A = (Σ, Q, δ, q0 , F ) sei ein DFA. Dann sind A und der Äquivalenzklassenautomat
A0 äquivalente DFAs, d.h. es gilt
L(A) = L(A0 ).
Beweis: Wir zeigen die Behauptung in drei Schritten.
1. Schritt 1: Zeige, dass
δ 0 ([q0 ]A , w) = [δ(q0 , w)]A
für alle w ∈ Σ∗ gilt. Wenn wir also wissen möchten, in welchem Zustand sich A0 nach Lesen
des Worts w befindet, dann bestimmen wir den Zustand p = δ(q0 , w) von A nach Lesen
von w. A0 befindet sich dann im Zustand [p]A und das ist alles andere als überraschend.
2. In den Schritten 2 und 3 zeigen wir die Inklusionen L(A) ⊆ L(A0 ) und L(A0 ) ⊆ L(A).
3.1. MINIMIERUNG
67
Verifikation von Schritt 1:
Induktionsanfang:
[δ(q0 , )]A .
Durch vollständige Induktion über die Länge von w.
Betrachte w = . Nach Definition von δ 0 gilt: δ 0 ([q0 ]A , ) = [q0 ]A =
Induktionsschritt: Betrachte w = ua mit u ∈ Σ∗ und a ∈ Σ. Nach Induktionsannahme gilt
δ 0 ([q0 ]A , u) = [δ(q0 , u)]A . Wir müssen zeigen
Beh.: δ 0 ([q0 ]A , ua) = [δ(q0 , ua)]A .
Beweis:
δ 0 ([q0 ]A , ua)
=
δ 0 δ 0 ([q0 ]A , u), a
Induktionsannahme
=
δ 0 [δ(q0 , u)]A , a
=
δ 0 ([p]A , a),
Definition von δ 0
=
für p := δ(q0 , u)
[δ(p, a)]A = [δ δ(q0 , u), a ]A = [δ(q0 , ua)]A .
Schritt 1
Verifikation von Schritt 2: Zeige, dass L(A) ⊆ L(A0 ) gilt. Sei also w ein beliebiges Wort
in L(A).
1. A akzeptiert die Eingabe w, d.h. es gilt: p := δ(q0 , w) ∈ F .
2. Nach Schritt 1 gilt: δ 0 ([q0 ]A , w) = [δ(q0 , w)]A = [p]A .
3. Nach Definition von F 0 gilt: [p]A ∈ F 0 , denn p ∈ F .
Somit wird w von A0 akzeptiert, d.h. es gilt w ∈ L(A0 ).
Schritt 2
Verifikation von Schritt 3: Zeige, dass L(A0 ) ⊆ L(A) gilt. Wir zeigen eine Zwischenbehauptung.
Beh: Wenn p ≡A q und p ∈ F , dann auch q ∈ F .
Beweis: Wenn p ≡A q, dann folgt aus der Definition der Verschmelzungsrelation δ(p, w) ∈ F ⇔
δ(q, w) ∈ F für alle Worte w ∈ Σ∗ . Also gilt insbesondere: δ(p, ) = p ∈ F ⇔ δ(q, ) = q ∈ F .
Zurück zu Schritt 3. Wir nehmen an, dass A0 die Eingabe w akzeptiert, d.h. es gilt: δ 0 ([q0 ]A , w) ∈
F 0 . Wir müssen w ∈ L(A) zeigen, d.h., dass δ(q0 , w) ∈ F gilt.
Nach Schritt 1 gilt:
δ 0 ([q0 ]A , w) = [δ(q0 , w)]A .
Aber δ 0 ([q0 ]A , w) ∈ F 0 . Nach Definition von F 0 muss es einen Zustand p ∈ F mit p ≡A δ(q0 , w)
geben. Also folgt aus der Zwischenbehauptung δ(q0 , w) ∈ F , d.h. w ∈ L(A).
Schritt 3
L(A) ⊆ L(A0 ) gilt nach Schritt 2 und L(A0 ) ⊆ L(A) nach Schritt 3. Es folgt L(A) = L(A0 )
und die Behauptung von Satz 3.5 ist gezeigt.
Der Äquivalenzautomat tut genau das, was wir von ihm verlangen. Allerdings müssen wir
später noch zeigen, dass A0 der kleinste mit A äquivalente DFA ist.
68
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
Bemerkung 3.1 Wenn wir den Äquivalenzklassenautomat für einen Moore oder Mealy Automaten bestimmen möchten, dann müssen wir die Verschmelzungsrelation dem Ausgabeverhalten des Automaten anpassen: Für die Ausgabefunktion λ führen wir die Erweiterung λ für
Worte w ∈ Σ∗ ein und definieren dann die Äquivalenz von Zuständen p, q durch
p ≡A q ⇔ für alle Worte w ∈ Σ∗ : λ(p, w) = λ(r, w).
3.1.4
Der Minimierungsalgorithmus
Um einen DFA A zu minimieren, entfernen wir zuerst alle vom Startzustand aus nicht erreichbaren Zustände, berechnen dann die Äquivalenzklassen von ≡A und bestimmen den Äquivalenzklassenautomaten A0 mit Hilfe der Klassen. Hier ist unser Minimierungsalgorithmus.
Eingabe: Ein DFA A = (Q, Σ, δ, q0 , F ).
Schritt 1: Entferne aus A alle überflüssigen Zustände, d.h. alle Zustände, die nicht von
q0 aus erreichbar sind.
Schritt 2: Bestimme alle Paare {p, q} mit p, q ∈ Q und p 6≡A q:
1. Markiere alle Paarmengen in M0 :=
{p, q} : p ∈ F, q ∈ Q \ F
; Setze i := 0
2. Wiederhole
3.
Für alle {p, q} ∈ Mi und für alle x ∈ Σ tue folgendes:
Markiere {p0 , q 0 } für alle p0 6= q 0 mit δ(p0 , x) = p und δ(q 0 , x) = q.
4.
5.
Sei Mi+1 die Menge aller hierbei neu markierten Paarmengen.
6.
i := i + 1
7. bis Mi = ∅
8. Ausgabe: M := M0 ∪ · · · ∪ Mi−1 .
Schritt 3: Konstruiere A0 := (Q0 , Σ, δ 0 , q00 , F 0 ):
Q0 :=
[q]A : q ∈ Q , wobei [q]A =
q00 := [q0 ]A , F 0 :=
[q]A : q ∈ F
p ∈ Q : {p, q} 6∈ M
δ 0 : Q0 × Σ → Q0 mit δ 0 [q]A , a := [δ(q, a)]A für alle q ∈ Q und x ∈ Σ.
Ist der Algorithmus korrekt und effizient? In jeder Iteration in Schritt 2 wird mindestens eine
neue Paarmenge markiert: Es gibt also höchstens |Q|2 Iterationen und der Algorithmus ist
effizient.
Die kritische Frage
„Ist A0 minimal?“
muss noch geklärt werden. Aber zuerst rechnen wir einige Beispiele durch.
Beispiel 3.6 Wir möchten den folgenden DFA minimieren:
3.1. MINIMIERUNG
69
a
b
a1
b1
a
a
b
a,b
3
bb
b
b
a2
a
b
b2
a
Die Menge M0 : bb ist der einzige akzeptierende Zustand. Deshalb hat die Menge M0 die
Form
M0 = {{, bb}, {a1 , bb}, {a2 , bb}, {b1 , bb}, {b2 , bb}}.
Was haben wir gelernt? {bb} ist eine Klasse der Verschmelzungsrelation, die restlichen Klassen
sind disjunkte Teilmengen von {, a1 , a2 , b1 , b2 }.
Wir veranschaulichen die Menge aller Paare von Zuständen durch eine zwei-dimensionale
Tabelle und vermerken alle zu M0 gehörenden Paare.
a1
a2
b1
b2
bb
M0
M0
a1
M0
a2
M0
b1
M0
b2
Die Menge M1 : Wir inspizieren alle nicht mit M0 markierten Positionen der Tabelle und
überprüfen, ob wir eine mit M0 markierte Position erhalten, wenn der Buchstabe a (bzw.
der Buchstabe b) gelesen wird. Dies ist der Fall zum Beispiel für die Position in Zeile b1 und
Spalte , die zur Paarmenge {b1 , } gehört. Es ist δ(b1 , b) = bb und δ(, b) = a2 : {b1 , } gehört
zur Menge M1 , weil {bb, a2 } zur Menge M0 gehört.
a1
a2
b1
b2
bb
M1
M1
M0
M1
M1
M0
a1
M1
M1
M0
a2
M0
b1
M0
b2
Die Menge M2 : Diesmal inspizieren alle nicht mit M0 oder M1 markierten Positionen der
Tabelle und überprüfen, ob wir eine mit M1 markierte Position erhalten, wenn der Buchstabe
a (bzw. der Buchstabe b) gelesen wird. Dies ist der Fall zum Beispiel für die Position in Zeile
a1 und Spalte , die zur Paarmenge {a1 , } gehört. Es ist δ(a1 , b) = b1 und δ(, b) = a2 : {a1 , }
gehört zur Menge M2 , weil {b1 , a2 } zur Menge M1 gehört.
a1
a2
b1
b2
bb
M2
M2
M1
M1
M0
M1
M1
M0
a1
M1
M1
M0
a2
M0
b1
M0
b2
70
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
Die Menge M3 : Wir müssen nur die unmarkierten Positionen (mit den jeweiligen Paarmengen {a2 , a1 } und {b2 , b1 }) inspizieren. Wir beginnen mit {a2 , a1 } und erhalten die unmarkierte
Paarmenge {a2 , a1 } für den Buchstaben a, bzw. die unmarkierte Paarmenge {b2 , b1 } für den
Buchstaben b: Die Paarmenge {a2 , a1 } bleibt unmarkiert.
Schließlich betrachten wir die Paarmenge {b2 , b1 }. Für den Buchstaben a erhalten wir die
unmarkierte Paarmenge {a2 , a1 } und für den Buchstaben b die Menge {bb, bb}, die natürlich
nicht markiert werden kann.
Fazit: Es ist M3 = ∅ und wir kennen die Verschmelzungsrelation: Die einzigen nicht-trivialen
Äquivalenzbeziehungen sind a1 ≡A a2 und b1 ≡A b2 , die weiteren Zustände und bb bilden
jeweils ihre eigene Äquivalenzklasse. Wir erhalten nach Verschmelzung der Zustände a1 , a2 ,
bzw. b1 , b2 im Ausgangsautomaten
a
b
a1
b1
a
a
b
a,b
3
bb
b
b
b
a2
b2
a
a
den Äquivalenzklassenautomaten
a, b
a
a, b
b
a
b
b
bb
a
Genügt es, wenn wir nur Zustände mit identischen Nachfolgezuständen verschmelzen? Nein,
der Automat aus dem letzten Beispiel ist ein Gegenbeispiel.
Beispiel 3.7 Wie stellt man fest, ob ein Wort das Suffix ab besitzt? Wir arbeiten mit dem
Alphabet Σ = {a, b} und speichern in unserem ersten Ansatz die beiden zuletzt gelesenen
Buchstaben im aktuellen Zustand ab. Wir benutzen deshalb die Zustände
Q = {, a, b, aa, ab, ba, bb}
• mit Startzustand q0 = („wir haben noch nichts gelesen“ und
• dem akzeptierenden Zustand ab: Die beiden letzten Buchstaben sind ab.
Hier ist unser erster Automat.
3
a
b
a
a
a
aa
b
b
ab
a
a
b
a
ba
b
a
b
b
b
bb
3.1. MINIMIERUNG
71
Die Menge M0 : ab ist der einzige akzeptierende Zustand. Deshalb hat die Menge M0 die
Form
M0 = {{, ab}, {a, ab}, {b, ab}, {aa, ab}, {ba, ab}, {bb, ab}}.
Was haben wir gelernt? {ab} ist eine Klasse der Verschmelzungsrelation, die restlichen Klassen
sind disjunkte Teilmengen von {, a, b, aa, ba, bb}.
Wir veranschaulichen die Menge aller Paare von Zuständen wieder durch eine zwei-dimensionale
Tabelle und vermerken alle zu M0 gehörenden Paare.
a
b
aa
ab
ba
bb
M0
M0
a
M0
b
M0
aa
M0
M0
ab
ba
Die Menge M1 : Dazu inspizieren wir alle nicht mit M0 markierten Positionen der Tabelle
und überprüfen, ob wir eine mit M0 markierte Position erhalten, wenn der Buchstabe a (bzw.
der Buchstabe b) gelesen wird. Dies ist der Fall zum Beispiel für die Position oben links, die
die Paarmenge {a, } repäsentiert. Es ist δ(a, b) = ab und δ(, b) = b: {a, } gehört zur Menge
M1 , weil {ab, b} zur Menge M0 gehört.
Um nicht jede nicht markierte Position der Tabelle gesondert zu diskutieren, machen wir
die folgende Beobachtung. Für x = a oder x = b gilt: Wenn δ(p0 , x) = p, δ(q 0 , x) = q und
{p, q} ∈ M0 , dann ist {p0 , q 0 } ∈ M1 . Der Zustand ab wird aber genau dann erreicht, wenn der
Buchstabe x = b in den Zuständen a, aa oder ba gelesen wird. Demgemäß erhalten wir für
M1 die Tabelle
a
b
aa
ab
ba
bb
M1
M1
M1
M0
M1
M0
M1
a
M1
M0
M1
b
M0
M1
aa
M0
M0
ab
M1
ba
Was haben wir gelernt?
1. Kein Zustand in der Menge a, aa, ba kann mit einem Zustand in der Menge , b, bb äquivalent sein.
2. Die weiteren Äquivalenzklassen der Verschmelungsrelation sind disjunkte Teilmengen entweder von {a, aa, ba} oder von {, b, bb}.
Lassen sich die Zustände in {a, aa, ba} (bzw. in {, b, bb}) voneinander trennen?
Die Menge M2 :
1. Die Zustände a, aa, ba können nicht voneinander getrennt werden, da sie alle unter a auf
den Zustand aa und unter b auf den Zustand ab führen.
72
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
2. b und bb lassen sich ebenfalls nicht mehr trennen. Beide führen unter a auf ba und unter
b auf bb.
3. Aber auch führt unter a auf die Klasse {a, aa, ba} und unter b auf b.
Es ist M2 = ∅, denn lässt sich nicht von b, bb trennen. Wie sehen die verschiedenen Äquivalenzklassen aus?
(a) {ab} ist die Klasse des einzigen akzeptierenden Zustands,
(b) {a, aa, ba} und {, b, bb} sind die beiden verbleibenden Klassen.
Und die Verschmelzung führt vom Ausgangsautomaten
3
a
b
a
a
a
b
b
aa
a
ab
b
a
b
b
a
ba
bb
b
a
b
auf den Äquivalenzklassenautomaten
b
3
a
a
b
b
a
a
ab
Beispiel 3.8 Der DFA A mit Zustandsdiagramm
1
0
0
1
1
0
2
3
1
4
0
5
1
1
0
0
akzeptiert die Binärdarstellungen aller durch 6 teilbaren Zahle akzeptiert, also die Sprache
L(A) =
n
w ∈ {0, 1}∗ :
|w|
X
o
wi 2|w|−i ≡ 0 (mod 6) .
(3.3)
i=1
Wir möchten wieder den Äquivalenzklassenautomaten A0 bestimmen und stellen zuerst die
Tabelle aller Paarmengen auf:
3.1. MINIMIERUNG
73
1
2
3
4
5
M0
M0
M0
M0
M0
0
M2
M1
M1
M2
M2
1
2
M1
M1
3
M2
4
Wir können somit die Zustände 1 und 4, aber auch die Zustände 2 und 5 verschmelzen.
3.1.5
Die Myhill-Nerode Relation
Was haben wir bisher gelernt? Der ursprüngliche Automat A = (Σ, Q, δ, q0 , F ) und sein
Äquivalenzklassenautomat A0 sind äquivalent. Wir können A0 effizient berechnen. Aber hat
A0 unter allen mit A äquivalenten DFAs die kleinste Zustandszahl?
Sei A = (Σ, Q, δ, q0 , F ) ein DFA. Wenn zwei Worte u, v ∈ Σ∗ auf denselben Zustand von A
führen (d.h. wenn δ(q0 , u) = δ(q0 , v) gilt), dann folgt
für alle w ∈ Σ∗ : (uw ∈ L(A) ⇔ vw ∈ L(A)).
(3.4)
Wir interpretieren Eigenschaft (3.4) als Definition der „Äquivalenz“ der Worte u und v und
führen deshalb die Myhill-Nerode Relation ein.
Definition 3.6 Σ sei eine endliche Menge und L sei eine Sprache über Σ, d.h. es gilt L ⊆ Σ∗ .
(a) Die Myhill-Nerode Relation ≡L für L ist eine 2-stellige Relation über Σ∗ . Für alle
Worte u, v ∈ Σ∗ definiere
u ≡L v :⇔ für alle w ∈ Σ∗ gilt: uw ∈ L ⇔ vw ∈ L .
(b) Wir sagen, dass das Wort w ∈ Σ∗ die Worte u, v ∈ Σ∗ trennt, bzw. dass w ein Zeuge für
die Inäquivalenz von u und v ist, wenn
uw ∈ L ∧ vw 6∈ L ∨ uw 6∈ L ∧ vw ∈ L
(c) Index(L) ist die Anzahl der Äquivalenzklassen von ≡L .
Die Myhill-Nerode Relation erlaubt, dass wir die Perspektive der DFAs aufgeben können und
uns nur noch auf die Struktur der Sprache L konzentrieren dürfen.
Satz 3.6 Sei L eine beliebige Sprache. Dann ist die Myhill-Nerode Relation für L eine Äquivalenzrelation.
Beweis: Die Myhill-Nerode Relation ≡L ist
1. reflexiv, denn für alle z ∈ Σ∗ gilt uz ∈ L ⇔ uz ∈ L und deshalb gilt u ≡L u für alle
Worte u ∈ Σ∗ .
2. symmetrisch, denn aus u ≡L v folgt uz ∈ L ⇔ vz ∈ L für alle z ∈ Σ∗ und damit auch
vz ∈ L ⇔ uz ∈ L für alle z ∈ Σ∗ . Die letzte Aussage ist aber äquivalent zu v ≡L u.
74
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
3. transitiv, denn
aus u ≡L v und v ≡L w folgt
für alle z ∈ Σ∗ uz ∈ L ⇔ vz ∈ L ∧ vz ∈
L ⇔ wz ∈ L . Also folgt uz ∈ L ⇔ wz ∈ L für alle z ∈ Σ∗ und damit u ≡L w.
Sei A = (Σ, Q, δ, q0 , F ) ein DFA für die Sprache L = L(A). Wenn k = Index(L), dann besitzen
die k verschiedenen Äquivalenzklassen der Myhill-Nerode Relation Vertreter u1 , . . . , uk , und
diese Vertreter sind natürlich paarweise inäquivalent.
Angenommen, zwei dieser Vertreter, z.B. ui und uj (mit i 6= j), führen auf denselben Zustand
in Q. Dann gilt
δ(q0 , ui ) = δ(q0 , uj )
und es ist δ(q0 , ui w) = δ(q0 , uj w) für alle Worte w ∈ Σ∗ . Aber A akzeptiert die Sprache L
und es ist ui w ∈ L ⇔ uj w ∈ L: Wir erhalten ui ≡L uj im Widerspruch zur Inäquivalenz von
ui und uj . Wir haben gezeigt
Satz 3.7 Für jeden DFA A = (Σ, Q, δ, q0 , F ) gilt
Index(L(A)) ≤ |Q|.
Mit anderen Worten: Wenn Index(L(A)) = |Q|, dann ist A ein minimaler Automat!
Beispiel 3.9 Wir betrachten die Sprache
Parität = {w ∈ {0, 1}∗ : w hat eine gerade Anzahl von Einsen }.
Es ist 6≡Parität 1 mit dem leeren Wort als Zeugen. Sei u ein beliebiges Wort mit gerade vielen
Einsen und v ein beliebiges Wort mit ungerade vielen Einsen. Dann gilt
w ∈ Parität ⇔ uw ∈ Parität
und 1w ∈ Parität ⇔ vw ∈ Parität
für alle w ∈ Σ∗ . Mit anderen Worte, die Myhill-Nerode Relation für Parität hat genau zwei
Äquivalenzklassen mit den jeweiligen Vertretern und 1. Der Index „zwei“ der Myhill-Nerode
Relation stimmt überein mit der Zustandszahl des folgenden DFA für Parität:
0
0
1
q0
q1
1
Beispiel 3.10 In Beispiel 3.7 haben wir die Sprache
L = {a, b}∗ · {ab}
betrachtet, also die Menge aller Worte, die mit ab enden, und haben einen DFA für L mit
drei Zuständen gefunden. Jetzt zeigen wir, dass der Index von L mindestens drei ist und
konstruieren dazu die folgenden drei paarweise inäquivalenten Worte:
, a, ab
Das Wort ab trennen wir mit dem Zeugen von und a. Schließlich ist nur noch zu beobachten,
dass 6≡L a mit dem Zeugen b gilt. Der in Beispiel 3.7 konstruierte DFA mit drei Zuständen
ist minimal.
3.1. MINIMIERUNG
75
Beispiel 3.11 Sei Σ ein beliebiges Alphabet und u ein Wort über Σ Wir möchten das TeilwortProblem studieren und betrachten deshalb die Sprache
Lu = { w ∈ Σ∗ : u ist ein Teilwort von w }.
Sei u = u1 · · · uk mit den Buchstaben u1 , . . . , uk ∈ Σ. Wir behaupten, dass der Index von Lu
mindestens k + 1 ist. Wir betrachten dazu die k + 1 Präfixe
, u1 , u1 u2 , . . . , u1 · · · ui , . . . , u1 · · · uk .
Zwei verschiedene Präfixe u1 · · · ui und u1 · · · uj (mit i < j) lassen sich mit dem Zeugen
uj+1 · · · uk trennen, denn u1 · · · uj · uj+1 · · · uk = u ∈ Lu , aber u1 · · · ui uj+1 · · · uk kann als ein
Wort mit weniger als k Buchstaben nicht in Lu liegen.
Editoren müssen das Teilwort-Problem blitzschnell lösen. Lässt sich ein kleiner DFA konstruieren, der genau alle Worte mit Teilwort u akzeptiert? Bei einer positiven Antwort können
wir das Teilwort-Problem tatsächlich blitzschnell auf kleinem Speicherplatz lösen! Es gelingt
sogar die Konstruktion eines DFA mit k + 1 Zuständen: Als Hinweis benutze, dass Zustand
i + 1 vom Präfix u1 · · · ui erreicht wird. Beachte, dass dieser DFA minimal sein muss.
Beispiel 3.12 In Beispiel 3.8 haben wir einen DFA mit vier Zuständen konstruiert, der alle
Binärdarstellungen mit durch sechs teilbarer Zahl akzeptiert. Sei L = L(A) die in (3.3)
definierte Sprache. Wir zeigen, dass Index von L mindestens vier ist.
Betrachte dazu die Worte 00, 01, 10, 11. 00 lässt sich durch das leere Wort von 01, 10, 11
trennen. Desweiteren können wir 11 von 01 und 10 trennen, wenn wir 0 als Zeugen verwenden.
Schließlich folgt 01 6≡L 10 mit dem Zeugen 10, denn 0110 stellt die Zahl sechs dar, während
1010 die nicht durch sechs teilbare Zahl zehn darstellt.
Der DFA nach Verschmelzen der Zustände 1 und 4, bzw. 2 und 5 ist somit minimal.
3.1.5.1
Der Äquivalenzklassenautomat ist minimal
Der Index der Myhill-Nerode Relation ≡L(A) stimmt mit der minimalen Zustandszahl eines
DFA für die Sprache L(A) überein. Und es kommt noch besser: Der Äquivalenzklassenautomat
A0 ist minimal!
Satz 3.8 Sei A = (Σ, Q, δ, q0 , F ) ein DFA.
(a) Der Äquivalenzklassenautomat A0 ist minimal.
(b) Index(L(A)) stimmt überein mit der minimalen Zustandszahl eines DFA für die Sprache
L(A).
Beweis (a) Wir zeigen:
(∗) Wenn u ≡L(A) v, dann führen u und v in A0 auf denselben Zustand, d.h. es
gilt δ 0 (q0 , u) = δ 0 (q0 , v).
Wenn die Aussage (∗) richtig ist, dann ist die Anzahl der Zustände von A0 höchstens so groß
wie der Index von L(A). Aber nach Satz 3.7 ist die Anzahl der Zustände eines jeden DFA für
L(A) mindestens so groß wie der Index und A0 muss minimal sein. Aber nicht nur das: Der
Index stimmt mit der Zustandszahl des minimalen Automaten A0 überein!
76
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
Wir zeigen die Kontraposition von (∗). Angenommen, Worte u, v ∈ Σ∗ führen in A0 zu verschiedenen Zuständen. Dann folgt δ 0 (q00 , u) 6= δ 0 (q00 , v).
Was passiert im Ausgangsautomaten A mit den Worten u und v? Für A sei p = δ(q0 , u) und
q = δ(q0 , v). Dann folgt [p]A = [δ(q0 , u)]A = δ 0 (q00 , u) 6= δ 0 (q00 , v) = [δ(q0 , v)]A = [q]A .
Es ist also p 6≡A q und es gibt einen Zeugen w ∈ Σ∗ für die Nicht-Äquivalenz. Also:
δ(p, w) ∈ F und δ(q, w) 6∈ F
oder δ(p, w) 6∈ F und δ(q, w) ∈ F ,
oder δ(q0 , uw) 6∈ F und δ(q0 , vw) ∈ F
bzw.
δ(q0 , uw) ∈ F und δ(q0 , vw) 6∈ F
bzw.
uw ∈ L(A) und vw 6∈ L(A) oder uw 6∈ L(A) und vw ∈ L(A)
und das war zu zeigen.
Aufgabe 25
Es sei Σ ein endliches Alphabet und P ein Wort aus Σ∗ . Wir definieren die „Suffix-Sprache“ LP = {T ∈
{a, b}∗ | P ist ein Suffix von T }. Beschreibe die Äquivalenzklassen der Nerode Relation von LP . Zeige, dass
stets
Index(LP ) ≥ |P | + 1
gilt.
Aufgabe 26
Ein Mealy-Automat ist ein endlicher Automat A, der für jeden Zustandsübergang eine Ausgabe ausgibt. D.h.
A ist durch den Vektor A = (Q, Σ, Γ, δ, λ, q0 ) gegeben, wobei λ : Q × Σ → Γ jedem Zustandsübergang
einen Buchstaben des Ausgabealphabets Γ zuweist. Als einziger Unterschied zu endlichen Automaten werden
also Buchstaben aus Γ pro Zustandsübergang ausgegeben; die Komponenten Q, Σ, δ und q0 behalten ihre
ursprüngliche Bedeutung. Die Ausgabe von A als Antwort auf die Eingabe a1 a2 · · · an ist deshalb
λ(q0 , a1 )λ(q1 , a2 ) · · · λ(qn−1 , an ),
wobei q0 , q1 , . . . , qn−1 die Folge von Zuständen mit δ(qi−1 , ai ) = qi für 1 ≤ i ≤ n ist.
Frage: Wie ist der Äquivalenzklassenautomat für A zu definieren?
Aufgabe 27
Minimiere den folgenden endlichen Automaten. (Das Eingabealphabet ist {a, b}, die Zustandsmenge ist
{q0 , . . . , q5 }, der Anfangszustand ist q0 und F = {q0 , q3 } ist die Menge der akzeptierenden Endzustände.)
Gib die Zwischenschritte an.
δ
q0
q1
q2
q3
q4
q5
a
q0
q5
q3
q3
q2
q0
b
q1
q4
q1
q4
q4
q4
q5m
HH
Y
a
⇒
HH
H
?
q0m
j
6
a
Aufgabe 28
Minimiere den folgenden Automaten:
b
a HH
b
b -?
qm
4
HH
6
H
b
b
HaH
H
H
H
- q1m
q3m
j a
6
a
HH
j
H
q2m
b
3.1. MINIMIERUNG
77
a
b
q1
c
q4
b
a c
a
b
c
b
a
q5
q2
b
b
c
c
b
a
c
c
a
q0
q3
a
q6
Aufgabe 29
Gib die Äquivalenzklassen der folgenden Sprachen über dem Alphabet Σ = {0, 1} bzgl. der Myhill-Nerode
Relation an:
L1 = {w ∈ Σ∗ | w besitzt mindestens
|w| 2
Einsen },
L2 = {w ∈ Σ∗ | 4 teilt Bin(w)}. (Für eine Eingabe w = w1 , . . . , wn bezeichne Bin(w) die durch w dargestellte
Binärzahl, d.h. Bin(w) =
n
P
wi 2n−i , sowie Bin() = 0.)
i=1
Aufgabe 30
Seien L, L1 und L2 reguläre Sprachen über dem Alphabet Σ. Beweise oder widerlege:
(a) Index(L ◦ Σ∗ ) ≤ Index(L),
(b) Index(L1 ∩ L2 ) ≤ Index(L1 ) · Index(L2 ),
(c) Index(L1 ◦ L2 ) ≤ Index(L1 ) · Index(L2 ).
Aufgabe 31
Bestimme zu gegebenem n zwei Sprachen L1 und L2 , so dass die folgenden drei Bedingungen gelten:
1. Index(L1 ) ≥ n,
2. Index(L2 ) ≥ n und
3. Index(L1 ∩ L2 ) = Index(L1 ) · Index(L2 )
Fazit: Die Zustandszahl wächst also unter Durchschnittsbildung im schlimmsten Fall mindestens multiplikativ
an.
Aufgabe 32
Seien m ≥ 3 und a ≥ 2 natürliche Zahlen. Für das Alphabet Σ = {0, 1, . . . , a − 1} sei die „Modulo-Sprache“
La,m gegeben durch
(
La,m =
∗
w∈Σ :
|w|
X
)
|w|−i
wi · a
≡0
(mod m)
.
i=1
La,m enthält also die a-ären Darstellungen der Zahlen, die durch m teilbar sind.
(a) Konstruiere einen DFA Aa,m mit L(Aa,m ) = La,m , der genau m Zustände besitzt.
(b) Zeige: Falls a und m nicht teilerfremd sind, ist Aa,m nicht minimal.
Hinweis: Das Durchrechnen des Falls a = 2, m = 6 kann helfen.
(c) Zeige: Falls a und m teilerfremd sind, ist Aa,m minimal.
Hinweis: Falls a und m teilerfremd sind, besitzt die Gleichung a · x + b ≡ c (mod m) genau eine Lösung.
78
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
3.1.5.2
Der Myhill-Nerode Automat
Ist der minimale Automat sogar, bis auf eine Umbenennung der Zustände eindeutig?
Wir wissen: Für jeden DFA A ohne überflüssige Zustände, der die Sprache L akzeptiert, gilt:
• Jeder Zustand q von A repräsentiert eine „A-Äquivalenzklasse“, nämlich die Menge aller
Worte u mit δ(q0 , u) = q.
• Myhill-Nerode Äquivalenzklassen sind Vereinigungen von A-Äquivalenzklassen.
Somit ist |Q| ≥ Index(L). Und wenn |Q| = Index(L)?
Dann muss jede Myhill-Nerode Äquivalenzklasse mit einer einzelnen A-Äquivalenzklasse übereinstimmen. Für jedes Wort u ist also
[u]L = { v ∈ Σ∗ : δ(q0 , v) = δ(q0 , u) }.
Aber dann gilt
u ≡L v ⇐⇒ δ(q0 , u) = δ(q0 , v)
für alle Worte u, v. Genau die Worte v mit u ≡L v erreichen den Zustand δ(q0 , u).
Fazit: Für jede reguläre Sprache L gibt es (bis auf Umbenennung der Zustände) genau einen
DFA mit minimaler Zustandszahl. Seine Zustände entsprechen den Äquivalenzklassen der
Myhill-Nerode Relation.
Jetzt drängt sich aber ein starker Verdacht auf: Können wir den minimalen DFA vielleicht
sogar direkt aus der Myhill-Nerode Relation bauen?
Wir sollten den Automaten so definieren, dass für alle u ∈ Σ∗ gilt: Der Zustand, in dem
der Automat nach dem Lesen des Worts u ist, gibt die Äquivalenzklasse von u bzgl. der
Myhill-Nerode Relation ≡L an. D.h.: Es sollte gelten
δL (q0 , u) = [u]L .
Definition 3.7 Sei L eine reguläre Sprache über dem Alphabet Σ. Der Myhill-Nerode Automat NL = (QL , Σ, δL , q0 , FL ) für eine reguläre Sprache L hat die folgenden Komponenten:
• Zustandsmenge QL := [u]L : u ∈ Σ∗
d.h.: Die Zustände sind gerade die Äquivalenzklassen der Myhill-Nerode Relation ≡L .
• Startzustand q0 := []L
• akzeptierende Zustände FL := [u]L : u ∈ L
• Programm δL mit
δL [u]L , a := [ua]L für alle u ∈ Σ∗ und a ∈ Σ.
Gilt L(NL ) = L?
Aufgabe 33
Zeige
δL ([v]L , u) = [vu]L
durch Induktion über die Länge von u.
Ja, als Konsequenz der Aufgabe und der Definition von NL gilt L(NL ) = L:
Satz 3.9 Die Sprache L sei regulär. Dann ist der Myhill-Nerode Automat NL der, bis auf
eine Umbenennung der Zustände, einzige minimale DFA für L.
3.2. REGULÄRE SPRACHEN
3.2
79
Reguläre Sprachen
Wir erinnern daran, dass eine Teilmenge L ⊆ Σ∗ eine reguläre Sprache ist, wenn es einen
DFA A gibt mit
L = L(A).
Klar: Um zu zeigen, dass eine Sprache L ⊆ Σ∗ regulär ist, reicht es, einen DFA A mit
L(A) = L zu finden.
Frage: Wie kann man nachweisen, dass eine bestimmte Sprache L ⊆ Σ∗ nicht regulär ist?
3.2.1
Der Satz von Myhill und Nerode
Mit Hilfe der Myhill-Nerode Relation können wir genau sagen, wann eine Sprache regulär ist.
Satz 3.10 (Satz von Myhill und Nerode) Sei Σ ein Alphabet und L eine Sprache über
Σ.
(a) L ist regulär ⇔ Index(L) ist endlich.
(b) Index(L) ist die Zustandszahl eines minimalen deterministischen Automaten für L.
Beweis. Wir haben Teil (a) schon in Satz 3.8 (b) gezeigt. Wir zeigen jede der beiden Richtungen für Teil (a).
⇒ Die Sprache L ⊆ Σ∗ sei regulär. Dann gibt es einen DFA A mit L = L(A). A hat mindestens
Index(L) viele Zustände und Index(L) muss endlich sein.
← Index(L) sei endlich. Dann ist der Myhill-Nerode Automat NL ein DFA für L und die
Sprache L ist regulär.
Wir können die Ernte mit dem Nachweis der Nicht-Regularität für zahlreiche Sprachen einfahren. Hier ist ein erstes Beispiel.
Satz 3.11 L = {an bn : n ∈ N} ist nicht regulär: DFAs können nicht unbeschränkt zählen.
Beweis: Wir müssen unendlich viele Worte uk ∈ {a, b}∗ bestimmen, so dass
uk 6≡L u`
für alle k 6= ` gilt. Setze ui = ai . Für k 6= ` gilt uk bk ∈ L und u` bk 6∈ L: uk 6≡L u` folgt. Wir
erhalten Index(L) = ∞ und L ist nicht regulär.
Satz 3.12 L = {ww : w ∈ {a, b}∗ } ist nicht regulär: DFAs können sich nur endlich viele
Dinge merken.
Beweis: Wir müssen unendlich viele Worte uk ∈ {a, b}∗ bestimmen, so dass
uk 6≡L u`
für alle k 6= ` gilt. Setze ui = ai b. Für k 6= ` gilt uk ak b ∈ L und u` ak b 6∈ L: uk 6≡L u` folgt.
Wir erhalten Index(L) = ∞ und L ist nicht regulär.
Weitere nicht-reguläre Sprachen L erhalten wir indem wir zeigen, dass Index(L) unendlich
groß ist. Das gelingt häufig sogar mit unendlich vielen Worten u1 , u2 , . . . und v1 , v2 , . . ., die
die Eigenschaften
80
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
• ui vi ∈ L und
• ui vj 6∈ L für i 6= j.
besitzen.
Satz 3.13 Keine der folgenden Sprachen ist regulär.
(a) L1 = { an bm : n, m ∈ N, n ≤ m }: DFAs können nicht vergleichen,
(b) L2 = { an bm cn+m : n, m ∈ N }: DFAs können nicht addieren, wenn sie sich an einen
Summanden erinnern müssen,
2
(c) L3 = { an : n ∈ N }: DFAs können nicht quadrieren,
(d) L4 = { w ∈ {a, b}∗ : w ist ein Palindrom }: Endliche Automaten haben nur ein endliches
Gedächtnis.
Der Myhill-Nerode Automat
Der Beweis des Satzes von Nerode hat gezeigt, dass eine Sprache L mit endlichem Index
von einem DFA akzeptiert wird. Wir haben den Beweis erbracht, in dem wir zuerst einen
unendlichen Automaten A für L gebaut haben und angemerkt haben, dass der Äquivalenzklassenautomat A0 endlich ist. Stattdessen hätten wir auch direkt aus der Myhill-Nerode
Relation einen DFA für L bauen können. Genau das tun wir jetzt.
Wir bezeichnen im folgenden die Äquivalenzklasse von x gemäß ≡L mit [x].
Der Myhill-Nerode Automat NL für L:
• Die Zustände von NL sind die Äquivalenzklassen von ≡L .
• Anfangszustand ist [],
• die Menge der akzeptierenden Zustände ist
n
o
F = [x] | x ∈ L
• das Programm ist definiert durch
δ([x], a) = [xa].
Satz 3.14 Index(L) sei endlich.
Dann gilt L = L(NL ), und NL ist ein minimaler DFA für L.
Beweis: Unser Vorgehen ähnelt dem Vorgehen bei der Betrachtung des Äquivalenzklassenautomaten. Zuerst überprüfen wir, ob NL wohldefiniert ist.
Die Gefahr ist, dass [x] = [y] und [xa] 6= [ya] gilt. In diesem Fall hängt die Definition von δ
von der Wahl eines Repräsentanten ab. Wir nehmen an, dass [x] = [y] gilt. Dann folgt für
alle w ∈ Σ∗
xw ∈ L
⇔
yw ∈ L.
3.2. REGULÄRE SPRACHEN
81
Sei a ∈ Σ ein beliebiger Buchstabe. Dann gilt für alle w0 ∈ Σ∗
xaw0 ∈ L
⇔
yaw0 ∈ L,
⇔
[x] ∈ F
und dies bedeutet, dass [xa] = [ya].
Im nächsten Schritt zeigen wir, dass
x∈L
für jedes Wort x ∈ Σ∗ gilt. Dies folgt aus
[x] ∈ F
⇔ Es gibt y ∈ L mit [x] = [y].
⇔ Es gibt y ∈ L, so dass x und y zum selben (akzeptierenden)
Zustand führen.
⇔ x ∈ L.
Wir kommen jetzt zum Nachweis von L = L(NL ). Sei x = x1 · · · xn ∈ Σn . Dann gilt, mit
Startzustand [],
δ([], x1 · · · xn ) = δ(δ([], x1 ), x2 · · · xn )
= δ([x1 ], x2 · · · xn )
= δ([x1 ], x2 · · · xn )
= δ([x1 x2 ], x3 · · · xn )
= δ([x1 · · · xn−1 ], xn )
= [x1 · · · xn ]
= [x]
und wir erhalten
NL akzeptiert x ⇔ [x] ∈ F
⇔ x ∈ L.
Die Minimalität von NL ist eine direkte Konsequenz von Satz 3.8 (b).
Sei A ein DFA. Dann kennen wir jetzt zwei minimale DFAs für L = L(A), nämlich den Äquivalenzklassenautomaten A0 und den Myhill-Nerode Automaten NL = (Σ, QNL , δNL , [], FNL ).
Wir zeigen jetzt, dass alle minimalen DFas für L sogar, bis auf eine Umbenennung der Zustände, identisch sind! Insbesondere sind also A0 und NL „isomorph“.
Bemerkung 3.2 Sei B = (Σ, QB , δB , q0 , FB ) irgendein minimaler DFA für L und L sei eine
Sprache über dem Alphabet Σ. Da B minimal ist, stimmen B und sein Äquivalenzklassenautomat B 0 überein. Wir wissen aus dem Beweis von Satz 3.14, dass
δNL (, x) = [x]
für eine beliebige Eingabe x ∈ Σ∗ und das Programm δNL des Myhill-Nerode Automaten gilt.
Welchen Zustand des Automaten B sollten wir dem Zustand [x] zuweisen? Na klar, genau
den Zustand, den B nach Lesen von x erreicht. Wir setzen also
f ( [x] ) := δB (q0 , x)
82
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
für die „Umbenennungsfunktion“ f : QNL → QB . Aber ist f auch „richtig“ definiert? Insbesondere, wenn [x] = [y], gilt dann auch δB (q0 , x) = δB (q0 , y)? Natürlich, denn x ≡L y und
xw ∈ L ⇔ yw ∈ L für alle w ∈ Σ∗ folgt. Dann gilt aber auch δB (q0 , xw) ∈ FB ⇔ δB (q0 , yw) ∈
FB und die Gleichheit δB (q0 , x) = δB (q0 , y) folgt, da B = B 0 .
Ist die Funktion f injektiv? Wenn f ([x]) = f ([y]), dann gilt δB (q0 , x) = δB (q0 , y) und
δB (q0 , xw) = δB (q0 , yw) folgt für alle w ∈ Σ∗ . Insbesondere gilt also xw ∈ L ⇔ yw ∈ L
und [x] = [y] folgt. Da |QNL | = |QB |, ist f bijektiv, und wir haben die gewünschte Umbenennung erhalten.
Aufgabe 34
Sei Σ = {(, )} das Alphabet aus öffnender und schließender Klammer. Die Sprache K der legalen Klammerausdrücke ist die kleinste Sprache mit den folgenden Eigenschaften.
1. ∈ K
2. w ∈ K → (w) ∈ K
3. u ∈ K ∧ v ∈ K → u ◦ v ∈ K
Zeige, dass die Sprache K aller legalen Klammerausdrücke unendlichen Index hat.
Fazit: Damit ist also K keine reguläre Sprache.
Aufgabe 35
2
Wir betrachten die Sprache L = {0(k ) | k ≥ 1 ist eine natürliche Zahl }.
Zeige, dass die Myhill-Nerode Relation von L unendlichen Index hat (und die Sprache L somit nicht regulär
ist).
Aufgabe 36
Gegeben seien die beiden Sprachen: L1 = {w ∈ {a, b}∗ | ba ist Teilwort von w} und L2 = {w ∈ {a, b}∗ | ab ist
Teilwort von w}.
Konstruiere einen minimalen deterministischen endlichen Automaten, der die Sprache L = L1 ◦ L2 erkennt.
3.2.2
Das Pumping-Lemma
Das Pumping-Lemma formalisiert eine weitere Methode um nachzuweisen, dass eine Sprache
nicht regulär ist.
Satz 3.15 (Pumping-Lemma) Sei L regulär. Dann gibt es eine Pumpingkonstante N , so
dass jedes Wort z ∈ L mit |z| ≥ N eine Zerlegung mit den Eigenschaften
(a) z = uvw, |uv| ≤ N und |v| ≥ 1,
(b) uv i w ∈ L für jedes i ≥ 0
besitzt. (Wenn Worte der Sprache lang genug sind, dann gibt es ein nicht-leeres Teilwort v,
das „aufgepumpt“ (i ≥ 1) oder „abgepumpt“ (i = 0) werden kann.)
In Anwendungen des Pumping-Lemmas wird gezeigt, dass das Auf- oder Abpumpen bestimmter, sorgfältig ausgewählter und genügend langer Worte z ∈ L zu Worten außerhalb der Sprache führt: Das ist im Widerspruch zur Aussage des Pumping-Lemmas und L kann somit nicht
regulär sein!
3.2. REGULÄRE SPRACHEN
83
Beweis: Da L regulär ist, gibt es einen endlichen Automaten A, der L akzeptiert. Sei q0
Anfangszustand und Q Zustandsmenge von A. Wir wählen
N = |Q|
als Pumping-Konstante. Sei z ∈ L mit z = z1 z2 · · · zs und |z| = s ≥ N beliebig gewählt. Der
Automat A durchläuft die Zustandsfolge
z
z
z
z
zN +1
z
1
2
3
N
s
q0 ⇒
q1 ⇒
q2 ⇒
··· ⇒
qN ⇒ · · · ⇒
qs ,
wobei qs ein akzeptierender Zustand ist. Nachdem A den Präfix z1 z2 · · · zN von z gelesen hat,
hat A genau N + 1 Zustände durchlaufen. Ein Zustand qi muß also zweimal aufgetreten sein
und es gibt i, j, j 6= i, mit qi = qj . Demgemäß wählen wir die Zerlegung (falls i < j)
u = z1 · · · zi , v = zi+1 · · · zj , w = zj+1 · · · zs
Dann ist |uv| ≤ N und |v| ≥ 1. Weiterhin gilt
δ(q0 , u) = qi = qj = δ(q0 , uv)
und deshalb akzeptiert A ebenfalls die Worte
uw, uv 2 w, uv 3 w, . . . , uv i w, . . .
Wie zeigt man, dass eine Sprache L nicht regulär ist? Entweder zeigen wir, dass der MyhillNerode von L unendlich ist oder wir müssen das Pumping Lemma falsifizieren. Wenn L
regullär ist, dann
- gibt es eine (uns unbekannte) Pumpingkonstante N ,
- so dass für jedes Wort z ∈ L mit |z| ≥ N
- eine Zerlegung z = uvw mit |uv| ≤ N und |v| ≥ 1 gibt, so dass
uv i w ∈ L
für alle i ≥ 0 gilt.
Wie zeigt man also, dass die Sprache L nicht regulär ist?
- Für jedes mögliche N
- müssen wir ein Wort z ∈ L mit |z| ≥ N konstruieren,
- so dass für jede mögliche Zerlegung z = uvw mit |uv| ≤ N und |v| ≥ 1
uv i w 6∈ L
für mindestens ein i ≥ 0 gilt.
Wir müssen also für jede mögliche Zerlegung z = uvw ein i finden, so dass uv i w ∈
/ L. Ist dies
gelungen, haben wir einen Widerspruch zur Regularität von L erhalten.
84
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
Beispiel 3.13 Wir zeigen, dass die Sprache aller Palindrome über {0, 1}, also
n
L = w ∈ {0, 1}∗ | w = wreverse
o
nicht regulär ist. Wir folgen dem obigen Rezept.
- N sei die unbekannte Pumping-Konstante.
- Wir wählen z = 0N 1 0N (und sichern damit |z| ≥ N ).
- Für jede Zerlegung z = uvw mit |uv| ≤ N und |v| ≥ 1 müssen wir uv i w 6∈ L für
mindestens ein i nachweisen.
Offensichtlich ist uv ein Präfix von 0N , denn wir wissen, dass |uv| ≤ N gilt. Dann gibt es
aber ein k mit v = 0k und
uv 2 w = 0N +k 1 0N 6∈ L.
Die Pumping-Eigenschaft zeigt, dass die Klasse der regulären Sprachen sehr eingeschränkt
ist. Aber:
Aufgabe 37
Zeige, dass jede endliche Menge regulär ist.
Aufgabe 38
Wir beweisen mit Hilfe des Pumping Lemmas, dass die endliche Sprache L = {a, b}100 nicht regulär ist.
Nehmen wir an L sei regulär. Aus dem Pumping Lemma folgt, dass es für das Wort a100 eine
Zerlegung a100 = xyz mit |xy| ≤Pumpingkonstante und |y| ≥ 1 gibt, so dass jedes Wort xy k z
(mit k ≥ 0 ) auch zu L gehört. Wir erhalten einen Widerspruch zur Annahme, dass die Sprache
L endlich ist, denn es gibt unendlich viele Strings der Form xy k z.
Finde den Fehler im Beweis.
Aufgabe 39
Zeige mit Hilfe des Pumping Lemmas, dass die folgenden Sprachen nicht regulär sind:
(a) L = {w ∈ {0, 1}∗ | w hat genau so viele Nullen wie Einsen }.
(b) L = {wwreverse | w ∈ {0, 1}∗ }.
Aufgabe 40
Beweise das verallgemeinerte Pumping Lemma. Die zu beweisende Aussage ist wie folgt:
Sei L eine reguläre Sprache. Dann gibt es eine Konstante n, so dass für jedes z ∈ L mit vorgegebener
Partition z = tyx mit |y| = n eine Zerlegung y = uvw mit |v| ≥ 1 gefunden werden kann, so dass
tuv i wx ∈ L für alle i ≥ 0.
(Mit anderen Worten, das verallgemeinerte Pumping Lemma erlaubt ein „Fenster“ der Länge n über die
Eingabe zu schieben, so dass innerhalb dieses Fensters „gepumpt“ werden kann.)
Aufgabe 41
Wende dieses verallgemeinerte Pumping Lemma an, um zu zeigen, dass die Sprache L = {1k | k ≥ 0} ∪
2
{0j 1(k ) | j ≥ 1, k ≥ 0} nicht regulär ist. ( L enthält alle Wörter, die mit mindestens einer Null beginnen,
gefolgt von einer quadratischen Anzahl von Einsen.)
Warum kann mit Hilfe des Pumping Lemmas der Vorlesung nicht gezeigt werden, dass L von keinem endlichen
Automaten akzeptiert wird?
(Das Pumping Lemma liefert somit keine hinreichende Bedingung für die Regularität von Sprachen.)
Aufgabe 42
Zeige, dass die wie folgt definierte Sprache über dem Eingabealphabet Σ = {0, 1} nicht regulär ist:
3.3. ENDLICHE AUTOMATEN UND NICHTDETERMINISMUS
L=
85
{w ∈ {0, 1}∗ | w hat eine Zerlegung der Form w = x1 . . . xn y1 . . . yn z0 , z1 . . . zn
für ein n ∈ N und es gilt
n
P
zi 2n−i =
n
P
xi 2n−i +
i=1
∗
i=0
n
P
yi 2n−i }
i=1
(Dies soll salopp formuliert heißen: Ein Wort w ∈ {0, 1} liegt in L, wenn es eine “korrekte Binäraddition”
beschreibt.)
3.3
Endliche Automaten und Nichtdeterminismus
Wir führen nichtdeterministische endliche Automaten (NFAs) ein und führen einen Vergleich
mit DFAs durch. Wir können die beiden folgenden wichtigen Fragen zufriedenstellend beantworten:
(a) Können NFAs nicht-reguläre Sprachen akzeptieren?
(b) Können NFAs reguläre Sprachen mit weitaus weniger Zuständen als DFAs akzeptieren?
Dann ändern wir das Automatenmodell und betrachten Zweiwege Automaten, die ihren Lesekopf sowohl nach links wie auch nach rechts bewegen dürfen. Auch hier vergleichen wir wieder
Determinismus und Nichtdeterminismus, können diesmal aber nur partielle Antworten geben.
3.3.1
Nichtdeterministische endliche Automaten: NFAs
Wir entwickeln nichtdeterministische endliche Automaten (NFAs), um Sprachen kurz beschreiben zu können.
Definition 3.8 Ein nichtdeterministischer endlicher Automat (NFA) hat die folgenden
Komponenten:
• eine endliche Menge Q von Zuständen,
• das Eingabealphabet Σ,
• den Anfangszustand q0 ∈ Q,
• eine Menge F ⊆ Q akzeptierender Zustände
• sowie das Programm δ, das wir als Funktion
δ : Q × Σ → P(Q)
auffassen, wobei P(Q) die Potenzmenge von Q bezeichnet.
Wenn ein deterministischer Automat im Zustand p den Buchstaben a liest, dann ist der
Nachfolgezustand eindeutig festgelegt, also „determiniert“. Ein nichtdeterminischer Automat
hingegen hat möglicherweise viele Optionen: Jeder Zustand in der Menge δ(p, a) kommt als
Nachfolgezustand in Frage! Ein NFA kann also im Gegensatz zu einem DFA viele verschiedene
Berechnungen auf einer Eingabe w durchführen. Wann sollten wir sagen, dass w akzeptiert
wird?
Wir legen fest, dass w genau dann akzeptiert wird, wenn mindestens eine Berechnung erfolgreich ist, also auf einen akzeptierenden Zustand führt.
86
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
Definition 3.9 Sei N = (Q, Σ, δ, q0 , F ) ein NFA. Automat.
(a) Wir definieren die Fortsetzung
δ : Q × Σ∗ → P(Q)
von Buchstaben auf Worte rekursiv wie folgt:
- δ(q, ) = {q}
- δ(q, wa) =
S
δ(p, a)
p∈δ(q,w)
Hiermit drücken wir aus, dass ein Zustand r ∈ Q durch Eingabe wa vom Zustand q aus
„erreichbar“ ist, falls ein Zustand p durch Eingabe w vom Zustand q erreichbar ist und
r ∈ δ(p, a) ein möglicher Nachfolgezustand ist.
(b) N akzeptiert w genau dann, wenn es einen akzeptierenden Zustand p ∈ F mit p ∈
δ(q0 , w) gibt.
L(N ) = {w ∈ Σ∗ | N akzeptiert w}
ist die von N akzeptierte (oder erkannte) Sprache.
Beschreibungen regulärer Sprachen durch DFAs erfordern manchmal „unangenehm“ viele
Zustände, obwohl die Sprachen einfach sind.
Beispiel 3.14 Wie betrachten die Sprache
Lk = {0, 1}∗ · {1} · {0, 1}k−1 .
Lk besteht also aus allen binären Worten, so dass der kletzte Buchstabe eine Eins ist. Wir
konstruieren einen sehr kleinen nichtdeterministischen Automaten, der die Position des (k)letzten Bits rät und nachfolgend verifiziert. Dies führt auf das folgende Zustandsdiagramm:
0, 1
q0
1
q1
0, 1
q2
0, 1
0, 1
qk
Dem entspricht das Programm δ(q0 , 0) = {q0 }, δ(q0 , 1) = {q0 , q1 }, . . ., δ(qi , 0) = δ(qi , 1) =
{qi+1 } für 1 ≤ i < k und δ(qk , 0) = δ(qk , 1) = ∅.
Man beachte, dass es durchaus erlaubt ist, einen NFA partiell zu definieren: Im obigen Beispiel
haben wir keine Übergänge vom Zustand qk aus definiert. Damit ist für alle w ∈ Σ∗
δ(qk , w) = ∅.
Wir zeigen, dass der Index von Lk mindestens 2k beträgt. Damit muß also jeder DFA für Lk
mindestens 2k Zustände und damit exponentiell mehr Zustände als unser NFA besitzen.
Es genügt zu zeigen, dass zwei beliebige, verschiedene Worte u, v ∈ {0, 1}k nicht Myhill-Nerode
äquivalent sind. Seien u, v ∈ {0, 1}k also beliebige verschiedene Worte.
Es gibt eine Position i mit ui 6= vi . Ohne Beschränkung der Allgemeinheit gelte
ui = 0 und vi = 1.
3.3. ENDLICHE AUTOMATEN UND NICHTDETERMINISMUS
87
Wir erhalten
v 0i−1 = v1 · · · vi−1 1 vi+1 · · · vk 0i−1 ∈ Lk ,
aber
u 0i−1 = u1 · · · ui−1 0 ui+1 · · · uk 0i−1 ∈
/ Lk .
Die beiden Worte u und v sind also nicht Myhill-Nerode äquivalent.
Sind denn nichtdeterministische Automaten überhaupt nützlich, d.h können wir das Wortproblem
Überprüfe für einen gegebenen nichtdeterministischen Automaten N und eine Eingabe
w, ob N die Eingabe w akzeptiert.
effizient lösen? Der Automat N rechnet nichtdeterministisch, aber wir müssen das Wortproblem mit einem deterministischen Algorithmus lösen!
Aufgabe 43
Sei N = (Q, Σ, δ, q0 , F ) ein nichtdeterministischer endlicher Automat (NFA). Beschreibe einen Algorithmus,
der das Wortproblem für N löst: Der Algorithmus muss also für eine Eingabe w ∈ Σ∗ entscheiden, ob N das
Wort w akzeptiert. Zeige, dass eine Laufzeit von O(|w| · |Q|2 ) ausreichend ist.
Hinweis: Für ein Wort w ∈ Σ∗ ist die Menge δ(q0 , w), also die Menge der Zustände, die vom Startzustand q0
nach Lesen von w erreichbar sind, zu bestimmen.
Das Wortproblem für nichtdeterministische Automaten ist also effizient lösbar und nichtdeterministische Automaten erlauben in einigen Fällen sehr viel kürzere Beschreibungen: Wo ist
der Haken? Sind die von nichtdeterministischen Automaten erkannten Sprachen auch stets regulär? Da steckt der Haken nicht, wie wir im nächsten Abschnitt zeigen, der Haken steckt zum
Beispiel in der Minimierung: Eine effiziente Minimierung nichtdeterministischer Automaten
ist in aller Wahrscheinlichkeit nicht mehr möglich.
Die Potenzmengenkonstruktion
Wir zeigen, wie äquivalente deterministische Automaten gebaut werden können und beginnen
mit einem Beispiel.
Beispiel 3.15 Der NFA N mit Zustandsdiagramm
a, b
q0
a
q1
b
q2
akzeptiert alle Worte über {a, b}∗ , die mit ab enden, die also ab als Suffix besitzen. Unser
Ziel ist die Konstruktion eines äquivalenten DFA A. Unsere Idee ist die gleichzeitige Simulation aller Berechnungen von N . Demgemäß wählen wir Teilmengen der Zustandsmenge
Q = {q0 , q1 , q2 } als Zustände.
88
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
Ziel der Konstruktion: Wenn der DFA A die Eingabe w gelesen hat und sich im Zustand
s ⊆ Q befindet, dann fordern wir
!
s = {p ∈ Q | Es gibt eine Berechnung von N für w, die in p endet}.
Die rechte Seite der Gleichung stimmt natürlich mit
δN (q0 , w)
überein. Wir geben jetzt die Konstruktion von A Schritt für Schritt an.
Schritt 1: Wir wählen {q0 } als Anfangszustand von A. Mit dem Buchstaben a kann N die
Zustandsmenge {q0 , q1 } erreichen, mit dem Buchstaben b hingegen nur die Zustandsmenge
{q1 }. Wir setzen deshalb
δ({q0 }, a) = {q0 , q1 } und δ({q0 }, b) = {q0 }.
mit dem vorläufigem Zustandsdiagramm
b
{q0 }
a
{q0 , q1 }
Schritt 2: Von {q0 , q1 } aus kann N mit Buchstaben a die Zustandsmenge {q0 , q1 } erreichen. Für den Buchstaben b wird die Zustandsmenge {q0 , q2 } erreicht. Deshalb setzen wir das
Diagramm wie folgt fort:
a
b
{q0 }
a
{q0 , q1 }
b
{q0 , q2 }
Wir haben den Zustand {q0 , q2 } als akzeptierend markiert. Warum? Weil der Zustand q2
akzeptierend ist und der Zustand {q0 , q2 } somit von mindestens einer akzeptierenden Berechnung erreicht wird.
Schritt 3: Wir setzen die Zustandsübergänge vom Zustand {q0 , q2 }. Mit dem Buchstaben a
wird die Zustandsmenge {q0 , q1 } erreicht, mit dem Buchstaben b verharrt man in der Menge
{q0 , q2 }.
a
b
b
b
{q0 }
a
{q0 , q1 }
{q0 , q2 }
a
3.3. ENDLICHE AUTOMATEN UND NICHTDETERMINISMUS
89
Beachte, dass unsere Konstruktion beendet ist, da wir einen vollständig definierten DFA erhalten haben. Statt der acht möglichen Zustände, nämlich den acht Teilmengen von {q0 , q1 , q2 }
entsprechend, haben wir nur drei Zustände. Dies ist eine Konsequenz useres Vorgehens: Wir
haben zuerst den Anfangszustand {q0 } „expandiert“ und Übergänge für alle Buchstaben des
Alphabets berechnet. Danach haben wir nur solche Zustände expandiert auf die wir vorher
gestoßen sind.
Die Potenzmengenkonstruktion, die wir in diesem Beispiel angewandt haben, kann für jeden
NFA benutzt werden.
Satz 3.16 Äquivalenz von DFAs und NFAs
Sei N ein nichtdeterministischer Automat mit Komponenten QN , Σ, δN , q0 und FN . Der
deterministische Automat A habe die Komponenten
• QA = {t | t ⊆ QN },
• Anfangszustand {q0 },
• FA = {t ∈ QA | t enthält einen Zustand aus FN }
• δA ist definiert durch
n
o
δA (t, a) = p ∈ QN | Es gibt q ∈ t mit p ∈ δN (q, a) .
Dann sind N und A äquivalent, das heißt es gilt L(N ) = L(A).
Beweis: Wir werden zeigen, dass
δA ({q0 }, w) = {p ∈ QN | Es gibt eine Berechnung von N für w, die p erreicht}.
(3.5)
Ist dies gezeigt, folgt
N akzeptiert w ⇔ Es gibt p ∈ FN mit p ∈ δN (q0 , w)
⇔ δA ({q0 }, w) ∈ FA
⇔ A akzeptiert w,
und die Behauptung des Satzes ist gezeigt.
Wir beweisen (3.5) durch Induktion über die Länge von w.
Basis:
|w| = 0.
Es ist δA ({q0 }, ) = {q0 }, aber auch alle Berechnungen von N für erreichen nur q0 .
Induktionsschritt:
Es gelte w =
w0 a
|w| = n + 1
und s0 = δA ({q0 }, w0 ). Wir erhalten
δA ({q0 }, w) = δA (δA ({q0 }, w0 ), a)
= δA (s0 , a)
= {p ∈ Q | Es gibt q ∈ s0 mit p ∈ δN (q, a)}
= {p ∈ Q | Es gibt eine Berechnung von N für
(3.6)
w0 ,
die einen
Zustand q ∈ Q erreicht mit p ∈ δN (q, a)}
(3.7)
= {p ∈ Q | Es gibt eine Berechnung von N für w, die p
erreicht},
(3.8)
und dies war zu zeigen. Gleichung (3.6) folgt gemäß Definition von δA . Gleichung (3.7) wendet
die Induktionshypothese an, während Gleichung (3.8) die Definition von δN widerspiegelt.
90
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
Bemerkung 3.3 A könnte überflüssige Zustände besitzen. Dies stellt kein Problem dar, wenn
wir wie im Beispiel vorgehen, also nur Zustandsmengen betrachten, die aus vom Startzustand
erreichbaren Zuständen bestehen.
Aufgabe 44
Sei N OT -EQk = {xy | x, y ∈ {0, 1}k , x 6= y}.
(a) Zeige, dass
Index(N OT -EQk ) ≥ 2k
gilt: Jeder deterministische endliche Automat für die Sprache N OT -EQk muss also mindestens 2k
Zustände besitzen.
(b) Beschreibe einen nichtdeterministischen endlichen Automaten mit möglichst wenigen Zuständen, der
die Sprache N OT -EQk erkennt.
Aufgabe 45
Betrachte den folgenden nichtdeterministischen endlichen Automaten N über dem Eingabealphabet Σ = {0, 1}
mit der Zustandsmenge Q = {q0 , . . . , q4 }, dem Anfangszustand q0 und F = {q4 }:
0,
1
⇒
q0m
1
? 1
- q1m
- q2m
0, 1
- q3m
1
- q4m
j
Führe die Potenzmengenkonstruktion für N aus und beschreibe den resultierenden deterministischen Automaten (mit Ausnahme überflüssiger Zustände!) durch sein Zustandsdiagramm.
Aufgabe 46
Für eine reguläre Sprache L ⊆ Σ∗ definieren wir
Präfix(L) = {w | es gibt ein v ∈ Σ∗ , so dass w · v ∈ L }.
Präfix(L) besteht also aus allen Präfixen von Wörtern aus L. Ist Präfix(L) regulär? Ist
Suffix(L) = {w | es gibt ein v ∈ Σ∗ , so dass v · w ∈ L }
regulär?
Aufgabe 47
Zeige oder widerlege: Wenn die unendlich
vielen Sprachen L1 , L2 , . . . , Ln , Ln+1 , . . . alle regulär sind, dann
S∞
ist auch die unendliche Vereinigung i=0 Li regulär.
Aufgabe 48
Das Minimierungsproblem für NFA’s ist mit aller Wahrscheinlichkeit nicht effizient lösbar: alle bekannten
Minimierungsalgorithmen benötigen eine Laufzeit, die exponentiell in der Anzahl der Zustände des zu minimierenden NFA ist.
Auch die Bestimmung der minimalen Zustandszahl ist ein komplexes Problem, das sich aber in einigen Fällen
lösen lässt.
(a) Zeige, dass jeder NFA für
Lm = {an : n ∈ N und n ist durch m teilbar}
mindestens m Zustände besitzt.
(b) Beweise oder widerlege: Wenn es NFA’s für L1 bzw. L2 mit höchstens n1 bzw. n2 Zuständen gibt,
dann gibt es einen NFA für L1 ∩ L2 mit höchstens n1 + n2 Zuständen.
3.3. ENDLICHE AUTOMATEN UND NICHTDETERMINISMUS
3.3.1.1
91
Minimierung von NFAs
DFAs können effizient minimiert werden: Es gibt Algorithmen, die einen DFA (mit Alphabet
Σ und Zustandsmenge Q) in Zeit O(|Σ| · |Q| · log |Q|) minimieren1 . Das Minimierungsproblem
für NFAs hingegen ist knüppelhart: Schon die Frage, ob L(A) 6= Σ∗ gilt, also ob der NFA
A mindestens ein Wort nicht akzeptiert, ist PSPACE-hart. Bitte auf der Zunge zergehen lassen: Die Frage, ob ein einziger Zustand ausreicht, ist so schwierig, wie die Bestimmung von
Gewinnstrategien für nicht-triviale Zwei-Personen Spiele. (Dieses Ergebnis zeigen wir in Satz
6.15.)
Aber für einige Sprachen L lassen sich zumindest gute „unteren Schranke“ für die Zustandszahl von NFAs angeben. Wie also kann man zeigen, dass jeder NFA, der L akzeptiert, mindestens k Zustände hat?
1. Wenn man Glück hat, gilt Index(L) ≥ 2k .
Dann hat nämlich jeder DFA für L mindestens 2k Zustände. Aus einem NFA für L mit
0
k 0 < k Zuständen kann man mit der Potenzmengenkonstruktion einen DFA mit 2k < 2k
Zuständen bauen. Als Konsequenz hat jeder NFA für L mindestens k Zustände.
2. Und wenn wir Pech haben?
Wir betrachten die Sprache
Lk = {0, 1}∗ · {1} · {0, 1}k−1
aus Beispiel 3.14. Wir haben gesehen, dass der Index von Lk mindestens 2k beträgt und
dementsprechend werden NFAs mindestens k Zustände besitzen. Aber wir haben nur einen
NFA mit k + 1 Zuständen angeben können. Sind denn k + 1 Zustände wirklich notwendig?
Satz 3.17 (Fooling Set Methode)
Sei Σ ein endliches Alphabet, L eine Sprache über Σ und sei k ≥ 1.
Falls es Paare von Worten (ui , vi ) für i ∈ { 1, . . . , k } gibt, so dass
• für alle i ∈ { 1, . . . , k } gilt: ui vi ∈ L,
• für alle i, j ∈ { 1, . . . , k } mit i 6= j gilt:
und
ui vj 6∈ L oder uj vi 6∈ L,
so muss jeder NFA, der L akzeptiert, mindestens k Zustände haben.
Die Menge { (ui , vi ) : i ∈ { 1, . . . , k }} wird auch Fooling Set der Größe k für L genannt.
Aufgabe 49
(a) Zeige Satz 3.17.
(b) Sei EQk = {xy | x, y ∈ {0, 1}k , x = y}. Zeige: EQk hat ein Fooling Set der Größe 2k . Jeder nichtdeterministische endliche Automat, der die Sprache EQk erkennt, benötigt also mindestens 2k Zustände.
(c) Sei Lk = {0, 1}∗ · {1} · {0, 1}k−1 . Zeige: Lk hat ein Fooling Set der Größe k+1. Unser NFA für Lk ist
also minimal.
1
N. Blum, An O(n log n) implementation of the standard method for minimizing n-state finite automata,
Information Processing Letters, 57, Seiten 65-69 1996
92
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
3.3.1.2
NFAs mit -Übergängen
Manchmal erhalten wir eine noch kürzere Beschreibung, wenn wir -Übergänge zulassen, also
Zustandsübergänge für die kein Buchstabe gelesen werden muss.
Definition 3.10
Ein NFA (Q, Σ, δ, q0 , F ) mit -Übergängen ist wie ein konventioneller NFA definiert. Als
einziger Unterschied hat das Programm jetzt die Form
δ : Q × Σ ∪ {} → P(Q)
Der Automat darf „-Übergänge“ benutzen, darf also einen Zustandswechsel durchführen ohne
Buchstaben zu lesen.
Auch bei -Übergängen werden nur reguläre Sprachen akzeptiert. Dies folgt, da wir -Übergänge
nach dem folgenden Schema entfernen können: Wenn es einen Weg von Zustand p nach Zustand q gibt und dieser Weg mit der Konkatenation a ∈ Σ markiert ist, dann füge die gerichtete
Kante (p, q) mit Markierung a ein. Nach diesem Einfüge-Schritt entferne alle -Übergänge.
3.3.2
Abschlusseigenschaften
Wir erinnern an die Definition von NFAs mit -Übergängen aus Definition 3.10. -Übergänge
helfen zum Beispiel im Nachweis der folgenden Abschlusseigenschaften.
Satz 3.18 Die Sprachen L, L1 und L2 seien regulär. Es folgt
(a) L ist regulär.
(b) L1 ∪ L2 und L1 ∩ L2 sind regulär.
(c) L1 ◦ L2 ist regulär.
(d) L∗ ist regulär.
Beweis: Die deterministischen Automaten A, A1 bzw. A2 mögen die Sprachen L, L1 bzw.
L2 akzeptieren.
(a) Q sei die Zustandsmenge von A. Ersetze die Menge F der akzeptierenden Zustände von
A durch Q \ F .
(b) Wir zeigen nur, dass L1 ∪ L2 regulär ist. (Die Regularität von L1 ∩ L2 folgt mit (a), da
L1 ∩ L2 = L1 ∪ L2 .)
L1 ∪ L2 ist regulär, da der Automat
A1
3
q0
3
genau die Vereinigung akzeptiert.
A2
3.3. ENDLICHE AUTOMATEN UND NICHTDETERMINISMUS
93
(c) Wir verbinden alle akzeptierenden Zustände von A1 durch -Übergänge mit dem Startzustand von A2 . Die akzeptierenden Zustände von A2 sind die akzeptierenden Zustände
des neuen Automaten: Der neue Automat akzeptiert L1 ◦ L2 .
(d) Verbinde alle akzeptierenden Zustände von A durch -Übergänge mit einem neuen Startzustand q0∗ : Der Zustand q0∗ wird auch der einzige akzeptierende Zustand des neuen Automaten. Schließlich füge einen -Übergang von q0∗ zum alten Startzustand q0 ein. Da q0∗
akzeptierend ist, wird auch das leere Wort akzeptiert, und der neue Automat akzeptiert
die Sternhülle.
Aufgabe 50
Ist die Konstruktion in Teil (d) richtig?
Die Klasse der regulären Sprachen ist also unter den wichtigsten mengentheoretischen Operationen abgesclossen wie auch unter der Konkatenation und der Sternoperation.
Aufgabe 51
Seien Σ1 und Σ2 Alphabete.
(a) Eine Substitution ist eine Funktion s von Σ1 nach P(Σ∗2 ) und S
wird durch die Vorschrift s(ε) = {ε},
s(wa) = s(w) ◦ s(a) auf Wörter aus Σ∗1 sowie durch s(L) = w∈L s(w) auf eine Sprache L ⊆ Σ∗1
fortgesetzt. Mit anderen Worten: In jedem Wort w ∈ L dürfen wir jeden Buchstaben a ∈ Σ1 durch ein
beliebiges Wort aus einer Sprache s(a) ersetzen. Falls die Sprache s(a) für jedes a ∈ Σ1 regulär ist, ist
s eine reguläre Substitution.
Zeige, dass die Klasse der regulären Sprachen abgeschlossen unter regulären Substitutionen ist, das
heißt: Ist L eine reguläre Sprache, so ist auch jede reguläre Substitution von L regulär.
(b) Ein Homomorphismus ist eine Funktion h von Σ1 nach Σ∗2 und wird durch h(ε) = ε, h(wa) = h(w)h(a)
auf Wörter aus Σ∗1 sowie durch h(L) = {h(w) | w ∈ L} auf eine Sprache L ⊆ Σ∗1 fortgesetzt. Homomorphismen können als Spezialfall regulärer Substitionen angesehen werden: Jeder Buchstabe wird durch
ein bestimmtes Wort ersetzt.
Die Funktion h−1 von Σ∗2 nach P(Σ∗1 ) mit h−1
{v ∈ Σ∗1 | h(v) = w} heißt inverser HomomorS(w) = −1
−1
phismus und wird wiederum durch h (L) = w∈L h (w) auf eine Sprache L ⊆ Σ∗2 fortgesetzt. Mit
anderen Worten: h−1 (L) enthält all diejenigen Wörter, die durch h auf ein Wort in L abgebildet werden.
Zeige, dass die Klasse der regulären Sprachen abgeschlossen unter inversen Homomorphismen ist.
Aufgabe 52
2
Mit dem Pumping-Lemma lässt sich zeigen, dass die Sprachen L1 = {an | n ≥ 1} und L2 = {am bm | m ≥ 1}
nicht regulär sind. Seien L3 = {abab2 ab3 a · · · bn a | n ≥ 0} und L4 = {a, b}∗ ∪ {ck am bm | k, m ≥ 0}.
(a) Finde einen Homomorphismus h, so dass h(L3 ) = L1 .
(b) Finde einen Homomorphismus h und eine reguläre Sprache R, so dass h(L4 ∩ R) = L2 .
(c) Finde Homomorphismen g und h und eine reguläre Sprache R, so dass g(h−1 (L3 ) ∩ R) = L2 .
Also sind auch L3 und L4 nicht regulär.
3.3.3
Zweiwege Automaten
Deterministische Zweiwege Automaten (2DFAs) verhalten sich wie konventionelle DFAs, können aber in jedem Schritt entscheiden, ob sie den vorangegangenen linken oder den folgenden
rechten Buchstaben der Eingabe w ∈ Σ∗ besuchen möchten. Um Zweiwege Automaten zu beschreiben, markieren wir zuerst das linke Ende der Eingabe mit dem Buchstaben α und das
rechte Ende mit dem Buchstaben β, die Eingabe w wird also durch die transformierte Eingabe
αwβ ersetzt. (Wir nehmen natürlich an, dass α und β nicht im Alphabet Σ vorkommen.)
94
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
Definition 3.11 Ein deterministischer endlicher Zweiwege Automat (oder 2DFA)
(Σ, Q, δ, q0 , F ) hat die folgenden Komponenten:
• das Eingabealphabet Σ für das {α, β} ∩ Σ = ∅ gelte,
• eine endliche Menge Q von Zuständen,
• das Programm δ, das wir als Funktion
δ : Q × (Σ ∪ {α, β}) → Q × { links, rechts }
auffassen. Wir nehmen also an, dass die Eingabe w durch das Wort αwβ repräsentiert
wird.
• den Anfangszustand q0 ∈ Q
• sowie eine Menge F ⊆ Q akzeptierender Zustände.
Wie arbeitet ein 2DFA A auf einer Eingabe w ∈ Σ∗ ? A arbeitet auf der transformierten
Eingabe αwβ. Wie auch im Fall von DFAs beginnt A im Anfangszustand q0 mit dem Lesen des
ersten Buchstabens α der (transformierten) Eingabe. In jedem Schritt schreibt das Programm
δ die Leserichtung vor, wobei A allerdings die Eingabe αwβ nicht nach links verlassen darf.
A akzeptiert das Wort w genau dann, wenn der Automat die transformierte Eingabe nach
rechts in einem Zustand aus F verlässt. Die Sprache
L(A)
ist die Menge aller von A akzeptierten Worte w ∈ Σ∗ .
Zweiwege Automaten können im Vergleich zu DFAs weitaus kompaktere Beschreibungen erreichen.
Aufgabe 53
Die Sprache EQk der Gleichheit von Worten der Länge k ist definiert durch
EQk = { uu : u ∈ {a, b}k }.
Wir erinnern an die Sprache
Lk = {0, 1}∗ · {1} · {0, 1}k−1 .
Beschreibe Zweiwege Automaten mit möglichst wenigen Zuständen für EQk wie auch für Lk .
Wie auch im Fall von DFAs können wir für 2DFAs in völlig analoger Weise 2NFAs, also nichtdeterministische Zweiwege Automaten einführen: Das Programm δ eines 2NFA ist diesmal
eine Funktion
δ : Q × (Σ ∪ {α, β}) → P(Q × { links, rechts }).
Die Sprache L(N ) eines 2NFAs N definieren wir natürlich als die Menge aller Worte w ∈ Σ∗ ,
so dass w von einer Berechnung von N akzeptiert wird.
2NFAs erscheinen sehr mächtig. Zwar dürfen sie sich keine Notizen machen, haben also keinen
modifizierbaren Speicher, aber sie sind nicht an den Einwege-Modus von DFAs gebunden und
dürfen darüberhinaus nichtdeterministisch rechnen.
Frage: Können 2NFAs nicht-reguläre Sprachen akzeptieren?
Satz 3.19 (Zweiwege Automaten akzeptieren nur reguläre Sprachen)
N sei ein 2NFA. Dann ist L(N ) regulär.
3.3. ENDLICHE AUTOMATEN UND NICHTDETERMINISMUS
95
Beweis: Wir simulieren den 2NFA N = (Σ, QN , δN , q0 , FN ) durch einen NFA N ∗ . Wir benötigen die Menge F aller Funktionen f : QN → (QN ∪ {⊥}), wobei ⊥ das Symbol für
„undefiniert“ ist.
Beachte zuerst, dass wir uns auf Berechnungen von N beschränken können, die jede Eingabeposition höchstens einmal in demselben Zustand besuchen. Wir wählen
QN ∗ = QN × F
als Zustandsmenge von N ∗ . Wenn N ∗ den Zustand (p, f ) annimmt, dann spekuliert N ∗ , dass
N eine Berechnung besitzt, die
(a) den bisher gelesenen Präfix der Eingabe zum ersten Mal im Zustand p nach rechts hin
verlässt und
(b) den Präfix im Zustand f (r) nach rechts verlässt, wenn es den Präfix im Zustand r von
rechts aus betritt. (Wenn f (r) =⊥, dann betritt N unter dieser Berechnung den Präfix
von rechts kommend nicht im Zustand r.)
Mit anderen Worten, der Zustand (p, f ) wettet darauf, dass der bisher gelesene Präfix zum
ersten Mal nach rechts im Zustand p verlassen wird und dass f die Reaktion auf einen „Besuch
von rechts“ festhält.
Wir sagen, dass p0 für den Buchstaben a konsistent mit (p, f ) ist und schreiben
p0 ∈ K((p, f ), a),
wenn es eine Zustandsfolge (p1 , q1 , . . . , pk−1 , qk−1 , pk ) gibt mit
• p1 = p.
• (qi , links) ∈ δN (pi , a) und pi+1 = f (qi ).
• (p0 , rechts) ∈ δN (pk , a).
Wenn p0 für a konsistent mit (p, f ) ist, dann gibt es eine mit f konsistente Berechnung, die
im Zustand p beginnt und zum ersten Mal im Zustand p0 den Buchstaben a nach rechts hin
verlässt.
Wir beschreiben das Programm δN ∗ für unseren NFA N ∗ . Wir sagen, dass N ∗ von seinen
Startzustand q0∗ in einen Zustand (p, f ) wechseln darf, falls (p, rechts) ∈ δN (q0 , α) und
(f (r), rechts) ∈ δN (r, α) für alle Zustände r ∈ QN gilt. (Wenn δN (α, r) = ∅, setze f (r) =⊥.)
Wir setzen also
δN ∗ (q0∗ , α) = { (p, f ) : N ∗ darf in den Zustand (p, f ) wechseln }.
N ∗ besitzt einen Zustandsübergang
(p0 , f 0 ) ∈ δN ∗ (p, f ), a ,
wenn
(a) p0 ∈ K((p, f ), a) und
(b) für jeden Zustand r ∈ QN ist (f 0 (r), rechts ) ∈ δN (r, a),
96
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
die Berechnung von N besucht den Präfix von rechts kommend im Zustand r und
kehrt sofort wieder im Zustand f 0 (r) um,
oder es gibt einen Zustand s ∈ QN mit (s, links ) ∈ δN (r, a) und f 0 (r) ∈ K((s, f ), a).
Die Berechnung von N wandert zuerst um eine Position nach links und wechselt
in den Zustand s. Nach möglicherweise vielen weiteren Schritten verlässt sie den
Buchstaben a nach rechts hin im Zustand f 0 (r), wobei f 0 (r) ∈ K((s, f ), a) gilt.
Wir erfinden einen neuen Zustand „ja“ für N ∗ und setzen FN ∗ := { ja }. Wann sollte N ∗
akzeptieren, wenn N ∗ das Endesymbol β im Zustand (p, f ) liest? Genau dann, wenn es einen
Zustand p0 ∈ FN mit p0 ∈ K((p, f ), β)) gibt. In einem solchen Fall setzen wir
δN ∗ ((p, f ), β) := {( ja , rechts )}
für p ∈ FN . In allen anderen Fällen ist δN ∗ ((p, f ), β) := ∅.
Anfänglich, für (p, f ) ∈ δN ∗ (q0∗ , α), haben wir sichergestellt, dass N eine Berechnung besitzt,
die α im Zustand p nach rechts verlässt und dass f die Reaktion dieser Berechnung auf
einen Besuch von α, von rechts kommend, beschreibt. Wir haben sodann Zustandsübergänge
a
(p, f ) 7→ (p0 , f 0 ) so definiert, dass N ∗ genau dann den Zustand (p, f ) nach Lesen von αu
annimmt, wenn N eine Berechnung hat, die
• αu zum ersten Mal im Zustand p verlässt
• und αu im Zustand f (r) verlässt, falls αu im Zustand r von rechts betreten wird.
Die letzte Aussage zeigt man durch vollständige Induktion über die Länge von u.
Wenn N ∗ den Begrenzer β im Zustand (p, f ) erreicht, dann wird N den Begrenzer zum ersten
Mal im Zustand p besuchen und die transformierte Eingabe in den Zuständen aus K((p, f ), β)
nach rechts verlassen. Also akzeptiert N ∗ die transformierte Eingabe αwβ genau dann, wenn
N das Wort w akzeptiert.
3.3.3.1
Determinismus gegen Nichtdeterminismus
Wir haben gesehen, dass NFAs einige Sprachen wie etwa L = {0, 1}∗ ◦ {0} ◦ {0, 1}k−1 mit sehr
viel weniger Zuständen akzeptieren können als DFAs. Man sollte ein ähnliches Phänomen
auch für den Vergleich von 2NFAs und 2DFAs erwarten, allerdings ist der Nachweis einer
exponentiellen Ersparnis bis heute nicht gelungen. Wir betrachten deshalb „sweeping DFAs“
(SDFAs), also 2DFAs, die ihre Eingabe in Phasen bearbeiten, wobei der 2DFA in einer Phase
die Eingabe zuerst von ganz links nach ganz rechts und darauffolgend von ganz rechts nach
ganz links lesen darf.
Aufgabe 54
Betrachte die Sprache
Ln := { xy : x, y ∈ {0, 1}n und x 6= y }.
(a) Konstruiere SDFAs, die Ln mit möglichst wenigen Zuständen akzeptieren.
(b) Konstruiere NFAs sowie 2DFAs, die (Ln $)∗ mit möglichst wenigen Zuständen akzeptieren.
Aufgabe 55
Betrachte die Sprache Ln = {0, 1}∗ {1}{0, 1}n−1 {1}{0, 1}∗ .
(a) Zeige: Index(Ln ) ≥ 2n .
3.3. ENDLICHE AUTOMATEN UND NICHTDETERMINISMUS
97
(b) Beschreibe einen 2DFA, der Ln mit O(n) Zuständen erkennt.
(c) Beschreibe einen SDFA, der Ln mit O(n2 ) Zuständen erkennt.
Wir werden zeigen, dass SDFAs für (Ln $)∗ sehr viele Zustände benötigen. Das Konzept generischer Worte stellt sich als wichtig heraus.
Definition 3.12 Sei L eine Sprache über dem Alphabet Σ. Der Buchstabe $ gehöre nicht zu
Σ. Darüberhinaus sei A ein SDFA, der die Sprache (L$)∗ akzeptiere. Die Zustandsmenge von
A sei Q.
(a) Für ein Wort s ∈ Σ∗ definiere
→
0
0
Z (s) := { q ∈ Q : es gibt einen Zustand q , so dass q von einer in q beginnenden
links-nach-rechts Bewegung erreicht wird, wenn s gelesen wird }.
←
Die Menge Z (s) ist analog definiert, aber diesmal betrachten wir rechts-nach-links
Bewegungen.
→
→
(b) Ein Wort g ∈ (L$)∗ heißt generisch für A, wenn | Z (g) | ≤ | Z (gt) | wie auch
←
←
| Z (g) | ≤ | Z (tg) | für alle Worte t ∈ (L$)∗ gilt.
Wir zeigen, dass jeder SDFA A ein generisches Wort g besitzt.
Lemma 3.20 Sei A ein SDFA. Dann gilt
(a)
→
→
←
←
Z (uv) ⊆ Z (v) und Z (uv) ⊆ Z (u)
für beliebige Worte u, v ∈ (L$)∗ .
(b) A besitzt ein generisches Wort g.
→
Beweis (a) Zum Beispiel: Wenn der Zustand q zu Z (uv) gehört, dann wird q in einer
links-nach-rechts Bewegung für die Eingabe uv erreicht. Sei q 0 der Zustand nach Lesen von u.
Dann wird q nach einer links-nach-rechts Bewegung erreicht, wenn die Eingabe v, beginnend
im Zustand q 0 , gelesen wird.
(b) Sei u ∈ (L$)∗ beliebig. Wenn u nicht generisch für A ist, dann gibt es o.B.d.A. ein Wort
→
→
←
←
v mit | Z (uv) | < | Z (u) |. Nach Teil (a) wissen wir, dass Z (uv) ⊆ Z (u) gilt und deshalb
←
←
→
folgt | Z (uv)| ≤ | Z (u)|. Jetzt ersetze u durch uv: Die Größe von Z (u) hat sich verringert,
←
die Größe von Z (u) hat nicht zugenommen.
→
→
Wenn es ein neues „Gegenbeispiel“ v ∈ (L$)∗ mit | Z (uv) | < | Z (u) | gibt, dann wiederhole
←
←
das Argument. Gilt hingegen | Z (vu) | < | Z (u) |, dann wiederhole das Argument auch in
diesem Fall, aber ersetze u durch vu.
Offensichtlich führt dieses Argument auf ein generisches Wort u. Setze g := u.
Warum sind generische Strings so interessant?
98
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
Lemma 3.21 Der SDFA A akzeptiere die Sprache (L$)∗ und das Wort g ∈ (L$)∗ sei generisch für A. Dann gilt für jedes Wort w ∈ Σ∗
→
→
←
→
→
→
←
→
w ∈ L ⇒ Z (gs$g) =Z (g) und Z (gs$g) =Z (g),
w 6∈ L ⇒ Z (gs$g) ⊂Z (g) oder Z (gs$g) ⊂Z (g).
(3.9)
(3.10)
Beweis: Sei w ∈ Σ∗ beliebig. Wir wenden Lemma 3.20 an und erhalten
→
→
←
←
Z (gw$g) ⊆ Z (g) und Z (gw$g) ⊆ Z (g).
→
←
Wenn es ein Wort w ∈ L gibt, so dass zum Beispiel Z (gw$g) eine echte Teilmenge von Z (g),
dann ist g im Widerspruch zur Annahme nicht generisch. Also ist Behauptung (3.9) richtig.
Sei also w 6∈ L beliebig, aber es gelte
→
→
←
→
←
←
Z (gw$g) = Z (g) und Z (gw$g) = Z (g).
Dann folgt auch
→
←
i
i
Z g(w$g) = Z (g) und Z (gw$) g = Z (g)
→
für jede Zahl i. Also definiert (w$g)i eine Permutation auf Z (g) und (gw$)i eine Permutation
←
auf Z (g). Es muss aber eine Zahl j geben, so dass sowohl (w$g)j wie auch (gw$)j die
Identitätspermutation erzeugen. Auf der einen Seite ist g ∈ (L$)∗ und gw$g 6∈ (L$)∗ . Auf
der anderen Seite gilt g(w$g)j = (gw$)j g mit der Konsequenz, dass A sowohl für eine linksnach-rechts Bewegung wie auch für eine rechts-nach-links Bewegung keine Chance hat, g und
g(w$g)j auseinanderzuhalten.
Ein Fazit: Wenn A, nach Lesen von gw$g mit einer links-nach-rechts Bewegung von zwei
→
verschiedenen Zuständen p1 , p2 ∈Z (g) aus denselben Zustand erhält, dann muss w 6∈ L
gelten. Ebenso folgt w 6∈ L, wenn A nach Lesen von gw$g in einer rechts-nach-links Bewegung
←
verschiedene Zustände in Z (g) auf denselben Zustand transformiert.
3.3.3.2
Ein Kommunikationsargument
Wenn die Sprache (L$)∗ von einem SDFA mit wenigen Zuständen akzeptiert wird, dann ist
das Komplement von L strukturell stark eingeschränkt. Um diese Einschränkung herauszuarbeiten, führen wir ein Kommunikationsmodell ein.
(a) Zwei Spieler, Alice und Bob, nehmen teil. Alice erhält einen Präfix p der Eingabe w ∈ Σ∗ ,
Bob den verbleibenden Suffix s: Es gilt also
w = ps.
Weder hat Alice irgendeine Information über den Suffix s von Bob noch hat Bob irgendeine Information über den Präfix p von Alice.
(b) Beide schicken sich gegenseitig Nachrichten nach einem nichtdeterministischen Protokoll.
Danach muss Alice
• in mindestens einer Berechnung akzeptieren, wenn w nicht zu L gehört, bzw.
• in allen Berechnungen verwerfen, wenn w zu L gehört.
3.3. ENDLICHE AUTOMATEN UND NICHTDETERMINISMUS
99
Beide versuchen, möglichst wenige Nachrichten auszutauschen.
Sei N (L) die minimale Nachrichtenzahl einer nichtdeterministischen Berechnung: Gezählt
werden alle Nachrichtenfolgen, die für irgendein Wort w ∈ Σ∗ zwischen Alice und Bob ausgetauscht werden.
Wir zeigen in einem ersten Schritt, dass N (L) „klein“ ist, wenn (L$)∗ von einem SDFA mit
„wenigen“ Zuständen akzeptiert wird. In einem zweiten Schritt weisen wir für bestimmte Sprachen L nach, dass die minimale Nachrichtenzahl N (L) groß sein muss: Für solche Sprachen
L benötigt jeder SDFA für (L$)∗ viele Zustände.
Wir beginnen mit dem ersten Schritt.
Lemma 3.22 Wenn (L$)∗ von einem SDFA mit q Zuständen akzeptiert wird, dann gilt
N (L) ≤ 3q 2 .
Beweis: Wir erinnern uns, dass Alice einen Präfix p und Bob den dazugehörenden Suffix s
erhält. Beide versuchen nichtdeterministisch herauszufinden, ob w = ps nicht zu L gehört und
nutzen dazu aus, dass ein SDFA A die Sprache (L$)∗ mit höchstens q Zuständen akzeptiert.
→
→
←
→
Nach Lemma 3.21 gilt w 6∈ L genau dann, wenn Z (gs$g) ⊂Z (g) oder Z (gs$g) ⊂Z (g).
Alice beginnt die Kommunikation und rät die Richtung eines „Sweeps“ von A. Sie teilt Bob
ihre Entscheidung mit einem Bit mit.
Fall 1: Alice rät eine links-nach-rechts Bewegung.
→
Sie rät zwei Zustände p1 , p2 ∈Z (g), simuliert eine links-nach-rechts Bewegung von A für
Eingabe gp auf beiden „Anfangszuständen“ und teilt Bob die „Endzustände“ q1 , q2 mit. Bob
nimmt die Simulation einer links-nach-rechts Bewegung von A mit den neuen „Anfangszuständen“ q1 , q2 wieder auf, diesmal aber für die Eingabe s$g, und berechnet seine Endzustände
r1 , r2 . Wenn r1 = r2 ,dann schickt er eine „Eins“ an Alice und sonst eine „Null“. Alice akzep→
→
tiert genau dann, wenn sie eine Eins erhält: Sie weiß jetzt, dass Z (gs$g) ⊂Z (g) gilt.
In diesem Fall haben beide insgesamt höchstens 2q 2 Nachrichten ausgetauscht.
Fall 2: Alice rät eine rechts-nach-links Bewegung.
←
Diesmal übernimmt Bob die Initiative, rät Anfangszustände p1 , p2 ∈Z (g), simuliert eine
rechts-nach-links Bewegung von A auf Eingabe s$g und kommuniziert die Endzustände q1 , q2 .
Alice setzt die Simulation einer rechts-nach-links Bewegung jetzt für die Eingabe gp fort und
←
←
akzeptiert genau dann, wenn die Endzustände identisch sind: Sie weiß jetzt, dass Z (gs$g) ⊂Z
(g) gilt.
In diesem Fall haben beide insgesamt höchstens q 2 Nachrichten ausgetauscht.
In den Übungen haben wir die Sprache
Ln := { xy : x, y ∈ {0, 1}n und x 6= y }
betrachtet: NFAs wie auch 2DFAs können (Ln $)∗ mit wenigen Zuständen akzeptieren. SDFAs
hingegen tun sich sehr schwer, denn die Anzahl N (Ln ) verschiedener Nachrichten ist groß.
Satz 3.23 Ln hat nur große SDFAs
100
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
(a) N (Ln ) ≥ 2n .
(b) Jeder SDFA hat mindestens
p
2n /3 Zustände.
Beweis: Es genügt, wenn wir N (Ln ) ≥ 2n zeigen, denn mit Lemma 3.22 folgt dann
2n ≤ N (Ln ) ≤ 3q 2 ,
wobei q die Zustandszahl eines SDFA für (Ln $)∗ ist.
Wir betrachten ein beliebiges nichtdeterministisches Protokoll. Angenommen, x, y ∈ {0, 1}n
sind verschiedene Worte und es gibt eine gemeinsame akzeptierende Nachrichtenfolge m
~ sowohl für die Eingabe w1 = xx 6∈ Ln wie auch für die Eingabe w2 = yy 6∈ Ln . Dann führt m
~
fälschlicherweise dazu, dass die Eingabe xy ∈ Ln akzeptiert wird: Die 2n verschiedenen Worte
uu für u ∈ {0, 1}n besitzen ihre eigenen akzeptierenden Nachrichtenfolgen und N (Ln ) ≥ 2n
folgt.
Diese Argumentation kann leider nicht zu einer „Trennung“ von 2DFAs und 2NFAs führen,
da (Ln $)∗ ja kleine 2DFAs besitzt. Der Nachweis einer, im Vergleich zur Zustandszahl von
2NFAs super-polynomiell großen Zustandszahl für 2DFAs bleibt ein offenes Problem.
3.4
Endliche Automaten und Probabilismus
Ein probabilistische endlicher Automat (PFA) W = (Σ, Q, δ, q0 , F ) darf würfeln: Das
Programm
δ : Q × Σ × Q → [0, 1]
weist jedem Zustand p ∈ Q, jedem Buchstaben a ∈ Σ und jedem potentiellen Nachfolgezustand r ∈ Q die Wahrscheinlichkeit δ(p, a, r) zu, dass r tatsächlicher Nachfolgezustand von p
wird, wenn der Buchstabe a gelesen wird.
Für jeden Buchstaben a ∈ Σ definiert die Übergangsmatrix Pa die Übergangswahrscheinlichkeit vom Zustand p ∈ Q zum Zustand r ∈ Q. Insbesondere hat die Übergangsmatrix Pa
für jeden Zustand p ∈ Q eine Zeile und für jeden Zustand r ∈ Q eine Spalte und es gilt
Pa [p, r] := δ(p, a, r).
Beachte, dass die Matrix Pa eine stochastische Matriz ist, denn die Zeile von p definiert
P
eine Verteilung: Für alle Zustände p, r ∈ Q ist Pa [p, r] ≥ 0 und es ist r∈Q Pa [p, r] = 1.
Wie auch im Fall von NFAs setzen wir δ von Buchstaben auf Worte in Σ∗ fort.
Definition 3.13 Sei W = (Σ, Q, δ, q0 , F ) ein probabilistischer endlicher Automat (PFA).
(a) Für ein Wort u ∈ Σ∗ ist
δ(p, w, r)
die Wahrscheinlichkeit, dass sich W nach dem Lesen des Wortes u im Zustand r ∈ Q
befindet. Wir geben die folgende rekursive Definition an:
δ(p, ua, r) :=
X
s∈Q
δ(p, u, s) · δ(s, a, r).
(3.11)
3.4. ENDLICHE AUTOMATEN UND PROBABILISMUS
101
(b) Die Akzeptanzwahrscheinlichkeit pW (u) des Wortes w wird definiert durch
pW (u) := pr[ W akzeptiert u ] :=
X
δ(q0 , u, r).
r∈F
(c) Die reelle Zahl λ ∈ [0, 1] sei gegeben. Die Sprache Lλ (W ) besteht aus allen Worten u ∈ Σ∗ ,
die mit einer Wahrscheinlichkeit von größer als λ akzeptiert werden, also
Lλ (W ) := { u ∈ Σ∗ : pW (u) > λ}.
Um die Sprache des probabilistischen Automaten W zu definieren, müssen wir einen
Schwellenwert λ angeben.
Was genau steckt „hinter“ der rekursiven Definition (3.11)? Wenn u = a1 · · · an , dann folgt
δ(p, u, r) = Pa1 · · · Pan [p, r]
mit vollständiger Induktion: Die Wahrscheinlichkeit eines Zustandsübergangs vom Zustand p
zum Zustand r wird durch das Matrizenprodukt Pa1 · · · Pan , ausgewertet in Zeile p und Spalte
r wiedergegeben.
Frage: Ist die Sprache Lλ (W ) für jeden probabilistischen endlichen Automaten und für jedes
λ eine reguläre Sprache?
Die Antwort ist ein donnerndes Jein! Wir betrachten den simplen PFA W = (Σ, Q, δ, q0 , F )
mit
1. Σ = {0, 1},
2. der Zustandsmenge Q = {0, 1},
3. dem Anfangszustand q0 = 0,
4. dem akzeptierenden Zustand 1 und
5. dem Programm δ, definiert durch die beiden Übergangsmatrizen
"
P0 =
1
0
1
2
1
2
#
"
und P1 =
1
2
1
2
0
1
#
.
Um die Akzeptanzwahrscheinlichkeit für ein Wort u = a1 · · · an ∈ {0, 1}n zu bestimmen,
beachte
pW (u) = Pa1 · · · Pan [0, 1],
denn wir sind an der Wahrscheinlichkeit von Berechnungen interessiert, die im Zustand 0
beginnen und im Zustand 1 enden.
Aufgabe 56
Zeige: Die Akzeptanzwahrscheinlichkeit pW (u) = Pa1 · · · Pan [0, 1] für das Wort u = a1 · · · an besitzt die
Binärdarstellung 0,an · · · a1 .
Wenn wir Schwellenwerte 0 ≤ λ1 < λ2 ≤ 1 betrachten, dann gilt
Lλ2 (W ) ⊂ Lλ2 (W )
102
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
und die Inklusion ist als Konsequenz der obigen Aufgabe echt. Der PFA W akzeptiert also
überabzählbar unendlich viele Sprachen, nämlich eine Sprache für jeden Schwellenwert λ ∈
[0, 1]. Es gibt aber nur abzählbar unendlich viele DFAs und damit gibt es „nur“ abzählbar
unendlich viele reguläre Sprachen: Die meisten von W akzeptierten Sprachen Lλ (W ) sind
nicht regulär!
Aufgabe 57
(a) Zeige, dass die Klasse der regulären Sprachen abgeschlossen unter Rückwärtslesen ist, das heißt: Falls
L eine reguläre Sprache über dem Alphabet Σ ist, so ist auch
LR = {an · · · a1 | a1 , . . . , an ∈ Σ, a1 · · · an ∈ L}
regulär.
(b) Zeige, dass Lλ (W ) regulär ist, falls λ rational ist.
Hinweis: Jede rationale Zahl λ mit 0 ≤ λ < 1 besitzt eine Binärdarstellung der Form
0,xyyy . . .
∗
∗
mit x, y ∈ {0, 1} und y ∈
/ {1} .
(c) Zeige, dass Lλ (W ) nicht regulär ist, falls λ die irrationale Zahl mit der Binärdarstellung
0,10102 103 1 . . .
ist.
Hinweis: Zeige Index(Lλ (W )R ) = ∞.
Satz 3.24 Es gibt einen PFA W und einen Schwellenwert λ, so dass Lλ (W ) nicht regulär
ist.
Schade!?
Nicht wirklich, denn wie sollten wir denn herausfinden können, ob ein Eingabewort u zur
Sprache Lλ (W ) gehört, wenn wir nur die Möglichkeit haben, verschiedene Berechnungen von
W auf u zu beobachten? Für praktische Belange ist unsere Definition der Sprache eines PFA
(bzgl eines Schwellenwerts λ) viel zu weit gefasst: Wir sollten für eine reelle Zahl δ > 0 fordern,
dass alle Akzeptanzwahrscheinlichkeiten außerhalb eines Intervalls [λ−δ, λ+δ] liegen, weil wir
nur dann die Möglichkeit haben, experimentell bei nur wenigen beobachteten Berechnungen
mit hoher Wahrscheinlichkeit festzustellen, ob das Wort u zur Sprache Lλ (W ) gehört oder
nicht.
Definition 3.14 δ sei eine positive reelle Zahl. Ein PFA W akzeptiert die Sprache L = Lλ (W )
mit (Schwellenwert λ und) Lücke δ, falls
pW (u) 6∈ [λ − δ, λ + δ]
für alle Worte u ∈ Σ∗ gilt.
Angenommen, ein PFA W akzeptiert die Sprache Lλ (W ) mit Lücke δ. Stelle die Prognose
u ∈ Lλ (W ) für ein Eingabewort u auf, wenn W das Wort u in k Versuchen mindestens
(λ − δ/2) · k mal akzeptiert: Der Prognosefehler wird umso kleiner sein, umso größer die Lücke
δ ist.
Jeder DFA A lässt sich natürlich als ein PFA auffassen, der die Sprache L = L1/2 (A) mit
Schwellenwert 1/2 und der größtmöglichen Lücke 1/2 akzeptiert. Aber selbst Lücken der Größe
fast 1/2 lassen sich mit PFAs erzielen, die mit sehr viel weniger Zuständen als ihre deterministischen Mitbewerber oder sogar ihre nichtdeterministischen Wettbewerber auskommen.
Aufgabe 58
Wir betrachten die Sprache EQk = {w$w : w ∈ {0, 1}k }. Jeder NFA für EQk benötigt mindestens 2k
Zustände.
3.4. ENDLICHE AUTOMATEN UND PROBABILISMUS
103
Pk
(a) Fasse ein Wort w = w1 · · · wk ∈ {0, 1}k als Binärdarstellung der Zahl Z(w) = i=1 wi · 2k−i auf. Für eine
Zahl m konstruiere einen DFA Am , der ein Wort x$y genau dann akzeptiert, wenn x, y ∈ {0, 1}k und
Z(x) ≡ Z(y) (mod m).
Die Anzahl der Zustände von Am soll polynomiell in k und m sein.
(b) Konstruiere einen PFA mit poly(k) Zuständen, der EQk mit Schwellenwert
akzeptiert.
1+1/k
2
und Lücke
1−1/k
2
Hinweis: Für hinreichend großes n gibt es mindestens n2 Primzahlen kleiner oder gleich n3 .
Satz 3.25 (Satz von Rabin)
Sei W ein PFA, der die Sprache L = Lλ (W ) mit Lücke δ > 0 akzeptiert. Dann ist die Sprache
L regulär.
Beweis: Es gelte W = (Σ, Q, δ, q0 , F ). Der Satz von Myhill-Nerode (Satz 3.10) besagt, dass
L = Lλ (W ) genau dann regulär ist, wenn der Index von L unendlich ist. Was passiert also,
wenn die Worte u1 , . . . , uN Vertreter verschiedener Myhill-Nerode Klassen sind?
Für je zwei Worte ui und uj gibt es ein Wort x mit zum Beispiel
ui x ∈ L, aber uj x 6∈ L.
Also folgt
X
pW (ui x) =
δ(q0 , ui , p) · δ(p, x, q) > λ + δ,
p∈Q,q∈F
X
pW (uj x) =
δ(q0 , uj , p) · δ(p, x, q) < λ − δ
p∈Q,q∈F
und insbesondere
2 · δ = λ + δ − (λ − δ) < pW (ui x) − pW (uj x)
=
X
δ(q0 , ui , p) − δ(q0 , uj , p) · δ(p, x, q)
p∈Q,q∈F
=
X
(δ(q0 , ui , p) − δ(q0 , uj , p) ·
p∈Q
X
δ(p, x, q)
q∈F
Aber q∈F δ(p, x, q) ist eine reelle Zahl zwischen Null und |Q|, denn 0 ≤ δ(p, x, q) ≤ 1 für
alle Zustände p, q ∈ Q. Als Konsequenz folgt
P
X
|δ(q0 , ui , p) − δ(q0 , uj , p)| > 2 · δ/|Q|.
p∈Q
Die Vektoren ξi := ( δ(q0 , ui , p) : p ∈ Q ) haben also einen Abstand von mindestens 2δ/|Q|
voneinander, wenn wir den Abstand in der 1-Norm2 messen. Aber für jedes µ > 0 gibt es nur
endlich viele Vektoren im |Q|-dimensionalen Würfel [0, 1]|Q| mit dem paarweisen Abstand von
mindestens µ: Der Myhill-Nerode Index von L ist endlich und L ist regulär.
2
Der Abstand zweier Vektoren u, v ∈ Rn in der 1-Norm wird durch
Pn
i=1
|ui − vi | definiert.
104
3.5
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
Reguläre Ausdrücke
Wir führen eine weitere Beschreibungsmethode für reguläre Sprachen ein, nämlich reguläre
Ausdrücke. Wir haben reguläre Ausdrücke zum Beispiel bei der Definition der Sprache Lk =
Σ∗ ◦ {1} ◦ Σk eingesetzt: Diese Sprache besitzt NFA’s mit wenigen Zuständen wie auch einen
kurzen regulären Ausdruck, aber nur deterministische endliche Automaten mit exponentiell
in k vielen Zuständen.
Definition 3.15 Das Alphabet Σ = {a1 , . . . , ak } sei gegeben. Wir geben eine rekursive Definition regulärer Ausdrücke an:
(a) ∅, , a1 , . . . , ak sind reguläre Ausdrücke (für die Sprachen ∅, {} und
{a1 }, . . . , {ak }).
(b) Sei R ein regulärer Ausdruck (für die Sprache L), dann ist R∗ ein regulärer Ausdruck
(für die Sprache L∗ ), und (R) ist ein regulärer Ausdruck (für die Sprache L).
(c) Seien R1 und R2 reguläre Ausdrücke (für die Sprachen L1 und L2 ). Dann sind auch
R1 + R2
und
R1 · R2
reguläre Ausdrücke (für die Sprachen L1 ∪ L2 und L1 ◦ L2 ).
Die Menge der regulären Ausdrücke ist die kleinste Menge mit den Eigenschaften (a), (b) und
(c). Wenn R ein regulärer Ausdruck für eine Sprache L ist, dann sagen wir auch, dass R die
Sprache L beschreibt und definieren
L(R) := L.
Beispiel 3.16 Reguläre Ausdrücke für die Sprachen
L1 =
n
L2 =
n
L3 =
n
o
w ∈ {a, b}∗ | w beginnt und endet mit a
w ∈ {a, b}∗ | aba ist Teilwort von w
o
w ∈ {a, b}∗ | w hat eine gerade Anzahl von a’s
o
sind zu konstruieren. Wir erhalten zum Beispiel
R1 = a · (a + b)∗ · a
R2 = (a + b)∗ · a · b · a · (a + b)∗
R3 = b∗ + (b∗ · a · b∗ · a · b∗ )∗ .
Während die regulären Ausdrücke für L1 und L2 einfach sind (und sich der Formalismus regulärer Ausdrücke auszahlt), ist der reguläre Ausdruck für L3 , verglichen mit dem Automaten
b
q0
b
a
q1
a
relativ kompliziert: Jeder Formalismus hat seine Stärken und Schwächen.
3.5. REGULÄRE AUSDRÜCKE
105
Aufgabe 59
Die Sprache L (über dem Alphabet Σ = {a, b}) sei die kleinste Wortmenge mit den Eigenschaften „der
Buchstabe a gehört zu L“ und „wenn das Wort x zu L gehört, so gehören auch die Worte bx, ax und xb zu L“.
Finde einen regulären Ausdruck für die Sprache L und beweise, dass deine Beschreibung zu der obigen
rekursiven Definition äquivalent ist.
Aufgabe 60
In welchen Beziehungen stehen die drei Sprachen L1 , L2 und L3 zueinander? Es soll paarweise entschieden
werden, ob Gleichheit oder Teilmengenbeziehung besteht.
∗
L1
=
{a}∗ ◦ {b}∗ ◦ {c}+
L2
=
{a, b}∗ ◦ {c}+
L3
=
({a}∗ ◦ {c}+ ) ∪ ({b}∗ ◦ {c}+ )
∗
∗
Aufgabe 61
Finde je einen regulären Ausdruck für die beiden folgenden Sprachen über Σ = {a, b, c}.
(a) L1 := {w ∈ Σ∗ | w enthält das Teilwort abc}
(b) L2 := {w ∈ Σ∗ | w enthält das Teilwort abc nicht}
Lemma 3.26 Wenn R ein regulärer Ausdruck ist, dann ist L(R) regulär.
Beweis: Offensichtlich sind
∅, {}, {a1 }, . . . , {ak }
reguläre Sprachen. Mit Satz 3.18 sind aber auch L∗ , L1 ◦ L2 und L1 ∪ L2 regulär, wenn L, L1
und L2 regulär sind. Deshalb führen auch die regulären Ausdrücke
R∗ ,
R1 · R2
und
R1 + R2
auf reguläre Sprachen (wenn wir induktiv annehmen, dass R, R1 und R2 auf reguläre Sprachen
L und L1 , L2 führen).
Tatsächlich sind reguläre Ausdrücke und reguläre Sprachen identische Konzepte!
Satz 3.27 Satz von Kleene
Sei Σ ein endliches Alphabet. Eine Sprache L über Σ ist genau dann regulär, wenn es einen
regulären Ausdruck R mit L = L(R) gibt.
Beweis: Nach Lemma 3.26 ist L(R) für jeden regulären Ausdruck R eine reguläre Sprache.
Sei also L regulär. Wir müssen zeigen, dass es einen regulären Ausdruck für L gibt. Da L
regulär ist, gibt es einen (deterministischen) endlichen Automaten A, der L akzeptiert. Ohne
Beschränkung der Allgemeinheit sei
Q = {1, . . . , n}
die Zustandsmenge von A und q0 = 1 sein Anfangszustand. Wir betrachten die Menge
n
Lkp,q = w ∈ Σ∗ | δ(p, w) = q, und alle Zwischenzustände während des
Lesens von w liegen in der Menge {1, . . . , k}
o
106
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
Wir beachten, dass
L=
[
Ln1,p
p∈F
und es genügt deshalb zu zeigen, dass jede Sprache Lnp,q als regulärer Ausdruck darstellbar ist.
Wir zeigen mehr, nämlich dass jede Sprache Lkp,q durch einen regulären Ausdruck darstellbar
ist. Unsere Konstruktion verläuft rekursiv (nach k).
k = 0: L0p,q ist die Menge aller w ∈ Σ∗ mit δ(p, w) = q, wobei kein Zwischenzustand erlaubt
ist. Also ist
n
o
L0p,q =
a ∈ Σ | δ(p, a) = q ,
falls p =
6 q, bzw.
n
o
L0p,q = {} ∪ a ∈ Σ | δ(p, a) = p , falls p = q.
Die endliche Menge L0p,q ist offensichtlich durch einen regulären Ausdruck darstellbar.
k → k + 1: Es ist
k
k
k
Lk+1
p,q = Lp,q ∪ Lp,k+1 ◦ Lk+1,k+1
∗
◦ Lkk+1,q ,
denn entweder taucht Zustand k+1 beim Lesen von w (mit Startzustand p und Endzustand q)
nicht auf, oder wir können die Folge der Zwischenzustände so zerlegen, dass in jeder Teilfolge
k+1 kein Zwischenzustand, sondern nur Endzustand ist. Wenn aber die Sprachen Lkp,q , Lkp,k+1 ,
Lkk+1,k+1 und Lkk+1,q durch reguläre Ausdrücke beschrieben werden können, dann kann auch
Lk+1
p,q durch einen regulären Ausdruck beschrieben werden. (Beachte, dass wir einen Beweis
mit Hilfe der dynamischen Programmierung geführt haben.)
Aufgabe 62
Gegeben sei der folgende deterministische endliche Automat A über dem Eingabealphabet Σ = {0, 1} mit der
Zustandsmenge Q = {q0 , q1 , q2 }, dem Anfangszustand q0 und F = {q0 }:
0
1
1
q0
0
q1
1
q2
0
Bestimme einen regulären Ausdruck für die Sprache L(A) mit der rekursiven Konstruktion aus dem Beweis
von Satz 3.27
Aufgabe 63
Es seien r und s reguläre Ausdrücke über disjunkten Alphabeten, und es sei das leere Wort 6∈ r. Bestimme
einen regulären Ausdruck x, der die Gleichung x = r ◦ x + s erfüllt. Dabei bezeichnet ◦ die Konkatenation und
+ die Vereinigung.
3.5.1
Die Länge regulärer Ausdrücke
Wir definieren die Länge eines regulären Ausdrucks R als die Anzahl aller Zeichen in R, die
keine Klammern sind.
Aufgabe 64
Gib einen möglichst kurzen regulären Ausdruck für die folgenden Sprachen über Σ = {0, 1} an:
(a) L = {w ∈ {0, 1}∗ | w beginnt mit 1 und enthält das Teilwort 00 nicht },
(b) Lk = {w ∈ {0, 1}∗ | die Anzahl der Einsen in w ist durch k teilbar }.
3.5. REGULÄRE AUSDRÜCKE
107
Aufgabe 65
Gib möglichst kurze reguläre Ausdrücke für die folgenden Sprachen an und bestimme ihre Länge asymptotisch:
(a) Lk = {w ∈ {0, 1}∗ | w enthält 0k als Teilwort},
(b) Lk = {w ∈ {0, 1}∗ | w enthält 0k nicht als Teilwort}.
Seien n, k natürliche Zahlen mit n ≥ k und sei Ln,k = {w ∈ {0, 1}n | w enthält genau k Einsen}.
(c) Zeige: Index(Ln,k ) = Θ(k · (n − k)).
(d) Gib einen möglichst kurzen regulären Ausdruck für Ln,k an und bestimme seine Länge asymptotisch.
In den beiden nächsten Aufgaben wird der Zusammenhang zwischen der Länge regulärer
Ausdrücke und der Zustandszahl äquivalenter DFAs bzw. NFAs untersucht.
Aufgabe 66
(a) Sei R ein regulärer Ausdruck der Länge l. Zeige, dass es einen NFA A mit l Zuständen gibt, so dass
L(A) = L(R) gilt.
(b) Konstruiere einen regulären Ausdruck R der Länge l, so dass jeder DFA A mit L(A) = L(R) mindestens
2l Zustände besitzt.
Wenn also R ein regulärer Ausdruck mit l Zuständen ist, dann gibt es einen äquivalenten NFA
mit höchstens l Zuständen. Andererseits ist die Größe eines äquivalenten NFA möglicherweise
sogar exponentiell in l.
Wie groß ist der zu einem DFA A äquivalente reguläre Ausdruck R höchstens, wenn wir
A wie im Satz von Kleene mit dynamischer Programmierung in einen regulären Ausdruck
umwandeln?
Aufgabe 67
Sei A ein DFA mit Zustandsmenge Q. Dann produziert das Verfahren im Beweis des Satzes von Kleene einen
regulären Ausdruck der Länge höchstens 2O(|Q|) .
Wir wissen: Die Klasse aller regulären Sprachen ist abgeschlossen unter Komplement- und
Durchschnittbildung. Obwohl die regulären Ausdrücke keine expliziten Operatoren für Komplement- und Durchschnittbildung enthalten, gibt es daher für alle regulären Ausdrücke R und
S einen regulären Ausdruck
• R̃, der die Sprache L(R) beschreibt, und
• T , der die Sprache L(R) ∩ L(S) beschreibt.
Wie können wir bei gegebenen Ausdrücken R und S solche regulären Ausdrücke R̃ und T
konstruieren? Antwort:
R, S
NFAs
AL(R) , AL(S)
DFAs
BL(R) , BL(S)
DFAs
BL(R) , BL(R)∩L(S)
reguläre Ausdrücke R̃, T.
Laufzeit unserer Verfahren:
O(|R|)
Für R̃: 22
.
Für T : 22
O(|R|+|S|)
.
Geht das nicht schneller? Hier ist die Antwort3
3
W. Gelade, F. Neven, Succinctness of the Complement and Intersection of Regular Expressions, STACS,
Seiten 325-336, 2008
108
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
• Für R̃ ist unser Verfahren im Wesentlichen optimal: Es gibt reguläre Ausdrücke Rn
der Länge O(n), so dass die kürzesten regulären Ausdrücke, die die Sprache L(Rn )
n
beschreiben, die Länge mindestens 22 haben.
• Für T gibt es ein (relativ naheliegendes) Verfahren, das mit Laufzeit 2O(|R|·|S|) auskommt. Dieses Verfahren ist im Wesentlichen optimal: Es gibt reguläre Ausdrücke
Rn , Sn der Länge O(n2 ), so dass die kürzesten regulären Ausdrücke, die die Sprache
L(Rn ) ∩ L(Sn ) beschreiben, Länge mindestens 2n haben.
Aufgabe 68
Wir führen in dieser Aufgabe die erweiterten regulären Ausdrücke ein: Jeder reguläre Ausdruck ist auch ein
erweiterter regulärer Ausdruck. In erweiterten regulären Ausdrücken lassen wir zusätzlich die Operation ∩ zu,
d.h. wenn R1 und R2 erweiterte reguläre Ausdrücke für die Sprachen L1 und L2 sind, dann ist R1 ∩ R2 ein
erweiterter regulärer Ausdrück für die Sprache L1 ∩ L2 .
Beweise oder widerlege die folgende Aussage: Für alle regulären Sprachen L gilt: Gegeben sei ein erweiterter
regulärer Ausdruck R der Länge l (für L). Dann gibt es einen nichtdeterministischen endlichen Automaten mit
O(poly(l)) Zuständen (der L erkennt).
3.6
Grammatiken und reguläre Grammatiken
Was ist eine Grammatik?
Definition 3.16
(a) Eine Grammatik G hat die folgenden Komponenten:
• ein endliches Alphabet Σ,
• eine endliche Menge V von Variablen (oder Nichtterminalen) mit Σ ∩ V = ∅,
• das Startsymbol S ∈ V und
• eine endliche Menge P von Produktionen, wobei eine Produktion von der Form
(u, v) ist mit
u ∈ (Σ ∪ V )∗ V (Σ ∪ V )∗ und v ∈ (Σ ∪ V )∗
(b) Sei (u, v) eine Produktion von G. Dann definieren wir für Worte w1 und w2 ∈ (Σ ∪ V )∗
w1 → w2 ⇔ Es gibt x, y ∈ (Σ ∪ V )∗ mit w1 = xuy und
w2 = xvy.
(c) Seien r, s ∈ (Σ ∪ V )∗ . Dann definieren wir
∗
r → s ⇔ Es gibt Worte w1 = r, w2 , . . . , wk = s, so dass
w1 → w2 → . . . → wk .
n
∗
o
(d) L(G) = w ∈ Σ∗ | S → w ist die von der Grammatik erzeugte Sprache.
Warum betrachten wir Grammatiken? Programmiersprachen lassen sich am besten als eine
formale Sprache, die Sprache aller syntaktisch korrekten Programme auffassen. Eine Grammatik für eine Programmiersprache drückt dann die Regeln der Programmiersprache aus.
3.6. GRAMMATIKEN UND REGULÄRE GRAMMATIKEN
109
Beispiel 3.17 Wir geben eine Grammatik G für arithmetische Ausdrücke mit ganzzahligen
Komponenten an. G besitzt das Eingabealphabet
n
Σ = +, −, ∗, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, (, )
o
sowie
• das Startsymbol A und
• die Variablen I und Z.
Die Produktionen haben die Form
A → A + A | A − A | A ∗ A | (A) | I | + I | − I
I → ZI | Z
Z → 0|1|2|3|4|5|6|7|8|9
(Die vertikalen Linien trennen Produktionen, die dieselbe Variable ersetzen.) Die Regeln dieser
Grammatik spiegeln die rekursive Definition arithmetischer Ausdrücke wider.
Die erzeugte Sprache L(G) ist nicht regulär. (Warum?) Wenn wir aber das Startsymbol A
durch I ersetzen, erhalten wir eine reguläre Sprache, nämlich die Sprache der Dezimaldarstellungen natürlicher Zahlen.
Definition 3.17 Eine Grammatik G = (Σ, V, S, P ) heißt regulär, wenn alle Produktionen in
P die Form
u→
(für u ∈ V ) oder
u → av (für u, v ∈ V , a ∈ Σ)
haben.
Satz 3.28 L sei eine Sprache. Dann gilt:
L regulär ⇔ Es gibt eine reguläre Grammatik G mit L = L(G).
Beweis: „⇒ ı Sei L regulär und sei A ein endlicher Automat A, der L akzeptiert. Auf Eingabe
w führt A die Zustandsübergänge
w
w
w
q0 →1 q1 →2 . . . →n qn
durch und akzeptiert, falls qn ∈ F . Dies legt nahe, eine Grammatik zu konstruieren, die
Ableitungsfolgen der Form
q0 → w1 q1 → w1 w2 q2 → . . . → w1 · · · wn qn
erlaubt mit anschließender Produktion qn → . Deshalb definieren wir eine Grammatik G mit
• Variablenmenge Q,
• Startymbol q0 ,
110
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
• sowie den Produktionen
p → aq falls δ(p, a) = q
p→
falls p ∈ F .
„⇐“ Angenommen, L = L(G) für eine reguläre Grammatik G = (Σ, V, S, P ). Eine Ableitung
von G hat die Form
S → w1 V1 → w1 w2 V2 → . . . → w1 · · · wn Vn → w1 · · · wn .
Eine Simulation durch einen deterministischen Automaten scheint nicht sinnvoll, da im allgemeinen aus mehreren möglichen Produktionen gewählt werden kann. Es bietet sich vielmehr
eine Simulation durch einen nichtdeterministischen Automaten N an. Wir setzen
• Q=V,
• q0 = S
und definieren
• δ(X, a) = {Y | X → aY ∈ P }
• F = {X ∈ V | X → ∈ P }
Aufgabe 69
Beweise oder widerlege: Sei L regulär. Dann stimmt die minimale Zustandszahl eines NFA A für L überein
mit der kleinsten Zahl von Variablen einer regulären Grammatik G für L.
3.7
Entscheidungsprobleme
Wir zeigen jetzt, dass viele wichtige Eigenschaften deterministischer endlicher Automaten
effizient nachprüfbar sind. Entscheidungsprobleme für nichtdeterministische Automaten sind,
mit einigen wenigen Ausnahmen, deutlich schwieriger.
Satz 3.29 A, A1 und A2 bezeichne deterministische Automaten und N bezeichne einen nichtdeterministischen Automaten. Die folgenden Entscheidungsprobleme sind effizient lösbar:
(a) Ist L(A) 6= ∅, bzw. ist L(N ) 6= ∅?
(b) Ist L(A) = Σ∗ ?
(c) Ist L(A1 ) = L(A2 ), bzw. ist L(A1 ) ⊆ L(A2 )?
(d) Ist L(A) endlich?
Beweis (a): Wir untersuchen die Frage nach Leerheit nur für einen nichtdeterministischen
Automaten N , das Leerheitsproblem für deterministische Automaten kann völlig analog gelöst
werden. Sei q0 der Anfangszustand von N und sei F die Menge der akzeptierenden Zustände.
Wir beobachten, dass L(N ) genau dann nichtleer ist, wenn es einen Weg von q0 zu einem
Zustand in F gibt. Das Erreichbarkeitsproblem für mindestens einen Zustand in F können
3.8. ZUSAMMENFASSUNG
111
wir jetzt mit Hilfe der Tiefensuche, angewandt auf das Zustandsdiagramm von N , effizient
lösen.
(b), (c) und (d) sind als Übungsaufgaben gestellt.
Aufgabe 70
Sei A ein DFA. Entwerfe einen möglichst effizienten Algorithmus, der entscheidet ob A unendlich viele Worte
akzeptiert. Bestimme die Laufzeit in Abhängigkeit von der Anzahl der Zustände von A.
Bemerkung 3.4 Die Entscheidungsprobleme (b), (c) und (d) aus Satz 3.29 lassen sich in aller
Wahrscheinlichkeit nicht effizient für nichtdeterministische Automaten lösen: Siehe dazu Satz
?
6.15. Erstaunlicherweise gehört das anscheinend unschuldige Problem L(N ) 6= Σ∗ noch nicht
einmal zur Klasse NP: Einer der Gründe hierfür ist, dass sich der Unterschied zwischen L(N )
und Σ∗ erst für Worte zeigen kann, deren Länge exponentiell in der Anzahl der Zustände ist!
Auch das Minimierungsproblem für nichtdeterministische Automaten ist anscheinend äußerst
schwierig.
Viele vernünftige Entscheidungsprobleme lassen sich effizient für deterministische Automaten
lösen. Eine Ausnahme ist das Interpolationsproblem: Für gegebene Teilmengen P, N ⊆ Σ∗
und einen Schwellenwert N , gibt es einen DFA mit höchstens N Zuständen, der alle Worte
in P akzeptiert und alle Worte in N verwirft?
3.8
Zusammenfassung
Wir haben endliche Automaten und die von ihnen akzeptierten Sprachen, die regulären Sprachen, betrachtet. Wir haben eine Minimierungsprozedur besprochen, die zu einem gegebenen
deterministischen endlichen Automaten einen äquivalenten, aber minimalen Automaten, den
Äquivalenzklassenautomaten bestimmt. Der Beweis der Minimalität gelang durch den Index
der Sprache, der der Minimalanzahl von Zuständen entspricht. Unsere Argumentation hat
auch gezeigt, dass der minimale Automat, bis auf eine Umbenennung der Zustände, eindeutig
bestimmt ist.
Während der Betrachtung minimaler Automaten haben wir auch den Satz von Nerode erhalten, der reguläre Sprachen als Sprachen mit endlichem Index charakterisiert. Der Nachweis
der Nichtregularität einer Sprache kann deshalb mit den Satz von Nerode oder mit dem
Pumping-Lemma geführt werden.
Wir haben verschiedene äquivalente Charakterisierungen regulärer Sprachen kennengelernt,
nämlich durch
- deterministische endliche Automaten,
- nichtdeterministische endliche Automaten,
- probabilistische Automaten mit positiver Lücke,
- deterministische oder nichtdeterministische Zweiwege Automaten
- reguläre Ausdrücke oder
- reguläre Grammatiken.
112
KAPITEL 3. ENDLICHE AUTOMATEN UND REGULÄRE SPRACHEN
Die verschiedenen Charakterisierungen stellen reguläre Sprachen in unterschiedlicher Beschreibungslänge dar. Die größtmöglichen Unterschiede sind in vielen Fällen bekannt, allerdings ist die Frage, ob 2DFAs für einige reguläre Sprachen exponentiell mehr Zustände
als 2NFAs erfordern, weiterhin offen. Wir haben allerdings gezeigt, dass sweeping 2DFAs
exponentiell mehr Zustände als NFAs benötigen.
Weiterhin haben wir gesehen, dass reguläre Sprachen unter den Operationen
- Vereinigung, Durchschnitt und Komplement
- sowie Konkatenation und Kleene-Abschluß (Sternoperation)
abgeschlossen sind. Der Abschluß unter vielen weiteren Operationen wird in den Übungen
besprochen.
Wichtige algorithmische Probleme wie die Feststellung der Äquivalenz oder die Minimierung
lassen sich für deterministische endliche Automaten effizient lösen, sind aber für nichtdeterministische endliche Automaten notorisch schwierig (siehe Satz 6.15): Die größere Beschreibungskraft nichtdeterministischer endlicher Automaten muss algorithmisch teuer erkauft werden.
Kapitel 4
Kontextfreie Sprachen
Als Grundlage für die Syntaxdefinition von Programmiersprachen sind reguläre Sprachen zu
ausdrucksschwach. Deshalb betrachten wir in diesem Kapitel die weitaus mächtigere Klasse
der kontextfreien Sprachen, die wir durch kontextfreie Grammatiken einführen. Wir zeigen
wie das Wortproblem für kontextfreie Sprachen mit Hilfe der Chomsky Normalform effizient
gelöst werden kann und stellen Techniken vor, die es erlauben, Sprachen als nicht kontextfrei
nachzuweisen. Am Ende des Kapitels werden wir mit Hilfe von Kellerautomaten auf die
Klasse der deterministisch kontextfreien Sprachen geführt. Sie stellen den praxistauglichsten
Kompromiss zwischen Ausdruckskraft und Komplexität des Wortproblems dar.
Definition 4.1 Eine Grammatik G mit Produktionen der Form
u→v
mit u ∈ V und v ∈ (V ∪ Σ)∗
heißt kontextfrei. Eine Sprache L heißt kontextfrei, wenn es eine kontextfreie Grammatik G
mit
L(G) = L
gibt.
Beispiel 4.1 Wir beschreiben einen allerdings sehr kleinen Ausschnitt von Pascal durch eine
kontextfreie Grammatik. Dazu benutzen das Alphabet
Σ = {a, . . . , z, ;, :=}
und die Variablen
V
= {S, statements, statement, assign-statement, while-statement,
variable, boolean, expression }.
In den Produktionen unseres Pascal Fragments führen wir die Variablen „boolean, expression
und variable“ nicht weiter aus:
S → begin statements end
statements → statement | statement ; statements
statement → assign − statement | while − statement
assign − statement → variable := expression
while − statement → while boolean do statements
113
114
KAPITEL 4. KONTEXTFREIE SPRACHEN
Lassen sich denn stets die syntaktisch korrekten Programme einer modernen Programmiersprache als eine kontextfreie Sprache auffassen? Die erste Antwort ist Nein. In Pascal muss
zum Beispiel sichergestellt werden, dass Anzahl und Typen der formalen und aktuellen Parameter übereinstimmen.
Die „Kopiersprache“ {ww | w ∈ Σ∗ } modelliert die Überprüfung auf Typkonsistenz,
allerdings wird sich die Kopiersprache als nicht kontextfrei herausstellen.
Die zweite Antwort ist aber „im wesentlichen Ja, wenn man „Details“ wie Typ-Deklarationen
und Typ-Überprüfungen ausklammert.
Typischerweise beschreibt man die Syntax durch eine kontextfreie Grammatik, die alle
syntaktisch korrekten Programme erzeugt. Allerdings werden auch syntaktisch inkorrekte Progamme (z.B. aufgrund von Typ-Inkonsistenzen) erzeugt. Die nicht eingehaltenene
(nicht-kontextfreien) Syntax-Vorschriften können nach Erstellung des Ableitungsbaums
überprüft werden.
Was ist ein Ableitungsbaum? Das klären wir im nächsten Abschnitt.
4.1
Ableitungsbäume
Im Compilerproblem möchten wir nicht nur entscheiden, ob ein Wort w von einer kontextfreien
Grammatik erzeugt werden kann, sondern wir möchten zusätzlich eine Ableitung von w, bzw.
einen Ableitungsbaum von w konstruieren.
Definition 4.2 Sei G = (Σ, V, S, P ) eine kontextfreie Grammatik und sei B ein Baum mit
den folgenden Eigenschaften:
• Die Wurzel von B ist mit S markiert,
• innere Knoten sind mit Variablen markiert, während Blätter mit Buchstaben aus Σ
markiert sind,
• wenn der Knoten v mit der Variablen A markiert ist und wenn die Kinder von v die
Markierungen (von links nach rechts) v1 , . . . , vs tragen, dann ist A → v1 · · · vs eine
Produktion von G.
B heißt ein Ableitungsbaum des Wortes w, wenn man w durch die links-nach-rechts Konkatenation der Markierungen der Blätter von B erhält.
Beispiel 4.2 Wir geben zuerst eine kontextfreie Grammatik für die Sprache
n
L = w ∈ {0, 1}+ | w hat gleich viele Nullen wie Einsen
an. Unsere Grammatik G besitzt das Startsymbol S sowie die Variablen Null und Eins. Alle
von Null (bzw. Eins) ableitbaren Worte werden genau eine Null (bzw. Eins) mehr als Einsen
(bzw. Nullen) besitzen. Dies wird erreicht durch die Produktionen
S → 0 Eins | 1 Null
Eins → 1 | 0 Eins Eins | 1 S
Null → 0 | 1 Null Null | 0 S
4.1. ABLEITUNGSBÄUME
115
(Zeige zuerst durch Induktion über die Länge der Ableitungen, dass
n
∗
o
n
o
∗
o
n
o
w ∈ {0, 1}+ | Eins → w = w ∈ {0, 1}+ | w hat eine Eins mehr
und
n
w ∈ {0, 1}+ | Null → w = w ∈ {0, 1}+ | w hat eine Null mehr
gilt. Dann folgt die Behauptung L = L(G).)
Wir betrachten als Nächstes das Wort w = 000111. w besitzt die Ableitung
S → 0 Eins → 00 Eins Eins → 000 Eins Eins Eins →
0001 Eins Eins → 00011 Eins → 000111.
und deshalb den Ableitungsbaum
S
0
Eins
0
0
Eins
Eins
Eins
Eins
1
1
1
Beachte, dass jedem Ableitungsbaum verschiedene Ableitungen entsprechen, nämlich zum
Beispiel Linksableitungen (die jeweils die linkeste Variable ersetzen), sowie Rechtsableitungen
(die jeweils die rechteste Variable ersetzen):
S → 0 Eins → 00 Eins Eins → 00 Eins 1 →
000 Eins Eins 1 → 000 Eins 11 → 000111.
Ordnet ein Compiler unterschiedlichen Ableitungsbäumen unterschiedliche Bedeutung zu,
dann kann ein Wort, abhängig von der Ableitung unterschiedliche Bedeutungen besitzen:
Ein Programm, das in einer mehrdeutigen Programmiersprache geschrieben wurde, besitzt
somit compiler-abhängige Semantiken! Wir sollten also schon auf eindeutigen Grammatiken
bestehen!
Definition 4.3 Sei G eine kontextfreie Grammatik.
(a) G heißt genau dann mehrdeutig, wenn es ein Wort w ∈ L(G) mit zwei verschiedenen
Ableitungsbäumen gibt.
Wenn G nicht mehrdeutig ist, dann heißt G eindeutig.
(b) Eine Sprache L heißt eindeutig, wenn es eine eindeutige Grammatik G gibt mit L =
L(G). Ansonsten heißt L inhärent mehrdeutig.
116
KAPITEL 4. KONTEXTFREIE SPRACHEN
n
o
Beispiel 4.3 Es kann gezeigt werden, dass L = ai bj ck | i = j oder j = k inhärent mehrdeutig ist. Woran liegt das? Wenn w ∈ L, dann gilt w = ai bi ck oder w = ai bj cj . Eine Grammatik
„sollte“ deshalb eine der zwei Optionen auswählen müssen; wenn aber beide Optionen zutreffen, also wenn w = ai bi ci , dann hat w zwei verschiedene Ableitungsbäume und die Grammatik
ist mehrdeutig.
Beispiel 4.4 Die Grammatik G besitze die Komponenten
• Σ = {x, y, +, −, ∗, (, )}
• V = {S}
• die Produktionen
S → S + S | S ∗ S | (S) | x | y.
Damit ist L(G) die Sprache aller (teilweise geklammerten) arithmetischen Ausdrücke in den
Variablen x und y. G ist nicht eindeutig, denn x + x ∗ y besitzt die zwei Ableitungsbäume
S
S
x
S
+
S
S
x
*
S
S
S
y
x
+
*
S
S
y
x
Ableitungsbäume werden bei der Compilierung zur Codegenerierung benutzt. Der erste Baum
liefert dann den Code x + (x ∗ y), während der zweite Baum den Code (x + x) ∗ y liefert. Es
wäre also hilfreich, wenn die Sprache L eindeutig wäre, und dies ist auch tatsächlich der Fall,
wenn wir eine andere Grammatik G benutzen:
Die Grammatik G mit dem Startsymbol S und den Variablen T (generiert Terme) und F
(generiert Faktoren) wird eindeutig sein. Die Produktionen von G haben die Form
S → S + T |T
T
→ T ∗ F |F
F
→ (S) | x | y.
Mit dieser Grammatik legen wir fest, dass die Multiplikation „starker bindet“ als die Addition. Wir zeigen durch Induktion über die Länge eines arithmetischen Ausdrucks A, dass G
eindeutig ist.
Basis:
Es ist A ≡ x oder A ≡ y.
Zum Beispiel für A ≡ x ist S → T → F → x die (sogar)1 eindeutige Ableitung.
Induktion:
Wir überprüfen exemplarisch den Fall A ≡ A1 + A2 .
+ kann nur durch die Produktion S → S + T eingeführt werden. Also wird eine Ableitung
von A mit der Produktion S → S + T beginnen. Die von S und T abgeleiteten Ausdrücke
sind aber kürzer, und somit sind ihre Ableitungsbäume eindeutig. Also besitzt A genau einen
Ableitungsbaum.
1
Beachte, dass eindeutige Grammatiken verschiedene Ableitungen für dasselbe Wort w besitzen können,
nämlich zum Beispiel die Links- und die Rechtsableitung von w. Alle Ableitungen von w müssen aber zum
eindeutig bestimmten Ableitungsbaum von w gehören.
4.1. ABLEITUNGSBÄUME
117
Aufgabe 71
Beschreibe kontextfreie Grammatiken für die Sprachen L1 und L2 :
L1 = {ai bj ck | i, j, k ≥ 0 und i 6= j + k}.
Es sei Σ = {x, y, (, ), +, ∗}. L2 ist die Menge aller arithmetischen Ausdrücke über Σ (mit Variablen
x und y, sowie mit den Operationen Addition und Multiplikation). Ein arithmetischer Ausdruck darf aber
keine überflüssigen Klammern enthalten. Wir folgen den konventionellen Prioritätsregeln, nämlich dass die
Multiplikation eine höhere Priorität hat als die Addition.
Zum Beispiel gehören die Ausdrücke x ∗ x ∗ y, (x ∗ y + x) ∗ y, x + y + x zu L3 , während die Ausdrücke (x ∗ x) ∗ y,
((x ∗ y) + x) ∗ y, (x + y) + x überflüssige Klammern besitzen und deshalb nicht zu L3 gehören.
Aufgabe 72
Es sei L = {w ∈ {0, 1}∗ |für jedes Präfix u von w gilt: |u|0 ≥ |u|1 }. (|u|b zählt die Anzahl der Vorkommen von
b in u.)
Konstruiere eine kontextfreie Grammatik G, die die Sprache L erzeugt. Beweise, dass L(G) = L ist.
Aufgabe 73
Sei L = {ai bj ck : i, j, k ≥ 0 und i + j ≤ k ≤ 2 · (i + j)}.
(a) Zeige, dass L nicht regulär ist.
(b) Zeige, dass L kontextfrei ist, indem du eine kontextfreie Grammatik für die Sprache angibst.
Aufgabe 74
Es sei L = {ai bj ck | k 6= i + j}. Konstruiere eine eindeutige kontextfreie Grammatik für die Sprache L.
Beweise die Eindeutigkeit.
Aufgabe 75
(a) Die Dyck-Sprache D aller wohlgeformten Klammerausdrücke ist durch die kontextfreie Grammatik mit
den Produktionen
S → (S) | SS | ε
definiert.
Beweise die Mehrdeutigkeit der angegebenen Grammatik und konstruiere eine eindeutige kontextfreie
Grammatik für D.
(b) Die Grammatik G mit dem Terminalalphabet {anweisung, bedingung, if, then, else} und den Produktionen
S → if bedingung then S else S | if bedingung then S | anweisung
ist eine Spezifikation der if-Anweisung.
Entwirf eine eindeutige kontextfreie Grammatik G0 für die Sprache L(G): G0 wird zusätzliche Variablen
besitzen müssen. Zeige, dass G und G0 dieselbe Sprache erzeugen. Beweise außerdem die Eindeutigkeit
von G0 .
Beachte, dass G0 auch die Semantik der if-Anweisung definiert. Wie sieht diese Semantik für das
„Programm“
if bedingung then if bedingung then anweisung else anweisung
aus?
Aufgabe 76
Sei L eine reguläre Sprache. Zeige, dass L eine eindeutige reguläre Grammatik besitzt.
Aufgabe 77
Zeige, dass die folgende Grammatik G mehrdeutig ist. G hat die folgenden Komponenten: das Alphabet
Σ = {a}, die Variablen S und A, das Startsymbol S und die Produktionen S → AA, A → aSa | a.
Beschreibe eine äquivalente, aber eindeutige kontextfreie Grammatik G0 . (Wir nennen G und G0 äquivalent,
wenn L(G) = L(G0 ).)
Hinweis: Versuche zuerst, L(G) zu bestimmen.
118
KAPITEL 4. KONTEXTFREIE SPRACHEN
Aufgabe 78
Gegeben sei die folgende kontextfreie Grammatik G = (Σ, V, S, P ), mit Σ = {a, b, c, d}, V = {S, B} und den
Produktionen S ⇒ aS | SB | d, B ⇒ Bb | c.
Zeige, dass G nicht eindeutig ist.
Zeige, dass die Sprache L(G) eindeutig ist.
4.2
Die Chomsky-Normalform und das Wortproblem
Wir versuchen jetzt, eine effiziente Lösung des Compilerproblems zu erhalten. Um dies vorzubereiten, werden wir zuerst zeigen, dass sich jede kontextfreie Grammatik (die nicht das
leere Wort erzeugt) in Chomsky-Normalform überführen läßt.
Definition 4.4 Eine Grammatik ist in Chomsky-Normalform, wenn alle Produktionen die
Form
A → BC oder A → a
besitzen (für A, B, C ∈ V und a ∈ Σ).
Satz 4.1 Sei L kontextfrei mit ∈
/ L. Dann gibt es eine Grammatik G in Chomsky-Normalform
mit L = L(G).
Beweis: Es gelte L = L(G) für eine kontextfreie Grammatik G = (Σ, V, S, P ).
Schritt 1: Wir erzwingen, dass die rechte Seite einer Produktion entweder nur aus Variablen
besteht oder nur aus einem Buchstaben.
Für jeden Buchstaben a ∈ Σ füge die neue Variable Xa hinzu und erlaube Xa → a als neue
Produktion. Jetzt kann jede Produktion
A → α1 a1 α2 a2 · · · αr ar αr+1
(mit Buchstaben a1 , . . . , ar und α1 , . . . , αr+1 ∈ V ∗ ) durch die Produktion
A → α1 Xa1 α2 Xa2 · · · αr Xar αr+1
ersetzt werden. P1 sei die Menge der neuen Produktionen.
Schritt 2:
besitzen.
Erzwinge, dass alle Produktionen eine rechte Seite der Länge höchstens zwei
Ersetze jede Produktion
p ≡ A → C1 · · · Cs
(mit s ≥ 3)
durch die Produktionen
A → C1 X1p ,
X1p → C2 X2p ,
..
.
p
Xs−2
→ Cs−1 Cs
P2 sei die neue Produktionenmenge.
Schritt 3:
Entferne alle -Produktionen A → .
4.2. DIE CHOMSKY-NORMALFORM UND DAS WORTPROBLEM
119
Die Produktion A → gehöre zu P2 . Es bietet sich an, die Produktion A → zu entfernen
und gleichzeitig für jede Produktion der Form
B → AC,
B → CA oder B → A
die neuen Produktionen
B → C,
B→C
oder B → hinzuzufügen. Aber damit haben wir uns eine neue -Produktion eingehandelt.
Schritt 3.1:
∗
Bestimme V 0 = {A ∈ V | A → }.
Wie? Seien A1 → , . . . , Ak → sämtliche -Produktionen in P2 . Wir setzen anfänglich
W = {A1 , . . . , Ak },
V 0 = ∅,
P 0 = P2
(1) Entferne irgendeine Variable A aus der Menge W , und füge A zu V 0 hinzu. Für jede
Produktion der Form
B → AC,
B → CA oder B → A
(mit B 6= A)
füge die neuen Produktionen B → C, B → zur Menge P 0 hinzu. Wenn B → zu P 0
hinzugefügt wird, dann füge B zur Menge W hinzu. Um zu verhindern, dass A wieder
in die Menge W hinzugefügt wird, entferne alle Produktionen
A→α
von P 0 .
(2) Wiederhole (1), solange W 6= ∅.
Schritt 3.2:
Für jede Regel
A → BC
oder A → CB
mit B ∈ V 0
füge die Regel A → C zu P2 hinzu und streiche alle -Produktionen. Nenne die neue Produktionenmenge P3 .
Schritt 4:
Die Produktionen in P3 sind von der Form
A → a,
A → B,
A → BC,
und nur die Kettenregeln A → B sind noch zu entfernen.
Schritt 4.1: Um die Kettenregeln besser veranschaulichen zu können, betrachten wir den
Graphen H(P3 ):
- Die Knoten von H(P3 ) entsprechen den Variablen,
- für jede Kettenregel A → B erhält H(P3 ) die entsprechende Kante.
Mit einer Tiefensuche auf dem Graphen H(P3 ) können wir alle Kreise des Graphen entdecken:
Ein Kreis wird nämlich durch Rückwärtskanten geschlossen. Wähle einen beliebigen Kreis
A1 → A2 → . . . → Ak → A1 . Jetzt ersetze systematisch in jeder Produktion jede Variable
A2 , . . . , Ak durch A1 ; dabei entstehende Produktionen A1 → Ai werden entfernt.
120
KAPITEL 4. KONTEXTFREIE SPRACHEN
Die Variablen A2 , . . . , Ak sind jetzt überflüssig, da sie in keiner Produktion mehr auftauchen.
Wir wiederholen dieses Verfahren, bis alle Kreise zerstört sind. Die neue Produktionenmenge
sei P4 .
Schritt 4.2: Der Graph H(P4 ) ist jetzt kreisfrei. Wir numerieren die Knoten mit der Methode des topologischen Sortierens, so dass
Ai → Aj
bedingt, dass i < j. Seien A1 , . . . , Am die Variablen.
Es gibt offensichtlich keine Kettenregel der Form Am → Ai . Wir betrachten nun sämtliche
unmittelbaren Vorgänger von Am . Existiert eine Produktion Ak → Am , so entfernen wir diese
Produktion und fügen für jede Produktion Am → α die Produktion Ak → α hinzu.
α ist aber entweder ein Buchstabe oder von der Form BC. Wir wiederholen dieses Verfahren,
bis alle Kettenregeln entfernt sind. Jetzt haben wir Chomsky-Normalform erreicht.
Bemerkung 4.1 Wir haben mehr erreicht als im Satz ausgesagt. Wir haben gezeigt, wie aus
einer kontextfreien Grammatik G eine äquivalente Grammatik in Chomsky-Noormalform effizient konstruiert werden kann. Weiterhin ist die Größe der Grammatik, also die Gesamtlänge
aller Produktionen, nur polynomiell angestiegen.
Wir spielen nun den kompletten Algorithmus schrittweise an einer Fallstudie durch. Unsere Ausgangsgrammatik sei G = (Σ, V, S, P ) mit Σ = {a, b, c} und V = {S, A, B, C}. Die
Produktionsmenge P ist:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
S
S
S
A
A
A
A
B
B
B
B
C
C
C
→
→
→
→
→
→
→
→
→
→
→
→
→
→
aABCb
C
ABC
B
cC
aSc
aC
S
b
cC
SCCB
Im ersten Schritt haben wir die Regeln 1, 7, 8, 9 und 12 zu bearbeiten. Wir führen die
neuen Variablen Xa , Xb und Xc ein. Die betreffenden Produktionen lauten nun
10 S → Xa ABCXb
70 A → Xc C
80 B → Xa SXc
90 B → Xa C
120 C → Xc C
und weisen rechts nur noch Strings aus V ∗ auf. Dazu kommen die neuen Produktionen
4.2. DIE CHOMSKY-NORMALFORM UND DAS WORTPROBLEM
121
15 Xa → a
16 Xb → b .
17 Xc → c
Im zweiten Schritt widmen wir uns den Produktionen, die auf Variablenstrings abbilden,
die länger als 2 sind. Wir teilen die Produktionen 1’, 4, 8’, 13 auf. Danach lautet unsere
Produktionsmenge P2 :
10 a
S → Xa X11
10 b X11 → AX21
10 c X21 → BX31
10 d X31 → CXb
2
S → 3
S → C
4a
A → AX14
X14 → BC
4b
5
A → B
6
A → 70
A → Xc C
80 a
B → Xa X18
80 b X18 → SXc
90
B → Xa C
10
B → S
11
B → b
120
C → Xc C
13a
C → SX113
13
13b X1 → CX213
13c X213 → CB
14
C → 15
Xa → a
Xb → b
16
17
Xc → c
Jetzt haben wir uns den -Produktionen in Schritt drei zu widmen. Wir müssen die Menge
aller Variablen bestimmen, die auf abgebildet werden können. (Schritt 3.1). Wir stellen den
Ablauf tabellarisch dar.
Ausgangssituation: W = {S, A, C}, V 0 = ∅, P 0 = P2
Phase 1, bewege S aus W nach V 0
hinzuzufügen X18 →Xc
B→
C→X113
füge B zu W hinzu.
entfernen
S→Xa X11
S→
S→C
W = {A, C, B} V 0 = {S}
Phase 2, bewege A aus W nach V 0
hinzuzufügen X11 →X21
A→X14
W bleibt unverändert
entfernen
A→AX14
A→B
A→
A→Xc C
A→X14
W = {C, B} V 0 = {S, A}
122
KAPITEL 4. KONTEXTFREIE SPRACHEN
Phase 3, bewege C aus W nach V 0
hinzuzufügen X31 →Xb
X14 →B
B→Xa
C→Xc
X113 →X213
X213 →B
W bleibt unverändert
entfernen
C→cC
C→SX113
C→
C→X113
C→Xc
W = {B} V 0 = {S, A, C}
Phase 5, bewege X14 aus W nach V 0
hinzuzufügen
nichts
W bleibt unverändert
entfernen X14 →BC
X14 →B
X14 →C
X14 →
13
W = {X2 } V 0 = {S, A, C, B, X14 }
Phase 4, bewege B aus W nach V 0
hinzuzufügen X21 →X31
X14 →C
X213 →C
X14 →
X213 →
W := W ∪ {X14 , X213 }
entfernen
B→Xa X18
B→Xa C
B→S
B→b
B→
B→Xa
4
13
W = {X1 , X2 } V 0 = {S, A, C, B}
Phase 6, bewege X213 aus W nach V 0
hinzuzufügen X113 →C
X113 →
W := W ∪ {X113 }
entfernen X213 →BC
X213 →B
X213 →C
X213 →
W = {X113 } V 0 = {S, A, C, B, X14 , X213 }
Phase 7, bewege X113 aus W nach V 0
hinzuzufügen
nichts
W =∅
entfernen X113 →CX213
X113 →X213
X113 →C
X113 →
W = ∅ V 0 = {S, A, C, B, X14 , X213 , X113 }
Als Menge V 0 erhalten wir also {S, A, B, C, X14 , X113 , X213 }. Das ist die Menge all jener Variablen, die auf abgebildet werden können.
Gemäß Schritt 3.2 können wir nun die Produktionenmenge P3 bestimmen. Wir stellen P2
und P3 in der folgenden Tabelle gegenüber.
4.2. DIE CHOMSKY-NORMALFORM UND DAS WORTPROBLEM
10 b
P2
S→Xa X11
X11 →AX21
10 c
X21 →BX31
10 d
X31 →CXb
2
3
4a
S→
S→C
A→AX14
10 a
4b
X14 →BC
5
6
70
A→B
A→
A→Xc C
80 a
80 b
B→Xa X18
X18 →SXc
90
B→Xa C
10
11
120
B→S
B→b
C→Xc C
13a
C→SX113
13b X113 →CX213
13c X213 →CB
14
15
16
17
C→
Xa →a
Xb →b
Xc →c
123
P3
S→Xa X11
X11 →AX21
X11 →X21
X21 →BX31
X21 →X31
X31 →CXb
X31 →Xb
S→C
A→AX14
A→X14
X14 →BC
X14 →B
X14 →C
A→B
A→Xc C
A→Xc
B→Xa X18
X18 →SXc
X18 →Xc
B→Xa C
B→Xa
B→S
B→b
C→cC
C→Xc
C→SX113
C→S
C→X113
13
X1 →CX213
X113 →C
X113 →X213
X213 →CB
X213 →C
X213 →B
Xa →a
Xb →b
Xc →c
Beachte, dass wir hier entstehende neue -Regeln, wie sie formal etwa in Zeile 4b entstehen
würden (X14 → ) gleich unterdrückt haben. Auch die in Zeile 4a entstehende triviale Regel
A → A haben wir gar nicht erst aufgenommen.
Für den abschließenden vierten Schritt benötigen wir nunmehr den Graphen, der die Kettenregeln der Grammatik darstellt. Man vergleiche:
124
KAPITEL 4. KONTEXTFREIE SPRACHEN
#
Xa
6
-
?
X14
X31
Xc
A
XXX
6
XXX
@
I
@
X
R
@
@
XXX
z
Xb
X21
C X
S
B
yXX
XX XX
@ @
I
X
X
X
@ @
@ X 13
X18
X213
X11
1
R
@
-
Mittels eines gängigen Graphenalgorithmus wie etwa der Tiefensuche ermittelt man die Kreise. Nehmen wir an, wir würden Kreis B, S, C, X113 , X213 finden, dann können wir diese fünf
Variablen nun zu einer zusammenfassen. Da das Startsymbol unter ihnen ist, wählen wir
dieses. Wir erhalten:
#
-
Xa
-
4
1
X1
X3
A
: Xc
@
6
I
@
R
@
@
S
X21
Xb
X18
X11
4.2. DIE CHOMSKY-NORMALFORM UND DAS WORTPROBLEM
125
Der Kreis ist nun zykelfrei. Unsere Produktionenmenge P3 verkleinert sich zu P4 :
P4
S→Xa X11
X11 →AX21
X11 →X21
X21 →SX31
X21 →X31
X31 →SXb
X31 →Xb
A→AX14
A→X14
X14 →SS
X14 →S
A→S
A→Xc S
A→Xc
S→Xa X18
X18 →SXc
X18 →Xc
S→Xa S
S→a
S→b
S→Xc C
S→c
S→SS
S→Xa
s→Xc
Xa →a
Xb →b
Xc →c
Eine topologische Sortierung kann z.B. so aussehen:
-
#
Xa 9
-
X14
1
X3 3
: Xc 10
@
6
I
@
R
@
@
7
A
S
8
6
Xb
X21 2
4
X18 5
X11 1
Wir beseitigen nun sukzessive die Kettenregeln in der durch die Sortierung vorgegebenen
Reihenfolge. Unsere Grammatik wächst noch einmal. Aber das Ziel ist damit auch erreicht.
126
KAPITEL 4. KONTEXTFREIE SPRACHEN
statt
S→Xc
X18 →Xc
A→Xc
S→Xa
X14 →S
A→S
A→X14
X31 →Xb
X21 →X31
X11 →X21
neu
ex. bereits
S→c
X18 →c
A→c
S→a ex. bereits
X14 →Xa X11
X14 →Xa X18
X14 →Xa S
X14 →a
X14 →b
X14 →Xc C
X14 →c
X14 →SS ex. bereits
A→Xa X11
A→Xa X18
A→Xa S
A→a
A→b
A→Xc C
A→c ex. bereits
A→SS
A→SS ex. bereits
A→Xa X11 ex. bereits
A→Xa X18 ex. bereits
A→Xa S ex. bereits
A→a ex. bereits
A→b ex. bereits
A→Xc C ex. bereits
A→c ex. bereits
X31 →b
X21 →SXb
X21 →b
X11 →SX31
X11 →SXb
X11 →b
Diese Grammatik ist nun in Chomsky-Normalform.
Wir können jetzt das Compilerproblem (bzw. das Wortproblem) effizient lösen.
Satz 4.2 Satz von Cocke, Younger und Kasami
Sei G eine Grammatik in Chomsky-Normalform. Dann kann in Zeit
O |Produktionen von G| · |w|3
entschieden werden, ob w ∈ L(G).
Beweis: Wir benutzen die Methode der dynamischen Programmierung. Die Grammatik G =
(Σ, V, S, P ) liege in in Chomsky-Normalform vor und w = w1 · · · wn ∈ Σn sei die Eingabe.
4.3. DAS PUMPING LEMMA UND OGDEN’S LEMMA
127
Für jedes i, j (1 ≤ i ≤ j ≤ n) möchten wir die Menge
∗
n
Vi,j = A ∈ V | A → wi · · · wj
o
bestimmen. (Beachte, dass w ∈ L(G) genau dann gilt, wenn S ∈ V1,n .)
(1) Die Mengen Vi,i können sofort bestimmt werden, da
∗
n
o
o
n
Vi,i = A ∈ V | A → wi = A ∈ V | A → wi ,
denn G ist in Chomsky-Normalform.
(2) Angenommen, alle Mengen Vi,j mit j −i < s sind bestimmt. Seien jetzt i und j vorgegeben
mit j − i = s. Es gilt
A ∈ Vi,j
∗
⇔ A → wi · · · wj
⇔ Es gibt eine Produktion A → BC mit
∗
∗
B → wi · · · wk , und C → wk+1 · · · wj
⇔ Es gibt eine Produktion A → BC mit
B ∈ Vi,k und C ∈ Vk+1,j .
Wir können jetzt Vi,j in Zeit höchstens
n · Anzahl der Produktionen
bestimmen. Die behauptete Laufzeit folgt, da
n
2
Mengen zu bestimmen sind.
Kubische Laufzeit ist für Anwendungen nicht tolerabel. Wir werden uns deshalb später auf
determinstisch kontextfreie Sprachen beschränken.
4.3
Das Pumping Lemma und Ogden’s Lemma
Kontextfreie Grammatiken scheinen recht mächtig zu sein und die Frage nach den Grenzen
ihrer Beschreibungskraft drängt sich auf: Wie sehen möglichst einfache, nicht-kontextfreie
Sprachen aus? Für die Beantwortung dieser Frage leiten wir zuerst ein Pumping-Lemma für
kontextfreie Sprachen her:
Satz 4.3 Sei L eine kontextfreie Sprache. Dann gibt es eine Pumpingkonstante N , so dass
jedes z ∈ L mit |z| ≥ N eine Zerlegung z = uvwxy besitzt mit den Eigenschaften
(a) |vwx| ≤ N und |vx| ≥ 1 und
(b) uv i wxi y ∈ L für alle i ≥ 0.
Wir betrachten zuerst zwei Beispiele:
Beispiel 4.5 Wir wollen zeigen, dass
n
L = am bm cm | m ≥ 0
o
128
KAPITEL 4. KONTEXTFREIE SPRACHEN
nicht kontextfrei ist. Den Beweis führen wir durch eine Anwendung des Pumping-Lemmas.
Sei N die (unbekannte) Pumpingkonstante. Wir wählen dann das Wort z = aN bN cN ∈ L.
Wenn L kontextfrei ist, dann gibt es eine Zerlegung
z = uvwxy
(mit |vwx| ≤ N und |vx| ≥ 1, so dass uv i wxi y ∈ L für jedes i ≥ 0. Da |vwx| ≤ N , enthält
vwx nur a’s und b’s oder nur b’s und c’s. Wir nehmen das Erstere an. (Beachte, dass es auch
möglich ist, dass vwx nur a’s, nur b’s oder nur c’s enthält. Diese Fälle werden aber durch die
Erstgenannten mit abgedeckt.)
Dann ist aber uv 2 wx2 y ∈
/ L, denn das aufgepumpte Wort enthält mindestens ein a oder
mindestens ein b mehr als es c’s enthält. Also ist L nicht kontextfrei.
Beispiel 4.6 Wir möchten zeigen, dass die Sprache
n
L = dr ax by cz | r = 0 oder x = y = z
o
nicht kontextfrei ist. Wir versuchen, das Pumping-Lemma anzuwenden. Für die Pumpingkonstante N sei z ∈ L ein Wort mit |z| ≥ N .
Fall 1: d kommt nicht in z vor.
Dann wird d auch nach dem Auf- oder Abpumpen nicht im Wort vorkommen, und das aufoder abgepumpte Wort gehört deshalb zur Sprache L.
Fall 2: d kommt in z vor.
Dann werden wir allerdings nicht mit der Zerlegung
u = v = w = ,
x = d und
y = dr−1 ax bx cx
„fertig“: Auf- oder Abpumpen wird nur die Anzahl von d’s variieren.
Eine Argumentation mit dem Pumping-Lemma mißlingt also. Wir benötigen stattdessen eine
Version des Pumping-Lemmas, die es uns erlaubt, mindestens ein a, b oder c aufpumpen zu
können. Dies wird erreicht durch
Satz 4.4 Ogden’s Lemma
Sei L eine kontextfreie Sprache. Dann gibt es eine Pumpingkonstante N , so dass jedes z ∈ L
mit
mindestens N markierten Buchstaben
eine Zerlegung z = uvwxy besitzt, wobei
(a) höchstens N Buchstaben in vwx markiert sind,
(b) mindestens ein Buchstabe in vx markiert ist und
(c) uv i wxi y ∈ L für alle i ≥ 0 gilt.
4.3. DAS PUMPING LEMMA UND OGDEN’S LEMMA
129
Bemerkung 4.2 (a) Beachte, dass das Pumping-Lemma aus Odgen’s Lemma folgt, wenn
wir alle Buchstaben von z markieren.
(b) Wir können jetzt zeigen, dass
n
dr ax by cz | r = 0 oder x = y = z
o
nicht kontextfrei ist. Wenn N die Pumpingkonstante ist, wähle
z = daN bN cN
und markiere aN bN cN . Dann besitzt vwx kein a oder kein c (denn vwx besitzt nur n markierte Buchstaben). Nach dem Aufpumpen wird uv 2 wx2 y also zuwenige a’s oder zuwenige c’s
besitzen.
Beweis von Satz 4.4: Wenn L kontextfrei ist, dann ist auch L \ {} kontextfrei, und es
genügt, Odgen’s Lemma für L \ {} zu beweisen. Deshalb können wir annehmen, dass
L \ {} = L(G)
für eine Grammatik G = (Σ, V, S, P ) in Chomsky-Normalform ist. Wir wählen
N = 2|V |+1
als Pumpingkonstante. Sei nun z ∈ L ein beliebiges Wort in L mit mindestens N markierten
Buchstaben. Wir betrachten einen Ableitungsbaum B für z:
S
A
A
w
x
}
v
}
}
}
}
u
y
Wir sagen, dass ein Knoten v von B ein Verzweigungsknoten ist, wenn v markierte Blätter
sowohl im linken wie auch im rechten Teilbaum besitzt. Wir erhalten die folgenden Eigenschaften von B:
(a) B ist binär, da G in Chomsky-Normalform vorliegt.
(b) B hat 2|V |+1 markierte Blätter, also Blätter, die einen markierten Buchstaben speichern.
(c) Es gibt einen Weg W von der Wurzel zu einem Blatt, so dass W mindestens |V | + 1
Verzweigungsknoten besitzt.
Die Eigenschaften (a) und (b) sind offensichtlich. Wir weisen Eigenschaft (c) nach. Konstruiere
einen Weg W so, dass W jedes Mal mit dem Kind mit den meisten markierten Blättern
fortgesetzt wird. W beginnt an der Wurzel mit mindestens N markierten Blättern. Da die
Anzahl der markierten Blätter sich nur bei einem Verzweigungsknoten verringert, und dann
auch nur um höchstens den Faktor 2, muß W mindestens log2 N = |V |+1 Verzweigungsknoten
besitzen.
130
KAPITEL 4. KONTEXTFREIE SPRACHEN
Unter den Verzweigungsknoten von W betrachten wir die letzten |V |+1 Verzweigungsknoten,
unter denen dann auch eine Variable A zweimal vorkommt. Das erste Vorkommen von A
benutzen wir zur Definition von v (Konkatenation der Blätter im linken Teilbaum) und wx
(Konkatenation der Blätter im rechten Teilbaum).
Beachte, dass v (und damit auch vx) mindestens einen markierten Buchstaben besitzt. Weiterhin besitzt vwx höchstens 2|V |+1 = N markierte Buchstaben: Wenn vwx mehr als N
markierte Buchstaben besitzt, dann besitzt W (auf seinem Endstück) auch mehr als |V | + 1
Verzweigungsknoten. Damit gilt
∗
S → uAy
sowie
∗
A → vAx und
∗
A → w.
Deshalb sind auch die Ableitungen
∗
∗
S → uAy → uwy = uv 0 wx0 y
wie auch
∗
∗
∗
S → uAy → uvAxy → uv 2 Ax2 y
∗
∗
∗
→ . . . → uv i Axi y → uv i wxi y
möglich, und deshalb ist uv i wxi y ∈ L für alle i ≥ 0.
Aufgabe 79
Eine Grammatik heißt linear, wenn jede Produktion in P die Form u ⇒ xvy, für u, v ∈ V und x, y ∈ Σ∗ oder
u ⇒ hat.
Entwirf einen Algorithmus, der das Wortproblem für eine fest vorgegebene lineare Grammatik G = (Σ, V, S, P )
löst. Der Algorithmus sollte in Zeit O(|w|2 ) entscheiden, ob w ∈ L(G) ist.
Hinweis: Man kann die dynamische Programmierung benutzen.
Aufgabe 80
Gegeben sei eine kontextfreie Grammatik G = (Σ, V, S, P ) in Chomsky-Normalform. Außerdem sei eine Kostenfunktion über den Produktionen P der Grammatik gegeben, die jeder Produktion p ∈ P einen Kostenfaktor
c(p) ∈ N zuordnet.
∗
Die Kosten einer Ableitung S ⇒ w sind die Summe der Kosten der benutzen Produktionen.
Beschreibe einen möglichst effizienten Algorithmus, der für ein Wort w ∈ Σ∗ den Wert einer Ableitung mit
minimalen Kosten bestimmt (bzw. den Wert unendlich ausgibt, falls w ∈
/ L(G)). Bestimme die Laufzeit deines
Algorithmus.
Aufgabe 81
Welche der folgenden Sprachen über dem Alphabet Σ = {a, b, c} sind kontextfrei?
Entwirf eine kontextfreie Grammatik, falls eine Sprache kontextfrei ist; benutze das Pumping-Lemma für
kontextfreie Sprachen oder Ogden’s Lemma, um zu zeigen, dass eine Sprache nicht kontextfrei ist.
L1 = {ai bj aj bi | i, j ≥ 0},
L2 = {ai bj ai bj | i, j ≥ 0},
L3 = {ai bi cj | i 6= j},
L4 = {ai bj ck | i ≤ k oder j ≤ k},
L5 = {ai bj ck |i = j = k gilt nicht},
L6 = {ai bj ci·j |i, j ≥ 0},
L7 = {ai bi cj dj |i, j ≥ 0}.
Aufgabe 82
Zeige oder widerlege die Kontextfreiheit der folgenden Sprachen:
4.3. DAS PUMPING LEMMA UND OGDEN’S LEMMA
131
(a) L1 = {w ∈ {a, b}∗ | w 6= wR },
(b) L2 = {ai bj ci | i, j ≥ 0, i 6= j},
(c) L3 = {xy | x, y ∈ {a, b}∗ , |x| = |y|, x 6= y}.
Falls eine Sprache nicht kontextfrei ist, wende das Pumping-Lemma oder Ogdens Lemma an, andernfalls
konstruiere eine kontextfreie Grammatik und entscheide, ob die jeweilige Sprache eindeutig ist.
Aufgabe 83
Wir betrachten in dieser Aufgabe eine vereinfachte Klasse von „Programmiersprachen“. Programme der Sprache müssen durch die folgende kontextfreie Grammatik G erzeugbar sein.
Es sei G = {Σ, V, S, P }, mit Σ = {REAL, IN T, x, y, 0, 1, +, −, ; , ., e},
V
= {S, D, A, < decl >, < type >, < var-list >, < id >, < integer >, < sign >,
< digit >, < real >} und den Produktionen:
S
D
A
< decl >
< type >
< var-list >
< id >
< integer >
< sign >
< digit >
< real >
⇒
⇒
⇒
⇒
⇒
⇒
⇒
⇒
⇒
⇒
⇒
DA
ε | D < decl >
ε | A < id >=< integer >; | A < id >=< real >;
< type >< var-list >;
REAL | IN T
< id >|< var-list >, < id >
x | y |< id > x |< id > y
< sign >< digit >
ε|+|−
< digit > 0 |< digit > 1 | 0 | 1
< sign >< digit > . < digit > e < sign >< digit >
Zusätzlich soll für unsere Programmiersprache folgendes gelten: Jede im Anweisungsteil A benutzte Variable
muß zuvor im Deklarationsteil D deklariert sein, und der Typ der im Anweisungsteil benutzten Variablen muß
mit dem im Deklarationsteil festgelegten Typen übereinstimmen.
Zeige, dass diese Programmiersprache nicht kontextfrei ist.
Anmerkung: Wie wir an dieser Aufgabe sehen, ist folgende Arbeitsweise von Compilern notwendig: Zunächst
wird der Deklarationsteil abgearbeitet, indem die Variablen in eine Symboltabelle gehasht werden. Danach
können auf dem verbliebenen Programm (ohne Deklarationsteil) die effizienten Lösungen des Compilerproblems
für kontextfreie Sprachen angewendet werden.
Aufgabe 84
Eine Grammatik heißt linear, wenn jede Produktion in P die Form u ⇒ xvy, für u, v ∈ V und x, y ∈ Σ∗ oder
u ⇒ hat. Wir nennen eine Sprache L linear, wenn es eine lineare Grammatik G mit L = L(G) gibt.
(a) Beweise das folgende Pumping-Lemma für lineare Sprachen: Wenn L eine lineare Sprache ist, dann
gibt es eine Pumping-Konstante N , so dass sich jedes z ∈ L mit |z| ≥ N als z = uvwxy schreiben lässt,
wobei |uvxy| ≤ N, |vx| ≥ 1 und uv i wxi y ∈ L für alle i ≥ 0 gilt.
(b) Zeige, dass {ai bi cj dj |i, j ≥ 0} keine lineare Sprache ist.
Aufgabe 85
Sei G eine Grammatik in Chomsky-Normalform.
(a) Sei L(G) endlich. Gib eine obere Schranke für die Länge eines längsten Wortes in L(G) an.
(b) Sei L(G) unendlich. Gib eine obere Schranke für die Länge eines kürzesten Wortes in L(G) an.
4.3.1
Abschlusseigenschaften kontextfreier Sprachen
Als Konsequenz von Beispiel 4.5 erhalten wir, dass kontextfreie Sprachen nicht unter Durchschnittsbildung und auch nicht unter Komplementbildung abgeschlossen sind:
Satz 4.5 (a) Wenn L1 und L2 kontextfrei sind, dann sind auch L1 ∪ L2 , L1 ◦ L2 und L∗1
kontextfrei.
132
KAPITEL 4. KONTEXTFREIE SPRACHEN
(b) Es gibt kontextfreie Sprachen L1 und L2 , so dass der Durchschnitt L1 ∩ L2 nicht kontextfrei ist.
(c) Es gibt eine kontextfreie Sprache L, so dass die Komplementsprache L nicht kontextfrei
ist.
Beweis: (a) Es gelte L1 = L(G1 ) und L2 = L(G2 ), wobei G1 = (Σ, V1 , S1 , P1 ), G2 =
(Σ, V2 , S2 , P2 ) und V1 ∩ V2 = ∅. Setze
- V = V1 ∪ V2 ∪ {S} mit S ∈
/ V1 ∪ V2
- P = P1 ∪ P2 ∪ {S → S1 , S → S2 }
für ein neues Symbol S. Dann ist offensichtlich L1 ∪ L2 = L(G), wobei G = (Σ, V, S, P ). Wenn
wir
o
n
P = P1 ∪ P2 ∪ S → S1 S2
setzen, erhalten wir L(G) = L1 ◦ L2 .
Schließlich erzeugt die Grammatik G1 ∗ = (Σ, V1 , S1 , P1 ∗ ) mit P1 ∗ = P1 ∪{S1 → S1 S1 , S1 → }
den Kleene-Abschluß L1 ∗ .
(b) Wir setzen
n
o
n
o
L1 = an bn cm | n, m ≥ 0
und
L2 = am bn cn | n, m ≥ 0 .
Beide Sprachen sind kontextfrei, denn zum Beispiel besitzt L1 die Grammatik
S → Sc | T
T
→ aT b | .
Aber L1 ∩ L2 ist nicht kontextfrei, denn es ist
n
o
L1 ∩ L2 = an bn cn | n ≥ 0 .
(c) Angenommen, mit L ist auch stets die Komplementsprache L kontextfrei. Wegen
L1 ∩ L2 = L1 ∪ L2
wären die kontextfreien Sprachen dann aber unter der Durchschnittsbildung abgeschlossen.
4.4
Kellerautomaten
Wir möchten wie im Fall regulärer Sprachen ein Maschinenmodell entwerfen, das genau die
Klasse kontextfreier Sprachen akzeptiert. Neben einer äquivalenten Charakterisierung kontextfreier Sprachen bieten Kellerautomaten die Möglichkeit, deterministisch kontextfreie Sprachen einzuführen (nämlich diejenigen Sprachen, die von einem deterministischen Kellerautomaten akzeptiert werden). Die Klasse der deterministisch kontextfreien Sprachen ist immer
noch ausdruckskräftig. Aber, und dies ist der große Vorteil, sehr schnelle Algorithmen lösen
das Compilerproblem.
4.4. KELLERAUTOMATEN
133
Definition 4.5 Eine kontextfreie Grammatik G = (Σ, V, S, P ) ist in Greibach-Normalform,
wenn alle Produktionen von der Form
A → aα
(für A ∈ V , a ∈ Σ und α ∈ V ∗ )
sind.
Satz 4.6 Die Grammatik G = (Σ, V, S, P ) sei in Chomsky-Normalform. Dann gibt es eine
Grammatik G∗ = (Σ, V ∗ , S ∗ , P ∗ ) in Greibach-Normalform, so dass
- L(G) = L(G∗ )
- |P ∗ | = O |P |3 .
Beweis: Siehe I. Wegener, Theoretische Informatik, S. 172–181.
Wir entwerfen jetzt das Maschinenmodell eines Kellerautomaten, das Linksableitungen für
eine Grammatik in Greibach-Normalform simulieren kann. Beachte, dass eine Linksableitung
eines Wortes w ∈ Σ∗ die Form
∗
S → w1 A1 α1 → w1 w2 A2 α2 → w1 w2 w3 A3 α3 → w1 · · · wn
hat. Es liegt deshalb nahe, das Maschinenmodell mit einem sequentiell lesbaren Eingabeband
und einem Stack auszustatten: Anfänglich befindet sich nur das Startsymbol S auf dem Stack.
Dann wird S gelesen und durch den String A1 α1 ersetzt, während der Lesekopf nachprüft, ob
der Buchstabe w1 gelesen wurde. Ist dies der Fall, wird im nächsten Schritt
- das zuoberst gelesene Symbol A1 gelesen und durch den String A2 α2 ersetzt, und
- der Lesekopf überprüft, ob w2 auf dem Eingabeband gelesen wurde.
Diese Schritte werden wiederholt, bis
- alle Buchstaben gelesen wurden und
- der Stack geleert wurde.
Wir werden allerdings auch den Akzeptanzmodus „Akzeptiere durch Zustand“ betrachten.
Definition 4.6 Kellerautomaten
(a) Ein nichtdeterministischer Kellerautomat (PDA) A besitzt die folgenden Komponenten:
• die endliche Zustandsmenge Q,
• das Eingabealphabet Σ,
• das Stackalphabet Γ,
• den Anfangszustand q0 und
• den anfänglichen Stackinhalt Z0 ∈ Γ sowie
134
KAPITEL 4. KONTEXTFREIE SPRACHEN
• die Zustandsüberführungsfunktion
δ : Q × Σ ∪ {} × Γ → P (Q × Γ∗ ) .
Für den Akzeptanzmodus durch Zustände ist zusätzlich noch eine Teilmenge F ⊆
Q von akzeptierenden Zuständen auszuzeichnen.
(b) Eine Konfiguration von A (für Eingabe w ∈ Σ∗ ) ist ein Tripel
(q, w0 , α)
mit q ∈ Q, w0 ∈ Σ∗ und α ∈ Γ∗ .
q ist der gegenwärtige Zustand, w0 ist der Suffix der noch nicht gelesenen Buchstaben)
von w, und α ist ein Stackinhalt. Wie arbeitet A? Wenn
0
(q, w10 · · · wm
, α1 · · · αs )
die gegenwärtige Konfiguration ist und wenn
(q 0 , Z1 · · · Zs ) ∈ δ(q, w10 , α1 ),
dann ist
0
(q 0 , w20 · · · wm
, Z1 · · · Zs α2 · · · αs )
eine mögliche Nachfolgekonfiguration. Wenn
(q 0 , Z1 · · · Zs ) ∈ δ(q, , α1 ),
dann ist
0
(q 0 , w10 · · · wm
, Z1 · · · Zs α2 · · · αs )
eine mögliche Nachfolgekonfiguration. Alle möglichen Nachfolgekonfigurationen werden
auf diese Art und Weise erhalten.
(c) Akzeptanz durch leeren Stack:
A akzeptiert die Eingabe w = w1 · · · wn genau dann, wenn es eine Konfigurationenfolge
(q0 , w1 · · · wn , Z0 ), . . . , (q, , )
gibt. Bis auf den letzten Schritt darf der Keller zu keinem anderen Zeitpunkt leer sein.
(d) Akzeptanz durch akzeptierende Zustände:
A akzeptiert die Eingabe w = w1 · · · wn genau dann, wenn es eine Konfigurationenfolge
(q0 , w1 · · · wn , Z0 ), . . . , (q, , α)
gibt mit α ∈ Γ∗ und q ∈ F . Bis auf den letzten Schritt darf auch diesmal der Keller
nicht leer werden.
Beispiel 4.7 L = {wwreverse | w ∈ {a, b}∗ }.
Wir entwerfen einen Kellerautomaten für L. Die Idee ist, dass sich der Kellerautomat in einer
ersten Phase die gelesenen Zeichen auf dem Stack merkt und irgendwann nichtdeterministisch
in eine zweiten Phase übergeht, in der die verbleibenden Zeichen der Eingabe mit dem Inhalt
des Stacks verglichen werden. Der Kellerautomat rät also die Mitte des Wortes.
Wir wählen Q = {push, pop, fail}, Γ = {a, b, Z0 }, q0 = push und die Befehle
4.4. KELLERAUTOMATEN
135
δ(push, a, x) = {(push, ax), (pop, ax)}
δ(push, b, x) = {(push, bx), (pop, bx)}
(
{(pop, )}
a=x
{(fail, x)} a =
6 x
(
{(pop, )}
b=x
{(fail, x)} b =
6 x
δ(pop, a, x) =
δ(pop, b, x) =
δ(fail, a, x) = {(fail, x)}
δ(fail, b, x) = {(fail, x)}
Satz 4.7 Sei G eine Grammatik in Greibach-Normalform. Dann gibt es einen Kellerautomaten A mit L(G) = L(A), und A akzeptiert L mit leerem Stack.
Beweis: Sei G = (Σ, V, S, P ). Wir definieren einen Kellerautomaten mit den folgenden Komponenten:
• Q = {q0 }: Q besteht also nur aus einem einziger Zustand,
• Γ=V,
• Z0 = S.
Das Programm wird so definiert, dass gilt:
∗
S → w1 · · · wn X1 · · · Xm
⇔
Der Automat A besitzt nach dem Lesen
von w1 · · · wn den Kellerinhalt X1 · · · Xm ,
wobei X1 zuoberst liegt.
Wir setzen deshalb
δ(q0 , a, y) = {(q0 , α) | y → aα ∈ P }.
In Worten: Wenn der Kellerautomat A das Symbol a ∈ Σ liest und y → aα eine Produktion
ist, dann darf
- die auf dem Stack zuoberst liegende Variable y durch α ersetzt werden und
- das nächste Symbol gelesen werden.
Dadurch werden keine -Bewegungen benötigt.
Sind Kellerautomaten mächtiger als kontextfreie Grammatiken?
Satz 4.8 Die Sprache L werde von einem Kellerautomaten A (mit leerem Stack) akzeptiert.
Dann gibt es eine kontextfreie Grammatik G mit
L(G) = L(A).
136
KAPITEL 4. KONTEXTFREIE SPRACHEN
Beweis: (Tripelkonstruktion) Sei A = (Q, Σ, Γ, q0 , Z0 , δ) ein Kellerautomat. Angenommen, A hat die Konfiguration
(p, u, X1 · · · Xm )
erreicht und hat bisher w = w1 · · · wk gelesen.
Versuch 1: Dann liegt es nahe, die Grammatik G so zu entwerfen, dass die Ableitung
∗
S → w1 · · · wk p X1 · · · Xm
möglich ist. Leider ist aber die Grammatik als kontextfrei zu entwerfen; der Ersetzungsschritt
wird also nur vom Zustand p (und nicht auch vom Kellersymbol X1 ) abhängen dürfen.
Fazit: Wir müssen Zustand und Kellersymbol in einer Variablen zusammenfassen.
Versuch 2:
∗
S → w1 · · · wk [p1 , X1 ][p2 , X2 ] · · · [pm , Xm ]
Was ist p1 , der gegenwärtige Zustand? Was ist p2 ? Der geratene Zustand, wenn das Symbol
X2 , also das Symbol unterhalb von X1 , an die Spitze des Stacks gelangt. Aber wie verifizieren
wir, dass p2 der richtige Zustand ist?
Wir arbeiten mit Tripeln, um uns an den geratenen Zustand zu erinnern!
Versuch 3: Wir entwerfen die Grammatik so, dass
∗
S → w1 · · · wk [p1 , X1 , p2 ][p2 , X2 , p3 ] · · · [pm , Xm , pm+1 ]
ableitbar ist.
Die Absicht ist, dass pi der aktuelle Zustand ist, wenn Xi an die Spitze des Stacks gelangt und
dass pi+1 der aktuelle Zustand wird, falls das darunterliegende Symbol an die Spitze gelangt.
Diese Absicht realisieren wir durch die fogenden Produktionen:
(a) S → [q0 , Z0 , p] gehört zur Produktionenmenge für jedes p ∈ Q: Wir raten den Endzustand p einer Berechnung.
(b) Für jeden Befehl (p0 , ) ∈ δ(p, a, X) fügen wir die Produktion
[p, X, p0 ] → a
hinzu.
(c) Für jeden Befehl
(p1 , α1 · · · αr ) ∈ δ(p, a, X)
mit a ∈ Σ ∪ {}
gehören die Produktionen
[p, X, qr+1 ] → a[p1 , α1 , p2 ][p2 , α2 , p3 ] · · · [pr , αr , pr+1 ]
zur Produktionenmenge, wobei alle Kombinationen (p2 , . . . , pr+1 ) durchlaufen werden.
In einer Linksableitung ist im nächsten Schritt die Variable [p1 , α1 , p2 ] zu ersetzen.
Wird α1 durch ein nicht-leeres Wort ersetzt, dann wird der (für die Offenlegung von α2 )
geratene Zustand p2 weiterhin festgehalten. Wird hingegen α1 mit dem Befehl (q, ) ∈
δ(p1 , b, α1 ) durch das leere Wort ersetzt, dann wird der geratene Zustand p2 auf die
Probe gestellt: Es muss q = p2 gelten. An dieser Stelle setzt also die Verifikation ein!
4.4. KELLERAUTOMATEN
137
Damit haben wir also nachgewiesen, dass die Klasse der kontextfreien Sprachen genau der
Menge der Sprachen, die von einem Kellerautomaten mit leerem Stack erkannt werden können,
entspricht. Im nächsten Satz machen wir die Aussage, dass die beiden Akzeptanzmodi „leerer
Stack“ bzw. „akzeptierender Zustand“ gleich mächtig sind.
Satz 4.9 (a) Sei A1 ein Kellerautomat, der mit Zuständen akzeptiert. Dann gibt es einen
äquivalenten Kellerautomaten A2 , der mit leerem Stack akzeptiert.
(b) Sei A1 ein Kellerautomat, der mit leerem Stack akzeptiert. Dann gibt es einen äquivalenten Kellerautomaten A2 , der mit Zuständen akzeptiert.
Beweis: (a) Hier ist die Idee: Wenn A1 irgendwann einen akzeptierenden Zustand erreicht,
dann sollte A2 die Option haben, den Stack zu leeren. Wenn aber A1 am Ende seiner Berechnung „zufälliger Weise“ einen leeren Stack geschaffen hat, dann sollte A2 nicht notwendigerweise akzeptieren.
Konstruktion von A2 :
- Am Anfang ersetze das Kellersymbol Z0 durch Z00 Z0 (kein „zufälliges“ Akzeptieren
durch leeren Stack).
- A2 übernimmt das Programm δ1 von A1 . Wenn ein Zustand in F erreicht wird, dann
darf A2 nichtdeterministisch seinen Stack leeren.
(b) Wir möchten, dass A2 bei leerem Stack (!) noch in einen akzeptierenden Zustand wechseln
kann.
Konstruktion von A2 :
- Zu Anfang ersetze Z0 über eine -Bewegung durch Z00 Z0 .
- Wenn das Kellersymbol Z00 erreicht wird, dann springe in einen akzeptierenden Zustand.
Damit haben wir also ein Maschinenmodell gefunden, welches genau den kontextfreien Sprachen entspricht. Warum haben wir diese Betrachtungen überhaupt angestellt? Wir hatten mit
dem CY K − Algorithmus doch bereits ein Werkzeug, das das Wortproblem einer jeden kontextfreien Sprache in Polynomialzeit löst. Aber die kubische Laufzeit des CY K −Algorithmus
bekommt zwar aus theoretischer Sicht das Etikett „effizient“ angeheftet, ist aber für praktische Anwendungen nicht verwendungsfähig. Man überlege sich wie groß der Source-Code
eines Programmes werden kann und wie furchterregend dann die Laufzeit wird. Es ist auch
festzuhalten, dass der CY K − Algorithmus immer in kubischer Zeit läuft. Insbesondere wird
das Wortproblem für reguläre Sprachen ebenso nur in kubischer Zeit gelöst.
Wir werden im nächsten Abschnitt deterministische Kellerautomaten, also Kellerautomaten
ohne Wahlmöglichkeiten, untersuchen. Wir werden sehen, dass wir durch die Auflage des
Determinismus zu einer Einschränkung der Sprachklasse kommen. Wir werden aber auch
feststellen, dass die Ausdruckskraft immer noch respektabel ist und dass häufig eine sehr
schnelle Compilation möglich ist.
138
KAPITEL 4. KONTEXTFREIE SPRACHEN
4.4.1
Deterministisch kontextfreie Sprachen
Wir führen nun den deterministischen Kellerautomaten ein.
Definition 4.7
(a) A heißt ein deterministischer Kellerautomat (DPDA), wenn
- für jedes Tripel (q, a, z) (mit q ∈ Q, a ∈ Σ und z ∈ Γ)
|δ(q, a, z)| + |δ(q, , z)| ≤ 1
gilt und
- A mit Zuständen akzeptiert.
(b) Eine Sprache L heißt deterministisch kontextfrei, wenn L von einem deterministischen
Kellerautomaten erkannt wird.
Ein deterministischer Kellerautomat erlaubt also höchstens eine Nachfolgekonfiguration, darf
aber -Schritte durchführen. Beachte, dass die deterministisch kontextfreien Sprachen eine
Untermenge der kontextfreien Sprachen sind.
Beispiel 4.8 Wir entwerfen einen deterministischen Kellerautomaten für die Sprache aller
legalen Klammerausdrücke, also für die von den Produktionen
S → [S] | SS | erzeugte Sprache.
n
o
n
o
Es ist natürlich Σ = [, ] . Wir wählen Γ = [, Z0 , Q =
Programm δ hat die Form
n
o
δ ok, [, [ = ok, [[
n
o
ok, false
und q0 = ok. Das
/* Der Kellerautomat zählt die öffnenden Klammern */
δ ok, ], [ =
n
o
ok, /* Der Automat hat ein Paar zusammengehöriger Klammern gefunden */
δ ok, [, Z0 =
δ ok, ], Z0 =
n
n
ok, [Z0
o
false, Z0
o
Es wurde keine entsprechende offene Klammer gefunden und deshalb ist false der neue
Zustand. Im Zustand false wird keine Aktion ausgeführt, bis auf das Weiterlesen der Eingabe.
Wenn der Klammerausdruck legal ist, wird für jede öffnende Klammer auch eine schließende
Klammer gefunden: Unser Automat hält nur mit leerem Stack.
Wenn unser Automat mit leerem Stack hält, wurde für jede öffnende Klammer auch eine
schließende gefunden, und der Klammerausdruck ist legal. Unser Automat sollte also mit
leerem Stack akzeptieren.
4.4. KELLERAUTOMATEN
139
Wir haben nun die Frage zu beantworten, inwiefern die Auflage des Determinismus zu einer
Einschränkung der Sprachklasse führt.
Bemerkung 4.3 Im letzten Abschnitt haben wir einen Kellerautomaten konstruiert, der
L = {wwreverse |w ∈ Σ∗ }
erkennt. Wir haben Nichtdeterminismus eingesetzt, um die Mitte des Wortes zu raten. Man
kann aber zeigen, dass ein deterministischer Kellerautomat hier überfordert ist.
Fragen:
1) Warum erlauben wir -Bewegungen in der Definition der deterministischen Kellerautomaten?
2) Warum haben wir Akzeptanz durch Zustand gefordert?
Antwort zu 1): Die Sprache L = {an bm cr dn | n > 0, m > r, r > 0} kann von einem deterministischen Kellerautomaten mit -Bewegung erkannt werden. Ohne -Bewegungen erreicht
man aber die gespeicherten a’s nicht.
An dieser Stelle kommen wir noch einmal auf die beiden uns bekannten Akzeptanzmodi
akzeptierender Zustand und leerer Stack zurück. Im letzten Abschnitt haben wir gesehen, dass
die beiden Modi die gleiche Sprachklasse akzeptieren. Für deterministische Kellerautomaten
kommen wir hier zu einem negativen Resultat und damit zu einer Antwort zu 2).
Definition 4.8 Wir definieren
LStack
= {L ⊆ Σ∗ |∃DPDA A, A akzeptiert L mit leerem Stack}
D
F
LD
= {L ⊆ Σ∗ |∃DPDA A, A akzeptiert L mit akzeptierendem Zustand}.
Satz 4.10
LStack
⊂ LFD
D
Beweis: Im Beweis von Satz 4.9 haben wir aus einem Automaten A1 , der mit leerem Stack
akzeptierte, einen Automaten A2 gebaut, der per Zustand akzeptierte und L(A2 ) = L(A1 )
erfüllte. Man überzeuge sich, dass diese Konstruktion keinen Nichtdeterminismus hinzugefügt
hat. Damit haben wir
LStack
⊆ LFD
D
nachgewiesen. Wir betrachten nun die Sprache L = {0, 01}. Zunächst überzeuge man sich,
dass L durch einen deterministischen Kellerautomaten akzeptiert werden kann, der mit Zuständen akzeptiert.
Dass diese Sprache nicht von einem deterministischen Kelleratomaten mit leerem Stack akzeptiert werden kann, macht man sich mit einer einfachen Fallunterscheidung klar.
- Schreibt der Automat im Anfangszustand beim Eingabezeichen 0 ein Zeichen auf den
Stack, so wird das Eingabewort 0 nicht akzeptiert: Fehler.
- Schreibt der Automat im Anfangszustand beim Eingabezeichen 0 nichts auf den Stack,
so bricht die Berechnung nach dem Lesen des ersten Zeichens bereits erfolgreich ab.
Auch 00 ∈
/ L wird akzeptiert: Fehler.
140
KAPITEL 4. KONTEXTFREIE SPRACHEN
Damit haben wir die Echtheit der Inklusion gezeigt. Akzeptieren per Zustand ist für deterministische Kellerautomaten der mächtigere Akzeptanzmodus.
Bemerkung 4.4 Für deterministisch kontextfreie Sprachen liefert der akzeptierende deterministische Kellerautomat eine schnelle Lösung des Compilerproblems, wenn keine -Schritte
durchgeführt werden. In diesem Fall erhalten wir eine Lösung in linearer Zeit. Man mache
sich aber klar, dass das Fortlassen von -Schritten eine wesentliche Einschränkung ist.
Warum ist die Betrachtung von deterministischen kontextfreien Sprachen nun so wichtig?
Satz 4.11
(a) Jede deterministisch kontextfreie Sprache ist eindeutig.
(b) {wwreverse |w ∈ Σ∗ } ist eindeutig aber nicht deterministisch kontextfrei.
(c) Das Wortproblem für deterministisch kontextfreie Sprachen kann in Linearzeit gelöst
werden.
Beweis: Siehe zum Beispiel das Textbuch von Ingo Wegener.
Aufgabe 86
Zeige Satz 4.11 (a).
Hinweis: Wende die Tripelkonstruktion an. Jede deterministisch kontextfreie Sprache wird durch einen DPDA
erkannt, dessen Endzustände keine ausgehenden ε-Übergänge haben.
Zunächst ist die Eindeutigkeit aus Sicht des Compilerbaus ein immenser Vorteil, da einem
Wort mit einer eindeutiger Ableitung leicht eine Semantik zugeordnet werden kann. Desweiteren garantiert Teil (c) eine effiziente Lösung des Wortproblems.
4.4.2
Abschlusseigenschaften deterministisch kontextfreier Sprachen
Unter welchen Operationen sind deterministisch kontextfreie Sprachen abgeschlossen? Im Gegensatz zu kontextfreien Sprachen sind deterministisch kontextfreie Sprachen unter Komplementbildung abgeschlossen, aber nicht unter Vereinigung. Als unmittelbare Konsequenz
erhalten wir deshalb, dass deterministisch kontextfreie Sprachen eine echte Teilklasse der
kontextfreien Sprachen bilden.
Satz 4.12
(a) Wenn L deterministisch kontextfrei ist, dann auch L.
(b) Es gibt deterministisch kontextfreie Sprachen L1 und L2 , so dass der Schnitt L1 ∩ L2
nicht einmal kontextfrei ist.
(c) Die deterministisch kontextfreien Sprachen sind unter Vereinigung nicht abgeschlossen.
(d) Die deterministisch kontextfreien Sprachen bilden eine echte Untermenge der kontextfreien Sprachen.
Beweis: (a) Sei A ein deterministischer Kellerautomat mit A = (Q, Σ, q0 , Z0 , δ, F ). Wir
„bauen“ einen deterministischen Kellerautomaten A0 , der das Komplement von L akzeptiert.
Beachte, dass A eine Eingabe auch während eventueller -Bewegungen akzeptieren kann.
Deshalb verwirft A0 genau dann, wenn A irgendwann, und zwar nach dem Lesen des letzten
Buchstabens und vor dem Versuch den nächsten Buchstaben zu lesen, akzeptiert.
4.4. KELLERAUTOMATEN
141
(b) Wir wissen, dass
{an bn cn | n ≥ 0} = L
nicht kontextfrei ist. Aber
L = {an bn cm | n, m ≥ 0} ∩ {am bn cn | n, m ≥ 0},
und beide Sprachen sind deterministisch kontextfrei.
(c) Nun zur Vereinigung. Wir betrachten die folgenden Sprachen K1 und K2 .
K1 = {ax by cz | x 6= y}
K2 = {ax by cz | y 6= z}
K1 und K2 sind deterministisch kontextfrei, da wir jeweils leicht einen deterministischen
Kellerautomaten angeben können. Wie sieht die Vereinigung der Sprachen K = K1 ∪ K2 aus?
K = K1 ∪ K2
= {ax by cz | x 6= y oder y 6= z}
Nehmen wir an, K sei deterministisch kontextfrei. Dann wäre wegen Teil (a) auch K deterministisch kontextfrei. Wie sieht diese Sprache aus:
K = {ax by cz | x = y = z}
Diese Sprache ist aber nicht kontextfrei, womit K nicht deterministisch kontextfrei gewesen
sein kann.
(d) Die oben betrachtete Sprache
K = {ax by cz | x 6= y oder y 6= z}
ist nicht deterministisch kontextfrei. Da sie aber kontextfrei ist, belegt sie die Echtheit der
Inklusion.
Aufgabe 87
Die Grammatik G mit dem Terminalalphabet {anweisung, bedingung, if, then, else} und den Produktionen
S → if bedingung then S else S | if bedingung then S | anweisung
ist eine Spezifikation der if-Anweisung.
Konstruiere einen DPDA für die Sprache L(G).
Aufgabe 88
Ein Wort w = w1 · · · wn aus Teilwörtern wi ∈ {+1, −1}3 beschreibt ein zweidimensionales Array mit n Spalten
und drei Zeilen. Wenn wi = a1 a2 a3 , dann ist der Knotenwert in Spalte i und Zeile j genau aj Euro. Beachte,
dass aj positiv oder negativ sein kann.
Wir definieren die Sprache P über dem Terminalalphabet {+1, −1}. Das Wort w gehört genau dann zur
Sprache P , wenn es ein zweidimensionales Array beschreibt, das einen profitablen Weg W mit den folgenden
Eigenschaften enthält:
• W beginnt in Zeile 1 und Spalte 1.
• W läuft in einer Zeile stets von links nach rechts.
• In derselben Spalte kann W von Zeile j zu Zeile j + 1 springen, falls j ≤ 2. Wenn W die dritte Zeile
erreicht hat, kann er sie also nicht mehr verlassen.
• W endet in Spalte n.
142
KAPITEL 4. KONTEXTFREIE SPRACHEN
Der Weg ist genau dann profitabel, wenn die Summe der durchlaufenen Knotenwerte positiv ist.
Beschreibe einen Kellerautomaten, der die Sprache P akzeptiert. Jeder Akzeptanzmodus, also Akzeptanz
durch leeren Keller oder Akzeptanz durch Zustände, ist erlaubt.
Aufgabe 89
Zeige, dass die folgenden Sprachenklassen abgeschlossen unter Durchschnitt mit regulären Sprachen sind:
• Die Klasse der kontextfreien Sprachen,
• die Klasse der deterministisch kontextfreien Sprachen,
• die Klasse der Sprachen, die durch Echtzeit-DPDAs erkannt werden.
Ein Echtzeit-DPDA ist ein deterministischer Kellerautomat ohne ε-Übergänge.
Aufgabe 90
Zeige die folgenden Aussagen:
(a) Die Sprache L1 = {0} ∪ {01ai bi ck | i, k ≥ 0} ∪ {1ai bk ck | i, k ≥ 0} ist deterministisch kontextfrei.
(b) Die Sprache L2 = {01ai bj ck | i, j, k ≥ 0, i = j oder j = k} ist nicht deterministisch kontextfrei.
Du darfst voraussetzen, dass die Sprache L3 = {ai bj ck | i, j, k ≥ 0, i = j oder j = k} nicht deterministisch
kontextfrei ist.
Zeige jetzt, dass die Klasse der deterministisch kontextfreien Sprachen nicht abgeschlossen ist unter den
Operationen
(c) Konkatenation,
(d) Kleene-Stern.
Hinweis: Finde je Teilaufgabe eine Transformation, die L1 in eine nicht deterministisch kontextfreie Sprache überführt. Jede Transformation darf korrekte Abschlusseigenschaften sowie die jeweils zu widerlegende
Abschlusseigenschaft ausnutzen.
4.5
Entscheidungsprobleme
Nur wenige Entscheidungsprobleme für KFGs sind entscheidbar oder sogar effizient entscheidbar. Das vielleicht wichtigste effizient entscheidbare Problem ist das Wortproblem, das vom
Algorithmus von Cocke-Younger-Kasami gelöst wird. Beispiele von weiteren effizient entscheidbaren Problemen sind
?
- das Leerheitsproblem (L(G) = ∅ und
- das Endlichkeitsproblem (ist L(G) endlich?).
Aufgabe 91
Gegeben sei eine kontextfreie Grammatik G = (Σ, V, S, P ) in Chomsky-Normalform.
(a) Beschreibe einen möglichst effizienten Algorithmus, der entscheidet, ob L(G) leer ist.
∗
Hinweis: Nenne eine Variable X produktiv, wenn es eine Ableitung X → w für ein Wort w aus Terminalen
gibt. Zeige, wie man alle produktiven Variablen effizient bestimmt.
(b) Beschreibe einen möglichst effizienten Algorithmus, der entscheidet, ob L(G) endlich ist.
Bestimme jeweils die Laufzeit deines Algorithmus.
Viele wichtige Entscheidungsprobleme für kontextfreie Sprachen sind hingegen unentscheidbar. Das Postsche Korrespondenzproblem ist die „Ursache allen Übels“.
4.5. ENTSCHEIDUNGSPROBLEME
4.5.1
143
Das Postsche Korrespondenzproblem
In der Untersuchung der Unentscheidbarkeit von Entscheidungsproblemen für kontextfreie
Sprachen und Kellerautomaten spielt das Postsche Korrespondenzproblem (PKP) ein wichtige
Rolle. Die Eingabe von PKP besteht aus einem endlichen Alphabet Σ, einer Zahl k ∈ N (k > 0)
und einer Folge (x1 , y1 ), (x2 , y2 ), . . . , (xk , yk ) von Wortpaaren mit x1 , y1 , . . . , xk , yk ∈ Σ+ . Es
ist zu entscheiden, ob es ein n ∈ N (n > 0) und Indizes i1 , . . . , in ∈ {1, . . . , k} gibt, so dass
xi1 xi2 · · · xin = yi1 yi2 · · · yin gilt. Mit anderen Worten, es ist zu entscheiden, ob es eine
x-Folge gibt, deren Konkatenation mit „ihrer“ Partnerfolge übereinstimmt.
Bei PKP handelt es sich somit um eine Art von Dominospiel, bei dem die Dominosteine nicht
wie üblich ein linkes und rechtes Feld, sondern diesmal ein oberes Feld (beschriftet mit xi ) und
ein unteres Feld (beschriftet mit yi ) besitzen. Wir müssen die Dominosteine so nebeneinander
legen, dass die obere mit der unteren Zeile übereinstimmt.
Beispiel 4.9 Das PKP mit Eingabe Σ = {0, 1}, k = 3 und
(x1 , y1 ) = (1, 111),
(x2 , y2 ) = (10111, 10),
(x3 , y3 ) = (10, 0).
hat eine Lösung mit n = 4 und i1 = 2, i2 = 1, i3 = 1, i4 = 3, denn wenn wir die „Dominosteine“ nebeneinander legen erhalten wir
x2 x1 x1 x3 = 10111 1
y2 y1 y1 y3 =
10
1
111 111
10
0
und die untere stimmt mit der oberen Zeile überein.
Bevor wir zeigen, dass PKP unentscheidbar ist, betrachten wir einige Problemvarianten. Die
Eingabe des modifizierten PKP (MPKP) ist identisch zur Eingabe von PKP. Diesmal ist
aber zu entscheiden, ob es eine mit x1 beginnende x-Folge gibt, die mit ihrer Partnerfolge
übereinstimmt.
Beispiel 4.10 Betrachtet als Eingabe für das MPKP hat das obige Beispiel keine Lösung.
Warum?
PKPΣ ist eine letzte PKP-Variante: Hier ist das Alphabet nicht mehr Teil der Eingabe,
sondern von vorne herein fixiert. Wir reduzieren die universelle Sprache
U = { hM iw | die Turingmaschine M akzeptiert Eingabe w }
auf das Postsche Korrespondenzproblem und seine Varianten. Da U unentscheidbar ist, folgt
die Unentscheidbarkeit von PKP, MPKP und PKP{0,1} .
Satz 4.13 Es gilt U ≤ MPKP ≤ PKP ≤ PKP{0,1} .
Beweisskizze: Wir zeigen zuerst die Reduktion PKP ≤ PKP{0,1} . Für ein endliches Alphabet Σ = {a1 , . . . , am } geben wir zuerst eine Binärkodierung seiner Buchstaben an und
zwar kodieren wir aj durch h(aj ) = 0 1j für alle j ∈ {1, . . . , m}. Die Reduktion von PKP
auf PKP{0,1} weist einer Eingabe Σ, k, (x1 , y1 ), . . . , (xk , yk ) für’s PKP die folgende Eingabe für’s PKP{0,1} zu: k ist unverändert,
aber wir benutzen diesmal die binären Wortpaare
h(x1 ), h(y1 ) , . . . , h(xk ), h(yk ) .
144
KAPITEL 4. KONTEXTFREIE SPRACHEN
Warum funktioniert die Reduktion? Für alle n ∈ N (n > 0) und alle i1 , . . . , in ∈ {1, . . . , k}
gilt:
xi1 xi2 · · · xin = yi1 yi2 · · · yin
⇐⇒
h(xi1 )h(xi2 ) · · · h(xin ) = h(yi1 )h(yi2 ) · · · h(yin ).
Da die Reduktion f berechenbar ist, ist f eine Reduktion von PKP auf PKP{0,1} .
Die Reduktion MPKP ≤ PKP stellen wir als Übungsaufgabe. Wir kommen also jetzt zum
zentralen Ziel, nämlich dem Nachweis der Reduktion U ≤ MPKP. Gesucht ist eine Transformation f , die jedem Wort u ∈ {0, 1}∗ eine Eingabe f (u) für’s MPKP zuordnet, so dass
u ∈ H, d.h. u = hM i w für eine
⇐⇒ das MPKP f (u) besitzt eine Lösung.
TM M , die Eingabe w akzeptiert
Betrachten wir zuerst den leichter Fall, dass u nicht von der Form hM i w. Dann wählen wir
eine Eingabe f (u) für’s MPKP, die keine Lösung besitzt, z.B., Σ = {0, 1}, k = 1, x1 = 0,
y1 = 1.
Kümmern wir uns um den schwierigen Fall, nämlich u = hM i w für eine Turingmaschine
M = (Σ, Q, Γ, δ, q0 , F ). Wir nehmen o.B.d.A. an, dass M nur dann in einen akzeptierenden
Zustand q ∈ F wechselt, wenn sie unmittelbar danach anhält. Schließlich fordern wir ebenfalls
o.B.d.A, dass M nie den Kopf auf einer Zelle stehen lässt und nie seinen Eingabebereich nach
links hin verlässt.
Hier ist die Idee der Reduktion. Wir repräsentieren eine Konfigurationen von M durch Worte
˙ wie folgt:
über dem Alphabet Γ∪Q
uqv repräsentiert die Situation, bei der M im Zustand q ist, die Bandinschrift uv ist,
und der Kopf auf dem ersten Symbol von v steht. Die Startkonfiguration bei Eingabe
w wird also durch q0 w repräsentiert.
Wir geben jetzt eine Eingabe f (hM i w) für’s MPKP an, die aufeinander folgende Konfigurationen von M erzeugt, also die Berechnung von M nachmacht.
• Das Alphabet ist Γ ∪˙ Q ∪˙ {#}. Das Symbol # dient als Trennsymbol zwischen den
einzelnen Konfigurationen.
• Für ein geeignetes k ∈ N wählen wir Wortpaare (x1 , y1 ), (x2 , y2 ), . . . , (xk , yk ) wie folgt,
wobei
(x1 , y1 ) mit x1 := # und y1 := #q0 w#
das Startpaar ist. Das Wort y1 beschreibt also die Startkonfiguration, wenn M auf dem
leeren Wort rechnet. (Wenn w das leere Wort ist, dann wähle y1 = #q0 B#.) Als weitere
„Regeln“ verwenden wir
– für Rechtsbewegungen δ(q, a) = (q 0 , a0 , rechts) das Paar
(qa, a0 q 0 ),
solange q 6= qv ,
– für Linksbewegungen δ(q, a) = (q 0 , a0 , links) das Paar
(bqa, q 0 ba0 )
mit b ∈ Γ, solange q 6= qv ,
4.5. ENTSCHEIDUNGSPROBLEME
145
– die Kopierregeln mit den Paaren
(a, a)
für a ∈ Γ
– sowie die Abschlußregeln
(#, #), bzw. (#, B#)
für q ∈ F .
Tatsächlich müssen wir noch weitere Regeln aufnehmen, um die folgende Behauptung zu
zeigen.
Behauptung: M akzeptiert Eingabe w ⇐⇒ f (hM i) besitzt eine Lösung mit Startpaar
(x1 , y1 ).
Wie müssen die fehlenden Regeln aussehen? Betrachten wir die Richtung ⇒. Unser Ziel ist
die Konstruktion übereinstimmender x- und y-Zeilen. Das Startpaar (#, #q0 w#) erzwingt
dann ein Wort x2 das mit q0 beginnt und damit muss die Regel (q0 w1 , a0 q 0 ) für eine Rechtsbewegung δ(q0 , w1 ) = (q 0 , a0 , rechts) gewählt werden. Eine solche Regel steht aber nur dann
zur Verfügung, wenn M auf w1 eine Rechtsbewegung im Zustand q0 durchführt: Das muss M
aber tun, denn sonst verlässt es seinen Eingabebereich nach links hin. Also ist zwangsläufig
x2 = q0 w1 und y2 = a0 q 0 .
Die x-Zeile ist jetzt #q0 w1 und die y-Zeile ist #q0 w1 · · · wn #a0 q 0 w2 . Wir sind gezwungen ein
mit w2 beginnendes Wort x3 zu wählen und der Begrenzer # zwingt uns die Kopierregeln
anzuwenden, bis wir die x-Zeile #q0 w1 · · · wn und die y-Zeile #q0 w1 · · · wn #a0 q 0 w2 · · · wn erreicht haben. Auch der nächste Schritt ist erzwungen, denn der Begrenzer muss hinzugefügt
werden. (Die Abschlussregel (#, B#) ist zu wählen, wenn w = w1 und M somit im nächsten
Schritt das Blanksymbol liest.)
Unsere Regeln gewährleisten also, dass x- und y-Zeile eine Berechnung von M auf Eingabe w
simulieren! Wir wissen nach Fallannahme, dass M die Eingabe w akzeptiert und deshalb, wenn
wir unsere Konstruktion genügend lange fortsetzen, entspricht die y-Zeile einer akzeptierenden
Konfiguration mit einem Zustand q ∈ F . Wir fügen jetzt die „Aufholregeln“
(aq, q), bzw. (qa, q)
für jeden akzeptierenden Zustand q und jeden Buchstaben a des Bandalphabets hinzu und
können damit die x-Zeile gegenüber der um die letzte Konfiguration längeren y-Zeile langsam auffüllen: Wir benutzen Kopierregeln gefolgt von einer Anwendung der Aufholregel und
wiederholen diesen Prozess solange bis wir Gleichstand mit der Regel
(q##, #)
erreicht haben.
Da die Umkehrung ⇐ mit gleicher Argumentation folgt, ist die Beweisskizze erbracht.
4.5.2
Unentscheidbare Probleme für kontextfreie Sprachen
Wir zeigen leider, dass viele wichtige Entscheidungsprobleme für kontextfreie Sprachen unentscheidbar sind. Wir reduzieren jedes Mal das Postsche Korrespondenzproblem auf das
betreffende Entscheidungsproblem.
146
KAPITEL 4. KONTEXTFREIE SPRACHEN
Satz 4.14 Die folgenden Probleme für kontextfreie Grammatiken G, G1 , G2 und einen regulären Ausdruck R sind unentscheidbar:
(a) L(G1 ) ∩ L(G2 ) 6= ∅?
(b) Ist die Grammatik G eindeutig?
(c) L(G) = Σ∗ ?
(d) L(G1 ) = L(G2 )? und L(G1 ) ⊆ L(G2 )?
(e) L(R) = L(G)? und L(R) ⊆ L(G)?
Beweis: Gegeben sei ein Postsches Korrespondenzproblem (PKP) über dem Alphabet Σ =
{0, 1} mit den Wortpaaren (x1 , y1 ), . . . , (xk , yk ).
(a) Um das PKP mit Hilfe der Frage „L(G1 ) ∩ L(G2 ) 6= ∅?“ zu lösen verwenden wir die
Sprachen
L(G1 ) = {xi1 · · · xin $yireverse
· · · yireverse
| n ∈ N i1 , . . . , in ∈ {1, . . . , k}},
n
1
L(G2 ) = {w$wreverse | w ∈ {0, 1}∗ }.
Offensichtlich ist das PKP genau dann lösbar, wenn L(G1 ) ∩ L(G2 ) 6= ∅ gilt. Beachte, dass
L(G1 ) kontextfrei ist: Benutze die Produktionen
S → xi S yireverse | xi $ yireverse für i = 1, . . . , k.
(b) Wir verwenden das Alphabet Σ = {0, 1, 1, 2, . . . , k} und wählen die kontextfreie Grammatik G mit den Produktionen
S → A|B
A → x1 A1 | x2 A2 | · · · | xk Ak | ε
B → y1 B1 | y2 A2 | · · · | yk Ak | ε.
G ist genau dann eindeutig, wenn das PKP keine Lösung besitzt.
(c) Wir definieren die Sprache
L1 = {w$wreverse | w ∈ {0, 1}∗ },
wobei aber das Zeichen # an beliebiger Stelle in beliebiger Anzahl vorkommen kann, sowie
die Sprache
L2 = {xi1 # · · · #xin $ yireverse
# · · · #yireverse
| n ∈ N i1 , . . . , in ∈ {1, . . . , k}}.
n
1
L1 und L2 sind deterministisch kontextfrei. Also sind sowohl {0, 1, #, $}∗ \ L1 wie auch
{0, 1, #, $}∗ \ L2 kontextfrei. Dann ist aber auch
L = ({0, 1, #, $}∗ \ L1 ) ∪ ({0, 1, #, $}∗ \ L2 )
= {0, 1, #, $}∗ \ (L(G1 ) ∩ L(G2 ))
kontexfrei. Also ist das PKP genau dann unlösbar, wenn L = {0, 1, #, $}∗ .
(d) und (e) sind unmittelbare Konsequenz von (c).
4.5. ENTSCHEIDUNGSPROBLEME
4.5.3
147
Das Äquivalenzproblem für Finite State Transducer
Wir geben eine weitere Konsequenz der Unentscheidbarkeit des Postschen Korrespondenzproblems für Finite State Transducer (FST) an: Ein FST A = (Q, Σ, Γ, I, F, δ) ist wie ein
nichtdeterministischer endlicher Automat mit Ausgabe aufgebaut. Insbesondere ist
• Q die Zustandsmenge, I ⊆ Q die Menge der Anfangszustände und F die Menge der
akzeptierenden Zustände,
• Σ ist das Eingabealphabet und Γ das Ausgabealphabet.
• Die Überführungsrelation δ hat die Form
δ ⊆ Q × Σ ∪ {} × Γ ∪ {} × Q.
Wenn sich die Maschine A im Zustand q befindet und den Buchstaben a ∈ Σ liest, dann
darf A genau dann in den Zustand q 0 wechseln und den Buchstaben a0 drucken, wenn
(q, a, a0 , q 0 ) ∈ δ.
Wir sagen, dass A unter Eingabe x ∈ Σ∗ die Ausgabe y ∈ Γ∗ produzieren kann, wenn es einen
Anfangszustand i ∈ I gibt, so dass eine in Zustand i beginnende Berechnung für Eingabe x
die Ausgabe y produziert.
Die Äquivalenz von NFA’s ist eine durchaus schwierige Aufgabe, die aber entscheidbar ist:
Überführe die nfa’s in dfa’s mit Hilfe der Potenzmengenkonstruktion und überprüfe die Äquivalenz der dfa’s. Die Äquivalenz von FST’s hingegen ist überraschender Weise (?!) unentscheidbar.
Korollar 4.15 Die Frage, ob zwei gegebene Finite State Transducer dieselbe Sprache erkennen, ist nicht entscheidbar.
Beweis: Wir reduzieren PKP{0,1} auf das Äquivalenzproblem für Finite State Transducer.
Seien k und die Paare (x1 , y1 ), . . . , (xk , yk ) eine Eingabe für PKP{0,1} . Für das Eingabealphabet Σ = {1, . . . , k} und das Ausgabealphabet Γ = {0, 1} bauen wir zuerst einen recht trivialen
FST A1 , der für jede Eingabe ξ ∈ Σ∗ jede Ausgabe η ∈ Γ∗ produzieren kann. Der FST A2 ist
ebenfalls sehr einfach: Für eine Eingabe i1 · · · in ∈ Σ∗ produziert A2 jede mögliche Ausgabe
w ∈ Γ∗ , falls w 6= xi1 · · · xin oder w 6= yi1 · · · yin .
Angenommen, es gibt eine Lösung für PKP{0,1} und die Eingabe (x1 , y1 ), . . . , (xk , yk ). Dann
gibt es i1 , . . . , in mit x1 · · · xk = y1 · · · yk . Dann wird aber A2 nicht die Ausgabe xi1 · · · xin produzieren und damit unterscheidet sich A1 von A2 . Ist PKP{0,1} für Eingabe (x1 , y1 ), . . . , (xk , yk )
hingegen nicht lösbar, dann sind A1 und A2 äquivalent.
Aufgabe 92
Zeige: Die Frage, ob zwei gegebene Kellerautomaten dieselbe Sprache akzeptieren, ist nicht entscheidbar.
Aufgabe 93
(a) Im Problem k-UNIVERSALITY ist eine kontextfreie Grammatik G = (Σ, V, S, P ) mit |Σ| = k gegeben und es ist zu entscheiden, ob L(G) = Σ∗ gilt. Aus dem Beweis von Satz 4.14 (c) folgt, dass
4-UNIVERSALITY unentscheidbar ist.
Zeige, dass auch 2-UNIVERSALITY unentscheidbar ist.
148
KAPITEL 4. KONTEXTFREIE SPRACHEN
(b) Eine kontextfreie Grammatik G = (Σ, V, S, P ) heiße minimal, falls jede kontextfreie Grammatik für die
Sprache L(G) mindestens |P | Produktionen besitzt. Im Minimierungsproblem für kontextfreie Grammatiken ist eine kontextfreie Grammatik G gegeben und es ist eine minimale kontextfreie Grammatik
für die Sprache L(G) zu bestimmen.
Zeige, dass es keinen Algorithmus gibt, der das Minimierungsproblem für jede kontextfreie Grammatik
löst.
Hinweis: Überlege, wie ein Minimierungsalgorithmus eingesetzt werden kann, um 2-UNIVERSALITY
zu entscheiden. Beachte, dass 1-UNIVERSALITY entscheidbar ist.
4.6
Zusammenfassung
Wir haben gesehen, dass kontextfreien Sprachen eine wesentlich größere Sprachklasse abdecken als die regulären Sprachen. Allerdings haben das Pumping-Lemma bzw. das mächtigere
Lemma von Ogden auch die Grenzen der Ausdrucksstärke kontextfreier Sprachen gezeigt.
Das Konzept des Ableitungsbaums hat sich in diesen Untersuchungen als besonders hilfreich
erwiesen.
Wir haben die Chomsky-Normalform kontextfreier Sprachen eingeführt und gezeigt, dass wir
mit Hilfe der dynamischen Programmierung der (CYK-Algorithmus) das Wortproblem in Zeit
O(|Produktionen| · |w|3 )
lösen können. Für praktische Anwendungen ist das Konzept der kontextfreien Sprachen dennoch etwas zu weit gefaßt. Kubische Laufzeit ist ab einer gewissen Sourcecodelänge nicht
mehr akzeptabel.
Als Konsequenz haben wir die kontextfreien Sprachen noch weiter eingeschränkt und kamen
zu den deterministisch kontextfreien Sprachen, die wir mit Hilfe deterministischer Kelleratomaten eingeführt haben. Nebenbei haben wir beobachtet, dass nichtdeterministische Kellerautomaten genau die kontextfreien Sprachen akzeptieren. Die wichtigen Eigenschaften der
Klasse deterministisch kontextfreier Sprachen sind einerseits ihre Eindeutigkeit und andererseits die Lösung des jeweiligen Wortproblems in Linearzeit.
Mit Hilfe des Postschen Korrespondenzproblems (PKP) kann die Unentscheidbarkeit vieler
Entscheidungsprobleme für kontextfreien Sprachen und Kellerautomaten gezeigt werden. Wir
haben die Unentscheidbarkeit des Äquivalenzproblems für kontextfreie Grammatiken und
Finite State Transducer mit Hilfe der Unentscheidbarkeit von PKP nachgewiesen.
Kapitel 5
XML und reguläre
Baumgrammatiken∗
Im Compilerproblem haben wir uns die Aufgabe gestellt, die syntaktische Korrektheit eines
Programms P zu überprüfen. Dazu haben wir uns P als einen String, nämlich als Konkatenation aller Anweisungen von P vorgestellt. Im Typechecking Problem für XML-Dokumente
sehen wir uns mit einer neuen Situation konfrontiert:
Ein XML-Dokument D ist hierarisch strukturiert. Eine Interpretation von D als eine
Folge von Buchstaben unterdrückt die Zusatzinformation der hierarischen Strukturierung und ist deshalb nicht angemessen. Vielmehr stellt es sich heraus, dass wir D als
einen Baum auffassen sollten, dessen Knoten mit Worten beschriftet sind.
Wir werden deshalb Grammatiken betrachten, die beschriftete Bäume erzeugen und untersuchen Baumsprachen, also Sprachen, die nicht mehr aus Strings, sondern aus beschrifteten
Bäumen bestehen. Wir schließen die Betrachtung von XML mit den Sprachen XPath und
XQuery, die für die Auswertung von XML-Dokumenten vor Allem in Hinblick auf Datenbankanwendungen eingesetzt werden.
5.1
XML
Wir geben eine kurze Beschreibung von XML (extensible Markup Language oder in Deutsch:
erweiterbare Auszeichnungssprache1 ). XML ist ein vom World Wide Web Konsortium W3C
verabschiedeter Standard für einen plattform-unabhängigen Austausch von Daten zwischen
Rechnern. Die Regeln von XML unterstützen eine hierarische Strukturierung, also eine Baumstrukturierung der Daten.
Wir geben zuerst einen kurzen Überblick über die Syntax von XML-Dokumenten. Ein XMLDokument entspricht einem Baum aus Elementen. Elemente mit Inhalt besitzen eine Startund Endkennung, die jeweils mit dem Namen des Elements beschriftet ist:
<element-name>
element-beschreibung
</element-name>
1
HTML und LaTex sind Beispiele „konventioneller“ Auszeichungssprachen.
149
150
KAPITEL 5. XML UND REGULÄRE BAUMGRAMMATIKEN∗
Elemente ohne Inhalt werden durch <element-name element-beschreibung /> spezifiziert.
Elemente mit Inhalt besitzen Kinder-Elemente und Attribute, Elemente ohne Inhalt besitzen
nur Attribute. Jedes XML-Dokument besitzt eine Baumstruktur. Dazu fordert die Syntax
von XML, dass ein XML-Dokument
- genau ein Wurzelelement besitzt und
- dass die Kennung eines Elements vor der Endkennung des Elternelements oder der
Startkennung eines Geschwisterelements zu schließen ist.
Beispiel 5.1 Ein XML-Rezept.
<rezept name="Mein erster Pfannkuchen" benoetigte-zeit="1" einheit="Stunde">
<zutaten>
<zutat
name="Mehl"
wieviel="250" einheit="Gramm"/>
<zutat
name="Eier"
wieviel="2"
einheit="Stueck"/>
<zutat
name="Zucker"
wieviel="1"
einheit="Essloeffel"/>
<zutat
name="Milch"
wieviel="500" einheit="Milliliter"/>
<zutat
name="Rapsoel" wieviel="5"
einheit="Gramm"/>
</zutaten>
<zubereitung>
Alle Zutaten in eine Schuessel geben und
<em>kraeftig</em> umruehren. Dann Rapsoel
in der Pfanne erhitzen, den Teig in die Pfanne
geben und <em>rechtzeitig</em> herausnehmen.
</zubereitung>
<kommentar>
Lecker
</kommentar>
</rezept>
Die erste Annotation <rezept>...</rezept> definiert das Wurzelelement mit Startkennung
(engl: start tag) <rezept> und Endkennung (engl: end tag) </rezept>. Der von <rezept>
und </rezept> eingeschlossene Teil definiert den Inhalt des Elements, also in unserem Fall
- die in der Reihenfolge zutaten, zubereitung, kommentar geordneten „regulären“ Kinder sowie
- die Attribute name, benoetigte-zeit und einheit, die als ungeordnete, „irreguläre“
Kinder des Elements auftreten.
Ein Attribut kommt stets im Inhalt eines Elements vor, besitzt keine Kinder und nimmt
Werte an.
Das Element rezept definiert also einen XML-Baum mit Wurzel rezept und den drei geordneten Kindern zutaten, zubereitung,kommentar. Der Inhalt von zutaten besteht aus den
fünf zutat Elementen, die ihrerseits drei Attributkinder, nämlich name, wieviel und einheit
besitzen. Das Element zubereitung besitzt fünf Kinder, ein Textknoten gefolgt von dem Element em, einem Textknoten, einem weiteren Vorkommen von em und einem abschließendem
Textknoten. Schließlich hat kommentar einen Textknoten als Kind.
5.1. XML
151
Die Start-Ende Kennungen eines XML-Dokuments legen also den zu einem XML-Dokument
gehörenden Baum eindeutig fest und dieser Baum ist sehr schnell bestimmbar.
Definition 5.1 Ein XML-Baum (W, E, λ, ν) ist ein geordneter Baum mit Knotenmenge W
und Kantenmenge E. Innere Knoten entsprechen Elementen, Blätter entsprechen Attributen.
Die Funktion λ weist einem Textknoten die Markierung „Text“, jedem anderen Knoten seine
Kennung, bzw seinen Attributnamen zu. Die Funktion ν weist Textknoten den zugehörigen
Text und Attributen Werte zu.
Wir unterscheiden also zwischen der Beschriftung λ, die Textknoten identifiziert, bzw. den
Namen (für ein Element oder ein Attribut) zuweist und der Beschriftung ν, die Werte zuweist. Im Folgenden werden wir uns nur auf die Graphstruktur eines XML-Baums und die
Namensgebung λ konzentrieren, die Wertezuweisung werden wir also unterschlagen.
Jedes XML-Dokument D wird also durch einen XML-Baum B repräsentiert. Wie erhalten
wir D, wenn nur B gegeben ist? Wir drucken die Knoten von B in einem Präorderdurchlauf
von B aus und weisen Werte mit Hilfe der Funktion ν zu!
Anwendungsspezifische XML-Sprachen wie
• RSS (Veröffentlichung von Änderungen auf Webseiten),
• XHTML (Neuformulierung von HTML 4 in XML 1.0),
• SVG –scalable vector graphics– (Beschreibungssprache für zweidimensionale Vektorgrafiken),
• MathML (Darstellung mathematischer Formeln),
• GraphML (Beschreibung und Darstellung von Graphen)
schränken die XML-Syntax ein. Jede dieser Sprachen unterscheidet zwischen zwei Klassen
von XML-Dokumenten, nämlich den sinnvollen, für die das XML-Dokument syntaktisch korekt ist und den Rest. XML Schema Sprachen geben die Möglichkeit, eine Syntax für XMLDokumente zu beschreiben. XML-Parser (oder XML-Prozessoren) überprüfen dann die syntaktische Korrektheit eines vorgegebenen XML-Dokuments. Wir konzentrieren uns im Folgenden auf grammatik-basierte Schema Sprachen (wie DTD, XML Schema, RELAX NG und
XSLT), also auf die am weitesten verbreitete Klasse von Schema Sprachen.
KAPITEL 5. XML UND REGULÄRE BAUMGRAMMATIKEN∗
152
5.2
DTDs
Eine Syntaxbeschreibung durch DTDs hat die Form
<!DOCTYPE Name-der-Syntax
[ eine Liste von Elementdefinitionen ]>
Der Typ eines Elements wird dann durch die Beschreibung
<!ELEMENT Name-des-Elements ( Definition-des-Elements )>
festgelegt. Eine DTD (Document Type Definition) legt fest, welche Wahlmöglichkeiten für
die Kinder eines jeden Elements bestehen. Diese „Kinderregeln“ weisen dazu dem Element v
einen regulären Ausdruck in den „Kinder-Elementen“ von v zu.
Beispiel 5.2 Eine DTD für XML-Rezepte könnte zum Beispiel das folgende Aussehen haben:
<!ELEMENT
<!ELEMENT
<!ELEMENT
<!ELEMENT
<!ELEMENT
<!ELEMENT
<!ATTLIST
rezept
zutaten
zutat
zubereitung
em
kommentar
rezept
<!ATTLIST zutat
(zutaten, zubereitung, kommentar?)>
(zutat*)>
>
((#PCDATA | em )*)>
(#PCDATA)>
(#PCDATA)>
name
CDATA #REQUIRED
benoetigte-zeit
CDATA #REQUIRED
einheit
CDATA #REQUIRED>
name
CDATA #REQUIRED
wieviel
CDATA #REQUIRED
einheit
CDATA #REQUIRED>
In den regulären Ausdrücken steht ein Komma für die Konkatenation, der vertikale Strich für
die Vereinigung, der Stern für den Kleene-Operator und das Fragezeichen für die optionale
Wahl. Zusätzlich wird + für ein mindestens einmaliges Auftreten verwandt.
Das Schlüsselwort #PCDATA steht für parsed character data und gibt an, dass der jeweilige Textknoten Stringwerte annimmt. Die Deklarationen von Attributen geschieht durch die
5.2. DTDS
153
<!ATTLIST ... > Kennung; die Markierung #REQUIRED gibt an, dass das Attribut auftreten
muss.
Die DTD beschreibt also die Klasse zulässiger Bäume mit Wurzel rezpt. Zum Beispiel legen
wir fest, dass rezept das linke Kind zutaten und darauffolgend das Kind zubereitung
besitzt; möglicherweise hat rezept auch noch kommentar als rechtestes Kind. zutaten hat
unbeschränkt viele Kinder vom Typ zutat, wobei in zutat die Attribute name, wieviel,
einheit auftreten.
Ein Element darf durchaus mehrfach im Baum vorkommen. Bei mehrmaligem Auftreten
im Baum gilt aber stets die eine in der DTD beschriebene Deklaration, verschiedene, vom
Kontext-abhängige Deklarationen sind also verboten.
Das Wortproblem für nichtdeterministische Automaten kann in Zeit O(|w| · |Q|2 ) für ein
Eingabewort w gelöst werden. Da ein regulärer Ausdruck der Länge L in einen nichtdeterministischen Automaten mit höchstens L Zuständen umgebaut werden kann, ist also auch das
Wortproblem für reguläre Ausdrücke effizient lösbar. Um aber eine noch schnellere Berechnung zu erlauben, werden in DTDs nur deterministische reguläre Ausdrücke zugelassen.
Definition 5.2 Sei R ein regulärer Ausdruck über dem Alphabet Σ. Wir ersetzen R durch
den regulären Ausdruck R0 , indem für alle i und alle Buchstaben a ∈ Σ das ite Vorkommen
von a durch den neuen Buchstaben ai ersetzt wird.
R ist deterministisch, wenn es keinen Buchstaben b ∈ Σ und keine Worte w, v, v 0 gibt, so dass
die beiden Worte wbi v und wbj v 0 mit i 6= j den Ausdruck R0 erfüllen.
Der reguläre Ausdruck R = ab + ac ist also nicht deterministisch, denn sowohl a1 b wie auch
a2 c erfüllen den Ausdruck R0 = a1 b1 + a2 c1 . Beachte aber, dass der äquivalente Ausdruck
R = a(b + c) sehr wohl deterministisch ist, denn jeder Buchstabe taucht genau einmal auf.
Das Wortproblem für einen deterministischen Ausdruck R lässt sich in einem links-nach-rechts
Durchlauf des Worts Eingabeworts u lösen, da für jeden Buchstaben b nur ein Vorkommen
von b in R “passt”. Wenn wir das Wortproblem für das Eingabewort aaa und den Ausdruck
(a + b)∗ a lösen möchten, dann wissen wir nicht, welches Vorkommen von a in (a + b)∗ a für das
erste a in aaa passt. Der mit (a + b)∗ a äquivalente (und deterministische) Ausdruck b∗ a(b∗ a)∗
stellt kein Problem dar. (Warum?)
Aufgabe 94
Zeige, dass (a + b)∗ a und b∗ a(b∗ a)∗ äquivalent sind und dass b∗ a(b∗ a)∗ ein deterministischer Ausdruck ist.
Aufgabe 95
Zeige, dass das Wortproblem für deterministische reguläre Ausrücke in einem links-nach-rechts Durchlauf des
Eingabeworts gelöst werden kann.
Wenn wir die Eigenheiten der DTD-Syntax ausblenden und auch die Deklaration der Attribute
vernachlässigen, werden wir auf den folgenden Kern der Deklaration geführt.
Rezept
Zutaten
Zutat
Zubereitung
Em
Kommentar
#PCDATA
->
->
->
->
->
->
->
rezept(Zutaten, Zubereitung, Kommentar?)
zutaten(Zutat*)
zutat()
zubereitung((#PCDATA | Em)*)
em(#PCDATA)
kommentar(#PCDATA)
#pcdata
KAPITEL 5. XML UND REGULÄRE BAUMGRAMMATIKEN∗
154
Wir können diese Deklarationen auch als Produktionen einer erweiterten kontextfreien Grammatik auffassen: Die Variablen der Grammatik entsprechen den Elementen, die Produktionen den regulären Ausdrücken. Beachte, dass wir Elementnamen gross schreiben, wenn wir
das jeweilige Element als Variable auffassen. Die Kleinschreibung deutet die Sichtweise als
„Buchstabe“ an: Start- und Endkennung mit dem jeweiligen Namen sind einzufügen. Unsere
Produktionen sind also stets von der Form
X → a(R),
(5.1)
wobei X eine Variable, a ein Buchstabe und R ein regulärer Ausdruck ist, der nur aus Variablen besteht.
Genauso wie in diesem Beispiel können wir auch beliebige DTD-Deklarationen als eine erweiterte2 kontextfreie Grammatik G auffassen und erhalten als Konsequenz:
Wenn wir Attribute und Text-Elemente vernachlässigen, dann entsprechen XML-Bäume
genau den Ableitungsbäumen von G.
Das Wortproblem (oder das Typchecking Problem) für einen vorgegebenen DTD-Typ ist
deshalb wesentlich einfacher als für allgemeine kontextfreie Grammatiken, denn wir müssen
ja nur überprüfen, ob ein vorgegebener Ableitungsbaum legal ist.
5.2.1
Ein Parser für DTDs
Das XML-Dokument D liege mit einer DTD-Deklaration vor. Typechecking wird durch
einzigen links-nach-rechts Durchlauf von D durchgeführt:
(1) Wenn eine Startkennung mit Namen a angetroffen wird, dann bestimme die eine
Produktion X → aR, die a erzeugen kann.
(2) Wenn die entsprechende Endkennung gelesen wird, dann überprüfe, ob die den
Kindern zugeordnete Buchstabenfolge den regulären Ausdruck R erfüllt. Ist dies
nicht der Fall, dann brich mit einer Fehlermeldung ab.
/* Hier zahlt sich die DTD-Beschränkung auf deterministische Ausdrücke aus, da
das Wortproblem für R ebenfalls in einem links-nach-rechts Durchlauf lösbar ist.
*/
Typechecking geschieht also blitzschnell und benötigt noch nicht einmal eine explizite Bestimmung des XML-Baums. Man sagt auch, dass der Parser im „Event Modell“ arbeitet, wobei
jede Start- und Endkennung ein Event, also ein Ereignis darstellt. Wir können uns natürlich
die Arbeitsweise des Parsers auch auf dem zugehörigen XML-Baum vorstellen, wenn wir uns
erinnern, dass ein XML-Dokument aus seinem Baum durch einen Präorderdurchlauf entsteht:
Der Parser arbeitet den Baum also nach der Präorderreihenfolge ab.
5.3
Reguläre Baumsprachen
Wie groß ist die Beschreibungskraft von DTDs, beziehungsweise welche anderen vernünftigen
Beschreibungsmechanismen stehen uns noch zur Verfügung? Um diese Fragen zu beantworten,
stellen wir jetzt reguläre Baumgrammatiken vor, die beschriftete Bäume und insbesondere
XML-Bäume erzeugen.
2
Natürlich könnten wir auch konventionelle kontextfreie Grammatiken verwenden, müssten dann aber die
regulären Ausdrücke durch mehrere konventionelle Produktionen ersetzen, ein kleiner Schönheitsfehler.
5.3. REGULÄRE BAUMSPRACHEN
155
Definition 5.3 Eine reguläre Baumgrammatik (V, Σ, S, P ) besteht aus
• der endlichen Menge V der Variablen,
• dem Alphabet Σ,
• dem Startsymbol S ∈ V
• und einer endlichen Menge P von Produktionen.
Jede Produktion in P ist von der Form
X → aR,
wobei X ∈ V eine Variable, a ∈ Σ ein Buchstabe und R ein regulärer Ausdruck ist, der nur
aus Variablen besteht. Wir sagen auch, dass R die Kinderstruktur von X beschreibt.
Beachte, dass wir annehmen können, dass es zu jeder Variablen X ∈ V und zu jedem Buchstaben a ∈ Σ höchstens eine Produktion X → aR gibt: Wir können ja zwei Produktionen
X → aR1 und X → aR2 zu der einen Produktion X → a(R1 + R2 ) vereinigen.
Eine erste Beobachtung zeigt, dass wir eine DTD Deklaration als eine reguläre Baumgrammatik auffassen können, wenn wir statt der Produktionen X → a(R) in (5.1) die Produktionen
X → aR verwenden. Reguläre Baumgrammatiken stimmen also mit kontextfreien Grammatiken in Greibach Normalform überein, der Unterschied ist natürlich, dass diesmal Bäume und
nicht Strings erzeugt werden:
Der Buchstabe a ist der Name des zugehörigen Knotens und R beschreibt die Kinderstruktur des Knotens.
Definition 5.4 (a) Sei G = (V, Σ, S, P ) eine reguläre Baumgrammatik und sei (W, E, λ) ein
beschrifteter Baum: Es ist also (W, E) ein geordneter Baum und λ : W → Σ ist seine Beschriftung. Wir sagen, dass G den Baum (W, E, λ) genau dann erzeugt, wenn es eine Funktion
λ0 : W → V mit den folgenden Eigenschaften gibt:
- Für die Wurzel w des Baums gilt λ0 (w) = S.
- Für jeden Knoten u ∈ W mit den (geordnet aufgelisteten) Kindern u1 , . . . , uk gibt es
eine Produktion X → aR, so dass
– λ0 (u) = X,
– λ(u) = a und
– λ0 (u1 )λ0 (u2 ) · · · λ0 (uk ) erfüllt den Ausdruck R.
Die von G erzeugte Baumsprache L(G) besteht aus allen von G erzeugten Bäumen.
(b) Eine Sprache L ist genau dann eine reguläre Baumsprache, wenn L = L(G) für eine
reguläre Baumgrammatik gilt.
Wir verwenden im Folgenden Großschreibung für Variablen und Kleinschreibung für Terminale. Um die Lesbarkeit zu erleichtern, benutzen wir runde Klammern, um reguläre Ausdrücke
von „ihrem“ Terminal abzugrenzen.
KAPITEL 5. XML UND REGULÄRE BAUMGRAMMATIKEN∗
156
Beispiel 5.3 Wir konstruieren eine reguläre Baumgrammatik, die alle arithmetischen Ausdrucksbäume erzeugt. Wir verwenden nur eine Variable Ausdruck, die natürlich auch gleichzeitig das Startsymbol ist. Das Alphabet ist Σ = {+, −, ∗, /, variable}, und wir verwenden
die Produktionen
Ausdruck
Ausdruck
Ausdruck
Ausdruck
Ausdruck
->
->
->
->
->
+ ( Ausdruck
- ( Ausdruck
* ( Ausdruck
/ ( Ausdruck
variable()
,
,
,
,
Ausdruck+)
Ausdruck )
Ausdruck+)
Ausdruck )
(Für eine Variable X bezeichnet X+ beliebige Wiederholungen von X, wobei X mindestens
einmal vorkommen muss.)
Beispiel 5.4 Wir sagen, dass ein Binärbaum B ein Und/Oder Baum ist,
- wenn die Blätter mit entweder 0 oder 1,
- die inneren Knoten mit entweder and oder or beschriftet sind
- und wenn B als Und/Oder Schaltung aufgefasst, den Wert 1 berechnet.
Wir zeigen, dass die Sprache aller Und/Oder Bäume eine reguläre Baumsprache ist. Wir
verwenden die Variablenmenge V = {Null, Eins}, das Alphabet Σ = {0, 1, and, or}, das
Startsymbol S = Eins und die Produktionen
Null
Null
Null
Eins
Eins
Eins
->
->
->
->
->
->
or
and
0()
or
and
1()
( Null , Null )
( (Eins , Null ) | ( Null , Eins) | (Null , Null) )
( (Eins , Null ) | ( Null , Eins) | (Eins , Eins) )
( Eins , Eins )
Wie sehen DTD-Deklarationen aus, wenn wir sie als reguläre Baumgrammatiken auffassen?
Definition 5.5 Sei G = (V, Σ, S, P ) eine reguläre Baumgrammatik.
(a) Wir sagen, dass zwei Variablen X, Y ∈ V im Buchstaben a ∈ Σ kollidieren, falls es zwei
Produktionen X → aR1 , Y → aR2 mit R1 6= R2 in P gibt.
(b) G heißt lokal, wenn keine zwei Variablen in einem Buchstaben kollidieren.
(c) Eine reguläre Baumsprache L heißt lokal, wenn L von einer lokalen Baumgrammatik
erzeugt wird.
Wenn wir die DTD-Beschränkung auf deterministische reguläre Ausdrücke aufheben, dann
stimmen DTD-Deklarationen in ihrer Ausdruckskraft mit lokalen Baumgrammatiken überein,
denn in einer DTD-Deklaration gibt es für jeden Elementnamen a genau eine Produktion, die
den Buchstaben a erzeugen kann, also von der Form X → aR.
Beispiel 5.5 Die folgende Baumsprache, die nur aus dem Baum B besteht, ist nicht durch
DTD-Deklarationen erzeugbar:
5.3. REGULÄRE BAUMSPRACHEN
157
B hat die Wurzel autohaendler. Der linke Teilbaum hat die Wurzel gebrauchtwagen
mit dem einzigem Kind fabrikat und den beiden Enkelkindern modell und baujahr.
Der rechte Teilbaum hat die Wurzel neuwagen mit dem einzigen Kind fabrikat und
den beiden Enkelkindern modell und rabatt.
Aufgabe 96
Zeige, dass es keine lokale Baumgrammatik gibt, die nur den Baum B erzeugt.
Damit ist die „Ausdruckskraft“ regulärer Baumgrammatiken sehr viel größer als die Ausdruckskraft von DTD-Deklarationen. Diese geringe Ausdruckskraft ist ärgerlich, weil zum
Beispiel Kontext-abhängige Deklarationen von Elementen wie in Beispiel 5.5 ausgeschlossen
sind.
5.3.1
Baumsprachen mit eindeutigen Typen
Wir kommen jetzt zu XML Schema, einer Schema Sprache, die gegenwärtig am weitesten
verbreitet ist. (XML Schema ist durchaus umstritten, was zum Teil auf ihre extrem aufwändige
Beschreibung zurückzuführen ist.) Die Ausdruckskraft von XML Schema im Vergleich zu
DTDs nimmt zu. Von der Perspektive der regulären Baumsprachen aus gesehen, lassen sich
XML Schema Deklarationen als Baumgrammatiken mit eindeutigen Typen (single type tree
grammar) auffassen.
Definition 5.6 G = (V, Σ, S, P ) sei eine reguläre Baumgrammatik.
(a) Wir sagen, dass G eindeutige Typen hat genau dann, wenn für jede Produktion X → aR
in P keine zwei in R auftretenden Variablen in einem Buchstaben aus Σ kollidieren.
(b) Eine reguläre Baumsprache L hat eindeutige Typen, wenn L von einer Baumgrammatik
mit eindeutigen Typen erzeugt wird.
Wir zeigen jetzt, dass der Baum aus Beispiel 5.5 durch eine Baumgrammatik mit eindeutigen
Typen erzeugt werden kann: XML Schema ist also mächtiger als DTDs.
Wir verwenden die Produktionen
Autohaendler
Gebrauchtwagen
Neuwagen
Gebraucht
Neu
->
->
->
->
->
autohaendler (Gebrauchtwagen, Neuwagen)
gebrauchtwagen(Gebraucht)
neuwagen(Neu)
fabrikat(Modell, Baujahr)
fabrikat(Modell, Rabatt)
KAPITEL 5. XML UND REGULÄRE BAUMGRAMMATIKEN∗
158
Modell
Alter
Rabatt
-> modell()
-> baujahr()
-> rabatt()
Wo liegen die Schwächen von Baumgrammatiken mit eindeutigen Typen?
Beispiel 5.6 Wir betrachten die folgende Sprache L2 , die aus Bäumen der Tiefe zwei besteht:
Alle Bäume besitzen die Wurzel neuwagen, die zwei Kinder mit dem identischen Namen
fabrikat besitzt. Ein fabrikat-Knoten besitzt entweder ein Kind mit Namen modell oder
zwei Kinder mit den Namen modell und rabatt. Zusätzlich fordern wir, dass jeder Baum in
L2 mindestens ein „rabatt-Blatt“ besitzt.
Wir zeigen, dass L2 eine reguläre Baumsprache ist und geben dazu die folgenden Produktionen
an.
Neuwagen
Neu
Neur
Modell
Rabatt
->
->
->
->
->
neuwagen((Neu,Neur) | (Neur,Neu) | (Neur,Neur) )
fabrikat(Modell)
fabrikat(Modell,Rabatt)
modell()
rabatt()
Diese spezielle Baumgramatik ist natürlich nicht eindeutig, da die im Inhalt von Neuwagen
auftretenden Variablen Neu und Neur im „Buchstaben“ fabrikat kollideren.
Aufgabe 97
Zeige, dass L2 keine Baumsprache mit eindeutigen Typen ist.
Es ist also nicht möglich, eine Klasse von XML Schema Dokumenten zu definieren, das alle
Autohändler aufführt, die mindestens einen Neuwagen mit Rabatt anbieten. Für reguläre
Baumgrammatiken hingegen stellt dies kein Problem dar: Sie können die globale Eigenschaft
„mindestens einmal eine Eigenschaft zu erfüllen“ beschreiben:
Aufgabe 98
Die Sprache L bestehe aus allen Bäumen, deren Knoten mit entweder a oder b beschriftet sind. Zusätzlich
verlangen wir, dass mindestens ein Knoten mit a markiert ist.
Zeige, dass L eine reguläre Baumsprache ist.
Lemma 5.1
(a) Die Klasse der lokalen Baumsprachen ist eine echte Teilmenge der Klasse der Baumsprachen mit eindeutigen Typen.
(b) Lokale Baumsprachen und Baumsprachen mit eindeutigen Typen sind abgeschlossen unter Durchschnitt, nicht aber unter Vereinigung und Komplementen.
5.3. REGULÄRE BAUMSPRACHEN
159
Beweis (a) Jede lokale Baumgrammatik ist auch eine Baumgrammatik mit eindeutigen
Typen. Beispiel 5.5 zeigt, dass es Baumsprachen mit eindeutigem Typ gibt, die keine lokalen
Baumsprachen sind.
(b) Der Nicht-Abschluss unter Vereinigung wird in der folgenden Aufgabe nachgewiesen. Für
die verbleibenden Aussagen verweisen wir auf die Literatur.
Aufgabe 99
Die Sprachen L1 = {B1 } und L2 = {B2 } bestehen jeweils aus genau einem Baum der Tiefe zwei; alle Knoten
sind mit dem Buchstaben a beschriftet. B1 ist der vollständige binäre Baum. B2 hat ebenfalls eine Wurzel mit
zwei Kindern, die beiden Kinder haben aber selbst nur jeweils ein Kind.
Zeige: L1 , L2 sind lokale Baumsprachen, L1 ∪ L2 ist keine Baumsprache mit eindeutigem Typ.
Also sind weder lokale Baumsprachen noch Baumsprachen mit eindeutigem Typ unter Vereinigung abgeschlossen.
Trotz gewonnener Ausdrucksstärke erlauben Baumsprachen mit eindeutigen Typen weiterhin
eine pfeilschnelle Lösung des Typechecking Problems.
Ein Parser für XML Schema, bzw. für Baumsprachen mit eindeutigen Typen
Das XML-Dokument D liege mit einer XML Schema Deklaration, also einer eindeutigen Baumgrammatik G vor. Typechecking wird wieder durch einzigen links-nach-rechts
Durchlauf von D durchgeführt:
(1a) Wenn die Wurzelkennung mit Namen a angetroffen wird, dann suche eine S-Produktion S → aR. Wenn es keine solche Produktion gibt, dann brich mit einer
Fehlermeldung ab.
(1b) Wenn eine von der Wurzelkennung verschiedene Startkennung mit Namen a angetroffen wird, dann haben wir bereits die Startkennung des Elternknotens gelesen
und genau eine Produktion Y → bR0 für den Elternknoten ausgewählt. Wir wählen
eine Produktion X → aR aus, so dass X in R0 auftaucht. Wenn es keine solche
Produktion gibt, dann brich mit einer Fehlermeldung ab.
/* Da die Baumgrammatik eindeutig ist, gibt es keine zwei Variablen, die in R0
auftauchen und im Buchstaben a kollidieren. Unsere Wahl ist also eindeutig! */
(2) Wenn die entsprechende Endkennung gelesen wird, dann überprüfe, ob die den
Kindern zugeordnete Buchstabenfolge den regulären Ausdruck R erfüllt. Ist dies
nicht der Fall, dann brich mit einer Fehlermeldung ab.
5.3.2
Reguläre Baumgrammatiken und Baumautomaten
Wir betrachten jetzt uneingeschränkte reguläre Baumsprachen, die die Ausdruckskraft von
Schema Sprachen wie RELAX NG3 charakterisieren. Wir beschränken uns auf beschrifte
Binärbäume.
Ein Parser für reguläre Baumsprachen
Das XML-Dokument D werde durch die reguläre Baumgrammatik G erzeugt. Auch
diesmal genügt ein links-nach-rechts Durchlauf von D:
3
Regular Language Description for XML New Generation
160
KAPITEL 5. XML UND REGULÄRE BAUMGRAMMATIKEN∗
(1) Wenn eine Startkennung mit Namen a angetroffen wird, dann betrachte alle Produktionen X → aR.
/* Jetzt können wir uns nicht auf eine einzige Produktion konzentrieren.
*/
(2) Wenn die entsprechende Endkennung gelesen wird, dann wurden bereits die Kinder
v1 , v2 des aktuell betrachteten Knotens v verarbeitet. Wir nehmen an, dass wir für
jedes Kind vi eine Menge Kandidaten(vi ) von Variablen bestimmt haben.
/* In Kandidaten(vi ) sammeln wir alle Variablen, die für die Erzeugung von vi in
Betracht kommen.
*/
Wir nehmen eine Variable X in die Menge Kandidaten(v) auf, wenn es eine Produktion X → aR und Variablen Y ∈ Kandidaten(v1 ), Z ∈ Kandidaten(v2 ) gibt,
so dass Y Z den regulären Ausdruck R erfüllt.
Gib eine Fehlermeldung aus, wenn Kandidaten(v) leer ist.
(3) Typechecking ist erfolgreich, wenn das Startsymbol in der Kandidatenmenge der
Wurzel vorkommt.
Für jeden Knoten v müssen wir bis zu |P | · |V |2 Mal überprüfen, ob ein regulärer Ausdruck erfüllt wird. Typechecking kann also weiterhin effizient durchgeführt werden, allerdings
wächst der Aufwand beträchtlich. Beachte, dass wir zum ersten Mal möglicherweise mehrere Ableitungen erhalten: Unterschiedliche Interpretationen desselben Dokuments können
für nachfolgende XML-Anwendungen problematisch sein und sollten zu einer Warnung des
XML-Parsers führen. Diese mögliche Mehrdeutigkeit wie auch das verlangsamte Typechecking
sind die Schwachstellen allgemeiner regulärer Baumgrammatiken, ihre Stärken liegen in ihrer
Ausdruckskraft.
Auch allgemeine reguläre Baumsprachen, also reguläre Baumsprachen mit möglicherweise
nicht-binären Bäumen besitzen effiziente Parser. Die eher ärgerlichen technischen Details besprechen wir hier nicht.
Wie groß ist die Klasse der regulären Baumsprachen und welche Eigenschaften hat die Klasse?
Um diese Frage zu beantworten, setzen wir Baumautomaten ein. Angenommen, ein beschrifteter binärer Baum B wird von einer regulären Baumgrammatik G = (V, Σ, S, P ) erzeugt. Wir
stellen uns vor, dass für jeden Buchstaben a ∈ Σ ein Teilmenge Q(a) aus einer Zustandsmenge ausgewählt wird. Für jedes Blatt von B ersetzen wir die Beschriftung a des Blatts durch
einen (nichtdeterministisch geratenen) Zustand q(a) ∈ Q(a). Ein Baumautomat berechnet
jetzt (ebenfalls nichtdeterministisch) sukzessive Zustände für alle inneren Knoten v. Wenn v
die Kinder v1 , v2 besitzt und
- wenn vi den Zustand qi erhalten hat
- und wenn v mit dem Buchstaben a beschriftet ist,
! dann erhält v nichtdeterministisch einen Zustand aus der Zustandsmenge δ(q1 , q2 , a).
Wir sagen, dass der Automat akzeptiert, wenn es eine Berechnung gibt, für die die Wurzel
mit einem akzeptierenden Zustand beschriftet wird.
Definition 5.7 Ein nichtdeterministischer Baumautomat A = (Q, Σ, δ, ( Q(a) | a ∈ Σ), F )
besitzt die folgenden Komponenten:
• Die endliche Zustandsmenge Q und das Alphabet Σ,
5.3. REGULÄRE BAUMSPRACHEN
161
• das Programm δ mit δ(q1 , q2 , a) ⊆ Q für alle Zustände q1 , q2 ∈ Q und alle Buchstaben
a ∈ Σ,
• für jeden Buchstaben a ∈ Σ eine Menge Q(a) ⊆ Q von Anfangszuständen und
• die Menge F ⊆ Q akzeptierender Zustände.
Der Automat ist genau dann deterministisch, wenn die Mengen δ(q1 , q2 , a) und Q(a) für alle
Zustände q1 , q2 ∈ Q und alle Buchstaben a ∈ Σ einelementig sind.
L(A) ist die Menge aller mit Buchstaben aus Σ beschrifteten Bäume, die von A akzeptiert
werden.
Beispiel 5.7 Wir beschreiben einen deterministischen Baumautomaten A für die Sprache der
binären Und/Oder Bäume aus Beispiel 5.4. A hat zwei Zustände Null und Eins, wobei Null
Anfangszustand für den Buchstaben 0 und Eins Anfangszustand für den Buchstaben 1 ist.
Eins ist der einzige akzeptierende Zustand. Hier ist das Programm:
δ(Null, Null, or) = {Null},
δ(Eins, Null, and) = δ(Null, Eins, and) = δ(Null, Null, and) = {Null},
δ(Eins, Null, or) = δ(Null, Eins, or) = δ(Null, Null, or) = {Eins},
δ(Eins, Eins, and) = {Eins}.
Aufgabe 100
(a) Die Grammatik G = (V, Σ, P, S) sei eine Grammatik mit eindeutigen Typen. Zeige, dass es einen deterministischen Baumautomaten A mit |V | Zuständen gibt, so dass L(G) = L(A) gilt.
(b) Die Baumsprache L werde von einem deterministischen Baumautomaten mit q Zuständen akzeptiert.
Zeige, dass das Typechecking Problem für L und einen Baum B in Zeit O(|B|) gelöst werden kann. Eine
Vorverarbeitung, die nicht von B abhängt und in Zeit O(q 2 · |Σ|) abläuft, ist erlaubt.
Gibt es zu jeder regulären Baumgrammatik einen äquivalenten Baumautomaten und umgekehrt, gibt es zu jedem Baumautomaten eine äquivalente reguläre Baumgrammatik? Ja! Wenn
zum Beispiel eine reguläre Baumgrammatik G = (V, Σ, P, S) gegeben ist, dann entwerfen wir
einen Baumautomaten mit Zustandsmenge Q = V und dem Programm δ, so dass
δ(Y, Z, a) = { X ∈ V
| X → aR ist eine Produktion in P und
Y Z erfüllt den regulären Ausdruck R }.
Welche Anfangszustände sollten wir für den Buchstaben a wählen? Wir setzen
Q(a) = {X ∈ V | X → a ist eine Produktion in P }.
Der Automat rät also in jedem Fall eine Variable, die die aktuelle Beschriftung verursacht
haben könnte. Sind alle Vermutungen des Automaten richtig, dann muss der Baum aus der
Grammatik ableitbar sein, solange der Automat das Startsymbol S für die Wurzel geraten
hat. Wir setzen deshalb
F = {S}.
Wenn aber der Baum aus den Regeln der Grammatik ableitbar ist, dann muss es auch eine
Folge richtiger Vermuungen geben.
Wir haben gezeigt, dass es zu jeder regulären Baumgrammatik G einen nichtdeterministischen
Baumautomaten A mit L(G) = L(A) gibt. Auch die Umkehrung ist richtig:
162
KAPITEL 5. XML UND REGULÄRE BAUMGRAMMATIKEN∗
Aufgabe 101
Sei A ein nichtdeterministischer Baumautomat. Zeige: Dann gibt es eine reguläre Baumgrammatik G mit
L(A) = L(G).
Satz 5.2 Baumautomaten akzeptieren genau die Klasse der regulären Baumsprachen.
Baumgrammatiken erzeugen Bäume B nach dem top-down Muster, denn die Erzeugung von B
beginnt mit der Wurzel und endet an den Blättern. Baumautomaten hingegen arbeiten nach
dem bottom-up Prinzip, denn Baumautomat durchforsten B beginnend mit den Blättern
und arbeiten sich zur Wurzel durch. Satz 5.2 zeigt also, dass die top-down mit der bottom-up
Sichtweise zusammenfällt.
Wir können natürlich auch „top-down Baumautomaten“ A definieren:
Wenn A die Zustandsmenge Q besitzt, dann weist das Programm δ jedem Paar (q, a) ∈
Q × Σ eine Teilmenge δ(q, a) ⊆ Q × Q zu.
Wie arbeitet A auf einem Binärbaum B? A beginnt an der Wurzel und arbeitet sich
nichtdeterministisch bis zu den Blättern durch. Wenn A den Knoten v mit Namen a
erreicht hat und sich im Zustand q befindet, dann wählt A nichtdeterministisch ein Paar
(q1 , q2 ) ∈ δ(q, a) aus und weist q1 dem linken Kind und q2 dem rechten Kind zu. B wird
akzeptiert, wenn alle den Blättern zugewiesenen Zustände akzptierend sind.
Schließlich definiere L(A) als die Menge aller von A akzeptierten Binärbäume.
Aufgabe 102
Sei A ein (bottom-up) Baumautomat. Zeige, dass es einen top-down Baumautomaten A0 mit L(A) = L(A0 )
gibt.
Aufgabe 103
Sei A ein top-down Baumautomat. Zeige, dass es einen (bottom-up) Baumautomaten A0 mit L(A) = L(A0 )
gibt.
Aufgabe 104
Die reguläre Baumsprache L bestehe aus zwei Bäumen B1 und B2 . Der Baum B1 besteht aus der Wurzel
und den mit a und b beschrifteten Blättern. Baum B2 stimmt mit B1 überein, allerdings ist die Reihenfolge
der Blattmarkierungen vertauscht. Zeige, dass es keinen deterministischen top-down Automaten gibt, der L
akzeptiert.
Nichtdeterministische top-down Automaten erzeugen also genau die Klasse der regulären
Baumsprachen. Wenn wir allerdings mit deterministischen top-down Baumautomaten arbeiten, dann verlieren wir Ausdruckskraft!
Für konventionelle Baumautomaten, also für bottom-up Baumautomaten, ist die Situation
gänzlich anders: Zu jedem nichtdeterministischen Baumautomaten N gibt es einen äquivalenten deterministischen Baumautomaten D. Wir gehen genauso vor wie im Fall von Worten:
Insbesondere wird D für jeden Knoten eines Baums die Menge der von N zugewiesenen Zustände als Zustand annehmen, wir verwenden also wieder die Potenzmengenkonstruktion.
Satz 5.3 Zu jedem nichtdetermministischen Baumautomaten N gibt es einen äquivalenten
deterministischen Baumautomaten D.
Jetzt können wir die Ernte einfahren und erhalten die folgenden Abschlusseigenschaften.
5.4. XPATH UND XQUERY
163
Satz 5.4 Wenn L1 und L2 reguläre Baumsprachen sind, dann sind auch L1 ∪ L2 , L1 ∩ L2 und
L1 reguläre Baumsprachen.
Beweis Angenommen, der nichtdeterministische Baumautomat Ni akzeptiert Li . Dann bauen
wir einen nichtdeterministischen Baumautomaten N für L1 ∪ L2 wie folgt: N entscheidet
sich nichtdeterministisch zu Anfang, ob er N1 oder N2 simulieren soll. Danach führt er die
Simulation durch und akzeptiert, wenn der simulierte Austomat akzeptiert.
Um L1 zu akzeptieren, wählen wir einen deterministischen Baumautomaten D für L1 und
akzeptieren genau dann, wenn D verwirft.
Schließlich beachte L1 ∩ L2 = L1 ∪ L2 und auch der Abschluss unter Durchschnitten folgt. Arbeitet man mit regulären Baumgrammatiken, dann lassen sich also problemlos zwei Dokumenttypen zu einem neuen Typ vereinigen.
Aufgabe 105
Zeige, dass das Leerheitsproblem:
Ist L(N ) 6= ∅ für einen nichtdeterministischen Baumautomaten N ?
effizient gelöst werden kann.
Aufgabe 106
Für einen beschrifteten Baum B ist string(B) die Konkatenation aller Blattbeschriftungen, wobei die Reihenfolge der Blätter durch einen Präorder-Durchlauf (gemäß der Ordnung des Baums) definiert ist.
(a) Zeige, dass
string(L) = { string(B) | B ∈ L }
kontextfrei ist, wenn L eine reguläre Baumsprache ist.
(a) Zeige, dass es für jede kontextfreie Sprache K eine reguläre Baumsprache L mit
K = string(L)
gibt.
5.4
XPath und XQuery
Wir geben eine kurze Beschreibungen der Sprachen XPath und XQuery, die für die Navigation, bzw. für Datenbankanfragen in XML-Dokumenten eingesetzt werden. Beide Sprachen
verwenden reguläre Ausdrücke als ihre zentralen Beschreibungsmechanismen.
5.4.1
XPath: Navigation in XML-Dokumenten
Die XPath-Ausdrücke sind ähnlich aufgebaut wie die Beschreibung von Verzeichniswegen in
Unix. Exemplarisch nehmen wir an, dass die Elemente a,b,c,d,e,f,g in einem vorgegebenen XML-Dokument vorkommen und dass x ein Attributwert ist. Wir betrachten einen
„typischen“ XPath Ausdruck
//a/b[c/d]//e[f=x]/g
// ist ein Nachfahren-Operator und / ist ein Kindoperator; die eckigen Klammern beschreiben
jeweils einen Filter. Da der Ausdruck mit einem Operator beginnt, nimmt XPath an, dass
die Navigation in der Wurzel beginnt und bestimmt alle Knoten, die Endpunkte der vom
Ausdruck beschriebenen Wege sind. Welche Wege beschreibt der Ausdruck?
164
KAPITEL 5. XML UND REGULÄRE BAUMGRAMMATIKEN∗
(1) Wir beachten zuerst die Filter nicht.
- Jeder Weg beginnt mit einem Nachfahren der Wurzel, der mit Element a beschriftet
ist und ein mit b beschriftetes Kind u besitzt.
- u muss einen Nachfahren v haben, der mit Element e beschriftet ist.
- Schließlich muss v ein mit g beschriftetes Kind w besitzen.
(2) Die Filter kommen jetzt ins Spiel. Nur die Wege überleben
- für die der Knoten u auch ein mit c beschriftetes Kind hat, das seinerseits ein mit
d beschriftetes Kind besitzt.
- Zuletzt wird gefordert, dass v ein mit f beschriftetes Kind besitzt und dass dieses
Kind den Attributwert x hat.
Die Ausgabe für den Ausdruck besteht dann aus allen Endpunkten w der überlebenden Wege.
Nicht erwähnt haben wir die Möglichkeit, Attribute mit dem @-Operator auszuwählen. Wenn
wir zum Beispiel die Namen aller Zutaten für das Pfannkuchenrezept ausgeben wollen, dann
gelingt dies mit dem Ausdruck //zutat/@name. Hätten wir hingegen eine Wurzel rezepte
mit Kindern vom „Typ“ rezept definiert, so müsste man diesmal den Ausdruck
/rezept[@name=Mein erster Pfannkuchen]//zutat/@name verwenden.
Viele Anfragen von XPath können auch durch Baumautomaten implementiert werden. Für
einen nichtdeterministischen Baumautomaten A zeichnen wir dazu eine Teilmenge S ⊆ Q von
„auswählenden Zuständen“ aus. Wir sagen dann, dass A einen Knoten v auswählt, wenn es
eine akzeptierende Berechnung von A gibt, die v mit einem Zustand aus S durchläuft.
5.4.2
XQuery: Eine Anfragesprache für XML-Datenbanken
XQuery ist eine „vollwertige“ Anfragesprache, das Analogon von SQL für relationale Datenbanken. Xquery benutzt XPath als „Navigationskomponente“ und verwendet unter anderem
for-let-where-return Ausdrücke (oder FLWR-Ausdrücke):
for $variable1 in AUSDRUCK1
let $variable2 := AUSDRUCK2
where BOOLESCHER AUSDRUCK
return AUSDRUCK3
Hier darf jeder XQuery Ausdruck benutzt werden: Da ein XPath Ausdruck auch ein XQuery
Ausdruck ist, dürfen somit zum Beispiel alle XPath Ausdrücke benutzt werden. Auch kann
zum Beispiel ein FLWR-Ausdruck als Ausdruck in einem anderen FLWR-Ausdruck vorkommen.
Wir geben ein Beispiel für die Datenbank einer Bibiothek, in der jedes Buch mit Autor,
Titel und Verlag aufgeführt ist. Wir möchten die Verlage herausfinden, die mindestens 100
in der Bibiothek geführte Bücher veröffentlicht haben. Wir benutzen dazu die Funktionen
distinct-values und count:
for $v in distinct-values(document("bib.xml")//Verlag)
let $b := document("bib.xml")//book[publisher = $v]
where count($b) > 100
return $v
5.4. XPATH UND XQUERY
165
In freier Übersetzung: Für jeden Verlag, der in der Datenbank bib.xml vertreten ist, betrachten wir alle von diesem Verlag publizierten Bücher. Das bib.xml-Dokument, eingeschränkt
auf alle Verlage, die mindestens 100 Bücher der Datenbank veröffentlicht haben, wird ausgegeben.
Während also XPath für ein vorgegebenes XML-Dokument eine Teilmenge von Knoten ausgibt, gibt XQuery ein modifiziertes XML-Dokument aus.
166
KAPITEL 5. XML UND REGULÄRE BAUMGRAMMATIKEN∗
Teil III
Komplexitätsklassen
167
Kapitel 6
Speicherplatz-Komplexität
Das Ziel dieses Kapitels ist die Bestimmung der Speicherplatz-Komplexität, also die Bestimmung des für die Lösung eines algorithmischen Problems notwendigen und hinreichenden
Speicherplatzes.
Warum sollte uns eine Untersuchung der Ressource „Speicherplatz“ interessieren? Es stellt
sich heraus, dass die Speicherplatzkomplexität hilft, die Komplexität der Berechnung von
Gewinnstrategien für viele nicht-triviale 2-Personen Spiele zu charakterisiere. Weitere algorithmische Probleme, deren Komplexität wir mit Hilfe der Speicherplatzkomplexität klären
werden, sind:
(a) Akzeptiert ein nichtdeterministischer endlicher Automat eine gegebene Eingabe?
(b) Sind zwei nichtdeterministische endliche Automaten äquivalent?
(c) Minimiere einen NFA.
Des weiteren lassen sich „nicht-klassischen“ Berechnungsarten wie die Randomisierung oder
Quantenberechnungen durch konventionelle deterministische Rechner simulieren, falls wir polynomiellen Speicherplatz erlauben. Im nächsten Kapitel werden wir zudem eine enge Verbindung zwischen der Speicherplatz-Komplexität eines Problems und seiner parallelen Rechenzeit
feststellen.
In Abschnitt 2.3.3 haben wir deterministische und nichtdeterministische I-O (input-output)
Turingmaschinen als Rechnermodell eingeführt und die fundamentalen Klassen
DL, NLund PSPACE
definiert.
6.1
Eine Platzhierarchie
Definition 6.1 Eine Funktion s : N → N mit s(n) = Ω(log2 n) heißt genau dann platzkonstruierbar, wenn es eine deterministische Turingmaschine gibt, die für eine jede Eingabe
der Länge n höchstens O(s(n)) Speicherplatz benötigt, um s(n) Zellen zu markieren.
Wir geben mit Hilfe der Diagonalisierungsmethode eine Speicherplatz-Hierarchie an und zeigen, dass man mit mehr zur Verfügung stehendem Speicher mehr Entscheidungsprobleme
lösen kann.
169
170
KAPITEL 6. SPEICHERPLATZ-KOMPLEXITÄT
Satz 6.1 (Das Speicherplatz-Hierarchie Theorem)
Die Funktion s sei platz-konstruierbar. Dann ist Dspace(o(s)) eine echte Teilmenge von
Dspace(s).
Beweis: Für eine platz-konstruierbare Funktion s konstruieren wir die folgende I-O Turingmaschine M ∗ .
Algorithmus 6.1 Die Diagonalisierungsmethode
(1) M ∗ bestimmt die Länge n der Eingabe w.
(2) M ∗ steckt auf dem Arbeitsband 2s(n) Zellen ab.
/* Dies ist mit Speicherplatz O(s(n)) möglich, da s platz-konstruierbar ist.
*/
(3) Wenn w nicht von der Form hM i0k für eine I-O Turingmaschine M und eine Zahl
k ∈ N ist, dann verwirft M ∗ .
/* hM i bezeichnet die Gödelnummer der Turingmaschine M .
*/
(4) M ∗ simuliert M auf Eingabe w = hM i0k und beginnt die Simulation mit dem Kopf in
der Mitte des abgesteckten Bereichs. M ∗ verwirft, wenn M irgendwann den abgesteckten
Bereich verlässt oder mehr als 2s(n) Schritte benötigt.
/* Kann M ∗ auf Speicherplatz s(n) gleichzeitig einen bis 2s(n) − 1 zählenden Zähler
implementieren und eine s(n) platzbeschränkte Berechnung von M simulieren? Ja, das
ist bei einem entsprechend vergrößerten Arbeitsalphabet unproblematisch.
*/
(5) M ∗ akzeptiert w, wenn M verwirft. Ansonsten akzeptiert M und M ∗ wird verwerfen.
Wir beachten zuerst, dass M ∗ immer hält und mit Speicherplatzbedarf O(s(n)) auskommt.
Also ist L(M ∗ ) ∈ Dspace(s).
Warum liegt L(M ∗ ) nicht in Dspace(r) für eine Funktion r = o(s)? Ist dies der Fall, dann wird
L(M ∗ ) von einer I-O Turingmaschine M mit Speicherplatzbedarf r erkannt. Für hinreichend
große Eingabelänge n rechnet M stets in Zeit höchstens 2s und M ∗ simuliert M für Eingaben
w = hM ∗ i0k mit hinreichend großem k erfolgreich. Jetzt garantiert Schritt (5), dass sich L(M )
und L(M ∗ ) unterscheiden: Speicherplatz r = o(s) ist unzureichend für die Berechnung von
L(M ∗ ).
Aufgabe 107
Zeige das Platz-Hierarchie Theorem für nichtdeterministische Turingmaschinen: Nspace(s) ist eine echte Teilmenge von Nspace(S), falls s = o(S) und falls S platz-konstruierbar ist.
6.2
Sub-Logarithmischer Speicherplatz
Was ist die Speicherplatzkomplexität regulärer Sprachen? Eine reguläre Sprache L wird durch
einen endlichen DFA A akzeptiert. Wir fassen A als eine I-O Turingmaschine auf, die wie A
programmiert wird und erhalten, dass jede reguläre Sprache in der Klasse Dspace(0) liegt.
Und was passiert, wenn wir wie bisher Bewegungen von links-nach-rechts, aber auch jetzt
von rechts-nach-links erlauben? Diese Frage haben wir in Satz 6.2 beantwortet: Auch diesmal
werden nur reguläre Sprachen akzeptiert. Also stimmt die Klasse Dspace(0) mit der Klasse
regulärer Sprachen überein.
Überraschenderweise führt sehr(!) geringer Speicherplatz im Vergleich zu leerem Speicher
nicht zu größerer Berechnungskraft wie das nächste Ergebnis zeigt.
6.3. LOGARITHMISCHER SPEICHERPLATZ
171
Satz 6.2 (Sprachen mit sehr geringem Speicherplatzbedarf sind regulär)
Die I-O Turingmaschine M akzeptiere L mit Speicherplatzbedarf sM = o(log2 log2 n). Dann
ist L regulär. Insbesondere folgt für jede Funktion s : N → N mit s = o(log2 log2 n), dass
Dspace(s) = Dspace(0) = die Klasse der regulären Sprachen.
Beispiel 6.1 Dspace(log2 log2 n) enthält auch nicht-reguläre Sprachen. Es sei bin(i) die Binärdarstellung der Zahl i ohne führende Nullen. Wir wählen Σ = {0, 1, $} als Eingabealphabet
und definieren die Sprache
BIN = {bin(1)$bin(2)$ · · · $bin(n) | n ∈ N}.
Man überzeugt sich leicht mit dem Pumping Lemma, dass BIN nicht regulär ist. Es bleibt
zu zeigen, dass BIN ∈ Dspace(log2 log2 n). Das ist aber klar(?), da bin(i) für jedes i ≤ n aus
höchstens dlog2 ne Bits besteht.
Insbesondere haben wir für die Sprache BIN das seltene Glück, die genaue Speicherkomplexität angeben zu können. Denn da BIN nicht regulär ist, folgt BIN 6∈ Dspace(s), falls
s = o(log2 n log2 n). Andererseits haben wir gerade BIN ∈ Dspace(log2 log2 n) nachgewiesen.
Die sublogarithmischen Speicher-Komplexitätsklassen sind aber recht mickrig und erst DL,
also logarithmische Speicherplatz-Komplexität besitzt eine vernünftige Berechnungskraft.
6.3
Logarithmischer Speicherplatz
DL und NL gehören zu den wichtigsten Speicherplatz-Klassen.
- Die Berechnungskraft ist durchaus signifikant, da die Maschinen sich jetzt Positionen
in der Eingabe merken können.
- Viele Eigenschaften, die für DL und NL gelten, verallgemeinern sich auf beliebige Speicherplatzklassen. Dieses Phänomen werden wir im Satz von Savitch und im Satz von
Immerman-Szlepscenyi beobachten.
Wir beginnen mit deterministisch logarithmischem Platz.
6.3.1
DL
Sei PALINDROM die Sprache aller Palindrome über dem Alphabet {0, 1}. Wir behaupten,
dass sich PALINDROM mit logarithmischem Speicherplatz berechnen lässt.
Wir konstruieren eine I-O Turingmaschine, die zuerst die Eingabelänge n in Binärdarstellung
abspeichert. Dies gelingt, indem ein Anfangs auf 0 gesetzter binärer Längen-Zähler sukzessive
inkrementiert wird bis der Eingabekopf das Ende der Eingabe erreicht hat. Sodann werden
nacheinander die Bitpositionen 1 und n, 2 und n − 1, . . . , k und n − k ... verglichen, indem der
Eingabekopf jeweils um n − 1 Positionen nach rechts, dann um n − 2 Positionen nach links,
um n − 3 Positionen nach rechts, ... bewegt wird.
Zur Ausführung dieser Kopfbewegungen wird eine Kopie des Längen-Zählers angelegt und der
Längen-Zähler wie auch die Kopie um Eins (auf n−1) vermindert. Die ersten Kopfbewegungen
um n − 1 Positionen nach rechts gelingen durch das Herunterzählen der Kopie. Nachdem
172
KAPITEL 6. SPEICHERPLATZ-KOMPLEXITÄT
das Ziel erreicht ist, wird der Längenzähler um Eins reduziert und der neue Inhalt in die
Kopie geladen. Die nächsten n − 2 Kopfbewegungen nach links, wie auch alle nachfolgenden
Kopfbewegungen, werden dann mit demselben Verfahren gesteuert.
Die Klasse DL ist die erste nicht-triviale Speicherkomplexitätsklasse und enthält neben der
Palindrom-Sprache weitere wichtige Sprachen wie die Dyck-Sprache aller wohlgeformten Klammerausdrücke oder die kontextsensitive Sprache {an bn cn | n ∈ N}.
Aufgabe 108
{w ∈ {(, )}∗ |w ist ein korrekter Klammerausdruck} ist die „Klammersprache“ . Dabei ist ein korrekter Klammerausdruck entweder
1. () oder
2. (A) für einen korrekten Klammerausdruck A oder
3. AB für korrekte Klammerausdrücke A, B.
Zeige, dass man die Klammersprache in DL entscheiden kann.
Wir können mit Hilfe des Konzepts der Konfiguration die Speicherplatzkomplexität der PalindromSprache exakt bestimmen. (Zur Erinnerung: Die Konfiguration kt zum Zeitpunkt t besteht
aus der Position des Lesekopfs zum Zeitpunkt t, dem gegenwärtigen Zustand, der Position
des Kopfs auf dem Arbeitsband und dem Inhalt des Arbeitsbands.) Es stellt sich heraus, dass
logarithmische Speicherkomplexität nicht nur hinreichend, sondern auch notwendig ist. Dies
bestätigt die Intuition, dass nicht-triviale Algorithmen zumindest die Fähigkeit haben sollten,
sich an eine Eingabeposition erinnern zu können; beachte, dass diese Fähigkeit logarithmischen Speicherplatz voraussetzt.
Lemma 6.3 Es ist PALINDROM ∈ DL. Andererseits ist PALINDROM 6∈ Dspace(s), falls
s = o(log2 n).
Beweis: Sei M eine I-O Turingmaschine mit Speicherplatzbedarf s(n), die die PalindromSprache erkenne. M besitze q Zustände und ein Arbeitsalphabet der Größe γ. Die Eingabelänge sei gerade.
n
2
Behauptung 1: M wird die Eingabe-Position
n
Ω( s(n)
) mal besuchen.
für mindestens eine Eingabe mindestens
Bevor wir die Behauptung beweisen, zeigen wir, dass das Lemma aus der Behauptung folgt.
Wir nehmen an, dass M den Speicherplatzbedarf s(n) = o(log2 n) hat. Für jede Eingabe wird
M dann, bei hinreichend großer Eingabelänge n, höchstens
√
q · s(n) · γ s(n) = o( n)
Konfigurationen besitzen, für die der Lesekopf die Eingabeposition n2 besucht. Aber Position
n
2 kann nur einmal in einer vorgegebenen Konfiguration besucht werden, da ein zweiter Besuch
in derselben Konfiguration zu einer Endlos-Schleife führt. Die Behauptung fordert aber eine
√
n
Besuchshäufigkeit von mindestens Ω( s(n)
) >> n und wir haben einen Widerspruch zur
Annahme s(n) = o(log2 n) erhalten.
Beweis von Behauptung 1: Wir weisen einer Eingabe w die Folge der Konfigurationen beim
Besuch der Eingabe-Position n2 zu. Wenn die Behauptung falsch ist, dann wird n2 höchstens
n
o( s(n)
) mal besucht. Insgesamt gibt es aber mit (6.1) höchstens
n
o( s(n)
)
(q · γ s(n) · s(n))
n
O(s(n))·o( s(n)
)
=2
= 2o(n)
6.3. LOGARITHMISCHER SPEICHERPLATZ
173
Konfigurationenfolgen, wenn wir die Position des Lesekopfes fixieren. Es gibt aber 2n/2 Palindrome der Länge n und deshalb gibt es zwei verschiedene Palindrome u, v der Länge n mit
identischer Konfigurationenfolge auf Position n2 .
Behauptung 2: Fooling Argument
Die Eingaben u, v mögen beide die Konfigurationenfolge k besitzen. Wenn u = (u1 , u2 ) und
v = (v1 , v2 ) mit |u1 | = |v1 | = n/2, dann besitzt auch die Eingabe w = (u1 , v2 ) die Konfigurationenfolge k.
Aufgabe 109
Zeige Behauptung 2.
Behauptung 1 ist jetzt eine unmittelbare Konsequenz von Behauptung 2, da M für Palindrome
u und v auch die Eingabe w akzeptiert, obwohl w kein Palindrom ist.
Aufgabe 110
Die Palindrom-Sprache soll erkannt werden. Gib I-O-Maschinen an, die P ALIN DROM
(a) in Zeit O(n) erkennen.
(b) in Zeit O(n2 / log n) mit Platz O(log n) erkennen.
Aufgabe 111
Zeige, dass O(s) platzbeschränkten I-O-Turingmaschinen Zeit Ω(n2 /s) für das Erkennen der Palindrom-Sprache
benötigen.
Hinweis: Betrachte Worte der Form w#n wR der Länge 3n (mit w ∈ {0, 1}n ) und die Konfigurationenfolgen auf
den Eingabepositionen i ∈ {n + 1, . . . , 2n}. Zeige, dass sich für alle Eingaben w#n wR und v#n v R (mit w 6= v)
auf Position i verschiedene Konfigurationsfolgen ergeben müssen. Daher muss es auf Position i mindestens 2n
verschiedene Konfigurationsfolgen geben und die meisten davon müssen lang sein. Schließe davon auf hohe
Rechenzeit für die meisten Eingaben.
Wie mächtig ist DL?
Satz 6.4 (Speicherplatz und Laufzeit)
(a) Sei M eine I-O Turingmaschine, die mit Speicherplatzbedarf s arbeite. Dann ist die
Laufzeit von M für Eingaben der Länge n durch n · 2O(s(n)) beschränkt.
(b) Es gelte s(n) ≥ log2 n. Dann ist Dspace(s) ⊆
DL ⊆ P.
S
k·s
k∈N Dtime(2 ).
Als Konsequenz folgt
Beweis (a): Sei M eine I-O Turingmaschine mit Speicherplatzbedarf s und sei w eine beliebige Eingabe der Länge n. Wir beschreiben die Berechnung von M auf Eingabe w durch eine
Folge von Konfigurationen. Die Konfiguration kt zum Zeitpunkt t besteht aus der Position
des Lesekopfs zum Zeitpunkt t, dem gegenwärtigen Zustand, der Position des Kopfs auf dem
Arbeitsband und dem Inhalt des Arbeitsbands.
Wir kommen zur wesentlichen Beobachtung: M wird für keine Eingabe eine Konfiguration
zweimal annehmen! Wäre dies nämlich der Fall, dann wird M in eine Endlos-Schleife gezwungen und hält nicht. Also ist die Laufzeit von M durch die Anzahl der Konfigurationen
beschränkt. Wir nehmen an, dass M q Zustände und ein Arbeitsalphabet der Größe γ besitzt.
Damit ist die Anzahl der Konfigurationen durch
n · q · s(n) · γ s(n) = n · q · s(n) · 2s(n)·log2 γ
174
KAPITEL 6. SPEICHERPLATZ-KOMPLEXITÄT
nach oben beschränkt und, da s(n) ≤ 2s(n) , erhalten wir
n · q · s(n) · 2s(n)·log2 γ = n · 2O(s(n)) .
(6.1)
Die Laufzeit ist natürlich durch die Anzahl der Konfigurationen beschränkt und die Behauptung folgt.
(b) ist eine direkte Konsequenz von Teil (a), denn wir nehmen s(n) ≥ log2 n an und n ·
2O(s(n)) ≤ 2O(s(n)) folgt.
Wir definieren die Sprache U-REACHABILITY als die Menge aller ungerichteten Graphen
G, die einen Weg von Knoten 1 nach Knoten 2 besitzen. Der Graph G werde durch seine
Adjazenzmatrix repräsentiert. Analog sei die Sprache D-REACHABILITY definiert, wobei
wir diesmal allerdings gerichtete Graphen betrachten.
Erst in 2004 konnte durch Omer Reingold gezeigt werden, dass U-REACHABILITY in DL
liegt. Die Methode des Random Walks erlaubt eine mehr oder minder offensichtliche Lösung von U-REACHABILITY mit logarithmischem Speicherplatzbedarf, wenn wir zufällig
arbeiten dürfen. Die von Reingold erhaltene Lösung für deterministische Turingmaschinen ist
wesentlich komplizierter.
Offensichtlich ist D-REACHABILITY das schwierigere der beiden Probleme: Wir werden
später starke Indizien erhalten, dass jede deterministische Turingmaschine mindestens die
Speicherkomplexität Ω(log22 n) für die Lösung von D-REACHABILITY benötigt.
Wir erhalten aber eine Lösung von D-REACHABILITY mit logarithmischem Speicherplatzbedarf, wenn wir nichtdeterministische Turingmaschinen betrachten: Eine nichtdeterministische
I-O Turingmaschine rät einen Weg von Knoten 1 nach Knoten 2 und benutzt ihren logarithmischen Speicher zum Durchsuchen der Adjazenzmatrix. Dieser Algorithmus ist Anlaß,
nichtdeterministische I-O Turingmaschinen zu betrachten.
Aufgabe 112
Gegeben sei ein gerichteter Graph als Adjazenzmatrix. Es soll entschieden werden, ob folgendes gilt: jeder
Knoten hat höchstens einen Nachfolger und Knoten 2 kann von Knoten 1 erreicht werden.
Gib einen möglichst speichereffizienten deterministischen Algorithmus zur Lösung des Problems (auf I-OTuringmaschinen) an.
Aufgabe 113
Im 2-Zusammenhangsproblem ist ein ungerichteter Graph als Adjazenzmatrix gegeben. Es soll entschieden
werden, ob der Graph zweifach zusammenhängend ist, d.h., ob der Graph bei der Herausnahme eines beliebigen
Knotens immer zusammenhängend bleibt.
Gib einen möglichst speichereffizienten deterministischen Algorithmus zur Lösung des Problems (auf I-OTuringmaschinen) an.
6.3.2
NL und NL-Vollständigkeit
Ist D-REACHABILITY deterministisch mit logarithmischem Speicherplatz erkennbar? Wir
werden im Folgenden zeigen, dass eine positive Antwort die Gleichheit der Klassen DL und
NL erzwingt, und die wahrscheinliche Antwort ist also negativ. Insbesondere zeigen wir,
dass D-REACHABILITY eine schwierigste Sprache in NL ist, wobei „Schwierigkeit“ durch
LOGSPACE-Reduktionen gemessen wird.
Definition 6.2 Seien Σ1 und Σ2 Alphabete und seien L ⊆ Σ∗1 , K ⊆ Σ∗2 Sprachen über Σ1
beziehungsweise Σ2 .
6.3. LOGARITHMISCHER SPEICHERPLATZ
175
(a) Wir sagen, dass L LOGSPACE-reduzierbar auf K ist (geschrieben L ≤LOG K), falls es
eine (deterministische) I-O Turingmaschine M mit logarithmischem Speicherplatzbedarf gibt,
so dass für alle Eingaben w ∈ Σ∗1 ,
w ∈ L ⇔ M (w) ∈ K.
(b) Die Sprache K heißt NL-hart, falls L ≤LOG K für alle Sprachen L ∈ NL gilt.
(c) Die Sprache K heißt genau dann NL-vollständig, wenn K ∈ NL und wenn K NL-hart ist.
Lemma 6.5 (Die wesentlichen Eigenschaften der LOGSPACE-Reduktion)
(a) Wenn M ≤LOG K und K ≤LOG L, dann ist M ≤LOG L.
(b) Wenn L ≤LOG K und wenn K ∈ DL, dann ist auch L ∈ DL.
Beweis: Übungsaufgabe.
Wie auch für die Klassen P und NP (und die polynomielle Reduktion) fallen die Klassen DL
und NL zusammen, wenn eine einzige NL-vollständige Sprache in DL liegt.
Korollar 6.6 (LOGSPACE-vollständige und harte Sprachen)
(a) Die Sprache K sei NL-vollständig. Dann gilt
K ∈ DL ⇔ DL = NL.
(b) Wenn K NL-hart ist und wenn K ≤LOG L, dann ist auch L NL-hart.
Gibt es überhaupt NL-vollständige Probleme?
Satz 6.7 D-REACHABILITY ist NL-vollständig.
Beweis: Wir haben bereits gesehen, dass D-REACHABILITY in NL liegt. Es ist also L ≤LOG
D-REACHABILITY für eine beliebige Sprache L ∈ NL nachzuweisen.
Da L ∈ NL, gibt es eine nichtdeterministische Turingmaschine M , die L mit logarithmischem
Speicherbedarf erkennt. Für eine Eingabe w betrachten wir den Berechnungsgraph GM (w)
von M auf Eingabe w. Die Konfigurationen bilden die Knoten von GM (w). Wir fügen eine Kante von Konfiguration c nach Konfiguration d ein, wenn M auf Eingabe w in einem
Schritt von c nach d gelangen kann. Zusätzlich fügen wir eine Kante von jeder akzeptierenden Haltekonfiguration zu einem neuen Knoten ein, dem wir den „Namen“ 2 geben. Der der
Anfangskonfiguration entsprechende Knoten erhält den Namen 1.
Behauptung: GM (w) kann von einer deterministischen I-O Turingmaschine mit logarithmischem Speicherplatz berechnet werden.
Beweis: Wir beachten zuerst, dass GM (w) nur polynomiell (in |w|) viele Knoten besitzt,
da die Konfigurationenzahl polynomiell ist. Wir müssen also auf logarithmischem Platz die
polynomiell große Adjazenzmatrix von GM (w) berechnen. Diese Aufgabe ist aber einfach, da
wir ja nur die Möglichkeit eines Ein-Schritt Übergangs zwischen zwei Konfigurationen (zu
jeweils logarithmischem Speicherplatz) überprüfen müssen.
176
KAPITEL 6. SPEICHERPLATZ-KOMPLEXITÄT
Wir weisen GM (w) der Eingabe w zu und erhalten
w ∈ L ⇔ GM (w) ∈ D-REACHABILITY.
Die Behauptung des Satzes folgt.
Das nächste Ergebnis zeigt, dass NL in P enthalten ist. Dieses Ergebnis ist nicht mehr überraschend, sondern wegen der NL-Vollständigkeit des Problems D-REACHABILITY naheliegend.
Satz 6.8 DL ⊆ NL ⊆ P ⊆ NP.
Beweis: Die Beziehungen DL ⊆ NL sowie P ⊆ NP sind offensichtlich und es genügt der Nachweis
von NL ⊆ P.
Man überzeuge sich zuerst, dass aus L ≤LOG K und K ∈ P auch L ∈ P folgt. (Wende
Satz 6.4 (a) an!) Für eine beliebige Sprache L in NL gilt L ≤LOG D-REACHABILITY. Da
D-REACHABILITY in P liegt, folgt somit auch L ∈ P.
Es könnte durchaus sein, dass beide Inklusionen in DL ⊆ NL ⊆ P echte Inklusionen sind.
Beispiel 6.2 Die Klasse LOGCFL besteht aus allen Entscheidungsproblemen, die LOGSPACEreduzierbar auf eine kontextfreie Sprache sind.
Man kann zum Beispiel zeigen, dass NL eine Teilklasse von LOGCFL ist: Es gibt also eine
kontextfreie Sprache, auf die D-REACHABILITY reduziert werden kann.
Aufgabe 114
Zeige, dass es eine kontextfreie Sprache L mit
D-REACHABILITY ≤LOG L
gibt.
Hinweis: Verwende für L das Terminalalphabet {a, b} und repräsentiere jede Kante (r, s) eines gerichteten
Graphen G = (V, E) mit V = {1, . . . , n} durch ar bs . Konstruiere eine LOGSPACE-Reduktion M und einen
nichtdeterministischen Kellerautomaten A, so dass A durch einmaliges Lesen von M (G) die Zugehörigkeit von
G zu D-REACHABILITY verifizieren kann.
Desweiteren stimmt LOGCFL mit der Klasse aller Entscheidungsprobleme überein, die durch
Schaltkreise logarithmischer Tiefe gelöst werden können. Während verlangt wird, dass der
Fanin eines UND-Gatters zwei ist, ist der Fanin von ODER-Gattern unbeschränkt. Zudem
muss man die Schaltkreise durch „einfache Algorithmen“ beschreiben können –man sagt, dass
die Schaltkreise uniform sind.
6.3.3
Der Satz von Savitch
Um wieviel mächtiger ist NL im Vergleich zu DL?
Aufgabe 115
Zeige: Wenn Dspace(log n) = Nspace(log n), dann gilt Dspace(s) = Nspace(s) für alle platz-konstruierbaren
Funktionen s.
Aufgabe 116
Es seien s, S Funktionen mit s = O(S) und s = Ω(n). Weiterhin gelte für alle g mit g = Ω(s) und g = O(S),
dass g nicht platz-konstruierbar ist. Zeige: Dann gilt Dspace(s) = Dspace(S).
Hinweis: Zeige, dass die Funktion spaceM (n) für Turingmaschinen M mit mindestens linearem Platzverbrauch
platz-konstruierbar ist.
6.3. LOGARITHMISCHER SPEICHERPLATZ
177
Satz 6.9 (Der Satz von Savitch)
(a) D-REACHABILITY ∈ Dspace(log22 n).
(b) Die Funktion s sei platz-konstruierbar. Dann ist
Nspace(s) ⊆ Dspace(s2 )
und insbesondere folgt
NL ⊆ Dspace(log22 n) und PSPACE = NPSPACE.
Beweis (a): Leider können wir D-REACHABILITY weder mit Tiefensuche noch mit Breitensuche lösen, denn sowohl der Stack der Tiefensuche wie auch die Queue der Breitensuche
verlangen bis zu linearem Speicherplatz. Wir beschreiben deshalb ein neues Traversierungsverfahren, das wesentlich speicher-effizienter sein wird.
Algorithmus 6.2 (Eine platz-effiziente Traversierung)
(1) Der Graph G sei als Adjazenzmatrix gegeben. G bestehe aus n Knoten.
(2) Für jedes m ≤ n − 1 rufe Algorithmus 6.3 mit dem Eingabegraphen G sowie den Parametern 1, 2 und m auf.
/* Algorithmus 6.3 wird überprüfen, ob es in G einen Weg der Länge m (m ≤ n − 1)
vom Knoten 1 zum Knoten 2 gibt.
*/
(3) Akzeptiere genau dann, wenn Algorithmus 6.3 mindestens einmal akzeptiert.
Algorithmus 6.3
(1) Die Eingaben seien der Graph G sowie die Knoten u und v und die Weglänge m.
(2) Wenn m=1, dann akzeptiere, falls (u, v) eine Kante von G ist und verwerfe ansonsten.
(3) Für alle Knoten w führe zwei rekursive Aufrufe mit den jeweiligen Parametern u, w
m
und d m
2 e beziehungsweise w, v und b 2 c durch.
(4) Akzeptiere, wenn es einen Knoten w mit zwei akzeptierenden Aufrufen gibt und verwerfe
ansonsten.
Algorithmus 6.2 akzeptiert offensichtlich genau dann, wenn es einen Weg vom Knoten 1
zum Knoten 2 gibt. Die entscheidende Frage ist die Größe des Speicherplatzbedarfs. Der
rekursive Algorithmus 6.3 benötigt einen Stack der Höhe log2 n, wobei jedes Element des
Stacks einem Knoten entspricht und damit ebenfalls logarithmischen Speicher in Anspruch
nimmt. Insgesamt benötigen wir, wie versprochen, also Speicherplatz O(log22 n).
Am Rande sei vermerkt, dass Algorithmus 6.3 zwar speicher-effizienter als Tiefen- oder Brei2
tensuche ist, dafür aber bis zu 2O(log2 n) Schritte verschlingt.
(b) Es sei s(n) ≥ log2 n und s sei platz-konstruierbar. Weiterhin sei M eine beliebige nichtdeterministische Turingmaschine mit Speicherplatzbedarf s und w sei eine Eingabe. Wir konstruieren eine deterministische Turingmaschine M ∗ , die M auf Speicherplatz O(s2 ) simuliert.
178
KAPITEL 6. SPEICHERPLATZ-KOMPLEXITÄT
Da s platz-konstruierbar ist, kann M ∗ einen Speicherplatz von s(n) Zellen abstecken und
damit die Konfigurationen von M systematisch erzeugen. Wir gehen davon aus, dass die
Startkonfiguration den Namen 1 trägt und dass es genau eine akzeptierende Haltekonfiguration gibt, der wir den Namen 2 zuweisen. M ∗ wendet nun Algorithmus 6.2 auf den Berechnungsgraphen GM (w) (mit höchstens 2O(s(|w|)) Knoten) an und akzeptiert genau dann, wenn
Algorithmus 6.2 akzeptiert.
Offensichtlich akzeptiert M ∗ die Eingabe w genau dann, wenn M die Eingabe w akzeptiert.
Die Behauptung folgt, da M ∗ nur den Speicherplatzbedarf O(s2 ) hat: Der Name eines jeden
Knotens hat höchstens O(s) Bits, und die Rekursionstiefe ist ebenfalls durch O(s) beschränkt.
Der Beweis des Satzes von Savitch betont die überragende Rolle von D-REACHABILITY
für die Speicherplatzkomplexität. Aussagen über die nichtdeterministische Speicherplatzkomplexität werden zuerst für NL (und damit für D-REACHABILITY) nachgewiesen. Sodann
ist zu gewährleisten, dass sich die Aussagen nach „oben“ vererben, also auch für größeren
Speicherplatz gelten.
Aufgabe 117
Jede Sprache L in N P kann wie folgt beschrieben werden: Es gibt eine Sprache K ∈ P und eine Konstante c,
so dass für alle Eingaben x
x ∈ L ⇐⇒ ∃y ∈ {0, 1}∗ (|y| ≤ |x|c ∧ (x, y) ∈ K).
Definiere Σp1 = N P , Πp1 = co − N P sowie für alle k ∈ N, k > 1
Σpk = {L ⊆ {0, 1}∗
|
∃K ∈ Πpk−1 , c ∈ N ∀x ∈ {0, 1}∗ (x ∈ L ⇐⇒
∃y ∈ {0, 1}∗ (|y| ≤ |x|c ∧ (x, y) ∈ K))}.
Weiterhin ist Πpk = coΣpk und P H = ∪k∈N Σpk . P H heißt die polynomielle Hierarchie.
Zeige: (a) NP = coNP ⇐⇒ P H = N P .
(b) P H ⊆ PSPACE.
6.3.4
Der Satz von Immerman und Szlepscenyi
Wir zeigen als nächstes, dass überraschenderweise jede Sprache und ihr Komplement die
gleichen nichtdeterministischen Speicherplatz-Ressourcen benötigen, oder in anderen Worten,
dass nichtdeterministischer Speicherplatz abgeschlossen ist unter Komplementbildung. Der
wesentliche Schritt wird der Nachweis sein, dass das Komplement von D-REACHABILITY,
also
D-UNREACHABILITY = {G | es gibt keinen Weg von Knoten 1 nach Knoten 2 }
ebenfalls in NL liegt.
Satz 6.10 (Der Satz von Immerman und Szlepscenyi)
(a) D-UNREACHABILITY ∈ NL.
(b) Die Funktion s sei platz-konstruierbar. Dann ist
Nspace(s) = coNspace(s),
wobei coNspace(s) = {L | L ∈ Nspace(s)} genau aus den Komplementen von Sprachen
aus Nspace(s) besteht.
6.3. LOGARITHMISCHER SPEICHERPLATZ
179
Beweis (a): Der Graph G sei die Eingabe für D-UNREACHABILITY. Angenommen, wir
könnten das Anzahlproblem in NL lösen, also die Anzahl m der von Knoten 1 aus erreichbaren
Knoten bestimmen. Wir zeigen zuerst, dass dann auch D-UNREACHABILITY zu NL gehört.
Im zweiten Schritt lösen wir dann das Anzahlproblem mit nichtdeterministisch logarithmischem Platz.
Wir nehmen also an, dass wir die Zahl m der von 1 aus erreichbaren Knoten kennen. Unsere
nichtdeterministische Maschine versucht jetzt nacheinander m verschiedene Knoten v1 , . . . , vm
zu finden, die von 1 aus erreichbar sind. Wenn der Knoten 2 von all diesen Knoten verschieden
ist, dann kann M folgern, dass 2 nicht von 1 aus erreichbar ist und M wird akzeptieren.
Im Detail sieht das Vorgehen von M wie folgt aus. Die erste Phase von M ist trivial: M
„setzt“ v1 = 1, da 1 von 1 aus erreichbar ist. In der i + 1ten Phase rät M einen Knoten vi+1
und rät sukzessive eine Knotenfolge beginnend mit Knoten 1. M verwirft, wenn vi+1 ≤ vi
oder wenn vi+1 = 2 oder wenn die geratene Knotenfolge keinem im Knoten vi+1 endenden
Weg entspricht. Ansonsten akzeptiert M , falls i+1 = m, beziehungsweise beginnt Phase i+1,
falls i + 1 < m.
Wir haben also D-UNREACHABILITY gelöst, wenn das Anzahlproblem gelöst ist. Wie können wir aber das Anzahlproblem in NL lösen? Sei mi die Anzahl der Knoten, die durch Wege
der Länge höchstens i von Knoten 1 aus erreichbar sind. Offensichtlich ist m0 = 1 und
mn−1 = m. Wir müssen nur für jedes i zeigen, dass mi+1 in NL berechnet werden kann, wenn
mi bekannt ist.
Wir können also annehmen, dass mi bekannt ist. Wir setzen zu Anfang mi+1 = 1 und wiederholen dann im wesentlichen das Vorgehen von M für alle Knoten (in aufsteigender Reihenfolge). Wenn Knoten k behandelt wird, raten wir sukzessive Knoten vi,1 < · · · < vi,mi und
verifizieren, dass jeder geratene Knoten vom Knoten 1 durch einen Weg der Länge höchstens
i erreichbar ist.
Wenn wir für den gegenwärtigen Knoten k gerade den Knoten vi,r verifiziert haben, dann
prüfen wir zusätzlich nach, ob vi,r ein Vorgänger von k ist. Ist dies der Fall, dann erhöhen
wir mi+1 um 1 und brechen die Behandlung von Knoten k ab, um mit der Behandlung von
Knoten k + 1 zu beginnen. Ist dies nicht der Fall, dann setzen wir die Ratephase für Knoten
mit Abstand höchstens i vom Knoten 1 fort. In diesem Fall beginnt die Behandlung von
Knoten k + 1 erst, wenn alle mi Knoten überprüft wurden.
Also ist auch das Anzahlproblem in NL lösbar und die Behauptung ist gezeigt.
(b) Die Sprache L werde von einer nichtdeterministischen Turingmaschine M mit Speicherplatzbedarf s erkannt. Wir wissen, dass s platz-konstruierbar ist und damit gilt insbesondere
auch s ≥ log2 n. Unser Ziel ist die Konstruktion einer nichtdeterministischen Turingmaschine
M ∗ , die das Komplement L mit Speicherplatzbedarf O(s) erkennt. M ∗ muss also nachprüfen, ob M für eine Eingabe w eine akzeptierende Berechnung besitzt (sprich: einen Weg von
der Startkonfiguration 1 zur akzeptierenden Haltekonfiguration 2 besitzt) und genau dann
akzeptieren, wenn es eine akzeptierende Berechnung nicht gibt.
M ∗ wendet den Algorithmus aus Teil (a) auf den Berechnungsgraphen GM (w) an, wobei M ∗
die Existenz von Kanten selbst klären muss. Offensichtlich gelingt diese Klärung in Platz
O(s), da die Konfigurationen von M nur Platz O(s) benötigen.
Aufgabe 118
Zeige: Wenn L vollständig für NL ist, dann ist auch das Komplement L vollständig für NL.
Die Sprache 2-SAT besteht aus allen erfüllbaren aussagenlogischen Formeln in konjunktiver
Normalform mit jeweils höchstens zwei Literalen pro Klausel.
180
KAPITEL 6. SPEICHERPLATZ-KOMPLEXITÄT
Korollar 6.11 2-SAT ist NL-vollständig.
Beweis: Wir zeigen zuerst die nicht-offensichtliche Aussage, dass 2-SAT in NL liegt. Sei also φ
eine Formel in konjunktiver Normalform mit jeweils zwei Literalen pro Klausel. Wir weisen φ
den gerichteten Graphen G(φ) zu, wobei die Knoten von G(φ) den Literalen von φ entsprechen.
Wir setzen eine Kante vom Literal α zum Literal β ein, falls ¬α ∨ β eine Klausel ist. Eine
Kante (α, β) entspricht also einer Implikation α → β. Für jede Kante (α, β) fügen wir auch
die „symmetrische“ Kante (¬β, ¬α) in G(φ) ein; beachte, dass α → β und ¬β → ¬α logisch
äquivalent sind.
Behauptung: φ ist genau dann nicht erfüllbar, wenn es ein Literal x gibt, so dass es einen
Weg von x nach ¬x wie auch einen Weg von ¬x nach x gibt.
Beweis ⇐: Die Existenz eines Weges von α nach β erzwingt für jede erfüllende Belegung,
die α auf 1 setzt, auch dass β auf 1 gesetzt wird. Also müssen x und ¬x auf denselben Wert
gesetzt werden, was aber nicht erlaubt ist.
⇒: Wir wissen also, dass φ nicht erfüllbar ist. Wir nehmen an, dass die Behauptung falsch ist
und konstruieren dann eine erfüllende Belegung. Wir beginnen mit irgendeinem ungesetzten
Literal x, für das wir annehmen können, dass es keinen Weg von x nach ¬x gibt. Wir weisen
x und allen von x in G(φ) erreichbaren Literalen den Wert 1 zu und weisen ¬x und allen
Literalen, die ¬x erreichen, den Wert 0 zu.
Unser Vorgehen ist wohl-definiert, da es kein Literal y geben kann, so dass sowohl y wie
auch ¬y von x aus erreichbar sind. Der Graph G(φ) garantiert ja mit seinen symmetrischen
Kanten auch symmetrische Wege: Zu jedem Weg von x nach y gibt es auch einen Weg von
¬y nach ¬x und simultane Wege von x nach y wie auch von x nach ¬y implizieren einen
(ausgeschlossenen) Weg von x nach ¬x über ¬y.
Weiterhin kann es kein von x aus erreichbares Literal geben, das vorher auf 0 gesetzt wurde.
Ein solcher Fall ist ausgeschlossen, da dann x schon gesetzt worden wäre.
Offensichtlich können wir unser Vorgehen solange wiederholen bis alle Literale gesetzt sind.
Wir haben aber alle Klauseln erfüllt und die Formel φ ist im Widerspruch zur Annahme
erfüllt.
Aus der Behauptung erhalten wir sofort, dass die Nicht-Erfüllbarkeit in NL liegt, da wir ja nur
die Existenz von Wegen zwischen sich widersprechenden Literalen zu raten brauchen. Damit
folgt aber aus dem Satz von Immerman und Szlepscenyi, dass Erfüllbarkeit, also 2-SAT, in
NL liegt.
Es bleibt zu zeigen, dass 2-SAT NL-vollständig ist. Wir konstruieren zuerst die Reduktion DUNREACHABILITY ≤LOG 2-SAT. Sei also G ein Eingabegraph. Wir weisen dem Graphen
G eine Formel φG wie folgt zu. Wir fassen die Knoten von G als Variablen auf und fügen für
jede Kante (u, v) die Klausel ¬u ∨ v ein. Desweiteren verwenden wir die Einer-Klauseln 10
sowie ¬20 .
Behauptung: φG ist genau dann erfüllbar, wenn es keinen Weg von 1’ nach 2’ gibt.
Beweis: Wenn es keinen Weg von 1’ nach 2’ gibt, dann ist φG erfüllt, wenn wir 1’ und allen
von 1’ erreichbaren Knoten den Wert 1 und den restlichen Knoten den Wert 0 zuweisen. Gibt
es hingegen einen Weg von 1’ nach 2’, dann müssen alle Knoten des Weges (und damit auch
2’) auf 1 gesetzt werden: φG ist nicht erfüllbar.
Die Transformation G → φG etabliert also die Reduktion. Jetzt brauchen wir nur noch zu
beachten, dass D-UNREACHABILITY NL-vollständig ist (warum?) und das Ergebnis folgt
mit Korollar 6.12.
6.4. PSPACE-VOLLSTÄNDIGKEIT
181
Wir kennen also mittlerweile vier NL-vollständige Probleme, nämlich D-REACHABILITY und
2SAT sowie die beiden Komplemente. Bipartitness und das Wortproblem für NFAs sind auch
NL-vollständig:
Aufgabe 119
Sei LNFA = {hAiw | A ist ein NFA und akzeptiert w} das Wortproblem für NFAs.
(a) Zeige, dass LNFA in NL liegt.
(b) Zeige, dass LNFA NL-hart ist. Hinweis: Zeige D-REACHABILITY ≤LOG LNFA .
6.4
PSPACE-Vollständigkeit
Wir möchten die schwierigsten Sprachen in PSPACE bezüglich der polynomiellen Reduktion
bestimmen. Zur Erinnerung: Wir sagen, dass ein Entscheidungsproblem L1 genau dann auf
ein Entscheidungsproblem L2 polynomiell reduzierbar ist (geschrieben L1 ≤P L2 ), wenn
w ∈ L1 ⇔ T (w) ∈ L2
für alle Eingaben w von L1 gilt. Die Transformation w 7→ T (w) muss in polynomieller Zeit
durch eine deterministische Turingmaschine berechenbar sein.
Die Definition der PSPACE-vollständigen Sprachen folgt dem Schema der NL- und NP-Vollständigkeit.
Definition 6.3 Sei K eine Sprache.
(a) K heißt PSPACE-hart, falls L ≤P K für jede Sprache L ∈ PSPACE gilt.
(b) K heißt PSPACE-vollständig, falls K PSPACE-hart ist und falls
K ∈ PSPACE.
PSPACE-harte Sprachen sind mindestens so schwierig wie NP-harte Sprachen:
Aufgabe 120
(a) Zeige: Jede PSPACE-harte Sprache ist NP-hart.
(b) Zeige: Wenn eine PSPACE-harte Sprache in NP liegt, ist NP = PSPACE.
(c) Unterstelle in dieser Teilaufgabe die folgende, falsche Definition von „PSPACE-Härte“: Eine Sprache K
heiße „PSPACE-hart“, falls L ≤PSPACE K für alle L ∈ PSPACE gilt. Die Reduktion ≤PSPACE sei analog zu
≤LOG durch eine transformierende Turingmaschine mit polynomiellem Speicherplatzbedarf definiert.
Zeige, dass nach dieser Definition von „PSPACE-Härte“ jede Sprache K ⊆ Σ∗ mit ∅ 6= K 6= Σ∗ „PSPACEhart“ ist.
Wie auch im Fall der NP- oder NL-Vollständigkeit führt eine Berechnung der vollständigen
Probleme innerhalb der kleineren Klasse (sprich: P) zum Kollaps der größeren Klasse. Weiterhin genügt, wie üblich, zum Nachweis der Vollständigkeit die Reduktion auf ein vollständiges
Problem.
Korollar 6.12 (PSPACE-vollständige und PSPACE-harte Sprachen)
(a) Die Sprache K sei PSPACE-vollständig. Dann gilt
K ∈ P ⇔ P = PSPACE.
(b) Die Sprache K sei PSPACE-hart. Wenn K ≤P L, dann ist auch L PSPACE-hart.
182
6.4.1
KAPITEL 6. SPEICHERPLATZ-KOMPLEXITÄT
QBF: Quantifizierte Boolesche Formeln
Wir konstruieren die Sprache QBF, die sich später als PSPACE-vollständig herausstellen wird.
Die Worte in QBF entsprechen Kodierungen hφi von quantifizierten Booleschen Formeln φ.
Die Formel φ besteht aus einem Quantorenteil gefolgt von einer aussagenlogischen Formel α.
Der Quantorenteil besteht aus All- und Existenz-Quantoren, so dass jede in α vorkommende
Variable von genau einem Quantor gebunden wird. Wir definieren
QBF = {hφi | φ ist eine wahre quantifizierte Boolesche Formel }.
Beispiel 6.3 Die Formel φ ≡ ∃p∀q((p∨¬q)∧(¬p∨q)) ist falsch, denn sie drückt die Äquivalenz
von p und q aus. Sicherlich gibt es aber keinen Wahrheitswert für p, der mit den beiden
Wahrheitswerten 0 und 1 äquivalent ist. Somit ist φ 6∈ QBF.
Die Formel ψ ≡ ∀p∃q((p ∨ ¬q) ∧ (¬p ∨ q)) ist hingegen wahr, denn zu jedem Wahrheitswert
für p gibt es einen äquivalenten Wahrheitswert für q. Also ist ψ ∈ QBF.
Satz 6.13 QBF ist PSPACE-vollständig.
Beweis: Wir zeigen zuerst, dass QBF in PSPACE liegt. Dazu betrachten wir den folgenden
rekursiven Algorithmus.
Algorithmus 6.4 (Erkennen wahrer quantifizierter Formeln auf polynomiellem Platz)
(1) Die quantifizierte Booleschen Formel φ sei die Eingabe.
(2) Wenn φ keine Quantoren besitzt, dann besteht φ nur aus aussagenlogischen Verknüpfungen der Konstanten 0 und 1 und kann direkt ausgewertet werden. Gib die Auswertung
aus.
(3) Wenn φ ≡ ∃pψ(p), dann führe rekursive Aufrufe mit den quantifizierten Booleschen
Formeln ψ(0) und ψ(1) durch. Wenn eine der Formeln zu 1 auswertet, dann gib 1 als
Auswertung aus. Ansonsten gib 0 als Auswertung aus.
(4) Wenn φ ≡ ∀pψ(p), dann führe rekursive Aufrufe mit den quantifizierten Booleschen
Formeln ψ(0) und ψ(1) durch. Wenn eine der Formeln zu 0 auswertet, dann gib 0 als
Auswertung aus. Ansonsten gib 1 als Auswertung aus.
Algorithmus 6.4 hat eine höchstens lineare Rekursionstiefe. In jedem Rekursionsschritt ist
aber nur ein Wahrheitswert abzuspeichern, so dass der Algorithmus nur einen linearen Speicherplatzbedarf hat und QBF ∈ PSPACE folgt.
Wir kommen zum Nachweis der PSPACE-Härte. Die Sprache L ∈ PSPACE werde von deterministischen Turingmaschine M mit Speicherplatzbedarf O(nk ) berechnet. Wir müssen für jede
Eingabe w von L in polynomieller Zeit eine quantifizierte Boolesche Formel φw konstruieren,
so dass
w ∈ L ⇔ φw ist wahr
gilt. Wir erinnern an den NP-Vollständigkeitsbeweis von KNF-SAT. Eine (nicht-quantifizierte)
t kodiert die Konfiguration der Turingmaschine zum Zeitpunkt t. Die
Boolesche Formel αw
Kodierung gelingt durch Einbeziehung der aussagenlogischen Variablen
6.4. PSPACE-VOLLSTÄNDIGKEIT
183
- Kopf t (z) für die Kopfposition. Kopf t (z) soll genau dann wahr ist, wenn der Kopf zum
Zeitpunkt t auf Zelle z steht,
- Zellet (z, a) für den Zelleninhalt. Zellet (z, a) soll genau dann wahr ist, wenn die Zelle z
zum Zeitpunkt t mit dem Buchstaben a beschriftet ist und
- Zustandt (q) für den aktuellen Zustand. Zustandt (q) soll genau dann wahr ist, wenn q
der Zustand zum Zeitpunkt ist.
Weiterhin wird die beabsichtigte Bedeutung erzwungen, in dem durch die Konjunktion von
zusätzlichen Klauseln sichergestellt wird, dass die Zelleninhalte, die Kopfbewegung und der
neue Zustand sich gemäss der Arbeitsweise der Maschine verändern.
Wir kehren zurück zum PSPACE-Vollständigkeitsbeweis von QBF und müssen eine kurze Formel φw für die möglicherweise exponentiell lange Berechnung der Turingmaschine M zu schreiben! Sei T die kleinste Zweierpotenz, die größer als die Anzahl der Konfigurationen von M ist.
c0 ist die Anfangskonfiguration und ca die eindeutig bestimmte akzeptierende Haltekonfiguration von M . (Wieso kann man verlangen, dass es genau eine akzeptierende Haltekonfiguration
gibt?) Unser Ziel ist die Konstruktion von höchstens polynomiell langen Formeln ψt (c, d), die
genau dann wahr sein sollen, wenn M –in der Konfiguration c startend– die Konfiguration d
nach höchstens t Schritten erreicht. Ist dies geschafft, dann setzen wir φw ≡ ψT (c0 , ca ) und
φw ist genau dann wahr, wenn M die Eingabe w akzeptiert.
Die Formeln ψ1 (c, d) sind einfach zu konstruieren. Wir müssen ausdrücken, dass c = d oder
dass d die Nachfolgekonfiguration von c ist. Wir übernehmen die Konfigurations-Kodierung
durch die drei Typen der aussagenlogischen Variablen aus dem N P -Vollständigkeitsbeweis
für KNF-SAT. Im Fall c = d müssen wir nur die Äquivalenz der c- und d-Variablen fordern,
während im anderen Fall die d-Variablen als Aktualisierung der c-Variablen zu formulieren
sind. In jedem der beiden Fälle sind keinerlei Quantoren notwendig.
Wir benutzen Existenz-Quantoren in der rekursiven Definition von ψt (c, d), um eine Zwischenkonfiguration e zu raten, sowie All-Quantoren, um die Formellänge klein zu halten. Wir
setzen
ψ2t (c, d) ≡ ∃e∀f ∀g( ((f = c ∧ g = e) ∨ (f = e ∧ g = d)) → ψt (f, g) ).
Beachte, dass ∃e einer Reihe von Existenz-Quantoren entspricht, nämlich den ExistenzQuantoren zu den Variablen der Konfiguration e bezüglich Kopfposition, Zelleninhalt und
Zustand; die gleiche Aussage gilt analog für ∀f und ∀g. Die Formel ψ2t (c, d) drückt aus, dass
eine Berechnung der Länge höchstens 2t aufgespalten werden kann in zwei aufeinanderfolgende Berechnungen der Länge höchstens t. Der All-Quantor erlaubt eine simultane Überprüfung
der beiden Berechnungen von c nach e und von e nach d. Dementsprechend wächst die Formellänge additiv um höchstens O(nk ), also höchstens um den Speicherplatzbedarf von M ,
und wir erhalten O(n2k ) als obere Schranke für die Länge der Formel ψT (c0 , ca ).
Wir können die Sprache QBF ein wenig vereinfachen ohne die PSPACE-Vollständigkeit zu verlieren. Insbesondere betrachten wir nur quantifizierte Boolesche Formeln φ, deren Quantoren
strikt alternieren: auf jeden All-Quantor folgt also ein Existenz-Quantor auf den wiederum ein
All-Quantor folgen muss. Diese Einschränkung ist oberflächlich, da wir stets beliebige Quantoren einfügen können, die in der Formel nicht vorkommende Variablen binden. In der zweiten
und letzten Einschränkung fordern wir, dass sich die in φ quantifizierte aussagenlogische Formel in konjunktiver Normalform befindet. Wir definieren dann QBF∗ als die Menge aller
quantifizierten Booleschen Formeln in QBF, die die beiden obigen Einschränkungen erfüllen.
Korollar 6.14 QBF∗ ist PSPACE-vollständig.
184
KAPITEL 6. SPEICHERPLATZ-KOMPLEXITÄT
Beweis: Die Formel φ sei eine (nicht eingeschränkte) quantifizierte Boolesche Formel. Wir
überführen φ in polynomieller Zeit in eine äquivalente, aber eingeschränkte Formel φ∗ . Zuerst führen wir Dummy-Quantoren ein, um strikte Quantoren-Alternation zu sichern. Dann
werden wir die aussagenlogische Formel α von φ durch Einführung neuer Variablen x in eine
äquivalente Formel ∃xα∗ (x) überführen, wobei α∗ in konjunktiver Normalform sein wird.
Wir nehmen zuerst an, dass sich Negationen nur auf Variablen beziehen; ist dies nicht der
Fall, dann schieben wir Negationen mit den de Morgan’schen Regeln bis zu den Variablen
vor. Sodann gehen wir indukiv vor.
Fall 1: α = α1 ∨ α2 . Wir erfinden neue Variablen x1 und x2 . x1 (bzw x2 ) wird mit jeder
Klausel der konjunktiven Normalform von α1 (bzw. α2 ) „verodert“. Sei α∗ die aus den beiden
modifizierten konjunktiven Normalformen sowie der neuen Klausel (¬x1 ∨ ¬x2 ) resultierende
konjunkive Normalform. Beachte, dass α ↔ ∃x1 ∃x2 α∗ .
Fall 2: α = α1 ∧ α2 . Wir definieren α∗ als die Konjunktion der konjunktiven Normalform für
α1 mit der konjunktiven Normalform für α2 . Etwaige Existenz-Quantoren in α1 oder α2 sind
nach vorne zu ziehen.
Wir können die Formel α∗ in polynomieller Zeit konstruieren und die Behauptung folgt.
Das PSPACE-vollständige Problem QBF ∗ hat also die Form ∃x1 ∀x2 ∃x3 . . . ∀xn P (x1 , . . . , xn )
für ein KNF-Prädikat P . Eine solche Struktur läßt sich als ein Zweipersonen-Spiel auffassen:
Der ziehende Spieler muss für eine gegebene Spielsituation einen Zug bestimmen,
der gegen alle Züge des Gegenspielers in eine gewinnbare Spielsituation führt. Das
Prädikat P definiert das Spiel.
In vielen interessanten Spielen ist die Spielauswertung P als eine aussagenlogische Formel
darstellbar, und die Frage nach einer Gewinnstrategie für den ziehenden Spieler liegt dann
in PSPACE. Tatsächlich kann man zeigen, dass viele Spiele (zum Beispiel n × n Versionen von
Go oder Schach) sogar PSPACE vollständig sind, und dass daher Gewinnstrategien nicht in P
berechenbar sind, es sei denn, es gilt P = PSPACE.
6.4.2
Das Geographie-Spiel
Wir definieren das GEOGRAPHIE-Spiel, eine Verallgemeinerung des Spiels, bei dem zwei
Spieler abwechselnd noch nicht genannte Städtenamen wählen, wobei jede Stadt mit dem
Endbuchstaben der zuvor genannten Stadt beginnen muß.
- Die Eingabe: Ein gerichteter Graph G = (V, E) und ein ausgezeichneter Knoten s ∈ V .
- Die Spielregeln:
– Zwei Spieler A und B wählen abwechselnd jeweils eine noch nicht benutzte Kante
aus E.
– Spieler A fängt an und wählt eine Kante mit Startknoten s.
– Jede anschließend gewählte Kante muß im Endknoten der zuvor gewählten Kante
beginnen.
– Der Spieler, der als erster keine solche unbenutzte Kante mehr findet, verliert das
Spiel.
6.4. PSPACE-VOLLSTÄNDIGKEIT
185
- Die Aufgabe: Es ist zu entscheiden, ob ein optimal spielender Spieler A gegen jeden
Spieler B auf G gewinnen kann.
Aufgabe 121
Zeige, dass GEOGRAPHIE durch eine deterministische Turingmaschine mit höchstens polynomiellem Speicherplatz gelöst werden kann. Warum gehört GEOGRAPHIE wahrscheinlich nicht zur Klasse NP?
6.4.3
NFA’s und reguläre Ausdrücke
Im Entscheidungsproblem der Nicht-Universalität für reguläre Ausdrücke ist ein regulärer
Ausdruck R genau dann zu akzeptieren, wenn L(R) 6= Σ∗ für die von R beschriebene Sprache
L(R) gilt. Ein solch einfaches Problem kann doch nicht schwierig sein, oder? Tatsächlich ist
die Nicht-Universalität für reguläre Ausdrücke hammer-hart, und als Konsequenz kann die
Größe von minimalen regulären Ausdrücken oder minimalen NFA’s nur völlig unbefriedigend
approximiert werden.
Satz 6.15 (Schwierige Entscheidungsprobleme für NFAs und reguläre Ausdrücke)
(a) Die Nicht-Universalität für reguläre Ausdrücke ist ebenso PSPACE-hart wie die NichtUniversalität für NFA.
(b) Das Äquivalenzproblem für reguläre Ausdrücke, also die Frage, ob zwei gegebene reguläre
Ausdrücke R1 und R2 dieselbe Sprache beschreiben –also ob L(R1 ) = L(R2 ) gilt–, ist
PSPACE-hart. Das Äquivalenzproblem für NFA ist ebenfalls PSPACE-hart.
(c) Es gelte P 6= PSPACE. Dann ist es nicht möglich, für einen gegebenen regulären Ausdruck
oder NFA A der Größe m, die Größe eines minimalen regulären Ausdrucks oder eines
minimalen NFA’s innerhalb des Faktors o(m) effizient zu approximieren.
Beweis (a): Das Entscheidungsproblem QBF ist PSPACE-vollständig und kann von einer
deterministischen Turingmaschine
M = (Q, Σ, Γ, δ, q0 , {qf })
gelöst werden, die in-place arbeitet, also nie den Eingabebereich verlässt.
Aufgabe 122
Wenn M eine nichtdeterministische Turingmaschine ist, die mit linearem Speicherplatz arbeitet, dann gibt es
eine zu M äquivalente in-place Turingmaschine M 0 .
Zusätzlich können wir verlangen, dass M für jede Eingabe der Länge n mindestens 2n Schritte
benötigt.
Für eine Eingabe w für M konstruieren wir einen regulären Ausdruck Rw , der alle Worte
akzeptiert, die nicht mit der Konfigurationenfolge einer akzeptierenden Berechnung von M
auf Eingabe w übereinstimmen. Haben wir die Konstruktion von Rw in polynomieller Zeit
geschafft, dann haben wir L(M ) –und damit QBF – auf die Nicht-Universalität für reguläre
Ausdrücke reduziert und, wie gefordert, die PSPACE-Härte nachgewiesen. Warum?
w ∈ L(M ) ⇔ nur die Konfigurationenfolge der akzeptierenden Berechnung
von M auf w gehört nicht zu L(Rw )
⇔ L(Rw ) 6= Σ∗ .
186
KAPITEL 6. SPEICHERPLATZ-KOMPLEXITÄT
Um Konfigurationen zu kodieren, benutzen wir das Alphabet
Σ0 = Q × Γ ∪ Γ ∪ {#}.
Das neue Symbol # trennt Konfigurationen, ein Symbol [q, a] ∈ Q × Σ repräsentiert die
Kopfposition von M und gibt an, dass gegenwärtig der Buchstabe a gelesen wird.
Wir stellen sicher, dass nur die Konfigurationenfolge einer akzeptierenden Berechnung von M
verworfen wird, wenn
(1) die Anfangskonfiguration nicht von der Form
#[q0 , w1 ]w2 · · · wn #
ist oder
(2) keine Konfiguration der Konfigurationenfolge den Buchstaben [qf , γ] für irgendein γ ∈ Γ
enthält oder
(3) die Folge nicht mit dem Trennsymbol # endet oder
(4) wenn sich der Bandinhalt oder der Zustand zwischen aufeinanderfolgenden Konfigurationen auf eine nicht-legale Weise ändert.
Aufgabe 123
Konstruiere Rw als Vereinigung von vier regulären Ausdrücken der Länge O(|w|)–also einen Ausdruck für jeden
der vier Fälle.
Hinweis: Um einen „kurzen“ regulären Ausdruck für den vierten Fall zu erhalten, beachte, dass in einer legalen Folge y von Konfigurationen für jedes Teilwort yi−1 yi yi+1 das „neue“ Symbol yi+n+1 eine Funktion von
yi−1 yi yi+1 ist. Insbesondere, wenn x eine illegale Konfigurationenfolge ist, dann gilt xi+n+1 6= xi , obwohl der
Kopf nicht auf Position i gestanden ist, oder xi+n+1 wird falsch aktualisiert.
Damit ist die Behauptung für reguläre Ausdrücke gezeigt. Das entsprechende Ergebnis für
NFA folgt mit einem völlig analogem Argument.
(b) Die Nicht-Universalität für einen regulären Ausdruck R ist äquivalent zur Frage, ob
L(R) 6= L(Σ∗ ) gilt, d.h. ob die beiden regulären Ausdrücke R und Σ∗ äquivalent sind. Die
PSPACE-Härte des Äquivalenzproblems für reguläre Ausdrücke folgt also aus Teil (a) und
Gleiches gilt für die PSPACE-Härte des Äquivalenzproblems für NFA.
(c) Wir nehmen P 6= PSPACE an. Nach Korollar 6.12 können dann PSPACE-vollständige Entscheidungsprobleme nicht effizient gelöst werden.
Insbesondere kann also nicht effizient bestimmt werden, ob w ∈ L(M ) für die Turingmaschine
aus Teil (a) gilt. Nun ist w 6∈ L(M ) genau dann, wenn L(Rw ) = Σ∗ , bzw. genau dann, wenn
der minimale, mit Rw äquivalente reguläre Ausdruck eine beschränkte Länge hat. Ist hingegen
w ∈ L(M ), dann folgt L(Rw ) 6= Σ∗ und genauer L(Rw ) = Σ∗ \{y} für die Konfigurationenfolge
y der akzeptierenden Berechnung für Eingabe w. Wie lang muss ein minimaler, mit Rw
äquivalenter Ausdruck in diesem Fall mindestens sein?
Wir haben gefordert, dass die Turingmaschine M mindestens 2n Schritte für Eingaben der
Länge n benötigt und deshalb hat y mindestens die Länge 2|w| . Ein deterministischer endlicher Automat benötigt mindestens |y| ≥ 2|w| Zustände, um Σ∗ \ {y} zu akzeptieren, ein
regulärer Ausdruck oder ein NFA muss deshalb mindestens |w| Zustände besitzen. Aber Rw
hat die Länge O(|w|), und wir können deshalb nicht effizient unterscheiden, ob ein minimaler
äquivalenter regulärer Ausdruck die Länge O(1) oder Ω(|w|) besitzt.
6.5. KOMPLEXITÄTSKLASSEN UND DIE CHOMSKY HIERARCHIE
187
Die Länge eines minimalen äquivalenten regulären Ausdrucks kann also so gut wie nicht nicht
approximiert werden. Gleiches gilt aber auch für die Größe von äquivalenten minimalen NFA,
denn auch ihre Größe variiert ziwschen O(1) –falls w 6∈ L(M )– und Ω(|w|) –falls w ∈ L(M ).
Aufgabe 124
Gib einen Algorithmus an, der mit polynomiell beschränktem Platz arbeitet, und der bei Eingabe eines nichtdeterministischen endlichen Automaten einen nichtdeterministischen endlichen Automaten mit minimaler Zustandsanzahl für dieselbe Sprache konstruiert.
Hinweis: Gib einen nichtdeterministischen Algorithmus an. Zum Vergleich der Sprachen zweier nichtdeterministischer endlicher Automaten mit höchstens n Zuständen reicht es aus, das Verhalten auf allen Worten der
Länge 2n zu vergleichen.
Aufgabe 125
(a) Zeige, dass das durch
L1 = {hAi | A = (Q, Σ, δ, q0 , F ) ist ein NFA mit L(A) = Σ∗ }
definierte Universalitätsproblem für NFAs zu PSPACE gehört.
Hinweis: Zeige zuerst, dass L(A) 6= Σ∗ genau dann gilt, wenn A ein Wort w ∈ Σ∗ mit |w| < 2|Q|
verwirft.
(b) Zeige, dass das durch
L2 = {hA1 , A2 i | A1 und A2 sind NFAs mit L(A1 ) = L(A2 )}
definierte Äquivalenzproblem für NFAs in PSPACE liegt. Beachte, dass das Äquivalenzproblem für Finite
State Transducer noch nicht einmal entscheidbar ist.
6.5
Komplexitätsklassen und die Chomsky Hierarchie
Unser Ziel ist ein Vergleich der bereits betrachteten Komplexitätsklassen und Sprachenklassen
Wir haben bisher die Komplexitätsklassen DL, NL, P, NP und die Klasse PSPACE, der auf polynomiellen Speicherplatz entscheidbaren Sprachen kennengelernt und die Klassen der regulären
und kontextfreien Sprachen untersucht. Insbesondere haben wir eingeschränkte Grammatiken als Grundlagen für die Beschreibung von Programmiersprachen behandelt: Die beiden
vorrangigen Ziele einer Programmiersprache sind entgegengesetzt, nämlich
1. eine effiziente Lösung des Wortproblems. Es sollte in vertretbarer Zeit entscheidbar sein,
ob ein vorgelegtes Wort ableitbar ist, bzw. ob ein Programm syntaktisch korrekt ist.
Dauert dieser Entscheidungsvorgang zu lange, so kommt die Sprachenklasse als mögliche
Grundlage für Programmiersprachen und Compiler nicht in Frage.
2. Die Sprachen sollten möglichst ausdruckstark sein, um höhere Programmiersprachen
komfortabel darzustellen zu können.
Wir führen die Klasse der kontextsensitiven Grammatiken ein und erhalten damit die ChomskyHierarchie, eine Grobeinteilung der Sprachenklassen.
Definition 6.4 (Chomsky-Hierarchie)
(a) Grammatiken ohne jede Einschränkung heißen Typ-0 Grammatiken. Die entsprechende
Sprachenfamilie ist
n
o
L0 = L(G) | G ist vom Typ 0
188
KAPITEL 6. SPEICHERPLATZ-KOMPLEXITÄT
(b) Eine Grammatik G mit Produktionen der Form
u→v
mit |u| ≤ |v|
heißt Typ-1 oder kontextsensitiv. Die zugehörige Sprachenfamilie ist
n
o
n
o
L1 = L(G) | G ist vom Typ 1 ∪ L(G) ∪ {} | G ist vom Typ 1
(c) Eine Grammatik G mit Produktionen der Form
u→v
mit u ∈ V und v ∈ (V ∪ Σ)∗
heißt Typ-2 oder kontextfrei. Die zugehörige Sprachenfamilie ist
n
o
L2 = L(G) | G hat Typ 2
(d) Eine reguläre Grammatik heißt auch Typ-3 Grammatik. Die zugehörige Sprachenfamilie
ist
n
o
L3 = L(G) | G hat Typ 3
Beispiel 6.4 Die kontextfreie Grammatik G mit Startsymbol S und Produktionen
S → 0S0 | 1S1 | erzeugt alle Palindrome über dem Alphabet {0, 1}. Diese Sprache ist offensichtlich nicht regulär. Da anderseits jede reguläre Grammatik kontextfrei ist, zeigt dieses Beispiel, dass L2
eine echte Obermenge von L3 ist.
Beispiel 6.5 Wir entwerfen eine kontextsensitive Grammatik, die die Sprache
n
K = ai bi ci | i ≥ 0
o
erkennt. Die Grammatik G besitzt drei Variablen, nämlich das Startsymbol S sowie die Variablen R und L. Die Produktionen haben die Form
S → | abc
S → aRbc
R wird ein neues a und b einführen, dann nach rechts wandern bis das erste c angetroffen
wird. Ein c wird eingefügt, und R wird durch L ersetzt:
aRb → aabbR, bRb → bbR und bRc → bcc | Lbcc
Die Variable L läuft nach links bis das erste a gefunden wird. Dann wird L durch R ersetzt:
bL → Lb und aLb → aRb.
Die Sprache Kist nicht kontextfrei. Da kontextfreie Sprachen L mit ∈
/ L durch Grammatiken in Chomsky Normalform erzeugt werden können, ist jede kontextfreie Sprache auch
kontextsensitiv, und L1 ist eine echte Obermenge von L2 .
Satz 6.16 Die Chomsky Hierarchie und die Platzkomplexität
6.5. KOMPLEXITÄTSKLASSEN UND DIE CHOMSKY HIERARCHIE
189
(a) L0 ist die Klasse aller rekursiv aufzählbaren Sprachen.
(b) Es gilt L1 = Nspace(n). Also ist L1 die Klasse aller Sprachen, die von nichtdeterministischen Turingmaschinen auf linearem Platz erkannt werden. Insbesondere ist jede
Sprache in L1 entscheidbar.
(c) NL ⊆ LOGCFL ⊆ Dspace(log22 n).
(Insbesondere sind alle kontextfreie Sprachen in Dspace(log22 n) enthalten, es gilt also
L2 ⊆ Dspace(log22 n).)
(d) Die Klasse der regulären Sprachen stimmt mit der Klasse Dspace(0) überein, es gilt also
L3 = Dspace(0).
(e) L3 ⊂ L2 ⊂ L1 ⊂ L0 und alle Inklusionen sind echt.
Beweis (a): Wir behaupten, dass L(G) für jede Grammatik G rekursiv aufzählbar ist.
Warum? Wenn wir entscheiden wollen, ob ein Wort w zur Sprache L(G) gehört, produzieren
wir alle mögliche Ableitungen: Wenn w ∈ L(G) werden wir eine Ableitung finden. Wenn
w∈
/ L(G), wird unser Programm nicht halten, aber dies ist auch nicht erforderlich.
Andererseits sei die Sprache L rekursiv aufzählbar. Es gibt also eine Turingmaschine M
mit L = L(M ). Wir müssen eine Grammatik G mit L(M ) = L(G) konstruieren. Für die
Konstruktion von G beachten wir, dass Berechnungen von M natürlich stets mit der Eingabe
w beginnen, während eine Ableitung von w mit w endet. Also sollten wir die Grammatik so
konstruieren, dass die Berechnungen von M „rückwärts“ simuliert werden.
Zuerst normieren wir M . Wir nehmen an, dass M
- nur einen akzeptierenden Zustand qa besitzt und
- dass akzeptierende Berechnungen mit dem leeren Band enden.
Wenn wir eine Berechnung von M anhalten, dann können wir die gegenwärtige Situation
durch den
- Bandinhalt α1 · · · αN ∈ ΓN ,
- den gegenwärtigen Zustand q ∈ Q und
- die Position des Kopfes
exakt beschreiben. Wenn der Kopf die Position i des Bands liest, dann beschreiben wir die
Konfiguration durch das Wort
α1 · · · αi−1 q αi · · · αN .
Die zu entwerfende Grammatik G wird Konfigurationen von M rückwärts konstruieren. G
besitzt
(Γ \ Σ) ∪ Q ∪ {}
als Variablenmenge und qa als Startsymbol. Zuerst wird der von M benutzte Bandbereich
durch die Produktionen qa → Bqa | qa B erzeugt. Dann beginnt die Rückwärtsrechnung.
Fall 1: δ(q, a) = (q 0 , b, links). Wir nehmen die Produktion
q 0 cb → cqa für alle c ∈ Γ
190
KAPITEL 6. SPEICHERPLATZ-KOMPLEXITÄT
auf: Wenn die Konfiguration ∗ · · · ∗ q 0 cb ∗ · · · ∗ schon erzeugt wurde, können wir damit die
mögliche Vorgänger-Konfiguration ∗ · · · ∗ cqa ∗ · · · ∗ erzeugen.
Fall 2: δ(q, a) = (q 0 , b, bleib). Wir fügen die Produktion
q 0 b → qa.
zu G hinzu.
Fall 3: δ(q, a) = (q 0 , b, rechts). Diesmal nehmen wir die Produktion
bq 0 → qa.
auf.
Am Ende der Ableitung werden wir eine Konfiguration
Bk q0 wBs
erzeugt haben. Die zusätzlichen Produktionen
q0 → 1
B 1 → 1
1 → 2
2 a → a2
für a ∈ Σ
2 → 3
3 B → 3
3 → das leere Wort
∗
garantieren jetzt, dass das Wort w abgeleitet wird und dass die Ableitung die Form qa →
∗
Bk q0 wBs → w hat. Insbesondere ist w genau dann ableitbar, wenn M die Konfigurationenfolge
∗
Bk q0 wBs → qa
durchläuft.
(b) Zuerst beachten wir, dass eine kontextsensitive Grammatik längenerhaltend ist: Die rechte Seite v einer kontextsensitiven Produktion u → v ist mindestens so lang wie die linke
Seite u. Wenn wir also aus dem Startsymbol ein Wort w ∈ Σ∗ erzeugen, dann sind alle zwischenzeitlich erzeugten Strings aus (Σ ∪ Γ)∗ in ihrer Länge durch |w| nach oben beschränkt.
Das aber bedeutet, dass wir eine mögliche Ableitungsfolge auf Platz O(|w|) raten und verifizieren können: Jede kontextsensitive Sprache kann also durch eine nichtdeterministische
Turingmaschine auf linearem Platz erkannt werden.
Betrachten wir jetzt eine nichtdeterministische Turingmaschine M , die auf linearem Platz
rechnet. Wir können zuerst annehmen, dass M sogar in-place arbeitet.
In Teil (a) haben wir eine beliebige Turingmaschine M durch Typ-0 Grammatiken simuliert
und insbesondere die Äquivalenz
∗
qa → Bk q0 wBs ⇔ w ∈ L(M )
∗
erhalten. Sämtliche Produktionen der Ableitung qa → Bk q0 wBs sind längenerhaltend. Wenn
die Maschine M aber in-place arbeitet, erhalten wir deshalb die Äquivalenz
∗
qa → q0 w ⇔ w ∈ L(M ).
6.5. KOMPLEXITÄTSKLASSEN UND DIE CHOMSKY HIERARCHIE
191
Mit anderen Worten, wenn L ∈ Nspace(n), dann besitzt q0 L eine kontextsensitive Grammatik.
Wir sind fertig, denn:
Aufgabe 126
Wenn q0 L kontextsensitiv ist, dann ist auch L kontextsensitiv.
(c) Für die Beziehung
NL ⊆ LOGCFL
genügt der Nachweis, dass D-REACHABILITY mit einer LOGSPACE-Reduktion auf eine
kontextfreie Sprache L reduziert werden kann. Wir beschreiben L, indem wir einen Kellerautomaten K angeben, der L akzeptiert.
K nimmt an, dass die Eingabe w ein Element von (a∗ b∗ )∗ ist und interpretiert ein Teilwort
ar bs als die Kante von Knoten r nach Knoten s; ein mehrmaliges Auftreten von Kanten ist
erlaubt.
K rät einen Weg von Knoten 1 nach Knoten 2,
- indem es eine erste Kante (1, u) rät und u auf den Keller legt.
- Der Knoten v liege gegenwärtig auf dem Keller. K rät eine Kante (v 0 , w), die in der
Eingabe nach den bisher geratenen Kanten erscheint.
– Mit Hilfe des Kellers verifiziert K, dass v = v 0 gilt. Gilt v 6= v 0 , verwirft K.
– K legt w auf den Keller und akzeptiert, wenn w = 2.
– Für w 6= 2 wiederholt K sein Vorgehen.
Wir beschreiben eine LOGSPACE-Reduktion von D-REACHABILITY auf L. Für einen gerichteten Graphen G zählen wir die Anzahl n der Kanten. Danach geben wir die Kanten, in
einer jeweils beliebigen Reihenfolge, genau n − 1 Mal aus. Der Kellerautomat K, wenn auf
die Ausgabe angesetzt, findet genau dann einen Weg von Knoten 1 nach Knoten 2, wenn ein
solcher Weg in G existiert.
Die verbleibende Beziehung „LOGCFL⊆ Dspace(log22 n)“ folgt aus der nächsten Übungsaufgabe.
Aufgabe 127
Zeige, dass das Wortproblem für kontextfreie Sprachen in Dspace(log22 n) liegt.
(d) Die Behauptung folgt aus Satz 6.2.
(e) Beachte, dass L1 eine echte Teilmenge von L0 ist, da alle Sprachen in L1 entscheidbar
sind. Die restlichen (echten) Inklusionen haben wir in den obigen Beispielen nachgewiesen. Wie schwierig ist das Wortproblemn für die Klasse der kontextsensitiven Sprachen? Viel
zu schwierig, denn das NP-vollständige Erfüllbarkeitsproblem ist kontextsensitiv. Aber die
Situation ist sogar noch viel schlimmer, denn das Wortproblem ist, wie wir gleich sehen
werden, sogar PSPACE-vollständig.
Satz 6.17 (Das Wortproblem für kontextsensitive Sprachen)
(a) Die Sprache KNF-SAT ist kontextsensitiv.
(b) Das Wortproblem für kontextsensitive Sprachen ist PSPACE-vollständig.
192
KAPITEL 6. SPEICHERPLATZ-KOMPLEXITÄT
Beweis (a): Wir können natürlich eine erfüllende Belegung auf linearem Platz raten und
verifizieren. Die Behauptung folgt also aus Satz 6.16 (b).
(b) ist eine Konsequenz der folgenden Übungsaufgabe.
Aufgabe 128
Zeige, dass das Wortproblem für kontextsensitive Sprachen PSPACE-vollständig ist.
Wie verhalten sich die Klassen P, NP und PSPACE zu den Klassen der Chomsky-Hierarchie?
Satz 6.18
(a) L3 ⊂ L2 ⊂ P und alle Inklusionen sind echt.
(b) L1 ⊂ PSPACE ⊂ L0 und alle Inklusionen sind echt.
Beweis (a): Da das Wortproblem in Zeit O(|w|3 ) lösbar ist, gehören alle kontextfreien Sprachen zur Klasse P. Die Sprache {ak bk ck | k ∈ N} ist nicht kontextfrei, gehört aber natürlich
zur Klasse P. Also ist L2 eine echte Teilmenge von P.
(b) In Satz 6.16 haben wir gezeigt, dass L1 = Nspace(n) gilt. Damit folgt L1 ⊆ Dspace(n2 )
aus dem Satz von Savitch. Schließlich können wir Dspace(n2 ) ⊂ PSPACE aus der Speicherplatz-Hierarchie von Satz 6.1 folgern.
Wiederum aus Satz 6.16 wissen wir, dass L0 mit der Klasse der rekursiv aufzählbaren Sprachen
übereinstimmt. Da jede Sprache in PSPACE entscheidbar ist, muss die Inklusion PSPACE
⊂ L0 echt sein.
6.6
Probabilistische Turingmaschinen und Quantenrechner
Um „wieviel mächtiger“ sind probabilistische Turingmaschinen oder Quanten-Turingmaschinen
im Vergleich zu „stink-normalen“ deterministischen Turingmaschinen?
Wir führen zuerst probabilistische Turingmaschinen ein. Eine probabilistische Turingmaschine
M wird durch den Vektor
M = (Q, Σ, δ, q0 , Γ, F )
beschrieben. Die Überführungsfunktion δ hat, im Gegensatz zu deterministischen Turingmaschinen die Form
δ : Γ × Q × Γ × Q × {links, bleib, rechts} −→ [0, 1] ∩ Q
und weist jedem möglichen Übergang
(γ, q) −→ (γ 0 , q 0 , Richtung)
die Wahrscheinlichkeit
δ(γ, q, γ 0 , q 0 , Richtung)
zu. Wir verlangen, dass für jedes Paar (γ, q) ∈ Γ × Q eine Wahrscheinlichkeitsverteilung auf
den Übergängen vorliegt. Das heißt, wir fordern für jedes Paar (γ, q) die Bedingung
X
(γ 0 ,q 0 ,Richtung)∈Γ×Q×{links,bleib,rechts}
δ(γ, q, γ 0 , q 0 , Richtung) = 1.
6.6. PROBABILISTISCHE TURINGMASCHINEN UND QUANTENRECHNER
193
Wie arbeitet eine probabilistische Turingmaschine M ? Für Eingabe x wird M potenziell viele
Berechnungen ausführen. Als Berechnung bezeichnen wir dabei die Folge von Konfigurationen
B : C0 → C1 → C2 → . . . → Cm ,
die die Maschine durchläuft. Die Konfiguration C0 ist die Konfiguration, bei der der Bandinhalt die Eingabe ist, der aktuelle Zustand der Anfangszustand q0 und der Lese-/Schreibkopf
in der Ausgangsposition ist. Als Wahrscheinlichkeit einer Berechnung bezeichnen wir das
Produkt aller Übergangswahrscheinlichkeiten. Also
prob(B) =
m−1
Y
pi
i=0
wenn pi die Wahrscheinlichkeit des Übergangs von Konfiguration Ci zu Konfiguration Ci+1
bezeichnet. Wie sollen wir die von einer probabilistischen Turingmaschine M akzeptierte
Sprache definieren? Es liegt nahe, für jede Eingabe x die Wahrscheinlichkeit akzeptierender
Berechnungen, also
X
px =
prob(B)
B ist akzeptierende Berechnung von x
zu messen.
Definition 6.5 Sei M eine probabilistische Turingmaschine, dann ist
LM = x ∈ Σ∗ |px >
1
2
die von M akzeptierte Sprache. Wir sagen, dass M beschränkten Fehler besitzt, falls es > 0
gibt, so dass stets px ≤ 12 − gilt, falls x nicht zur Sprache L gehört und px ≥ 12 + gilt, falls
x zur Sprache L gehört.
Probabilistische Berechnungen mit beschränktem Fehler sind ein sinnvolles und in der Praxis
nützliches Berechnungsmodell: Wenn wir eine Berechnung k-mal für eine vorgegebene Eingabe
x laufen lassen und das Mehrheitsergebnis übernehmen, dann wird die Wahrscheinlichkeit
eines Fehlers höchstens
2−Ω(k)
sein. (Warum ?)
Die Berechnungskraft probabilistischer Turingmaschinen mit unbeschränktem Fehler hingegen
ist immens. So kann man zum Beispiel zeigen, dass nichtdeterministische Turingmaschinen
ohne Zeitverlust simuliert werden können.
Satz 6.19 Sei M eine probabilistische Turingmaschine (mit nicht notwendigerweise beschränktem Fehler). Wenn die worst-case Laufzeit einer jeden Berechnung für Eingaben der Länge n
durch t(n) beschränkt ist, dann gilt
L(M ) ∈ Dspace(t).
Beweisskizze : Die höchstens 2O(t(n)) Berechnungen für eine vorgegebene Eingabe x werden
nacheinander simuliert. Ein Zähler summiert die Wahrscheinlichkeiten akzeptierender Berechnungen (auf O(t(n)) Zellen). Nachdem alle Berechnungen simuliert sind, wird geprüft, ob der
Zähler einen Wert größer 12 hat, und in diesem Fall wird akzeptiert.
194
KAPITEL 6. SPEICHERPLATZ-KOMPLEXITÄT
Wir kommen als nächstes zu einer allerdings nur recht oberflächlichen Beschreibung von
Quantenrechnern. Zu Anfang erinnern wir an das Rechnen mit komplexen Zahlen.
√ C = {x +
iy | x, y ∈ R} bezeichnet die Menge der komplexen Zahlen und es ist i = −1. Für die
komplexe Zahl z = x + iy ist z̄ = x − iy die Konjugierte von z. Die Länge von z ist durch
|z| =
q
x2 + y 2
definiert und für komplexe Zahlen z1 , z2 ∈ C mit zk = xk + iyk ist
z1 + z2 = x1 + x2 + i(y1 + y2 )
z1 · z2 = x1 · x2 − y1 · y2 + i(x1 · y2 + x2 · y1 ).
Die Grobstruktur eines Quantenrechners ähnelt der einer probabilistischer Turingmaschine.
Diesmal hat aber die Überführungsfunktion δ die Form
δ : Γ × Q × Γ × Q × {links, bleib, rechts} −→ Q + iQ
wobei nur komplexe Zahlen der Länge höchstens 1 zugewiesen werden. Wie im Fall probabilistischer Turingmaschinen gibt es zu jedem Paar (γ, q) ∈ Γ × Q potentiell viele Übergänge,
wobei diesmal
X
|δ(γ, q, γ 0 , q 0 , Richtung|2 = 1
γ 0 ,q 0 ,Richtung
gelten muß. Wir sagen, dass
δ(γ, q, γ 0 , q 0 , Richtung)
die (Wahrscheinlichkeits-)Amplitude ist und, dass
|δ(γ, q, γ 0 , q 0 , Richtung)|2
die zugewiesene Wahrscheinlichkeit ist. Bisher haben wir nur eine merkwürdige Darstellung
der Wahrscheinlichkeit eines Übergangs kennengelernt, der wesentliche Unterschied zu den
probabilistischen Turingmaschinen folgt aber sofort: Wir weisen jeder Berechnung B das Produkt pB der ihren Übergängen entsprechenden Wahrscheinlichkeitsamplituden zu. Charakteristischerweise werden wir im Allgemeinen aber viele Berechnungen haben, die in derselben
Konfiguration C enden. Wir weisen der Konfiguration C die Wahrscheinlichkeitsamplitude
X
τC =
pB
B führt auf C
zu und definieren
|τC |2
als die Wahrscheinlichkeit der Konfiguration C. Die von einem Quantenrechner Q akzeptierte
Sprache definieren wir dann als
L(Q) =




1 
|τC |2 > ,
2 
ist akzeptierende Konfiguration von Q auf Eingabe x
X
x|
C
analog zu probabilistischen Turingmaschinen.
Unsere Beschreibung ist zu diesem Zeitpunkt unvollständig: Das beschriebene Rechnermodell
ist weitaus mächtiger als das Modell der Quantenrechner. Deshalb noch einmal ein Ausflug
in die komplexe Zahlen.
6.6. PROBABILISTISCHE TURINGMASCHINEN UND QUANTENRECHNER
195
Für eine Matrix A = (zi,j )1≤i,j≤n mit komplexwertigen Einträgen ist
A = (zj,i )1≤i,j≤n
die konjugiert Transponierte von A. Wir nennen A unitär, falls
A · A = Einheitsmatrix.
Wir halten jetzt in der Konfigurationsmatrix AQ die Wahrscheinlichkeitsamplituden eines
1-Schritt Übergangs zwischen je zwei Konfigurationen C und C 0 fest. Also
AQ [C, C 0 ] = Wahrscheinlichkeitsamplitude des Übergangs von C nach C 0 .
Eine Quantenberechnung liegt vor, wenn die Matrix AQ unitär ist.
Satz 6.20 Wenn ein Quantenrechner Q die Sprache L(Q) in Zeit t(n) akzeptiert, dann ist
L(Q) ∈ Dspace(t2 ).
Hierzu ist die Forderung eines beschränkten Fehlers ebenso nicht notwendig wie die Forderung,
dass die Konfigurationsmatrix AQ unitär ist.
Beweisskizze : Die simulierende deterministische Turingmaschine wird die Einträge des
Matrix/Vektor-Produkts
t(n)
AQ
·v
nacheinander berechnen und die Wahrscheinlichkeiten akzeptierender Konfigurationen aufsummieren. Es wird akzeptiert, falls die Summe größer als 1/2 ist. Warum funktioniert dieser
Ansatz, wenn wir den Vektor v durch
(
vi =
0 i 6= Startkonfiguration
1
sonst
definieren? Der Vektor AQ ·v gibt die Wahrscheinlichkeitsamplituden der 1-Schritt Nachfolger
der Startkonfiguration wieder und allgemeiner listet der Vektor AkQ · v die Wahrscheinlichkeitsamplituden der k-Schritt Nachfolger auf. Im letzten Schritt (also k = t(n)) müssen wir dann
nur noch von den Wahrscheinlichkeitsamplituden zu den Wahrscheinlichkeiten übergehen.
t(n)
Wie berechnet man aber AQ · v in Platz O(t2 (n))? Die Matrix AQ besitzt ja 2O(t(n)) Zeilen
und Spalten! Hier ist ein Tip: Der Vektor AkQ · v kann in Platz O(k · t(n)) berechnet werden.
Selbst bei unbeschränktem Fehler liegen also Sprachen, die von probabilistischen Turingmaschinen oder von Quanten-Turingmaschinen in polynomieller Zeit akzeptiert werden, in
PSPACE. Diese Aussage gilt selbst bei unbeschränktem Fehler.
196
6.7
KAPITEL 6. SPEICHERPLATZ-KOMPLEXITÄT
Zusammenfassung
Wir haben zuerst deterministische Speicherplatzklassen untersucht. Wir haben gesehen, dass
die auf Speicherplatz o(log2 log2 n) berechenbaren Sprachen mit den regulären Sprachen übereinstimmen und deshalb „bringt ein zu kleiner Speicherplatz nichts Neues“.
Die erste nicht-triviale Klasse ist die Klasse DL aller auf logarithmischem Platz berechenbaren Sprachen. Wir haben die Grenzen der Berechnungskraft von DL am Beispiel von DREACHABILITY betrachtet. Wir haben das Konzept der Log-Space Reduktionen entwickelt,
um zu zeigen, dass D-REACHABILITY NL-vollständig ist, also ein schwierigstes Problem in
NL ist, der Klasse aller in logarithmischem Platz nichtdeterministisch lösbaren Entscheidungsprobleme. (Insbesondere folgt, dass NL in P enthalten ist.) Weitere NL-vollständige Probleme
sind 2-SAT, das Wortproblem für NFA und der Test auf Bipartitness.
Der Satz von Savitch weist nach, dass Nichtdeterminismus nur zu einem quadratischen Speicherplatzgewinn führt, da Nspace(s) ⊆ Dspace(s2 ) für platz-konstruierbare Funktionen s
gilt. Auch das Komplementverhalten ist „nicht typisch für Nichtdeterminismus“, denn es ist
überraschenderweise Nspace(s) = coNspace(s), falls s platz-konstruierbar ist.
Schließlich haben wir die wichtige Komplexitätsklasse PSPACE definiert. PSPACE lässt sich als
die Komplexitätsklasse nicht-trivialer Zwei-Personen Spiele auffassen, da das Problem der
quantifizierten Booleschen Formeln PSPACE-vollständig ist. Entscheidungsprobleme für reguläre Ausdrücke oder NFA, wie die Universalität, das Äquivalenzproblem oder die Minimierung,
haben sich als unanständig schwierig, nämlich als PSPACE-hart herausgestellt.
Die Klasse PSPACE ist mächtig und enthält alle Entscheidungsprobleme, die durch randomisierte Algorithmen oder Quanten-Algorithmen in polynomieller Zeit lösbar sind.
Wir haben dann die Chomsky-Hierarchie betrachtet. Die rekursiv aufzählbaren Sprachen sind
genau die Sprachen, die von unbeschränkten Grammatiken erzeugt werden können. Selbst die
kontextsensitiven Sprachen sind noch zu komplex, da ihr Wortproblem PSPACE-vollständig
sein kann. (Beachte, dass die Klasse PSPACE die Klasse NP enthält und dementsprechend ist
eine Lösung eines PSPACE-vollständigen Wortproblems in aller Wahrscheinlichkeit noch sehr
viel komplexer als die Lösung eines NP-vollständigen Problems.) Demgegenüber stehen die
kontextfreien Sprachen, deren Wortproblem bei Beschränkung auf deterministisch kontextfreie
Sprachen sogar in Linearzeit gelöst werden kann.
Kapitel 7
Parallelität
Das Textbuch „Limits to Parallel Computation: P-Completeness Theory“, von Raymond
Greenlaw, James Hoover und Walter Ruzzo, Oxford University Press (1995) ist eine sehr
gute Referenz für die Inhalte dieses Kapitels1 .
Wann ist ein algorithmisches Problem parallelisierbar und welcher Grad an Parallelisierbarkeit wird erreicht? Diese Frage haben wir bereits in Abschnitt 2.3.4 angesprochen und die
fundamentalen Klassen
ACk , NCk und NC
definiert.
Die Komplexitätsklasse NC ist unsere Definition der Klasse parallelisierbarer Probleme. NC
steht für „Nick’s Class“ (nach ihrem Autor Nick Pippenger). AC steht für „Alternating Circuits“, d.h. Schaltkreise die alternierend aus Schichten von UND- bzw. ODER-Gattern aufgebaut sind.
Der folgende Satz stellt eine Beziehungen zwischen den eingeführten Komplexitätsklassen und
zur Klasse P her.
Satz 7.1 Für alle k ∈ N gilt
(a) ACk ⊆ NCk+1 ⊆ ACk+1 .
(b) AC = NC ⊆ P.
Beweis (a): Die Inklusion NCk+1 ⊆ ACk+1 ist offensichtlich. Wir zeigen ACk ⊆ NCk+1 . Sei
(Sn )n∈N eine uniforme Schaltkreisefamilie, die eine Sprache aus ACk akzeptiert. Ein Undbzw. Oder-Gatter mit p Eingängen kann durch einen binären Baum der Tiefe dlog2 pe und
Größe höchstens 2p+1 simuliert werden. Da der Fanin von Sn durch n+Größe(Sn ) beschränkt
ist und da Größe(Sn ) polynomiell in der Eingabelänge n ist, führt die Ersetzung der Knoten
von Sn durch Binärbäume auf eine um höchstens den Faktor O(log2 n) größere Tiefe. Beachte,
daß die Größe durch die Ersetzungen höchstens quadriert wird.
(b) Die Gleichheit AC = NC folgt aus Teil (a). Betrachten wir die Inklusion NC ⊆ P. Sei L ∈ NC.
Dann gibt es eine uniforme Schaltkreisfamilie (Sn )n∈N , die L berechnet. Es genügt zu zeigen,
1
Das Buch kann auch über die Webseite
http://www.cs.armstrong.edu/greenlaw/research/PARALLEL/limits.pdf heruntergeladen werden.
197
198
KAPITEL 7. PARALLELITÄT
daß Sn in polynomieller Zeit konstruierbar und auswertbar ist. Die polynomielle Konstruierbarkeit folgt, da Sn durch eine logarithmisch-platzbeschränkte Turingmaschine berechenbar
ist. Eine Auswertung gelingt mit Tiefensuche in polynomieller Zeit, da Größe(Sn ) = poly(n).
Aufgabe 129
Zeige, dass man zwei Binärzahlen in AC0 addieren kann (d.h. jedes Bit der Summe in AC0 berechnen kann).
Aufgabe 130
Es sei ein nichtnegativ gewichteter, gerichteter Graph als Distanzmatrix mit Einträgen einer bestimmten
Bitlänge gegeben. Es soll für alle Knotenpaare die Länge des kürzesten Weges zwischen ihren Knoten bestimmt
werden. Hierzu wird ein paralleler Algorithmus gesucht, der ähnlich wie Floyds Algorithmus arbeitet. Der
Algorithmus soll mit den Ressourcen von NC2 arbeiten.
SC Hinweis: Betrachte eine Matrixmultiplikation, bei der statt der normalen Multiplikation die Addition und
statt der normalen Addition die Minimumbestimmung verwendet wird und wende diese auf das Problem an.
Aufgabe 131
Eine Formel ist ein Schaltkreis mit Fanin 2 und Fanout 1, d.h. die Graphstruktur einer Formel ist ein Baum.
Die Größe einer Formel ist die Anzahl der Blätter.
(a) Zeige: Jede Funktion in NC1 hat eine polynomiell große Formel.
(b) Zeige: Wenn f eine Formel der Größe N hat, dann hat f eine äquivalente Formel der Tiefe O(log2 N ).
Aufgabe 132
Die Klasse N-AC02 bestehe aus uniformen Schaltkreisfamilien mit unbeschränktem Fanin und Tiefe 2, die nichtdeterministisch arbeiten, d.h., die zusätzlich zur „normalen“ Eingabe ein nichtdeterministisches Ratewort lesen
und entsprechend akzeptieren.
Zeige: NP = N-AC02 .
7.1
Parallele Rechenzeit versus Speicherplatz
Welche Funktionen können uniforme Schaltkreisfamilien in Tiefe s(n) berechnen? Angenommen, die uniforme Schaltkreisfamilie (Sn )n∈N hat Tiefe s(n) = Ω(log2 n). Wir führen auf
dem Schaltkreis in umgekehrter Richtung, also von der Senke zu den Quellen, eine Tiefensuche durch, um die Ausgabe des Schaltkreises Sn speicherplatz-effizient zu berechnen. Anstatt
den gesamten Schaltkreis zu speichern, leiten wir jedes Mal die für den Abruf einer speziellen benötigten Information über Sn alle durch die Beschreibung des Schaltkreises gegebenen
Informationen. Das gelingt mit Speicherplatz O(s(n)).
Wir speichern den Weg der Tiefensuche durch die Bitfolge ~b ab. Falls bi = 1 (bzw. bi = 0), ist
der (i +1)-te Knoten des Wegs der rechte (bzw. linke) Nachfolger des i-ten Knoten. Die Länge
der Liste ist proportional zur Tiefe s(n) und die Turingmaschine rechnet mit Speicherplatz
O(s(n)). Wir haben also gerade nachgewiesen, dass
DEPTHuniform (s) ⊆ Dspace(s)
gilt. Um die umgekehrte Fragestellung, nämlich die Simulation von „Speicherplatz“ durch
„Tiefe“ zu untersuchen, betrachten wir die transitive Hülle von Graphen.
Lemma 7.2 Konstruiere uniforme Schaltkreisfamilien (mit unbeschränktem) Fanin, so dass
(a) zwei Boolesche n × n-Matrizen in Tiefe zwei mit O(n3 ) Gattern multipliziert werden und
(b) die transitive Hülle eines Graphen in Tiefe O(log2 n) und Größe O(n3 log2 n) mit unbeschränktem Fanin berechnet wird.
7.1. PARALLELE RECHENZEIT VERSUS SPEICHERPLATZ
199
Beweis (a): Offensichtlich kann ein Schaltkreis das Produkt
(A · B)[i, j] =
n
_
A[i, k] ∧ B[k, j]
k=1
in Tiefe zwei mit O(n3 ) Gattern berechnen.
(b) Sei A die Adjazenzmatrix eines gerichteten Graphen mit n Knoten und sei En die n × n
Einheitsmatrix. Man beweist durch Induktion über d, dass es genau dann einen Weg der
Länge d von i nach j gibt, wenn Ad [i, j] = 1.
Ein Weg von i nach j darf auf jedem seiner Knoten für mehrere Schritte verweilen. Mit
anderen Worten, es gibt genau dann einen Weg von i nach j, wenn (A ∨ En )n [i, j] = 1.
Die Matrix (A ∨ En )n kann mit wiederholtem Quadrieren für eine Zweierpotenz n schnell
berechnet werden.
B := A ∨ En ;
FOR i = 1 TO log2 n DO
B := B 2 ;
Jeder Quadrierungsschritt gelingt in Tiefe zwei und Größe O(n3 ) ist ausreichend. Wir haben
durch Übereinandersetzen von log2 n Schaltkreisen zur Matrizenmultiplikation die transitive Hülle in Tiefe O(log2 n) und Größe O(n3 log2 n) berechnet. Beachte, daß die erhaltene
Schaltkreisfamilie uniform ist (Warum? Wie geht man vor, wenn n keine Zweierpotenz ist?).
Wir können jetzt die enge Kopplung zwischen den Komplexitätsmaßen „Speicherplatz“ und
„Tiefe“ präzisieren.
Satz 7.3 Sei s : N → N mit s(n) = Ω(log2 n) gegeben. Die Funktion s sei platz-konstruierbar.
Dann ist
Dspace(s) ⊆ Nspace(s) ⊆ DEPTH − SIZEuniform (s2 , 2O(s) ) ⊆ Dspace(s2 ).
Beweis: Wir wissen, dass DEPTHuniform (s) ⊆ Dspace(s) gilt. Also genügt der Nachweis von
Nspace(s) ⊆ DEPTH − SIZEuniform (s2 , 2O(s) ). Sei also M eine nichtdeterministische Turingmaschine, die mit Speicherplatz höchstens s rechnet. Für Eingabe w betrachten wir den Berechnungsgraphen GM (w). Wir haben zu entscheiden, ob es einen Weg vom Startknoten zu einem
akzeptierenden Knoten in GM (w) gibt. Offensichtlich kann man annehmen, dass es genau
eine akzeptierende Konfiguration gibt, und wir müssen das Problem D-REACHABILITY für
GM (w) lösen
GM (w) hat höchstens N = 2O(s(n)) Knoten. Wir berechnen zuerst GM (w) und lösen sodann DREACHABILITY mit Lemma 7.2 in Tiefe O(log2 N ) = O(s) und Größe O(s(n)N 3 ) = 2O(s(n))
durch eine uniforme Schaltkreisfamilie2 . Um den Fanin von maximal 2O(s(n)) auf zwei zu
drücken, muss die Tiefe von O(s) auf O(s2 ) erhöht werden, die Größe ändert sich dabei
höchstens polynomiell.
Aufgabe 133
Zeige, dass NL ⊆ AC1 gilt.
2
Um die Schaltkreisfamilie uniform zu konstruieren, muss die Platzkonstruierbarkeit von s(n) gefordert
werden.
200
7.2
KAPITEL 7. PARALLELITÄT
P-Vollständigkeit
Wir möchten die vom Standpunkt der Parallelisierbarkeit „schwierigsten“ Probleme in P bestimmen und wählen die LOGSPACE-Reduzierbarkeit, um die Parallelisierbarkeit zweier vorgegebener Sprachen zu vergleichen. Weshalb betrachten wir die LOGSPACE-Reduktion?
Lemma 7.4
(a) DL ⊆ NC2 .
(b) Zwei Sprachen L1 , L2 ⊆ {0, 1}∗ seien gegeben. Aus L1 ≤LOG L2 und L2 ∈ NC folgt
L1 ∈ NC.
Beweis (a): ist eine direkte Konsequenz von Satz 7.3.
(b) Nach Definition existiert eine deterministische, logarithmisch-platzbeschränkte Turingmaschine M mit
w ∈ L1 ⇔ M (w) ∈ L2 .
Da M logarithmisch-platzbeschränkt ist, kann jedes Ausgabebit von M durch eine Schaltkreisfamilie (Tn |n ∈ N) mit polynomieller Größe und Tiefe O(log22 n) berechnet werden, denn
DL ⊆ NC2 . Wenn also L2 durch die uniforme Schaltkreisfamilie (Sn |n ∈ N) polynomieller Größe und polylogarithmischer Tiefe erkannt wird, so ist auch L1 in polynomieller Größe und
polylogarithmischer Tiefe erkennbar. Daher ist L1 ∈ NC.
Da DL ⊆ NC2 gilt, sind alle Sprachen in DL parallelisierbar. Insbesondere ist die LOGSPACEReduktion durch einen Schaltkreis polynomieller Größe und der Tiefe O(log2 n) simulierbar.
Aus Teil (b) folgt aus L1 ≤LOG L2 , dass L1 parallelisierbar ist, wenn L2 parallelisierbar
ist. Trotzdem ist Lemma 7.4 kein entscheidender Grund für die LOGSPACE-Reduktion, da
die Aussage auch für andere Reduktionen gilt. Zum Beispiel könnten wir statt LOGSPACEReduktionen als Transformation eine uniforme Schaltkreisfamilie mit Tiefe poly(log2 n) und
Größe poly(n) zulassen. Zwar ist ein solcher Ansatz legal und wird gelegentlich auch benutzt, allerdings werden meistens „starke“ Transformationen nicht benötigt: Die „schwache“
LOGSPACE-Reduktion genügt sogar, um die wichtigsten NP-Vollständigkeitsergebnisse zu
etablieren. Wir arbeiten daher im weiteren nur mit der LOGSPACE-Reduktion.
Definition 7.1
(a) Eine Sprache L heißt genau dann P-hart, wenn K ≤LOG L für alle Sprachen K ∈ P gilt.
(b) Eine Sprache L heißt genau dann P-vollständig, wenn L ∈ P und wenn L P-hart ist.
Die P-vollständigen Sprachen sind die vom Standpunkt der Parallelisierbarkeit die schwierigsten Sprachen in P: Wenn eine P-vollständige Sprache parallelisierbar ist, dann stimmen NC
und P überein und alle Sprachen in P wären überraschenderweise parallelisierbar.
Lemma 7.5 Sei L eine P-vollständige Sprache. Dann gilt:
P = NC ⇔ L ∈ NC.
Beweis ⇒: Da L ∈ P und da nach Voraussetzung P = NC, ist L ∈ NC.
⇐. Nach Voraussetzung ist L ∈ NC. Da L P-vollständig ist, gilt K ≤LOG L für alle K ∈ P.
Aus Lemma 7.4 folgt K ∈ NC für alle K ∈ P, also folgt P ⊆ NC. Nach Satz 7.1 gilt NC ⊆ P, und
wir erhalten die Behauptung.
7.2. P-VOLLSTÄNDIGKEIT
7.2.1
201
Das Circuit Value Problem
Für einen Schaltkreis S sei hSi die Binärkodierung eines Programmes, das
• die Gatter von S in irgendeiner Reihenfolge aufzählt,
• jedem Gatter seine Funktion zuweist,
• sämtliche Kanten aufzählt und
• jeder Quelle eine Bitposition der Eingabe zuweist.
In diesem Abschnitt werden wir unsere erste P-vollständige Sprache kennenlernen, das CircuitValue-Problem (CVP). Das Problem CVP spielt als generisches Problem dieselbe Rolle wie das
Erfüllbarkeitsproblem KNFSAT für die NP-Vollständigkeit, QBF für die PSPACE-Vollständigkeit
oder D-REACHABILITY für die NL-Vollständigkeit.
Definition 7.2 Wir nehmen an, daß der Fanin für alle zu betrachtenden Schaltkreise höchstens zwei ist.
(a) Die Sprache des Circuit-Value Problem ist gegeben durch
CVP = {hSix | S ist ein Schaltkreis mit Eingabe x und S(x) = 1.}
(b) Ein monotoner Schaltkreis besteht nur aus den Gatter ∧ und ∨. Die Sprache des monotonen Circuit-Value Problems ist gegeben durch
M − CVP = {hSix | der monotone Schaltkreis S akzeptiert die Eingabe x }.
(c) Ein NOR-Schaltkreis besteht nur aus NOR-Gattern. Die Sprache des NOR-CircuitValue Problems ist gegeben durch:
NOR − CVP = {hSix | der NOR-Schaltkreis S akzeptiert die Eingabe x }.
Lemma 7.6 Die Sprachen CVP, M − CVP und NOR − CVP liegen in P.
Beweis: Ein Schaltkreis der Größe s mit n Eingaben kann sequentiell zum Beispiel mit Hilfe
der Tiefensuche in Zeit O(s + n) ausgewertet werden.
Das zentrale Resultat dieses Abschnitts ist die P-Vollständigkeit des Circuit-Value Problems.
Satz 7.7 CVP ist P-vollständig.
Beweis: Nach Lemma 7.6 ist CVP eine Sprache in P. Wir müssen noch zeigen, daß CVP
P-hart ist. Sei L eine beliebige Sprache in P. Wir zeigen die Reduktion L ≤LOG CVP.
Was ist über L bekannt? Es gibt eine deterministische Turingmaschine M , die L in höchstens t(n) Schritten akzeptiert. Die Schrittzahl t(n) ist durch ein Polynom q(n) nach oben
beschränkt. Um die geforderte Reduktion zu konstruieren, simulieren wir M für Eingaben
der Länge n durch einen Schaltkreis Sn .
Wir simulieren M mit einem Schaltkreis Sn , dessen Grobstruktur einem zwei-dimensionalen
Gitter entspricht. Die „i-te Zeile“ des Gitters gibt Bandinhalt, Kopfposition und Zustand
von M zum Zeitpunkt i wieder. Die i-te Zeile ist aus identischen kleinen Schaltreisen Si,j
aufgebaut, wobei Si,j die Zelle j zum Zeitpunkt i simuliert. Ein solcher kleiner Schaltkreis
Si,j muß
202
KAPITEL 7. PARALLELITÄT
• den von Schaltkreis Si−1,j berechneten Bandinhalt speichern können, falls der Kopf von
M zum Zeitpunkt i die Zelle j nicht besucht und sonst
• den Bandinhalt verändern, abhängig vom gegenwärtigen Zustand und vom gegenwärtigen Bandinhalt. Weiterhin muss Si,j in diesem Fall den neuen Zustand und die Richtung
des Kopfes festlegen.
Diese Aufgaben lassen sich durch einen Schaltkreis konstanter Größe bewerkstelligen, wenn wir
die Ausgänge von Si−1,j−1 , Si−1,j und Si−1,j+1 zu Eingängen von Si,j machen. Die Ausgänge
jedes Schaltkreises müssen
• den Bandinhalt kodieren,
• angeben, ob die Zelle gerade besucht wurde und wenn ja, den neuen Zustand und die
Kopfrichtung spezifizieren.
Beachte, dass sämtliche Schaltkreise Si,j „baugleich“ gewählt werden können, mit Ausnahme der Schaltkreise S0,j , die entweder zu setzen sind (j ∈
/ {1, . . . , n}) oder an die Eingabe
anzuschliessen sind (j ∈ {1, . . . , n}).
Wir müssen das Gitter noch „auswerten“, d.h. wir müssen feststellen, ob der letzte Zustand
akzeptierend ist. Dies gelingt, wenn wir einen binären Auswertungsbaum „auf“ das Gitter setzen. Man beachte, daß der beschriebene Schaltkreis durch eine logarithmisch-platzbeschränkte
Turingmaschine konstruierbar ist.
Bemerkung 7.8 Der Beweis von Satz 7.7 zeigt, dass wir eine polynomiell zeitbeschränkte
Turingmaschine durch eine uniforme Schaltkreisfamilie polynomieller Größe simulieren können. Für den Nachweis von P 6= NP genügt somit der Nachweis, dass irgendein NP-vollständiges
Problem keine polynomiell großen Schaltkreise besitzt.
Satz 7.9 M − CVP und NOR − CVP sind P-vollständig.
Beweis: Nach Lemma 7.6 sind M-CVP und NOR-CVP Sprachen aus P. Wir müssen noch
zeigen, daß die Sprachen P-hart sind.
6
v1 ∨
(v1 , 0) ∨
]
v2
]
(v2 , 0)
¬
6
v3 v4
∧
∨
M
]
x1
x2
(v , 1)
6
x3
∧ i
i
-
(v3 , 0) ∧
∨ (v4 , 0)
M
x1
x2
]
O
(v2 , 1) ∧
1 1
(v , 1)
3
∧
∨
(v4 , 1) x3
M
¬x3
Abbildung 7.1: Beispiel zur Reduktion CVP ≤LOG M-CVP
Wir zeigen die Reduktion CVP ≤LOG M-CVP.
1
∧
¬x2
]
¬x1
7.2. P-VOLLSTÄNDIGKEIT
203
Sei (S, x) eine Eingabe für CVP. Wir „schieben“ sämtliche Negationsgatter hinab zu den
Quellen von S. Da
¬(u ∧ w) ⇔ ¬u ∨ ¬w
¬(u ∨ w) ⇔ ¬u ∧ ¬w
¬(¬u) ⇔ u
bedeutet der Schiebeprozess das Vertauschen von ∧- und ∨-Gattern sowie die Einführung
neuer Quellen für die negierte Eingaben.
Wir ersetzen ein Gatter v durch zwei Gatter (v, 0) und (v, 1) mit den Ausgaben v beziehungsweise ¬v. Die obige Abbildung zeigt ein Beispiel. Formal sieht die Transformation wie folgt
aus:
1. Für jedes Gatter v von S (mit Ausnahme der Senke von S) führen wir zwei Gatter (v, 0)
und (v, 1) ein. Mit (v, 0) simulieren wir das ursprüngliche Gatter, mit (v, 1) simulieren
wir das negierte Gatter. Die Senke s von S wird durch die Senke (s, 0) des neuen
Schaltkreises ersetzt. Wir nehmen an, daß die Senke ein ∧- oder ∨-Gatter war.
2. Für jedes ∧-, ∨- oder ¬-Gatter des alten Schaltkreises fügen wir im neuen Schaltkreis
Verbindungen, wie in den beiden Abbildungen angedeutet, ein.
v
(v, 0)
∧
∧
]
(v, 1)
]
-
∨
]
bzw.
u
w
(u, 0)
(w, 0)
v
(v, 0)
∨
∨
(w, 1)
(v, 1)
]
(u, 1)
]
-
∧
]
bzw.
u
w
(u, 0)
(w, 0)
(u, 1)
(w, 1)
Abbildung 7.2: Ersetzen von ∧- und ∨-Gattern.
3. Wir ersetzen eine Quelle v (mit Eingabe xi ) durch die beiden Quellen (v, 0) (mit Eingabe
xi ) und (v, 1) (mit Eingabe ¬xi ).
Sei S ∗ der neue Schaltkreis (mit gleicher Senke wie S) und sei x∗ die neue Eingabefolge von
S ∗ . Offenbar gilt:
S akzeptiert x ⇔ S ∗ akzeptiert x∗ .
Beachte, dass die Transformation
hSix 7→ hS ∗ ix∗
204
KAPITEL 7. PARALLELITÄT
v
(v, 1)
¬
∧
(v, 0)
6
]
-
u
∧
]
bzw.
(u, 0)
(u, 0)
(u, 1)
(u, 1)
Abbildung 7.3: Ersetzen von ¬-Gattern.
durch eine Turingmaschine mit logarithmischer Platzbeschränkung berechnet werden kann.
Wir zeigen die Reduktion CVP ≤LOG NOR-CVP. Es ist nor(u, v) = ¬(u ∨ v). Jede der Operationen ∧, ∨ und ¬ kann man mit NOR-Gattern darstellen, da nor(u, u) = ¬u, nor(¬u, ¬v) =
u∧v und nor(nor(u, v),nor(u, v)) = u∨v. Eine deterministische, logarithmisch-platzbeschränkte
Turingmaschine kann somit zu jedem {∧, ∨, ¬}-Schaltkreis S einen äquivalenten NOR-Schaltkreis
S ∗ konstruieren. Es gilt
S akzeptiert x ⇔ S ∗ akzeptiert x.
Beachte, dass die Reduktion
hSix 7→ hS ∗ ix
in logarithmischem Platz ausgeführt werden kann.
7.2.2
Die Lineare Programmierung
Wir betrachten als nächstes das Problem der linearen Ungleichungen und der linearen Programmierung.
Definition 7.3 Gegeben ist eine ganzzahlige Matrix A ∈ zm×n sowie Vektoren b ∈ Zm und
c ∈ Zn .
(a) Im Problem der linearen Ungleichungen ist zu entscheiden, ob es einen Vektor x ∈ Qn
mit Ax ≤ b gibt.
(b) Im Problem der linearen Programmierung ist zu entscheiden, ob es einen Vektor x ∈ Qn
mit Ax ≤ b und c · x ≥ t gibt.
Das Problem der linearen Programmierung wird konventionell als Optimierungsproblem formuliert:
Maximiere c · x, so daß Ax ≤ b und x ≥ 0 gilt.
Wir hingegen haben dieses Optimierungsproblem als Entscheidungsproblem formuliert.
Satz 7.10
(a) Das Problem der linearen Ungleichungen ist P-vollständig.
7.2. P-VOLLSTÄNDIGKEIT
205
(b) Das Problem der linearen Programmierung ist P-vollständig.
Beweis: Beide Sprachen liegen in P, denn es existieren Polynomialzeit-Algorithmen. Bekannte
Beispiele für solche Verfahren sind Karmarkars Algorithmus und die Ellipsoid-Methode.
(a) Wir zeigen die Reduktion M-CVP≤LOG Lineare Ungleichungen. Sei (S, x) eine Eingabe
für M-CVP. Wir weisen jedem Gatter von S Ungleichungen zu.
• Beschreibe zuerst die Eingabe x.
– Falls xi = 0, verwende die Ungleichungen xi ≤ 0 und −xi ≤ 0.
– Falls xi = 1, verwende die Ungleichungen xi ≤ 1 und −xi ≤ −1.
• Für ein Gatter v ≡ u ∧ w verwende die Ungleichungen: v ≤ u, v ≤ w, u + w − 1 ≤
v, 0 ≤ v.
• Für ein Gatter v ≡ u ∨ w verwende die Ungleichungen: u ≤ v, w ≤ v, v ≤ u + w, v ≤ 1.
Durch Induktion über die topologische Nummer eines Gatters zeigt man, dass das lineare
Ungleichungssystem genau eine Lösung hat und der gewünschten Lösung entspricht. Wir
fügen noch die Ungleichung
−s ≤ −1
für die eindeutig bestimmte Senke s des Schaltkreises hinzu. S akzeptiert genau dann die
Eingabe x, wenn das konstruierte, lineare Ungleichungssystem lösbar ist.
(b) Die Behauptung folgt, da die Reduktion
lineare Ungleichungen ≤LOG lineare Programmierung
trivial ist.
Korollar 7.11 Das Problem der linearen Ungleichungen und das Problem der linearen Programmierung bleiben sogar dann P-vollständig, wenn man die Koeffizienten der Matrix A und
des Vektors b auf {−1, 0, 1} beschränkt.
7.2.3
Parallelisierung von Greedy-Algorithmen
Greedy-Methoden sind im allgemeinen leicht zu implementieren und führen zu effizienten,
sequentiellen Algorithmen. Leider sind Greedy-Algorithmen häufig inhärent sequentiell. Wir
werden am Beispiel einer Heuristik für das Independent-Set-Problem sehen, dass eine Parallelisierung nicht gelingen wird. (Gleichwohl gibt es andere Heuristiken, die lokale Minima in
polylogarithmischer Zeit bestimmen.)
Sei G = (V, E) ein ungerichteter Graph mit V = {1, . . . , n}. Im Independent-Set Problem ist
eine unabhängige Knotenmenge größter Kardinalität ist zu bestimmen. (Eine Knotenmenge
ist unabhängig, wenn keine zwei Knoten der Menge durch eine Kante verbunden sind.)
Algorithmus 7.1 Heuristik für das Independent-Set-Problem.
Die Eingabe besteht aus einem ungerichteten Graphen G = (V, E) mit V = {1, . . . , n}.
(a) I(G) := ∅ .
206
KAPITEL 7. PARALLELITÄT
w
nor
]
u
v
Abbildung 7.4: Nor-Gatter im Induktionsschritt zu Beweis 7.12
(b) FOR v = 1 TO n DO
IF (v ist nicht mit einem Knoten in I(G) verbunden) THEN I(G) = I(G) ∪ {v}.
(c) Die Menge I(G) wird ausgegeben.
Die Heuristik des Greedy-Algorithmus’ 7.1 findet in jedem Fall ein lokales Minimum (also
eine unabhängige Menge, für die keine echte Obermenge unabhängig ist).
Im Lexicographically-First-Maximal-Independent-Set-Problem (LFMIS) ist ein ungerichteter
Graph G = (V, E) mit V = {1, . . . , n} und ein Knoten v ∈ V gegeben. Es ist zu entscheiden,
ob der Knoten v von Algorithmus 7.1 gewählt wird.
Satz 7.12 Die Sprache LFMIS ist P-vollständig.
Beweis: LFMIS liegt in P, denn die Laufzeit von Algorithmus 7.1 ist linear in n. Wir zeigen
die Reduktion: NOR-CVP ≤LOG LFMIS.
Sei (S, x) die Eingabe für NOR-CVP und sei G = (V, E) die Graphstruktur des Schaltkreises
S. Wir konstruieren einen ungerichteten Graphen G∗ = (V ∗ , E ∗ ) aus dem gerichteten Graphen G: Füge einen neuen Knoten v0 hinzu und setzen genau dann eine Kante {v0 , i} zum
Eingabeknoten i ein, wenn xi = 0 ist. Es ist also
V ∗ = V ∪ {v0 } und E ∗ = {{v0 , i} | xi = 0} ∪ E.
Wir nummerieren die Knoten, so dass v0 die Nummer Eins erhält und die übrigen Nummern
der topologischen Nummerierung des Schaltkreises entsprechen. Durch Induktion über die
Nummerierung zeigen wir
I(G∗ ) = {v0 } ∪ {v ∈ V | Gatter v hat den Wert 1}.
• Verankerung: Da der Algorithmus stets den ersten Knoten in I(G∗ ) aufnimmt, ist
v0 ∈ I(G). Wenn eine Quelle i den Wert Null hat, wird i wegen der Kante {v0 , i}
nicht in I(G∗ ) aufgenommen. Wenn eine Quelle i den Wert Eins hat, wird i in I(G∗ )
aufgenommen.
• Induktionsschritt: Betrachten wir den Knoten w, der im Schaltkreis einem Nor-Gatter
w =nor(u, v) entspricht. Die Nummer der Knoten u und v ist kleiner als die Nummer
von w und es ist w = ¬(u ∨ v) = 0 ↔ (u = 1) ∨ (v = 1). Nach Induktionsannahme
ist u (bzw. v) genau dann in I(G∗ ), wenn u = 1 (bzw. v = 1) ist. Wegen der Kanten
{u, w} und {v, w} nimmt der Algorithmus genau dann w in die Menge I(G∗ ) auf, wenn
das Gatter w den Wert Eins hat.
7.3. ZUSAMMENFASSUNG
207
Die Menge I(G∗ ) besteht also genau aus dem Knoten v0 und allen Knoten mit Ausgabe Eins.
Für die Senke s des NOR-Schaltkreises S ist
S(x) = 1 ⇐⇒ s ∈ I(G∗ )
und dies war zu zeigen.
7.3
Zusammenfassung
Wir haben Schaltkreise als paralleles Rechnermodell gewählt und die Klasse NC aller parallelisierbaren Sprachen eingeführt. Wir haben gesehen, dass ein enger Zusammenhang zwischen
den Komplexitätsmaßen Tiefe und Speicherplatz besteht. Die Parallel-Computation-Thesis
verallgemeinert diesen Zusammenhang auf alle möglichen Modelle paralleler Rechner und
postuliert eine polynomielle Beziehung zwischen der Rechenzeit eines jeden vernünftigen parallelen Rechnermodells und der Speicherplatzkomplexität der berechneten Sprache.
Wir haben die Parallelisierbarkeit von Problemen untersucht und die im Hinblick auf eine Parallelisierung schwierigsten Sprachen, die P-vollständigen Sprachen mit Hilfe der LOGSPACEReduktion eingeführt. Wir haben das P-vollständige Circuit-Value Problem kennengelernt, das
als generisches Problem dieselbe Rolle für die P-Vollständigkeit spielt wie das Erfüllbarkeitsproblem KNFSAT für die NP-Vollständigkeit, QBF für PSPACE oder wie D-REACHABILITY
für die NL-Vollständigkeit. Die Lineare Programmierung wie auch die Bestimmung der lexikographisch ersten maximalen unabhängigen Menge sind weitere P-vollständige Probleme.
Herunterladen
Random flashcards
Medizin

5 Karten Sophia Gunkel

Laser

2 Karten anel1973

Literaturepochen

2 Karten oauth2_google_55780ed8-d9a3-433e-81ef-5cfc413e35b4

Erstellen Lernkarten