GTI Mitschrift

Grundlagen der Theoretischen Informatik
mitgeschrieben von Martin Lenders
Dieses Dokument vom 6. Juli 2009 steht unter einer Creative Commons BY-NC-ND 3.0 Deutschland Lizenz
für die Seite http://page.mi.fu-berlin.de/mlenders/mitschriften/gti/
Inhaltsverzeichnis
1 Turing-Maschine, Berechenbarkeit, Entscheidbarkeit 5

1.1 Definition der Turing-Maschine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2 Church’sche These . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3 Registermaschinen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.4 Formale Sprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.4.1 Multiplikation von Wörtern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.4.2 Multiplikation von Sprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.4.3 Potenz von Wörtern und von Sprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.5 Konfiguration (Momentaufnahme einer Turingmaschine) . . . . . . . . . . . . . . . . . . . . . . . 8
1.6 Turingmaschine mit mehreren Bändern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.7 Die universelle Turingmaschine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.8 Unentscheidbarkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.8.1 Universelle Sprache und Diagonalsprache . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.8.2 Das Halteproblem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.8.3 Reduzierbarkeit von Problemen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.8.4 Das Post’sche Korrespondenzproblem (PKP) . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.8.5 Andere unentscheidbare Probleme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.8.6 Satz von RICE (1953) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2 Reguläre Sprachen und endliche Automaten 17

2.1 Deterministische endliche Automaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.2 Reguläre Ausdrücke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.3 Nichtdeterministische endliche Automaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.4 NEA mit ε-Übergängen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.4.1 Elimination von ε-Übergängen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.5 Minimierung deterministischer endlicher Automaten . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.5.1 Algorithmus zur Bestimmung des Minimalautomaten: . . . . . . . . . . . . . . . . . . . . 25
2.5.2 Satz von Nerode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.6 Das Pumping-Lemma für reguläre Sprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.7 Abschlusseigenschaften regulärer Sprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.8 Zusammenfassung: reguläre Sprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3 Grammatiken 31
3.1 Definition von Grammatiken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.2 Die Chomsky-Hierarchie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.3 Typ-0-Sprachen (rekursiv aufzählbare Sprachen) . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.4 Typ-3-Sprachen (reguläre Sprachen) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.5 Typ-1-Sprachen (kontextsensitive Sprachen) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4 Kontextfreie Sprachen (Typ-2-Sprachen) 35

4.1 Tiefenstruktur von Sprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.2 Dyck-Sprache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.3 Kontextfreie Grammtiken als Gleichungssysteme . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.4 Eindeutigkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.5 Chomsky-Normalform . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.6 Algorithus von CYK“ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
”
4.7 (Erweiterte) Backus-Naur-Form (E)BNF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
4.8 Pumping-Lemma für kontextfreie Sprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
4.9 Abschlusseigenschaften kontextfreier Sprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
4.10 Entscheidungsprobleme kontextfreier Sprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
4.11 Kellerautomaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
3
Inhaltsverzeichnis
4.12 Abschlusseigenschaften kontextfreier Sprachen gegenüber regulären Sprachen . . . . . . . . . . . 48

4.13 Deterministische kontextfreie Sprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
4.14 Deterministische Zweiwege-Kellerautomaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
4.14.1 Teilwortproblem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4
1 Turing-Maschine, Berechenbarkeit,
Entscheidbarkeit
1.1 Definition der Turing-Maschine
Steuerung
(q, a) Programm
Zustand
(Programmzähler)
Schreib−/Lesekopf (q ′ , a′ , b)
B B B 0 1 X B B B
Zweiseitiges, unendliches Band
Eine Turingmaschine wird beschrieben durch:

• Ein Eingabealphabet Σ
• ein Bandalphabet Γ ⊃ Σ
• ein Leerzeichen B ∈ Γ \ Σ
• eine endliche Menge Q von Zuständen
• eine Überführungsfunktion δ : Q × Γ → Q × Γ × {−1, 0, 1}
• ein Anfangszustand q0 ∈ Q
• (eventuell) eine Menge von akzeptierenden Zuständen F ⊆ Q
δ ist das Programm“ der TM
”
• δ(q, a) = (q ′ , a′ , b) bedeutet: Wenn die Maschine im Zustand q ist und unter dem Kopf das Symbol a steht,
dann wird a durch a′ auf dem Band ersetzt (a′ = a ist möglich), das Band wird um b verschoben und die
Maschine geht in den Zustand q ′
• Die Eingabe ist eine Folge von Symbolen aus Σ (ein Wort über Σ). Sie steht am Anfang auf dem Band;
der Kopf steht über dem ersten Symbol. Der Zustand ist q0 .
Beispiel:
Σ = {0, 1}, Γ = {0, 1, B, X}
n n
Erkenne die Eingabe der Form: 0 1 , für n ≥ 1
01, 0011, 000111, ... (richtig)

001, 1100, 0100101, ... (falsch)
rechts und links von der Eingabe stehen unendlich viele B-Symbole
• Phase 1: laufe einmal von links nach rechts über das Band und überprüfe, ob dort eine Folge von 0en
gefolgt von eine Folge von 1en steht.
• Phase 2: Fahre abwechselnd nach links und nach rechts und ersetze jeweils 0 und eine 1 durch X.
Akzeptiere, wenn am Ende alles durch X erstzt ist und kene 0, 1 übrig bleibt
5
KAPITEL 1. TURING-MASCHINE, BERECHENBARKEIT, ENTSCHEIDBARKEIT
δ 0 1 B X Kommentar
q0 (q0 , 0, 1) (q1 , 1, 1) (q− , B, 0) egal fahre nach rechts über Nullen
q1 (q− , 0, 0) (q1 , 1, 1) (q2 , B, −1) egal fahre nach rechts über Einsen
q2 (q3 , X, 1) (q2 , 1, −1) (q4 , B, 1) (q2 , X, −1) fahre nach links und suche 0,
ersetze sie durch X
q3 (q3 , 0, 1) (q2 , X, −1) (q4 , B, 1) (q3 , X, 1) fahre nach rechts und suche 1,
ersetze sie durch X
q4 (q4 , 0, 1) (q− , 1, 1) (q+ , B, 0) (q4 , X, 1) fahre nach rechts und suche 1;
akzeptiere wenn keine 1 mehr
vorhanden ist.
q− (q− , 0, 0) (q− , 1, 0) (q− , B, 0) (q− , X, 0)
q+ (q+ , 0, 0) (q+ , 1, 0) (q+ , B, 0) (q+ , X, 0)
• Die Maschine hält, wenn sie in einen Zustand q über einen Symbol a mit δ(q, a) = (q, a, 0) steht.
Q = {q0 , q1 , q2 , q3 , q4 , q+ , q− }
q0 = q0
F = {q+ }
• Die T. M. akzeptiert die Eingabe, wenn sie in einem Zustand aus F hält.
1.2 Church’sche These

Das was von einer Turing-Maschine berechnet werden kann, entspricht dem, was man intuitiv unter algorith-
”
misch berechenbar“ versteht.
Beispiel: Addition zweier Binärzahlen
Eingabe: bin(x)#bin(y)$ (bin(x) := Binärdarstellung einer positiven Zahl, führende Nullen sind egal)
Ausgabe: bin(x + y)#bin(y)$
Programmiertechniken:
• Verwenden mehrerer Spuren: Jedes Feld des Bandes wird als aus mehreren Unterfeldern beste-
hend betrachtet.
X X X
0 1 1 0 1
formal: Γ = Γ1 × Γ2 × Γ3 × . . . × Γk , Γi . . . Bandalphabet für die i-te Spur.

z. B.: {’ ’, x} × {0, 1, B, . . .}
• Speichern von Variablen mit endlichen Wertebereich als Teil des Zustandes.
formal: Q = Q0 × V , V . . . Wertebereich der Variablen.
1. Wandere nach rechts zur 1. unmarkierten Ziffer a.
s := a (merken)
Markiere diese Ziffer auf dem Band.
2. Wandere nach links zur 1. unmarkierten Ziffer b von x
Ersetze b durch b + s + ü, ü := Übertrag. (Markiere diese Ziffer)
3. Gehe zu 1 solange noch Ziffern übrig sind.
4. Lösche alle Markierungen
qüs , Zustand (Programmzeile) q mit Werten s, ü der Variablen, Haltezustand: h
s ∈ {0, 1}
ü ∈ {0, 1}
Eingabealphabet: Σ = {0, 1, #, $}
Bandalphabet: Γ = Σ ∪ {B, 0̄, 1̄}
6
1.3. REGISTERMASCHINEN
δ 0 1 0̄ 1̄ # $ B Schritt
qü0 qü0 , 0, + q00 , 1, + qü0 , 0̄, + qü0 , 1̄, + rü0 , #, +
rü0 rü0 , 0, + rü0 , 1, + s0ü , 0̄, − s0ü , 1̄, − s0ü , $, − 1
s0ü t0ü , 0̄, − t1ü , 1̄, − u0ü , #, −
tiü t0ü , 0̄, − t1ü , 1̄, − uiü , #, −
ui0 ui0 , 0̄, − ui0 , 1̄, −
u00 q00 , 0̄, + q00 , 1̄, + v00 , 0̄, + 2
u10 , u01 q00 , 1̄, + q00 , 0̄, + v00 , 1̄.+
u11 q10 , 0̄, + q10 , 1̄, + v01 , 0̄.+
vü0 vü0 , 0, + vü0 , 1, + vü0 , 0̄, + vü0 , 1̄, + wü0 , #, +
wü0 rü0 , 0, + rü0 , 1, + x0ü , 0̄, − x0ü , 1̄, −
x0ü yü0 , #, − 3
y00 y00 , 0̄, − y00 , 1̄, − z, B, +
y10 y10 , 0̄, − y10 , 1̄, − z, 1, +
z z, 0, + z, 1, + z, #, + p, $, − 4
p p, 0, − p, 1, − p, #, − h, B, +
• Unterprogrammtechnik
1.3 Registermaschinen
Simulation eines RAM-Speichers auf einer TM:
##x1 #y1 ##x2 #y2 ##...###[Programmcode]
xi ... Adresse, yi ... Inhalt auf Adresse xi
1.4 Formale Sprachen

Σ . . . endliches Alphabet (Vorrat an Zeichen)
Σ∗ . . . alle Wörter endlicher Länge l, die man mit den Buchstaben aus Σ bilden kann.
w = a 1 a 2 a 3 . . . al , a i ∈ Σ
l = |w| Länge des Wortes l ≥ 0
ε ist das leere Wort |ε| = 0
Definition: Eine formale Sprache L ist eine Teilmenge von Σ∗

Beispiel:
L = {0n 1n |n ≥ 1}
L=∅
L = {ε}
7
1.4.1 Multiplikation von Wörtern

u · v = uv (Buchstaben von u und v nebeneinander geschrieben)
Rechenregeln: 1. u · (v · w) = (u · v) · w
2. ∀u ∈ Σ∗ : u · ε = ε · u = u
Beispiel: u = abra
v = kadabra
u · v = abrakadabra
v = kad ·u
1.4.2 Multiplikation von Sprachen

L1 · L2 = {uv|u ∈ L1 , v ∈ L2 }
Rechenregeln: 1. L1 · (L2 · L3 ) = (L1 · L2 ) · L3

2. L · ∅ = ε · u = u
3. L · {ε} = L
Beispiel: L1 = {a,ab} L2 = {a,ba}

L1 · L2 = {aa,aba,abba}
1.4.3 Potenz von Wörtern und von Sprachen
ui = |u · u · u{z· . . . · u}
i−mal
1
u =u
u0 = ε
Li = |L · L {z
· . . . · L} = {u1 · u2 · . . . · ui |u1 ∈ L, u2 ∈ L, . . . , ui ∈ L}
i−mal
L1 = L L0 = {ε}
L∗ := L0 ∪ L1 ∪ L2 ∪ . . .
= Menge der Wörter, die man aus bel. vielen (≥ 0) Bestandteilen ∈ L zusammen multiplizieren kann.
1.5 Konfiguration (Momentaufnahme einer Turingmaschine)
Definition: Eine Konfiguration einer Turingmaschine ist ein Wort aus Γ∗ QΓ∗ , das nicht mit B anfängt oder
aufhört (ein Wort ∈ Γ∗ QΓ∗ \ (B(Γ ∪ Q)∗ ∪ (Γ ∪ Q)∗ B)).
Das Wort xqy mit x, y ∈ Γ∗ und q ∈ Q beschreibt den Zustand der Turingmaschine wo xy auf dem Band
steht und der Kopf über dem ersten Zeichen von y steht Für zwei Konfigurationen k1 und k2 schreibt man
k1 ⊢ k2 wenn die Turingmaschine in einem Schrittvon k1 nach k2 übergeht. (Nachfolgerrelation zwischen
Konfigurationen.)
∗
k1 ⊢ k2 bedeutet, dass auf k1 nach beliebig vielen Schritten (≥ 0) die Konfiguration k2 folgt.
8
1.6. TURINGMASCHINE MIT MEHREREN BÄNDERN
1.6 Turingmaschine mit mehreren Bändern

• Eine Turingmaschine mit k Bändern hat k Schreib-/Leseköpfe.
• Das erste Band ist das Eingabeband.
• Die übrigen Bänder sind zu Beginn leer.
• Die Übergangsfunktion δ : Q × Γk → Q × Γk × {−1, 0, +1}k
Beispiel: binäre Addition von 2 n-Bit Zahlen geht mit 2 Bändern in O(n) Schritten (≤ konst. (n)) (mit einem
Band in O(n2 ) Schritten).
Zuerst wird bin(y) auf das 2. Band kopiert, und dann bitweise von rechts nach links addiert.
Satz: Eine k-Band-Turingmaschine die nach T Schritten hält kann durch eine 1-Band-Turinmaschine simuliert
werden, die in höchstens const.T 2 Schritten hält.
Beweis: Simulation der k Bänder auf k Spuren eines einzigen Bandes. Die Kopfposition der Bänder ist af der
jeweiligen Spur vermerkt.
Γ1 = Γ ∪ (Γ × {X, ’ ’})k ∪ {L}

• L markiert die Position links neben der linkesten Position die die simulierte Turingmaschine auf allen
Bändern besucht hat. In einer konstanten Anzahl von Fahrten über das gesamte Band (ausgehend
von L) kann die Turingmaschine die Bandänderungen auf den k Bändern simulieren.
• Die simulierte Maschine kann in T Schritten höchstens T Schritte nach links und rechts gehen.
• Die Länge des überstrichenen Bandinhalts in jedem Simulationsschritt ist ≤ 2T + 1
• Ein Simulationsschritt geht in ≤ const.T Schritten T -mal ⇒ T 2
∗
• 2 n-Bit Binärzahlen können auf einem k-Band-TM in n · log n · const.log n Schritten multipliziert
werden (Martin Führer 2008, bestehender Rekord vorher const.n·log n log log n (Arnold Schön-
hage ≈ 1970))
log∗ n := min{i| log2 log2 log2 . . . log2 n ≤ 1}
| {z }
-mal
2
.. )
2.
2 i-mal
∗
Die Umkehrfunktion von log ist 2 =2↑i
Definition: Die von einer Turingmaschine M mit einer Teilmenge F ⊆ Q von akzeptierenden Zuständen akzep-
tierte Sprache L(M ) ist die Menge der Wörtern bei deren Eingabe die Maschine einen akzeptierenden
Zustand erreicht (und dann anhält).

∗
∗ ∗
L(M ) = x ∈ Σ q0 x ⊢ yqz, mit y, z ∈ Γ und q ∈ F

M hält in q ∈ F
 → x ∈ L(M )
Eingabe x M hält in q ∈
/F →x∈ / L(M )


M terminiert nicht → x ∈
/ L(M )
9
Definition: Eine Sprache L heißt rekursiv aufzählbar (semi-entscheidbar, engl. recursiv enumerable) wenn es
eine Turingmaschine M mit L = L(M ) gibt.
L heißt entscheidbar (rekursiv), wenn es eine Turingmaschine M gibt, die auf allen Eingaben hält und
mit L = L(M )
Unterscheide: abzählbare (denumerable) Mengen: endlich oder gleichmächtig mit N
Turingmaschine die etwas berechnet: x ∈ Σ∗ steht auf dem Eingabeband.
• Wenn die Maschine hält, steht ein Wort y ∈ Σ∗ auf dem Ausgabeband (bzw. auf dem einzigen Band).
• Die von der Turingmaschine berechnete (partielle) Funktion fM ist definiert auf der Menge A = {x ∈
Σ ∗ |M hält bei Eingabe um x}
fM : A → Σ∗ mit A ⊆ Σ∗
• Eine partielle Funktion f : A → Σ∗ mit A ⊆ Σ∗ oder eine totale Funktion f : Σ∗ → Σ∗ heißt
berechenbar, wenn es eine Turingmaschine M mit f = fM gibt.
1.7 Die universelle Turingmaschine

Eine universelle Turingmaschine liest als Eingabe:
1. Die Beschreibung einer beliebigen Turingmaschine M
2. Die Eingabe für M .
Dann simuliert sie M mit dieser Eingabe und hält genau dann, wenn M hält.
• Die Beschreibung von M wird als hM i ∈ {0, 1}∗ bezeichnet.
• Man nennt hM i die Gödelnummer von M .
Konventionen: a) M hat das Eingabealphabet {0, 1}

b) M hat Zustandsmenge Q = {q1 , q2 , ..., qk }
q1 ist der Startzustand
q2 ist der einzige akzeptierende Zustand
c) M hat Bandalphabet {0, 1, B, 3, 4, 5, . . . , |Γ| − 1} (keine wesentlichen Einschränkungen).
Jetzt müssen wir nur noch δ kodieren:
als Liste von 5-Tupeln: δ(q, a) = (q ′ , b, m) wird als (q, a, q ′ , b, m) geschrieben.
(qi1 , γj1 , qk1 , γl1 , m1 ), (qi1 , γj1 , ...), ...
⇒ |111|0i1 10j1 10j1 10k1 10l1 10m1 |11|0i2 10j2 10j2 10k2 10l2 10m2 |11|...|111|
Beispiel:
δ(q1 , 0) = (q2 , B, −1), δ(q4 , γ5 ) = (q2 , γ5 , +1), ...

⇒ hM i = 111010100100010110000100000100100000100011...111
1.8 Unentscheidbarkeit
1.8.1 Universelle Sprache und Diagonalsprache
Definition: Die universelle Sprache LU ist die Sprache
LU = {hM ix|M akzeptiert x} ⊆ {0, 1}∗
Satz: Es gibt eine universelle Turingmaschine MU mit L(MU ) = LU

Beweisskizze: MU muss zunächst den Anfang der Eingabe bis zum zweiten 111-Block lesen und entscheiden
ob es sich um eine gültige Gödelnummer handelt.
MU kopiert die Beschreibung auf ein zweites Band, und kann anschließend die Maschine M Schritt für
Schritt simulieren.
Wenn die simulierte Maschine M hält, dann hält auch MU (in einem akzeptierenden oder nicht akzep-
tierenden Zustand, je nach M ).
10
1.8. UNENTSCHEIDBARKEIT
Aufzählung aller Wörter aus {0, 1}∗ und aller Turingmaschinen:
w1 = ε
w2 = 0
w3 = 1
w4 = 00
w5 = 01
w6 = 10
w7 = 11
w8 = 000
..
.
M1 , M2 , ..., Mi , ...


 Turingmaschine M , falls wi = hM i ist

Turingmaschine, die einen Schritt
Mi =


 nach links macht, und dann in einem

akzeptierenzen Zustand anhält. falls wi keine gültige Gödelnummer ist
Definition: Die Diagonalsprache D ist
D = {wi | wi ∈
/ L(Mi ) , i = 1, 2, 3, ...}
| {z }
Mi akzeptiert wi nicht.
w1 w2 w3 ··· wi ··· wk ···

M1 +−
M2 + +−
M3 − + −+
M4 + − −
..
.
Mi + +− +
D − − + +
Satz: D ist nicht rekursiv aufzählbar und damit auch nicht entscheidbar.
Beweis durch Widerspruch: Angenommen, es gibt eine Turingmaschine Mk die D akzeptiert:
D = L(Mk ) = {w|Mk akzeptiert w}
Betrachtet das Wort wk :
wk ∈ D
Definition von D
⇐⇒ wk ∈
/ L(MK )
Annahme: Mk akzeptiert die Sprache D
⇐⇒ wk ∈
/D
Satz: Das Komplement D der Diagonalsprache
D = {wi |wi ∈ L(Mi )}
ist rekursiv aufzählbar, aber nicht entscheidbar
11
Beweis: 1. MD überprüft, ob die Eingabe eine gültige Gödelnummer hM i ist,

wenn nein, dann akzeptiere.
2. Wenn ja, verdopple die Eingabe und starte die universelle Turingmaschine:
hMi i wi
| {z }
=wi
akzeptiert genau dann, wenn wi ∈

/ L(Mi )
Nichtentscheidbarkeit folgt aus dem nächsten Satz.
Satz: 1. Eine Sprache L ⊆ Σ∗ ist genau dann entscheidbar, wenn die Komplementärsprache L = Σ∗ − L
entscheidbar ist.
2. L ist genau dann entscheidbar, wenn sowohl L als auch L rekursiv aufzählbar sind.
Beweis: 1. Drehe die Angabe des Entscheidungsalgorithmus um.
2. L entscheidbar ⇒ L entscheidbar ⇒ L, L rekursiv aufzählbar.
⇐ M1 akzeptiert L, M2 akeptiert L
Lasse M1 und M2 parallel“ laufen (abwechselnd) auf derselben Eingabe x ∈ Σ∗

”
Wenn x ∈ L, dann terminiert M1 .
Wenn x ∈ L, dann terminiert M2 .
Sobald eine der simulierten Turingmaschinen M1 und M2 anhält, ist die Antwort bekannt.
L L
entscheidbar entscheidbar
rekursiv aufzählbar, nicht entscheidbar nicht rekursiv aufzählbar
nicht rekursiv aufzählbar rekursiv aufzählbar, nicht entscheidbar
nicht rekursiv aufzählbar nicht rekursiv aufzählbar
Satz: Die universelle Sprache U ist unentscheidbar.
Beweis: Mit der Entscheidbarkeit von U könnte man auch die Diagonalsprache D = {wi |wi ∈
/ L(Mi )} entschei-
den.
Wir wollen untersuchen, ob wi ∈ D ist.
Überprüfe ob wi die Gödelnummer einer gültigen Turingmaschine M ist.
• Wenn nein: L(Mi ) = Σ∗ wi ∈ Σ∗ → Antwort: JA
• Wenn ja: Mi = M
Überprüfe ob hMi iwi ∈ U ⇔ wi ∈ L(Mi )
– wenn ja → Antwort: NEIN.
– wenn nein → Antwort: JA.
1.8.2 Das Halteproblem

Gegeben: Eine Turingmaschine M und eine Eingabe x ∈ Σ∗ (oder ein Programm in C, Java, ... mit einer
Eingabe).
Frage: Hält die Turingmaschine nach endlich vielen Schritten?
Formuliereung des Problems als formale Sprache:
H = {hM i|M hält bei Eingabe von x}
Satz: Das Halteproblem ist unentscheidbar

Beweis: indirekt.
Annahme: Es gibt einen Algorithmus, der das Halteprolem entscheidet.
Behauptung: Dann könnten wir auch die universelle Sprache U entscheiden.
U = {hM ix|x ∈ L(M ), M hält bei Eingabe von x in einem akzeptierenden Zustand}
12
Teste zuerst, ob hM ix ∈ H ist. Wenn nein, dann ist hM ix ∈/ U . Wenn ja, simuliere M auf der Eingabe
x, diese Simulation muss terminieren. Je nachdem, ob der Haltezustand von M ein akzeptierender
Zustand ist oder nicht, gehört hM ix zu U oder nicht.
Das spezielle Halteproblem
Hε = {hM i|M hält bei Eingabe ε}
Folgerung: Hε ist unentscheidbar.
Indirekter Beweis: Annahme wir hätten einen Algorithmus A, der Hε entscheidet.
Behauptung: Dann könnten wir H entscheiden.
hM ix sei Eingabe für H.
Konstruiere eine neue Turingmaschine M ′ die am Anfang das Wort x auf das Band schreibt, dann
nach links zurückkehrt und dann wie M weitermacht.
Teste mit dem Algorithmus A, ob hM i ∈ Hε
hM ′ i ∈ Hε ⇔ hM ix ∈ H
1.8.3 Reduzierbarkeit von Problemen

Definition: A, B ⊆ Σ∗
A ist auf B reduzierbar
A≤B
wenn es eine berechenbare Funktion f : Σ∗ → Σ∗ gibt mit
x ∈ A ⇔ f (x) ∈ B, ∀x ∈ Σ∗
Beispiel: H ≤ Hε
f (hM ix) = hM ′ i
f (y) = hM ∞ i, falls y nicht mit der gültigen Codierung einer Turingmaschine beginnt
M ∞ := eine Turingmaschine, die nie hält.
( y ist keine korrekte Eingabe für das Halteproblem“)
”
Beispiel: D ≤ U
Satz: 1. A ≤ B ∧ B ≤ C ⇒ A ≤ C
2. A ≤ B und B entscheidbar ⇒ A entscheidbar
3. A ≤ B und A unentscheidbar ⇒ B unentscheidbar
Beweis: 1. Transitivität
2. Wir wollen entscheiden, ob x ∈ A ist: Berechne f (x) und entscheide, ob f (x) ∈ B ist.
3. logisch äquivalent zu 2.
1.8.4 Das Post’sche Korrespondenzproblem (PKP)

Gegeben: Eine Folge von Paaren von Wörtern (x1 , x2 ), (y1 , y2 ), ..., (xn , yn ) xi , yi ∈ Σ∗
Frage: Gibt es eine Folge von Indizes i1 , i2 , ..., ik (k ≥ 1) mit xi1 xi2 xi3 ...xik = yi1 yi2 ...yik ?
Beispiel (1, 111), (10111, 10), (10, 0)
(((
i1 = (
1 ((i( (((
2 = 1 ⇒ i3 = 1
(( ((
x=
( (
111
(
y=
( ((((
(111111111
i1 = 2 i2 = 1 i3 = 1 i4 = 3
x = |10111 1 |{z}
{z } |{z} 1 |{z}
10
y = |{z}
10 |{z}
111 |{z}
111 |{z}
0
(10, 101), (011, 11), (101, 011)
(001, 0), (01, 011), (01, 101), (10, 001) kürzeste Lösung k = 66
13
Satz: PKP ist unentscheidbar
Beweis: U ≤ P KP Zwischenschritt: Modifiziertes PKP

zusätzliche Bedingung: i1 = 1 M P KP ≤ P KP
U ≤ P KP . Folge von Konfigurationen einer Turingmaschine
xi
↓
x1 q0 v#u1 q 1 v1 #u2 q 2 v2 #u3 q 3 v3 #...
|{z}
x1
#q0 v# u1 q 1 v1 #u2 q 2 v2 #u3 q 3 v3 #...

| {z }
y1 ↑
yi
Beispiel
xi + 1
xi
↓ xj
↓ z}|{ z}|{ z}|{ z}|{ z}|{
# 0 0 1 0 q1 10#
#0010q110#|{z}0 |{z}
0 |{z} 0 0q ′ 10#
1 |{z}
|{z}
↑
↑ yi
yi
yi + 1
δ(a, 1) = (q ′ , 0, +1)
Gegeben: M, x ∈ Σ∗
Alphabet für PKP = Γ ∪ Q ∪ {#}
Anfangspaar: (x1 , y1 ) = (#, #q0 x#)
Kopierpaare: (xi , yi ) = (a, a) für a ∈ Γ ∪ {#}
Zustandsübergänge:
(qa, q ′ b), falls δ(q, a) = (q ′ , b, 0)

(q#, q ′ b#), falls δ(q, B) = (q ′ b, 0)
(qa, bq ′ ), falls δ(q, a) = (q ′ , b, 1)
(q#, bq ′ #), falls δ(q, B) = (q ′ , b, 1)
(cqa, q ′ cb), falls δ(q, a) = (q ′ , b, −1)
(cq#, q ′ cb#), falls δ(q, B) = (q ′ , b, −1)
(#qa, #q ′ Bb), falls δ(q, a) = (q ′ , b, −1)
(#q#, #q ′ Bb#), falls δ(q, B) = (q ′ , b, −1)
M P KP ≤ P KP
Gegeben: Eingabe für M P KP
(x1 , y1 ), (x2 , y2 ), . . . (xn , ym )
Frage für MPKP: Gibt es eine Folge
i 1 , i2 , . . . , ik k ≥ 1 mit i1 = 1
Sodass xi1 xi2 ...xik = yi1 ...yik

Reduktion: Wir konstruieren uns eine Eingabe (x′0 , y0′ ), (x′1 , y1′ ), ..., (x′n+1 , yn+1
′
),
Dieses PKP hat eine Lösung ⇔ Das ursprüngliche MPKP hat eine Lösung.
14
Beispiel:
(0, 010), (11, 0), (101, 01) Eingabe für MPKP
x′i = xi mit einem neuen Symbol # nach jedem Buchstaben

yi′ = yi mit einem neuen Symbol # vor jedem Buchstaben
(x′1 , y1′ ) = (0#, #0#1#0) (x′2 , y2′ ) = (1#1#, #0) (x′3 , y3′ ) = (1#0#1#, #0#1)
x′0 = #x′1 x′0 = #0#

y0′ = y1′ y0′ = #0#1#0
Dieses PKP kann nur min(x′0 , y0′ ) beginnen
x′0 x′3 = #0#1#0#1# x1 x3 = 0101
′ ′
y0 y3 = #0#1#0#0#1y1 y3 = 01001
x′n+1 = $yn+1
′
= #$
....01 7→ 0#1#$
....01 7→ #0#1#$
Die Eingabe (x′0 , y0′ ), ..., (x′n+1 , yn+1
′
) ist aus (x1 , y1 ), ..., (xn , yn ) berechenbar.
Lemma: U ≤ M P KP
Beweis: Gegeben ist eine Eingabe hM ix für U
Wir konstruieren daraus eine Eingabe für MPKP mit folgenden Eigenschaften
MPKP hat eine Lösung ⇔ hM ix ∈ U
(M akzeptiert x)
Idee: MPKP simuliert die Berechnung von M
Lösungswort: #K0 #K1 #K2 #... Ki aufeinanderfolgende Konfigurationen von M
K0 = q0 x
Ki = ui q i vi qi ∈ Q, ui , vi ∈ Γ∗
xi1 xi2 ...xik = #|K1 #|K2 #K3 #|
yi1 yi2 ...yik = #K1 #|K2 #|K3 #K4 #|
Das y-Wort ist immer einen Schritt vorraus; dadurch können wir sicherstellen, dass Ki+1 aus Ki
durch einen Schritt vom M entsteht.
(x1 , y1 ) = (#, #q0 x#) Anfangsregel
(a, a) a ∈ Γ ∪ {#}... Kopierregel
Zustandsregeln:  ′

 (q , b, +1) ⇒ (qa, bq ′ )

(q ′ , b, 0) ⇒ (qa, q ′ b)
δ(q, a) =
 (cqa, q ′ cb)
(q ′ , b, −1) ⇒


(#qa, #q ′ Bb)
 ′

 (q , b, +1) ⇒ (q#, bq ′ #)

(q ′ , b, 0) ⇒ (q#, q ′ b#)
δ(q, B) =
 (cq#, q ′ cb#)
(q ′ , b, −1) ⇒


(#q#, #q ′ Bb#)
Löschregeln:
Wenn M in einen akzeptierenden Zustand q ∈ F gerät, dann frisst“ dieser Zustand den Bandinhalt
”
(qa, q)
∀q ∈ F, a ∈ Γ
(aq, q)
Abschlusspaar:
(q##, #) ∀q ∈ F
Satz: Das Post’sche Korrespondenzproblem ist unentscheidbar.
15
1.8.5 Andere unentscheidbare Probleme

• Lösbarkeit von Polynomgleichungen über Z. (Matijasević, 1970)

2
x = 3y − z


z 2 + u3 y − x4 = 0
...


S sei eine Eigenschaft von formalen Sprachen L, die von einigen aber nicht von allen rekursiv aufzählbaren
erfüllt wird:
Beispiele: Ist S = ∅?
Ist S = {ε}?
ε ∈ S?
Ist S endlich?
Ist S = {0n 1n |n ≥ 1}
1.8.6 Satz von RICE (1953)

Satz: Für jede nichttriviale Eigenschaft S (im obigen Sinn) ist das folgende Problem unentscheidbar:
Gegeben: Turingmaschine M .
Frage: Hat L(M ) die Eigenschaft S?
Annahme: ∅ hat nicht Eigenschaft S
Es gibt eine Sprache L+ , die Eigenschaft S hat und eine Turingmaschine M + mit L(M + ) = L+ Wir
reduzieren das spezielle Halteproblem Hε auf das Entscheidungsproblem für S:
Gegeben: Turingmaschine M
Frage: Hält M bei Eingabe ε?
Wir konstruieren daraus eine neue Turingmaschine M ′ mit der Eigenschaft
L(M ′ ) hat Eigenschaft S ⇔ M hält bei Eingabe ε
• M ′ bekommt die Eingabe x ∈ Σ∗

• M ′ simuliert zunächst M mit leerer Eingabe.
• Wenn M hält, dann simuliert M ′ die M + mit der Eingabe x, und akzeptiert genau dann,
wenn M + akzeptiert.
′
M ist aus M berechenbar.
Fall 1: M hält nicht bei Eingabe ε
⇒ M ′ hält nie ⇒ L(M ) = ∅ ⇒ L(M ) hat Eigenschaft S nicht.
Fall 2: M hält bei Eingabe ε
⇒ M ′ verhält sich wie M + ⇒ L(M ) = L(M + ) = L+ ⇒ L(M ) hat Eigenschaft S.
Wenn ∅ die Eigenschaft S hat, dann betrachte die komplementäre Eigenschaft S̄ ( nicht S“).
”
16
2 Reguläre Sprachen und endliche Automaten
2.1 Deterministische endliche Automaten
A = (Q, Σ, δ, q0 , F )
Ein (deterministischen) endlicher Automat (DEA) (engl.: deterministic finite automaton, DFA) hat:
• eine endliche Zustandsmenge Q
• ein endliches Eingabealphabet Σ
• eine Zustandsüberführungsfunktion δ : Q × Σ → Q
• einen Startzustand q0 ∈ Q
• eine Menge von akzeptierenden Zuständen F ⊆ Q
Arbeitsweise: Der Automat beginnt in q0 und liest in jedem Schritt das nächste Eingabesymbol und ändert
denm Zustand gemäß δ. Er akzeptiert das Eingabewort, wenn er sich nach dem Lesen des letzten Buch-
stabens in einem Zustand ∈ F befindet.
Beispiel:
Q = {q0 , q1 , q2 , q3 } Σ = {0, 1}
q0 = q0 F = {q3 }
δ 0 1
q0 q1 q2
q1 q0 q3
q2 q3 q0
q3 q2 q1
Zustandsdiagramm:
Eingabe: x = 0 0 1 1 0 0 1 ∈
/ L(A)
↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑
q0 q1 q0 q2 q0 q1 q0 q2 ∈
/F
L(A) = die von A akzeptierte Sprache

= {x ∈ {0, 1}∗|x enthält eine gerade Anzahl an 0en und eine ungrade Anzahl an 1en}
Wir erweitern δ : Q × Σ → Q auf δ : Q × Σ∗ → Q
δ(q, ε) = q, (∀q ∈ Q)
δ(q, a1 a2 ...an ) = δ(δ(q, a1 a2 ...an−1 , an )), (n ≥ 1)
17
KAPITEL 2. REGULÄRE SPRACHEN UND ENDLICHE AUTOMATEN
Beispiel: δ(q2 , 010) = q0 = δ(δ(δ(δ(q2 , ε), 0), 1), 0)
L(A) = die von A akzeptierte Sprache

= {x ∈ Σ∗ |δ(q0 , x) ∈ F }
Kann ein DEA die Sprache L = {0n 1n |b ≥ 0} akzeptieren?

Wir betrachten δ(q0 , 0), δ(q0 , 00), δ(q0 , 000), ... Nach höchstens |Q| Schritten muss sich ein Zustand wiederholen
∃i ≤ j : δ(q0 , 0i ) = δ(q0 , 0j )
δ(δ(q0 , 0i ), 1i ) = δ(q0 , 0i 1i ) ∈ F
weil A das Wort 0i 1i akzeptieren soll.
δ(q0 , 0j 1i ) = δ(δ(q0 , 0j ), 1i ) = δ(q0 , 0i 1i ) ∈ F ⇒ A akzeptiert 0j 1i

| {z }
=δ(q0 ,0i )
Definition: Die von DEA akzeptierten Sprachen heißen reguläre Sprachen.

Andere Charakteresierungen von regulären Sprachen:
• reguläre Ausdrücke
• NEA: nichtdeterministische endliche Automaten
• Typ-3-Grammatiken
2.2 Reguläre Ausdrücke

Beispiele für reguläre Ausdrücke:
(0 + 1)∗ (0∗ + 01∗ )10(1∗ )
Definition: reguläre Ausdrücke sind induktiv folgendermaßen definiert.
1. ∅, ε, a für a ∈ Σ, sind reguläre Ausdrücke
2. Wenn A und B reguläre Ausdrücke sund, dann sind auch
• (A) · (B)
• (A) + (B)
• (A)∗
reguläre Ausdrücke.
Beispiele: ((0) + (1))∗ = {0, 1}∗
(((((0)∗ ) + ((0) · ((1)∗ ))) · (1)) · (0)) · ((1)∗ )
Man verwendet folgende Vereinfachungsregeln:
1.) ∗ hat höchste Priorität, dann ·, dann +

2.) Überflüssige Klammern kann man weglassen.
3.) · kann man weglassen

4.) Endliche Mengen kann man auch als {..., ..., ...} schreiben
Jeder reguläre Ausdruck beschreibt eine Sprache:

• L(∅) = ∅
• L(ε) = {ε}
• L(a) = {a} für a ∈ Σ
• L((A) · (B)) = L(A) · L(B)

• L((A) + (B)) = L(A) ∪ L(B)
18
2.2. REGULÄRE AUSDRÜCKE
• L((A)∗ ) = (L(A))∗
Beispiel: 1∗ (01∗ 01∗ ) = {x ∈ {0, 1}∗|Anzahl der Nullen ist gerade}
Satz: Jede reguläre Sprache wird durch einen regulären Ausdruck beschrieben:
Beweis mit Kleene-Algorithmus: (Kleene, 1953) L = L(A) A = ({q1 , q2 , ..., qn }, Σ, δ, q1 , F )

Lkij = Menge der Wörter, die von qi nach qj führen, und dabei als Zwischenzustände (außer dem ersten
und letzen Zustand) nur die Zustände q1 , q2 , ..., qk
Lkij = {x1 x2 ...xn |δ(qi , x1 ....xn ) = qj , δ(qi , x1 ...xl ) ∈ {q1 , ..., qk } für 1 ≤ l < n}
k = n... keine Einschränkung der Zwischenzustände

[
L(A) = Ln1j
qj ∈F
k = 0... keine Zwischenzustände, nur direkten Übergang
L0ij = {a ∈ Σ|δ(qi , a) = qj } i 6= j
L0ii = {a ∈ Σ|δ(qi , a) = qi } ∪ {ε}
Die Lkij können induktiv für k = 0, 1, 2, ..., n definiert werden.
k−1 k−1 k−1 ∗ k−1

Lemma: Lkij = Lij ∪ Lik (Lkk ) Lkj
k−1 k−1 k−1 ∗ k−1

Beweis: ⊇“ Lij ⊆ Lkij nach Definition. Lik (Lkk ) Lkj ... ein Wort aus dieser Sprache wird, beginnend
”
in qi nur Zustände q1 , ..., qk−1 , qk besuchen und in qj enden.
⊆“ Betrachte ein Wort x ∈ Lkij und die Folge der Zustände die der Automat beim Lesen von x, ausgehend
”
von qi besucht.
Fall 1: qk tritt nicht als Zwischenzustand auf ⇒ x ∈ Lik−1 j
Fall 2: Zerlege x in Bestandteile an jeder Stelle, wo der Zustand qk erreicht wird.
qk qk qk qk
qi qj
k−1 k−1
∈ Lik ∈ Lkj
k−1
∈ Lkk
k−1 k−1
x besteht aus einem Anfangsstück ∈ Lik , beliebig vielen (≥ 0) Zwischenstücken ∈ Lkk und einem
k−1
Endstück ∈ Lkj
Wenn i = k oder j = k ist, dann kann man die Formel vereinfachen:
k−1 k−1
Beispiel: Lkik = Lik · (Lkk )
k k−1 ∗ k−1 ∗ k−1
Lkk = (Lkk ) Lkkj = ((Lkk ) Lkj
19
Durch Induktion nach k ergibt sich: Alle Sprachen Lkij sind durch reguläre Ausdrücke darstellbar, und
sonst auch L(A). Schranke für die Länge des Ausdrucks:
(|Σ| + 1) · 4|Q| · |Q|
(beim Übergang von k auf k + 1 wird die Länge höchstens mit 4 multipliziert.)
Der Algorithmus von Floyd-Warshall für kürzeste Wege in Graphen beruht auf dem gleichen Prinzip.
2.3 Nichtdeterministische endliche Automaten

DEA → regulärer Ausdruck
↑ ↓
NEA ←− (NEA + ε)
Definition: Ein nichtdeterministischer endlicher Automat (NEA) (engl.: nondeterministic finite automaton,
NFA) A = (Q, Σ, δ, q0 , F ) ist ähnlich wie ein DEA, außer dass:
δ : Q × Σ → 2Q (Potenzmenge von Q)
Wenn ein Automat sich im Zustand q ∈ Q befindet und das Symbol a ∈ Σ liegt, kann er in irgendeinem der
Zustände aus der Menge δ(q, a) gehen.
Gesund Kopfweh,Gesund
Hochdruckwetter Kälte
Gesund
Kopfweh
Gewitter Gesund
• Eine Berechnung des Automaten bei Eingabe von x = a1 a2 ...an ∈ Σ∗ ist eine Folge
(q0 , a1 , q1 , a2 , q2 , ..., qn−1 , an , qn ) mit qi ∈ Q mit q0 = Anfangszustand und qi+1 ∈ δ(qi , ai+1 ) für i =
0, ..., n − 1.
• Eine akzeptierende Berechnung ist eine Berechnung mit qn ∈ F .
• Ein Wort x ∈ Σ∗ wird von A akzeptiert, wenn es eine akzeptierende Berechnung für x gibt.
L(A) = Menge der akzeptierten Wörter
0,1 0,1
0 1 0 1
→ q0 q1 q2 q3 q4
L(A) = {Wörter, die 0101 enthalten} = (0 + 1)∗ 0101(0 + 1)∗

δ 0 1
q0 {q0 , q1 } {q0 }
q1 ∅ {q2 }
q2 {q3 } ∅
q3 ∅ {q4 }
q4 {q4 } {q4 }
Beispiel: 010 0101 0010000 würde akzeptiert werden, 011110000111 ∈ / L(A) jedoch nicht.
Ein DEA entspricht dem Spezialfall wo |δ(q, a)| = 1 für alle q und a.
Ursprünglicher Formalismus Alternativer Formalismus
δ : Q × Σ → 2Q δ ⊆ Q × Σ × Q (dreistellige Relation)
q ′ ∈ δ(q, a) (q, a, q ′ ) ∈ δ
20
2.3. NICHTDETERMINISTISCHE ENDLICHE AUTOMATEN
Konstruktion eines äquivalenten DEA A′ = (Q′ , Σ, δ ′ , q0′ , F ′ ) zu einem gegebenen NEA A = (Q, Σ, δ, q0 , F )
(Potenzmengenkonstruktion)
Q′ = 2 Q q0′ == {q0 }
δ ′ : Q′ × Σ →
SQ
′
F ′ = {q ′ ∈ Q|q ′ ∩ F 6= ∅}
′ ′
δ (q , a) = δ(q, a)
q∈q′
Behauptung: L(A′ ) = L(A)

δ ′ ({q1 , q2 }, 0) = δ(q1 , 0) ∪ δ(q2 , 0)
= ∅ ∪ {q3 } = {q3 }
δ ′ ({q0 , q1 , q4 }, 0) = δ(q0 , 0) ∪ δ(q1 , 0) ∪ δ(q4 , 0)
= {q0 , q1 } ∪ ∅ ∪ {q4 } = {q0 , q1 , q4 }
F ′ = {q ′ ∈ {q0 , q1 , q2 , q3 , q4 }|q4 ∈ q ′ }
Beweis: δ ′ (q0′ , a1 a2 ...ak ) = {q ∈ Q | es gibt eine Berechnung für a1 ...ak die im Zustand q0 beginnt und in q
endet.} = mögliche Zustände nach Lesen der ersten k Eingabezeichen.
”
Beweis durch Induktion nach k.
In der Praxis beginnt man mit q0′ = {q0 } und erzeugt nur diejenigen Zustandsmengen, die von q0 erreichbar
sind.
q′ 0 1
q0′ {q0 } {q0 , q2 } {q0 }
q1′ {q0 , q1 } {q0 , qq } {q0 , q2 }
q2′ {q0 , q2 } {q0 , q1 , q3 } {q0 }
q3′ {q0 , q1 , q3 } {q0 , q1 } {q0 , q2 , q4 }
q4′ {q0 , q2 , q4 } {q0 , q1 , q3 , q4 } {q0 , q4 }
q5′ {q0 , q1 , q3 , q4 } {q0 , q1 , q4 } {q0 , q2 , q4 }
q6′ {q0 , q4 } {q0 , q1 , q4 } {q0 , q4 }
q7′ {q0 , q1 , q4 } {q0 , q1 , q4 } {q0 , q2 , q4 }
0
0
q1 1 q2
0
0
1
→ q0 1 q3
1
0
0
q7 q4
1
0
0
1
q6 q5
1
0
L = {Wörter, deren 4-letzter Buchstabe eine 1 ist}
0,1
1 0,1 0,1 0,1
→ q0 q1 q2 q3 q4
⇒ NEA hat k + 1 Zustände

Jeder DEA benötigt mindestens 2k−1 Zustände
21
2.4 NEA mit ε-Übergängen

Unterschied: δ : Q × (Σ ∪ {ε}) → 2Q
Der Automat kann auch, statt einen Buchstaben zu lesen, einen ε-Übergang durchführen. Eine akzeptierende
Berechnung für x ∈ Σ∗ ist eine Folge (q0 , b1 , q1 , b2 , q2 , ..., qk ) mit q0 = Startzustand,
bi ∈ Σ ∪ {ε}, qi ∈ δ(qi−1 , bi ), x = b1 b2 ...bk , qk ∈ F
Satz: Zu jedem regulären Ausdruck S, gibt es einen NEA A mit ε-Übergängen und einem einzigen akzep-
tierenden Zustand mit L(A) = L(S)
Beweis: Induktion nach der Struktur von S
S=a∈Σ → a
S=∅ →
S=ε → ε
A1
S = S1 + S2 → ε
ε
ε
ε
L(A) = L(A1 ) ∪ L(A2 )
A2
S = S1 · S2 → A1 ε A2 L(A) = L(A1 ) · L(A2 )
ε
S = (S1 )∗ → A1 L(A) = L(A1 )∗
DEA Kleene-Algorithmus reguläre Ausdrücke
Potenzmengenkonstruktion
NEA Elimination von ε-Übergängen NEA mit ε-Übergängen
2.4.1 Elimination von ε-Übergängen

Idee: Zusammenpacken einer Folge von ε-Übergängen mit dem nachfolgenden Übergang wo ein Buchstabe
gelesen wir, in einem einzigen Übergang.
0
→ q1 ε, 1 q2
ε, 0
ε
1 0 1 q5
ε, 0
0
q3 1 q4
0
22
2.5. MINIMIERUNG DETERMINISTISCHER ENDLICHER AUTOMATEN
δ ′ (q1 , 0) = {q3 , q5 , q1 , q4 }F ′ = {q1 , q2 , q3 , q5 }

Gegeben: A = (Q, Σ, δ, q0 , F )
δ : Q × (Σ ∪ {ε}) → 2Q
neuer Automat: A′ = (Q, Σ, δ ′ , q0 , F ′ ) ohne ε-Übergänge
δ ′ (q, a) = {r ∈ Q | r kann im Automaten A von q aus durch eine Folge von k ≥ 0 ε-Übergängen, und
einen Übergang wo a gelesen wird, erreicht werden. }
F ′ = {q ∈ Q | Von q aus kann der Automat A in k ≥ 0 ε-Übergängen einen akzeptierenden Zustand r ∈ F
erreichen }
Der Automat A′ kann jede akzeptierende Berrechnung von A durch eine akzeptierende Berechnung ohne ε-
Übergängen simulieren“ und umgekehrt.
”
Berechnung der Menge Rε (q) = { Zustände, die von q aus durch ε-Übergänge erreichbar sind. }
R := {q}; ...Ergebnismenge
Q := {q}; ...Liste der zu bearbeitedenden Zustände
while !isEmpty(Q)
entferne einen Zustand r aus Q
forall s aus delta(r, epsilon):
if !(s aus R) then
R := R + {s}
Q := Q + {s}
→ q0 ε q1
ε
ε
q4
ε
q2 q3
[
δ ′ (q, a) = δ(r, a)
r∈Rε (q)
Beispiel: δ ′ (q1 , 0) = δ(q1 , 0) ∪ δ(q2 , 0) ∪ δ(q3 , 0) ∪ δ(q5 , 0)

F ′ = {q|Rε (q) ∩ F 6= ∅}
2.5 Minimierung deterministischer endlicher Automaten

0
1
→ a 0 b 1 c 0 d
1
0
1
1
0
e 1 f 1 g 0 h
0
1
23
1. Entfernen unerreichbarer Zustände: Zustände die nicht von q0 erreichbar sind

0
1
→ a 0 b 1 c
0
1 1
0
e 1 f 1 g 0 h
0
1
0
2. Zusammenfassen von äquivalenten Zuständen. Zwei Zustände heißen äquivalent, wenn es keine Rolle spielt,
in welchem der beiden Zustände man ist.
def
q ≡ r ⇐⇒ ∀x ∈ Σ∗ ; δ(q, x) ∈ F ⇔ δ(r, x) ∈ F
q 6≡ r ⇐⇒ ∃x ∈ Σ∗ ; δ(q, x) ∈ F ⊕ δ(r, x) ∈ F
(XOR)
| {z }
(∗)
Der Algorithmus beginnt mit einer ganz groben Klasseneinteilung in zwei Klassen Q = F ∪ (Q − F ). Diese
Klasseneinteilung wird nach und nach verfeinert, wenn sich herrausstellt, dass Zustände in der gleichen
Klasse nicht äquivalent sind.
Invariante: Wenn q und r nicht in derselben Klasse sind, dann gilt (∗):
∃x ∈ Σ∗ : (δ(q, x) ∈ F ∧ δ(r, y) ∈
/ F ) ∨ (δ(q, x) ∈
/ F ∧ δ(r, x) ∈ F )
Beispiel: Q = {a} ∪ {b, c, e, f, g, h} = K1 ∪ K2
δ(b, 0) = g ∈ K2
δ(c, 0) = a ∈ K1
δ(e, 0) = h ∈ K2
δ(f, 0) = c ∈ K2
δ(g, 0) = g ∈ K2
δ(h, 0) = g ∈ K2
⇒ c unterscheidet sich vom Rest, da δ(c, 0) ∈ K1 ∧ δ({b, e, f, g, h}, 0)
Zerlege K2 = A ∪ B, je nachdem in welche (bisherige) Klasse δ(q, 0) ist
K2 = {c} ∪ {b, e, f, g, h}
neue Klasseneinteilung: Q = {a} ∪ {c} ∪ {b, e, f, g, h}
K1 K2 K3
δ(b, 0) ∈ K3
δ(e, 0) ∈ K3
δ(f, 0) ∈ K2
δ(g, 0) ∈ K3
δ(h, 0) ∈ K3
Zerlege K3 = {f } ∪ {b, e, g, h}
Neue Zerlegung: Q = {a} ∪ {c} ∪ {f } ∪ {b, e, g, h}
K1 K2 K3 K4
δ(b, 0) ∈ K4
δ(e, 0) ∈ K4
δ(g, 0) ∈ K4
δ(h, 0) ∈ K4
24
2.5. MINIMIERUNG DETERMINISTISCHER ENDLICHER AUTOMATEN
δ(b, 1) = c ∈ K2
δ(e, 1) = f ∈ K3
δ(g, 1) = e ∈ K4
δ(h, 1) = c ∈ K2
Zerlege K4 = {e} ∪ {g} ∪ {b, h}

Neue Zerlegung: Q = {a} ∪ {c} ∪ {e} ∪ {f } ∪ {g} ∪ {b, h}
K1 K2 K3 K4 K5 K6
δ(b, 0) ∈ K6
δ(h, 0) ∈ K6
δ(b, 1) ∈ K3
δ(h, 1) ∈ K3
Es ergibt sich keine weitere Verfeinerung

0
1
→ a 0 {b, h} 1 c
1
0
0
0
e 1 f 1 g
0
1
a 6≡ c wenn x = ε
h 6≡ g weil δ(h, 1) = c, δ(g, 1) = e und c 6≡ e
c 6≡ e weil δ(c, 0) = a, δ(e, 0) = h und h 6≡ a
h 6≡ a weil h ∈
/ F, a ∈ F
h 6≡ g weil δ(h, 10) ∈ F, δ(g, 10) ∈
/F
2.5.1 Algorithmus zur Bestimmung des Minimalautomaten:

• Beginne mit der Terlegung Q = K1 ∪ K2 in zwei Klassen
K1 = F
K2 = Q − F
Q = K1 ∪ K2 ∪ ... ∪ Kj
Solange es zwei Zustände q, r in derselben Klasse Ki gibt und einen Buckstaben a ∈ Σ mit:
Klasse δ(q, a) gehört (q ∈ Ki )

Abbruchbedingung: ∀Ki ∀q, r ∈ Ki , ∀a ∈ Σ: δ(q, a) und δ(r, a) gehören zur gleichen Klasse.
Zustände des neuen Automaten: {K1 , ..., Kj }
δ ′ (Ki , a) = KLasse, zu der δ(q, a) gehört, für irgendein q ∈ Ki (unabhängig von der Wahl von q).
Satz: Zu jedem DEA (zu jeder regulären Sprache) gibt es einen eindeutig bestimmten (eindeutig bis auf
Bennenung der Zustände) Minimalautomaten, der die gleiche Sprache akzeptiert.
• Dieser hat unter allen äquivalenten DEA’s die kleinste Anzahl von Zuständen.
• Der Minimalautomat kann in O(|Q|2 · |Σ|) Schritten berechnet werden.
25

[l]Q = {q1 , q2 , q3 } ∪ {q4 , q7 } ∪ {q5 } ∪{q6 } 



  
δ(q1 , 0) δ(q1 , 1) ein Verfeinerungsschritt O(|Q| · |Σ|)

δ(q2 , 0) in der selben Klasse? δ(q2 , 1) ?

  

δ(q3 , 0) δ(q3 , 1)
Man kann höchstens (|Q| − 1)-mal verfeinern
Zusätzlich: Verwalten der Kalssen Einteilung
q1 1
q2 1
q3 1
q4 2
q5 3
q6 4
q7 2
Entfernen der unerreichbaren Zustände O(|Q| · |Σ|)

Es geht auch in O(|Q| · log |Q| · |Σ|) Zeit, Hopcroft:
Die Nerode-Relation bezüglich einer Sprache L.
Definition: Zwei Wörter u und v heißen Nerode-äquivalent, wenn
def
u ≡L v ⇐⇒ ∀x ∈ Σ∗ : ux ∈ L ⇔ vx ∈ L
Diese Relation ist eine Äquivalenzrelation. Daher können wir die Äquivalenzklassen [u]L = {v ∈ Σ∗ | v ≡L u}
bilden.
2.5.2 Satz von Nerode

Satz: Eine Sprache L ist genau dann regulär, wenn die Nerode-Relation endlich viele Äquivalenzklassen hat.
Die Anzahl der Äquivalenzklassen ist in diesem Fall die Anzahl der Zustände des Minimalautomaten.
Beweis: ⇒“
”
L = L(A) für DEA A = (Q, Σ, δ, q0 , F )
Wenn δ(q0 , u) = δ(q0 , v) dann u ≡L v
∀x ∈ Σ∗ : ux ∈ L ⇔ δ(q0 , ux) ∈ F
⇔ δ(δ(q0 , u), x) ∈ F
⇔ δ(δ(q0 , v), x) ∈ F
⇔ δ(δ(q0 , vx) ∈ F ⇔ vx ∈ L
Folgerung: ≡L hat höchstens |Q| Äquivalnzklassen. Jeder DEA hat mindestens so viele Zustände, wie ≡L
Äquivalenzklassen hat.
Beispiel:
L = {x ∈ {0, 1}∗ | k-letzter Buchstabe ist eine 1, |x| ≥ k}
= Σ∗ · 1 · Σk−1
Behauptung: u, v ∈ Σk , u 6= v u 6≡L v
⇒ ≡L hat mindestens 2k Äquivalenzklassen.
x
u = 1000100100000 ∈
/L
v = 1000110100000 ∈ L
Beweis der Behauptung: u 6= v unterscheiden sich in der i-ten Position, o. B. d. A. u hat dort eine 0, v
hat dort eine 1.
Für x = 0i−1 ux ∈
/ L, vx ∈ L
26
2.6. DAS PUMPING-LEMMA FÜR REGULÄRE SPRACHEN
Beweis: ⇐“
”
[u1 ]L [u2 ]L , ..., [uk ]L seine Äquivalenzklassen von ≡L
Q = {[u1 ]L [u2 ]L , ..., [uk ]L }
Σ
δ([ui ]L , a) = [ui a]L
q0 = [ε]L
F = {[ui ]L | ui ∈ L}
zu zeigen:
1) Dieser Automat ist wohldefiniert :
Das Ergebnis von δ, die Menge F hängt nicht davon ab, welcher Representant ui aus der Äquivalenz-
klasse [ui ]L gewählt wird.
δ: v ≡ ui ([v]L = [ui ]L ) ⇒ [va]L = [ui a]L ⇔ va ≡L ui a
v ≡L ui , a ∈ Σ ⇒ va ≡L ui a
def ∀x ∈ Σ∗ : vax ∈ L ⇔ ui ax ∈ L
∀y ∈ Σ∗ : vy ∈ L ⇔ ui y ∈ L ↑ y = a · x
F : z.z. [[ui ]L ] ≡ [v]L ⇒ (ui ∈ L ⇔ v ∈ L)

| {z }
⇔ui ≡L v
⇔ ∀x ∈ Σ∗ : (ui x ∈ L ⇔ vx ∈ L)
⇒ Für x = ε: ui ∈ L ⇔ v ∈ L
2) Der Automat akzeptiert L.
Behauptung: δ(q0 , x) = [x]L
Beweis durch Induktion nach |x|
IA: |x| = 0 x=ε
!
δ(q0 , ε) = q0 = [ε]L
X
IS: x = y · a a ∈ Σ, für y ist die Aussage bewiesen. δ(q0 , x) = δ(q0 , ya) = δ(δ(q0 , y), a) =
δ([y], a) = [ya] = [x]
Weil Definition von δ unabhängig von der Wahl des Representanten y in der Klasse [y] ist.
2.6 Das Pumping-Lemma für reguläre Sprachen

Für jede Reguläre Sprache L gibt es eine n0 ∈ N (∀L ⊆ Σ∗ : L regulär ⇒ ∃n0 ∈ N).
∀x ∈ L: |x| ≥ n0 ∃u, v, w ∈ Σ∗ : x = u · v · w, v 6= ε, ∀i ≥ 0: u · v i · w ∈ L, |uv| ≤ n0
| {z }
Sogar diese stärkere Aussage gilt
In Worten: In einer rgulären Sprache hat jedes genügend lange Wort eine Stelle, an der man pumpen“ kann.
”
Das Lemma wird in der Regel dazu verwendet, um zu zeigen, dass eine Sprache nicht regulär ist.
Beispiel: L = {0n 1n | n ≥ 1} nicht regulär.
Annahme: L wäre regulär ⇒ Pumping-Lemma ist anwendbar
∃n0 : Wähle x = 0n0 1n0
∃x = uvw, v 6= ε, sodass ∀i: uv i w ∈ L
Fall 1: v enthält nur Einsen uv 0 w enthält weniger Einsen als Nullen.
⇒∈/ L Widerspruch
00001 11 |{z}
| {z } |{z} 1
u v w
00001|1 i=0
00001111 i=1
00001 1111
| {z } 1 i=2
v2
..
. ∈L
27
Fall 2: v enthält nur Nullen ...

Fall 3: v enthält Nullen und Einsen
uv 2 w = u |{z}
v |{z}
v w enthält Einsen, die vor Nullen stehen. ⇒∈
/L
001 001
L = {0n 1n | n ≥ 1} ist nicht regulär
2
i
n0 0n0 = uvw | {zw} ∈ L
uv
0n0 +(i−1)·|v|
Die Längen der Wörter uv i w bilden eine arithmetische Folge mit Abstand |v| ≤ n20
Abstand zwischen zwei Quadratzahlen:
2
(n20 + 1)2 − (n20 )2 = 2 2 2 2 2 2
0 ) + 2(n0 ) + 1 − (n0 ) = 2n0 + 1 > n0
(n
> n20
+
+
+
+
+
+
+
+
+
+
+
Es gibt ein Wort uv i w, dessen Länge (n20 )2 < |uv i w| < (n20 + 1)2 ist. ⇒ Widerspruch
Beweis: L sei regulär (L ∈ L3 ), A... DEA mit L(A) = L
n0 := |Q|
|x| ≥ 0
x = x1 x2 ....xn
q0
Betrachte die Zustände:


δ(q0 , ε) = q0 


δ(q0 , x1 ) 


δ(q0 , x1 x2 ) Ein Zustand q ′ muss mehrfach vorkommen
.. 

. 



δ(q0 , x1 x2 ...xn0 )
u
q0 q′
v
∃0 ≤ i < j ≤ n0 : δ(q0 , x1 ...xi ) = δ(q0 , x1 ...xj )

| {z }
δ(δ(q0 , x1 ...xi ),xi+1 ...xJ )=q′ =q′
| {z }
q′
δ(q ′ , xi+1 ...xj ) = q ′
28
2.7. ABSCHLUSSEIGENSCHAFTEN REGULÄRER SPRACHEN
u = x1 ...xi
v = xi+1 ...xj 6= ε
w = xj+1 ...xn
i
uvw) ∈ F
∀i ≥ 0: δ(q0 , uv w) = δ(q0 , |{z}
x
2
L = {01} n0 = 3 L = {0i 1j | i ≥ 0, j ≥ 0}
0 1
⊲ q0 ·
2.7 Abschlusseigenschaften regulärer Sprachen

Satz: Die regulären Sprachen sind abgeschlossen gegenüber Vereinigung, Durchschnitt, Produkt, *-Operation,
Umkehrung, Komplement, Substitution mit regulären Sprachen, Homomorphismen und inverse Homo-
morphismen.
D. h. z. B.: L1 , L2 ∈ L3 ⇒ L1 ∪ L2 ∈ L3
Beweise: • Vereinigung, Produkt, *-Operation: reguläre Ausdrücke X

• Komplement:
Wenn L regulär ist, dann ist auch L = Σ∗ − L regulär.
Beweis: DEA A = (Q, Σ, δ, q0 , F ) akzeptiert L
A′ = (Q, Σδ, q0 , Q − F ) akzeptiert L
• Umkehrung (alle Wörter von hinten nach vorne gelesen)
reguläre Ausdrücke Bsp.: (a + b)(ab)∗ a∗ b∗ → b∗ a∗ (ba)∗ (a + b)
Beispiel: k-te Buchstabe von rechts = 1 DEA benötigt 2k Zustände
k-te Buchstabe von links = 1 DEA kommt mit k + 2 Zustände aus.
• Durchschnitt: L1 ∩ L2 = L1 ∪ L2
• Durchschnitt, Vereinigung mit DEA
Produkt zweier Automaten“ (Übung)
”
Anwendungsbeispiel L = {x ∈ {0, 1}∗ | x enthält gleich viele Einsen und Nullen}
L′ = L ∩ 0∗ 1∗ = {0n 1n |n ≥ 0}
nicht regulär nicht regulär
• Homomorphismus
Definition: Ein Homomorphismus h zwischen Σ∗ und Γ∗ ist eine Abbildung h : Σ∗ → Γ∗ mit der
Eigenschaft
h(x, y) = h(x) · h(y) (∀x, y ∈ Σ∗ )
Ein Homomorphismus ist durch eine beliebige Abbildung h : Σ∗ → Γ∗ eindeutig gegeben (Σ∗ =
Γ∗ ) ist nicht ausgeschlossen.
Beispiel:
h(a) = 01 h(abaabaab) = 0101010101

h(b) = ε
h(c) = 01
h(x1 ...xn ) = h(x2 ) · h(x2 ) · ... · h(xn ) xi ∈ Σ

• Substitution
Definition: Bei einer Substitution σ wird ein Buchstabe a ∈ Σ durch die Sprache σ(a) ersetzt.
∗
Substution ist gegeben durch die Abbildung σ : Σ → 2Γ
σ(L) = {y | y ∈ σ(x1 ) · σ(x2 )σ(x3 )...σ(xn ), x1 x2 x3 ...xn ∈ L}
29
Beispiel: L = (01)∗
σ(0) = {a}
σ(1) = {b, c}
σ(L) = {ababab, ababac, ac, abacacab, ε, ...} = (a(b + c))∗
——
σ(0) = a
σ(1) = ab∗ b
σ(L) = {aabbbbbaabaabbbb, ...} = σ(a(ab∗ b))∗ = (aab∗ b)∗
Satz: L ⊆ Σ∗ regulär
σ(a), a ∈ Σ seien regulär ⇒ σ(L) regulär
Spezialfall: |σ(a)| = 1... Homomorphismus.
Beweis: requläre Ausdrücke
R: regulärer Ausdruck für L, Ra regulärer Ausdruck für σ(a), a ∈ Σ
Ersetze in R jedes Vorkommen eines Buchstaben a ∈ Σ durch Ra
• inverse Homomorphismen
h : Σ∗ → Γ∗ Homomorphismus
Satz:
(L ⊆ Γ∗ ) ∈ L3 ⇒ h−1 := {x ∈ Σ∗ | h(x) ∈ L} ∈ L3
Beispiel: h(a) = 0
h(b) = 10
abaab
Beweis: DEA A = (Q, Γ, δ, q0 , F )
1
a, b
⊲ 0
b
0, 1 a 1 b 0a
b
0
a b
neuer DEA A′ = (Q, Σ, δ ′ , q0 , F )
δ ′ (q, x) = δ(q, h(x)), x ∈ Σ
2.8 Zusammenfassung: reguläre Sprachen

• DEA, NEA: Überprüfen ob x ∈ L
• NEA, reguläre Ausdrücke: Erzeugen der Wörter aus L
30
3 Grammatiken
3.1 Definition von Grammatiken
Beispiel: in Programmiersprachen; arithmetische Ausdücke:
• Zahlen und Variablen sind arithmetische Ausdrücke
• wenn A und B arithmetische Ausdrücke, dann sind auch A + B, A − B, A ∗ B, A/B, (A) arithmetische
Ausdrücke
S → V, S → Z, S → (S) S, → S + S,
S → S − S, S → S ∗ S, S → S/S,
Z → U, Z → U,
U → 0, U → 1, ..., U →9
⇒U → 0|1|...|9
B → B, V ′ → V ′ B, V ′ → V ′U
B → a, B → b, B → c, ...
⇒B → a|b|c|...
Σ = {(, ), +, −, ∗, /, 0, 1, ..., 9, a, b, c, ...}

V = {S, V ′ , Z, U, B}
Beispiel: 5 + (13 ∗ 2) ∈ L(G) 3 ∗ (−4) ∈

/ L(G)
S → S + S → Z + S → U + S → 5 + S → 5 + (S) → 5 + (S ∗ S) → 5(S ∗ Z) → 5 + (Z ∗ Z) →
5 + (U Z ∗ Z) → 5 + (U U ∗ Z) → 5 + (1U ∗ U ) → 5 + (13 ∗ U ) → 5 + (13 ∗ 2)
Definition: Eine Grammatik G besteht aus:

• einer Menge V aus Variablensymbolen
• einer Menge Σ aus Terminalsymbolen (Σ ∩ V = ∅)
• einer Menge P von Ersetzungsregeln (Produktionen), P ∈ V + × (V ∪ Σ)∗ V + = V ∗ − {ε}
• einem Startsymbol S ∈ V
Wörter aus (V ∪ Σ)∗ nennt man auch Satzformen.

u ∈ (V ∪ Σ)∗ , wenn v aus u dadurch entsteht, dass man ein Vorkommen einer linken Seite (Prämisse) x einer
Regel (x, y) ∈ P durch die rechte Seite (Konklusion) ersetzt, dann schreibt man u → {ε}
v ist aus u in einem Schritt ableitbar.
u → v ⇔ ∃(x, y) ∈ P, ∃u1 , u2 ∈ (Σ ∪ V )∗ : u = u1 xu2 ∧ v = u1 yu2

∗
Wenn v aus u in k ≥ 0 Schritten abgeleitet werden kann, dann schreibt man u → v:
∃v0 , v1 , ..., vk : u = v0 → v1 → v2 → ... → vk = v

| {z }
eine Ableitung
Definition: Die von einer Grammatik G = (V, Σ, P, S) beschriebene Spache L(G) ist
∗
L(G) = {x ∈ Σ∗ | S → x}
31
KAPITEL 3. GRAMMATIKEN
3.2 Die Chomsky-Hierarchie

Nach Noam Chomsky (zeitgenössischer Linguist)
• Typ-0-Grammatiken: beliebige Grammtiken
• Typ-1-Grammatiken: monotone bzw. kontext-sensitive Grammtiken
P ⊆ {(x, y) | x ∈ V + , y ∈ (Σ ∪ V \ {S})∗ , |x| ≤ |y|} ∪ {(S, ε)}
D. h. die Konklusionen der Regeln sind mindestest so lang wie die Prämissen.
• Typ-2-Grammatiken: kontextfreie Grammatiken
P ⊆ V × (Σ ∪ V )∗
• Typ-3-Grammatiken: rechtslineare Grammatiken
P ⊆ V × (ΣV ∪ {ε})
Beispiel:
S → aT |bS
T → +V
T →ε
Die beschriebenen Sprachen dieser Grammatiken entsprechen den regulären Sprachen (es gibt auch linkslin-
eare Grammatiken)
Entsprechend gibt es Typ-0-Sprachen, Typ-1-Sprachen, ...
L0 , L1 , L2 , L3 seien die Typ-0-Sprachen, Typ-1-Sprachen, ...
trivial
L3 ⊂ L2 ⊂ L1 ⊂ L0
regulär 6= kontextfrei 6= kontextsensitiv 6= rekursiv aufzählbar
L= {0n 1n } L= {0n 1n 0n } Die Sprachen aus L1 sind entscheidbar
3.3 Typ-0-Sprachen (rekursiv aufzählbare Sprachen)

Satz: Typ-0-Sprachen sind genau die rekursiv aufzählbaren Sprachen.
Beweis: ⇒“ G = (V, Σ, S, P ) sei gegeben, x ∈ Σ∗ . Ist x ∈ L(G)?
”
Algorithmus: Probiere alle Ableitungen der Länge k systematisch durch und prüfe, ob dabei x her-
auskommt, für k = 0, 1, 2, 3, ....
Dieser Algorithmus akzeptiert gdw. x ∈ L(G) (andernfalls kann er nicht terminieren).
⇐“ Gegeben TM M = (Q, Σ, δ, Γ, q0 , B, F )
”
Idee: q0 x ⊢ k1 ⊢ k2 ⊢ ... ⊢ k2
Simulation durch G: x ← $q0 x# ← ...... ← $kn−1 # ← $kn # ← ...... ← S
V = Q ∪ {$, #} ∪ {Va | a ∈ Γ} ∪{S}

| {z }
neue Variablen, die dem Bandalphabet entsprechen
Produktionen P :
δ(q, a) = (q ′ , b, 0) ⇒ q ′ Vb → qVa
δ(q, a) = (q ′ , b, +1) ⇒ Vb q ′ → qVa
δ(q, a) = (q ′ , b, −1) ⇒ q ′ Vc Vb → Vc qVa , ∀c ∈ Γ
32
3.4. TYP-3-SPRACHEN (REGULÄRE SPRACHEN)
Anfangsregeln: Erzeuge eine beliebige Konfiguration mit einem akzeptierenden Zustand und genügend
vielen B-Symbolen rechts und links.
S → $T #
T → T Va |Va T, ∀a ∈ Γ
T → q, ∀q ∈ F
Endregeln: B-Symbole an den Rändern löschen, $, # löschen, Symbole Vx in Terminalsymbole x

überführen, q0 löschen
VB # → #, #→ε
$VB → $, $q0 → ε
Vx → x, x∈Σ
Jede akzeptierende Berechnung für w ∈ Σ∗ kann in eine Ableitung von w transformiert werden.
Jede Ableitung eines Wortes x entspricht einer akzeptierenden Berechnung.
3.4 Typ-3-Sprachen (reguläre Sprachen)

Satz: Typ-3-Sprachen sind genau die regulären Sprachen
Beispiel:
S → aT |bS V = {S, T }
T → bT |bS|aS|ε Σ = {a, b}
S → aT → abS → abbS → abbaT → abbabT → abbab

| {z }
∈L(G)
Beweis: ⇐“ Gegeben: DEA (bzw. NEA) A = (Q, Σ, δ, q0 , F )

”
Gesucht: Typ-3-Grammatik für L(A)
G: V =Q
Σ=Σ
q a q′ q → aq ′
P = {q → aq ′ | q ∈ Q, a ∈ Σ, q ′ = δ(q, a)} ∪ {q → ε | q ∈ F }
q′ ∈δ(q,a)
S = q0
⇒“ Gegeben: G = (V, Σ, P, S)
”
Gesucht: NEA A mit L(A) = L(G)
A: Q=V
Σ=Σ
δ(q, a) = {q ′ | (q → aq ′ ) ∈ P }
F = {q ∈ V | (q → ε) ∈ P }
q0 = S Zustände des Automaten entsprechen den Variablen der Grammatik.
Berechnungen des Automaten werden durch Ableitungen der Grammatik dargestellt und umgekehrt.
L = {0n 1n |n ≥ 0} ist keine Typ-3-Sprache, aber sie ist eine Typ-2-Sprache
G: S → 0S1|ε
S → 0S1 → 00S11 → 000S111 → 000111
33
KAPITEL 3. GRAMMATIKEN
3.5 Typ-1-Sprachen (kontextsensitive Sprachen)

Bei alle Regeln ist die Konklusion mindestens so lang wie die Prämisse.
Ausnahme: S → ε ist erlaubt, S darf jedoch in keiner Konklusion vorkommen.
Folgerung: in einer Ableitung können die Satzformen nicht schrumpfen, außer bei der Ableitung S → ε, aber
diese Ableitung ist in einem Schritt zu Ende.
Beispiel: V = {S, T, U, W, V0 , V1 }
Σ = {0, 1}
S → ε|V0 T V1 V0 |010
T → V0 V1 U U V1 → V1 U U V0 → W V0 V0 |00 V1 W → W V1 V0 W → V0 T
V0 → 0 V1 → 1 V1 W → W V1 U 1 → 1U U V1 → V1 U
∗
S → 0T 10 → 001U10
∗
→ 0011U0 → 0011W 00
∗
→ 00W 1100 → 00T 1100
∗ ∗
→ 000W 111000 → 00001111U000
→ 000011110000
L(G) = {0n 1n 0n | n ≥ 0}
Bemerkung: Man kann die Regeln einer kontextsensitiven Grammatik in die Form bringen, dass immer nur
eine einzelne Variable durch etwas Neues ersetzt wird.
z. B. ABA A → ABAA01DA
| {z } C |{z}
Kontext Kontext
Beispiel: Regel ABC → BAD neue Variablen X1 , X2 , X3 , ...

wird ersetzt durch:
ABC → X1 BC X1 X2 X3 → BX2 X3
X1 BC → X1 X2 C BX2 X3 → BAX3
X1 X2 C → X1 X2 X3 BAX3 → BAD
Satz: Typ-1Sprachen sind entscheidbar.

Beweis: G... Gramatik, x ∈ Σ∗
Frage: x ∈ L(G) (auch bekannt als das Wortproblem)
Wenn x = ε x ∈ L(G) ⇔ (S → ε) ∈ P
Andernfalls können in der Ableitung von x nur Satzformen auftreten, die höchstend so lang wie x.
∗
M = {y ∈ (V ∪ Σ)∗ | |y| ≤ |x|, S → y, y 6= ε}
M kann folgendermaßen induktiv konstruiert werden:

Beginne mit M := {S}
Schleife :
∀y ∈ M : ∀z ∈ (V ∪ Σ∗ ): y → z, |z| ≤ |x| .
M := M ∪ {z}
w i e d e r h o l e , s o l a n g e neue Elemente zu M dazugekommen s i n d .
|x|
P
|M | ≤ (|Σ| + |V |)i endlich. Daher muss die Schleife irgendwann terminieren
i=1
x ∈ L(G) ⇔ x ∈ M
34
4 Kontextfreie Sprachen (Typ-2-Sprachen)
4.1 Tiefenstruktur von Sprachen
Das Wetter war gestern regnerisch.
Satz
Subjektgruppe Prädikatgruppe
Nominalgruppe Verb Adverb Prädikat
Artikel Hauptwort war“ gestern“ Adjektiv

” ”
das“ Wetter“ regnerisch“

” ” ”
Bei einer kontextfreien Grammatik wird bei der Syntaxanalyse ein solcher Syntax-Baum“ aufgebaut.
”
es | geregnet.
Gestern hat | |{z}
Subjekt
(Im Deutschen kann das Prädikat zerlegt werden ⇒ Analyse kann sehr schwer sein!)
4.2 Dyck-Sprache
D1 S → SS | (S) | ε
∗
S → SS → (S)S → (SS)S → ((S)S)S → (()S)S → (()(S))S → (()())S → (()())((S)) → (()())(()) ∈ D1
())(() ∈
/ D1
Klammertiefe:
Dyck-Weg
b b b
b b b b b
b b
( ( ) ( ) ) ( ( ) )
Definition: Der Weg mit n Schritten nach oben ր und n Schritten nach unten ց, der oberhalb der x-Achse
bleibt wird Dyck-Weg genannt.
35
KAPITEL 4. KONTEXTFREIE SPRACHEN (TYP-2-SPRACHEN)
D2 S → SS | (S) | [S] | ε
⇒ ([()()])[] ∈ D2
Dk ... k verschiedene Klammerpaare.
L = {x ∈ {a, b}∗ | x enthält gleich viele as wie bs}

a
b
a
b
b
b
ab
a
b
b
b
b
b
a
b
b
b
b
b
a
b
a
b
b
b
b b
S → SS|ε|aP b|bN a
P → P P |aP b|ε
N → N N |bN a|ε
P... positive“ Dyck-Wörter (= a, ) = b

”
N... negative“ Dyck-Wörter ) = a, (= b
”
4.3 Kontextfreie Grammtiken als Gleichungssysteme

Man kann eine kontextfreie Grammatik auch als Gleichungssystem, dessen Lösungen unbekannte Sprachen sind
interpretieren
VS = VS · VS ∪ {ε} ∪ a · Vp · b ∪ b · Vn · a
VP = VP · VP ∪ a · VP · b ∪ {ε}
VN = VN · VN ∪ b · VN · a ∪ {ε}
VS , VP , VN sind unbekannte“ Sprachen.

”
∗
VS = {x ∈ Σ∗ | S → x} = L
∗
VP = {x ∈ Σ∗ | P → x}
∗
VN = {x ∈ Σ∗ | N → x}
sind eine Lösung des Gleichungssystems (nicht unbedingt eindeutig).
S S
( S ) ( S )
S S ( S )
( S ) ( S ) ε
ε ε
36
4.4. EINDEUTIGKEIT
∗
Rechtsableitung: S → SS → S(S) → S((S)) → S (()) → (S)(()) → (SS)(()) → (()())(()) entspricht der
bottom-up-Syntaxanalyse
∗
Linksableitung: S → SS → (S)S → (SS)S → ((S)S)S → (()S)S → (()(S))S → (()())S → (()())((S)) →
(()())(()) entspricht der top-down-Syntaxanalyse
Die Beliebigkeit bei der Auswahl, welche Variable be einer Ableitung als nächstes ersetzt wird, kann auf drei
Arten aus der Welt geschafft werden:
1. Linksableitung: Es wird immer die linkeste Variable ersetzt
2. Rechtsableitung: Es wird immer die rechteste Variable ersetzt
3. Syntaxbaum: Wurzel = S, Kinder einses Variablenknotens sind die Symbole auf der rechten Seite einer
Regel in der passenden Reihenfolge, Blätter sind Terminalsymbole, dargestelltes Wort wird durch die Folge
der Blätter gegeben.
()()() kann durch 2 verschiedene Syntaxbäume / Linksableitungen / Rechtsableitungen dargestellt werden.
S S
( S ) S S
ε ( S ) ( S )
ε ε
S
S S
S S ( S )
( S ) ( S ) ε
ε ε
anders arithmetische Ausdrücke (am Beispiel 3 − 5 + 5):
S S

S + 5 3 - S

3 - 4 4 + 5
4.4 Eindeutigkeit
Definition: Eine kontextfreie Sprache ist eindeutig, wenn jedes Wort eine eindeutige Linksableitung / eine
eideutige Rechtsableitung / einen eindeutigen Syntaxbaum hat.
Beispiel: S → if B then S | if B then S else S | while ... | ...
if B1 then (if B2 then )S1 else S2
if B1 then (if B2 then S1 else S2 )

Grammatik nicht eindeutig!
37
A... bedingte Anweisung, die noch auf else“ wartet.

”
T... bbeliebige Anweisung, inklusive einer bedingten Anweisung mit else-Klausel, die abgeschlossen ist
S → A|T
A → if B then S | if B then T else A
T → if B then T else T | while ... | andere Anweisungen...
äquivalente Grammatik, die eindeutig ist.
S → S + S|S − S|Z (mehrdeutig)

S → Z|S + Z|S − Z (eindeutig)
Es gibt Sprachen, für die es keine eindeutige Grammatik gibt:
{0i 1j 01k | i = j ∨ j = k} = {0n 1n }0∗ ∪ 0∗ {1n 0n }
0n 1n 0n sind in beiden Teilsprachen“ enthalten.

”
Solche Sprachen heißen inhärent mehrdeutig.
4.5 Chomsky-Normalform
Definition: Eine kontextfreie Grammatik ist in Chomsky-Normalform (CNF), wenn jede Regel lediglich folgende
Gestalt haben:
1. A → BC, A, B, C ∈ V
2. A → b, A ∈ V, b ∈ Σ
Ausnahme: Die Regel S → ε ist erlaubt, aber S darf nie auf der rechten Seite einer Regel vorkommen.
Satz: Zu jeder kontextfreien Grammatik G gibt es eine Grammatik G′ in CNF mit
L(G′ ) = L(G) − {ε}
1. Elimination von Terminalsymbolen auf der rechten Seite:

• Führe für jedes a ∈ Σ eine neue Variable Va ein.
• Ersetze a durch Va auf allen rechten Seiten
• Füge Regeln Va → a hinzu.
Beispiel:
S → (S)... S → V( SV)
V( → (
V) →)
2. Zerlegung von Regeln mit mehr als 2 Variablen auf der rechten Seite
• Einführen von zusätzlichen Zwischenvariablen in mehreren Schritten
Beispiel:
A → BAAS... A → BSV1
V1 → AV2
V2 → AS
3. Elimination von ε-Regeln

∗
Konstruiere die Menge M aller Variablen A ∈ V , für die A → ε. Für jede Regel, die eine Variable
aus M auf der rechten Seite enthält, erstelle eine neue Regel, in der ein Vorkommen dieser Variablen
gestrichen wird.
38
4.5. CHOMSKY-NORMALFORM
Beispiel: M := {V, U, A} für
U →VW | V | W | ε
V →W | VV | ε | V
A→U | VV | ε | V
(B → AU BV | ABV | AU B | AB | BV | U B | B)
↓ ↓
ε ε
U →VW U →W
∗
• M wird initialisiert mit den Variablen A für die es eine Regel A → ε gibt.
∗
• Durch das Aufstellen neuer verkürzter Regeln können neue Regeln der Form A → ε entstehen.
• Die entsprechende Variablen werden dann zu M hinzugefügt.
• Erstelle für jede Variable A aus M eine neue Variable A′ .
• Auf der rechten Seite aller Regeln wird wird jede diese Variablen A durch A′ ersetzt.
• Die Regeln für A’ sind dieselben wie für A, nur die ε-Regel wird gestrichen.
Am Beispiel:
U → V ′W ′ | V ′ | W ′ | ε
U ′ → V ′W ′ | V ′ | W ′
V → W ′ | V ′V ′ | V ′ | ε
V ′ → W ′ | V ′V ′ | V ′
..
.
Behauptung: Für alle A ∈ M gilt

∗
LA′ = LA − {ε} (LX = {s ∈ Σ∗ | X → s})
∗
Begründung: X → S, S 6= ε Betrachte die rechte Seite der ersten Regel dieser Ableitung.
X → Y Z: Eventuell wird Y oder Z in der Ableitung zu ε gemacht; In diesem Fall enthält die
neue Grammatik eine Regel X ′ → Y ′ oder X ′ → Z ′ , wo das bereits berücksichtigt ist.
Für die nächsten Ableitungsschritte geht man genauso vor.
Lasse die Regeln für die ursprünglichen Variablen A ∈ M weg, außer für S. Falls S ∈ M ist, füge
dafür die Regeln S → ε, S → S ′ ein
4. Elimination von K → L
• Für jede Regel der Form A → BC, A → x ∈ Σ berechne die Variablenmenge

∗
VA = {X ∈ V | X → A}.
• Erstelle neue Regeln X → BC bzw. X → x für alle X ∈ VA .

• Anschließend entferne alle Regeln der Form A → B.
Beispiel: Angenommen für alle Regeln K → L ergeben folgenden Zusammenhang:
A B D
C E
In einer Ableitung kann eine Kette von Anwendungen derartiger REgeln vorkommen.
AB
A→B→C→A→B→B→C→A→B→C →D
a
(U V A U U → U V BU U → ........ → U V DU U )
B→V A
39
D → AB VD = {A, B, C, D, E}
A → AB, B → AB, C → AB, (D → AB), E → AB
Die Menge VA können durch umgekehrte Graphensuche bestimmt werden: Suche alle Variablen
X, von denen aus A erreichbar ist.
Folgerung: Typ-2-Sprachen sind Typ-1-Sprachen.
Grund: CNF-Grammatik erfüllt die Forderungen von Typ-1-Grammatiken
4.6 Algorithus von CYK“

”
Der CYK-Algorithmus (Cocke, Kasami, Younger) wird zur Lösung des Wortproblems für kontextfreie
Sprachen in CNF angewandt. (basiert auf dem Prinzip dynamischer Programmierung)
Eingabe: s = s1 s2 ...sn ∈ Σ∗ . Ist s ∈ L(G)
∗
Vij := {X ∈ V | X → si si+1 ...sj } (1 ≤ i ≤ j ≤ n)... Teilprobleme s1 s2 ... si ...sj ...sn
s ∈ L(G) ⇔ s ∈ V1n
Berechne Mengen Vij induktiv, nach Länge j − i + 1 der Teilkette si ...sj .
A → BC... → si si+1 ...sk |sk+1 ...sj
Vii = {X | (X → si ) ∈ P }
Vij = {X | ∃(X → BC) ∈ P, ∃k: i ≤ k ≤ j: B ∈ Vik ∧ C ∈ Vk+1,j }
vorher berechnet
Beispiele: Gegeben sei folgende Grammatik in CNF:
Σ = {0, 1, +}
S → 0 | SP
P → MS | +
M → 0 | 1 | PP
Ist das Wort s = 0 + 1 + 0 = s1 s2 s3 s4 s5 in der Sprache L(G)?
i, j 1 2 3 4 5
1 M, S S − − −
2 P − − −
3 M − −
4 P −
5 M, S
⇒ 0 + 1 + 0 ist nicht in der Sprache L(G).
V12 = {S} oder k = 2 oder V11 = {M, S} V22 = {P }
k=1 V11 = {M, S} V23 = ∅

V13 = ∅
oder k = 2 oder V12 = {S} V33 = {M }
40
4.7. (ERWEITERTE) BACKUS-NAUR-FORM (E)BNF
S P
S P M S
0 + P P 0
+ +
s=0+++0
i, j 1 2 3 4 5
1 M, S S S S S
2 P M − M
0
3 P M P
+
4 P −
+
5 M, S
+
[
i < j: Vij = {X | ∃(X → BC) ∈ P : B ∈ Vik ∧ C ∈ Vk+1,j }
k=i,i+1,...,j−1
Laufzeit: Es müssen höchstens n2 Mengen Vij berechnet werden. Jede Berechnung ist eine Schleife über
höchstens n Werte k. ⇒ O(n3 )
4.7 (Erweiterte) Backus-Naur-Form (E)BNF

Beispiel: (hypothetische) Grammatik eines Ausschnitts einer Programmiersprache
harithmetischer
| {z Ausdruck}i ::= hTermi {hAdditionsoperatorihTermi}
Variable der Grammatik
↑
→
hAdditonsoperatori ::= + | −
Terminalsymbol oder“ Terminalsymbol
”
hTermi ::= hFaktori {hMultiplikationsoperatorihFaktori}
hMultiplikationsoperatori ::= ∗ | /
hFaktori ::= hZahli | hVariablei | (hArithmetischer Ausdrucki | hFunltionsaufrufi)
hFunktionsaufrufi ::= hNamei() | hNamei (hArgumentlistei)
hArgumentlistei ::= hArgumenti {, hArgumenti}
::= | { } [ ] h i
| {z }
Metasymbole
{...} beliebig viele Wiederholungen (auch 0) des Inhalts

[...] Optional. Der Inhalt kann auch weggelassen werden.
41
{ } [ ] müssen bei der Übersetzung in eine kontextfreie Grammatik aufgelöst werden, durch Einführen von
neuen Variablen und zusätzlichen Regeln.
{abc} ↔ (abc)∗
[abc] ↔ (abc + ε)
| {z }
als regulärer Ausdruck
|↔+
4.8 Pumping-Lemma für kontextfreie Sprachen

Für jede kontextfreie Sprache L gibt es eine Schranke n0 ∈ N.

∀x ∈ L: |x| ≥ n0 ∃y, z, u, v, w ∈ Σ∗ : x = yzuvw ∈ L ∧ (∀i ≥ 0)yz i uv i w ∈ L ∧ z, v 6= ε
z v
Beispiel: L = {0n 1n | n ∈ N}
Annahme: L sein kontextfrei ⇒ n0
x = 0n0 1n0 0n0 = yzuvw
Fall 1: z enthält sowohl 0 als auch 1.
z 2 , z 3 , ...enthält mehr Übergänge zwischen 0 und 1 als z

⇒yz 2 uv 2 w enthält mehr als 2 Übergänge
⇒yz 2 uv 2 w ∈
/L
Fall 2: v enthält 0 und 1 analog.

Also ist z und v jeweils in einem der drei Blöcke 0n0 , 1n0 , 0n0 enthalten.
yz i uv i w...mindestens ein Block ändert seine Länge, mindestens ein Block ändert seine Länge nicht.
⇒yz i uv i w ∈
/ L für i 6= 1
⇒ L ist nicht kontextfrei
Beweis: Sei L(G), G in CNF

Ein Ableitungsbaum für x mit |x| = n hat n − 1 innere Knoten A mit je zwei Kindern.
Der Ableitungsbaum ist ein binärer Baum

Wenn jeder Weg von der Wurzel zu einem Knoten, aus dem ein Terminalsymbol entsteht, ≤ h Vari-
ablenknoten enthält, dann |x| ≤ 2h−1
1 S
2 X X
3 X X X X
4 a X X b c
0 1
42
4.9. ABSCHLUSSEIGENSCHAFTEN KONTEXTFREIER SPRACHEN
Wenn |x| > 2h−2 , dann gibt es einen Weg von der Wurzel, der h Variablenknoten enthält
h := |V | + 1
→ Dieser Weg muss eine Variable A mehrfach enthalten.
S
n := 2|V |−1 + 1 funktioniert
Die beiden Teilbäume, die unter diesen beiden

T1
A Knoten hängen heißen T1 und T2
T2 ⊂ T1
T2
A
y z u v w
∗
S → yAw
∗
T1 : A → zAv (zv 6= ε)
∗
T2 : A → u
∗ ∗ ∗
S → yAw→yzAvw → yzuvw
beliebig oft wiederholen

∗ ∗
S → yAw → yuw (= yz 0 uv 0 w)
(i=0)
∗ ∗ ∗ ∗ ∗
S → yAw → yzAvw → yzzAvvw → yz i Av i w → yz i uv i w
(i≥1)
Folgerung: Die Chomsky-Hierarchie ist echt: L0 , L1 , L2 , L3 seien die Typ-0-Sprachen, Typ-1-Sprachen, ...
L3 ⊂ L2 ⊂ L1 ⊂ L0
regulär 6= kontextfrei 6= kontextsensitiv 6= rekursiv aufzählbar
L= {0n 1n } L= {0n 1n 0n } ⊂ entscheidbare Sprachen Halteproblem
4.9 Abschlusseigenschaften kontextfreier Sprachen

Satz: Kontextfreie Sprachen sind abgeschlossen bezüglich ∪, ·, ∗
Kontextfreie Sprachen sind nicht abgeschlossen bezüglich ∩ und Komplement
Beweis: L1 = {0n 1n 0m | m, n ∈ N}, L1 = {0n 1m 0m | m, n ∈ N}

L1 ∩ L2 = {0n 1n 0n | b ∈ N} nicht kontextfrei.
L1 ∩ L2 = L1 ∪ L2 (de-Morgan)
Wenn kontextfreie Sprachen abgeschlossen bezüglich Komplement wären, dann wäre sie auch abgeschlossen
bezüglich ∩
Das Komplement von {0n 1n 0n } ist kontextsensitiv.
43
4.10 Entscheidungsprobleme kontextfreier Sprachen

Seien G1 , G2 kontextfreie Grammatiken
• L(G1 ) = 0? entscheidbar
• L(G1 ) = 0? entscheidbar
• Ist L(G1 ) regulär? unentscheidbar
• L(G1 ) = Σ∗ ? unentscheidbar (ohne Beweis)
• L(G1 ) = L(G2 )? unentscheidbar (ohne Beweis)
• L(G1 ) ⊆ L(G2 )? unentscheidbar (ohne Beweis)
• L(G1 ) ∩ L(G2 ) = ∅? unentscheidbar (s. Übung 11)
• L(G1 ) 6= ∅?
Wir nehmen an, dass G1 in CNF vorliegt.
Definition: Eine Variable heißt überflüssig, wenn sie in keiner Ableitung eines Wortes ∈ Σ∗ vorkommt.
2 Gründe: 1. S → AB → ABA → ... von S nicht ereichbar.
2. Aus der Variable lässt sich kein Terminalwert erzeugen.
Beispiel: A → AB (einzige Regel für A)
• Menge M : Initialisiere M := {A ∈ V | (A → x) ∈ P }
• Wenn ses eine Regel A → BC mit B, C ∈ M gibt, dann setzte M := M ∪ {A}.

• Wiederhole, bis keine neuen Varaiblen mehr in M aufgenommen werden. Variablen in M = V − M
sind überflüssig aus dem zweiten Grund.
• Entferne die Variablen in M und alle Reglen, die M enthalten aus der Grammatik.
S →
AC (A ∈ M )
M2 := Menge der Variablen, die von S aus erreichbar sind.
• Initialisiere M2 := {S}
• Wenn es eine Regel A → BC mit A ∈ M2 gibt, dann setze M2 = M2 ∪ {B, C}.
• Wiederhole, bis M3 sich stabilisiert.
• Streiche Variablen in V − M2 . Das Ergebnis ist eine Grammatik ohne Überflüssige Variablen.
4.11 Kellerautomaten
Typ-0-Sprachen ⇐⇒ Turingmaschinen
(Typ-1-Sprachen ∼ Turingmaschinen mit linearem Platzbedarf)
Typ-2-Sprachen ⇐⇒ Kellerautomaten
Typ-3-Sprachen ⇐⇒ endliche Automaten
Linksableitung:
S → ABC → bAABC → bbAAABC → bbAABC → bb B BSBC
| {z }
Terminalsymbole des endgültigen Wortes aktuelle Variable zukünftige Variablen“

”
D. h. Änderung nur am Anfang, den nur das erste Variablensymbol wird durch etwas anderes ersetzt.
44
4.11. KELLERAUTOMATEN
Definition: Ein (nichtdeterministischer) Kellerautomat (Push-down automaton, PDA) hat

• ein Eingabealphabet Σ
• eine Zustandsmenge Q
• ein Kelleralphabet Γ
• ein Bodensymbol Z0 ∈ Γ
• einen Anfangszustand q0 ∈ Q
∗
• eine Übergangsrelation δ: Q × (Σ ∪ {ε}) × Γ → 2Q×Γ
(q ′ , z) ∈ δ(q, a, γ) bedeutet: Wenn der PDA im Zustand q ist, as obere Kellersymbol γ ist, und er den Buchstaben
a liest (bzw. nichts liest, falls a = ε ist), dann kann er in den Zustand q ′ wechseln und die Spitze des Kellers
durch z ersetzen (z = ε: Das oberste Symbol γ wird gelöscht).
Es gibt zwei Arten von Kellerautomaten:

a) solche, die mit leerem Keller akzeptieren.
b) solche, die durch eine Menge F ⊆ Q von akzeptierenden Zuständen akzeptieren
Beispiel: L = {w#wR | w ∈ {0, 1}}

Σ = {0, 1, #}
Γ = {0, 1, Z0}
a) Q = {q0 , q1 }
b) Q = {q0 , q1 , q2 } mit F = {q2 }
δ(q0 , 0, Z0 ) = {(q0 , 0Z0 )} δ(q1 , 0, 0) = {q1 , ε}

δ(q0 , 1, Z0 ) = {(q0 , 1Z0 )} δ(q1 , 1, 1) = {q1 , ε}
δ(q0 , 0, 0) = {(q0 , 00)} a)δ(q1 , ε, Z0 ){q1 , ε}
δ(q0 , 0, 1) = {(q0 , 01)} a)δ(q1 , ε, Z0 ){q2 , Z0 }
δ(q0 , 1, 0) = {(q0 , 10)} δ(q1 , 0, 1) = ∅
..
δ(q0 , 1, 1) = {(q0 , 11)} .
δ(q0 , #, 1) = {(q1 , 1)} usw.
δ(q0 , #, 0) = {(q1 , 0)}
δ(q0 , #, Z0 ) = {(q1 , Z0 )}
Definition: Eine Konfiguration eines Kellerautomaten ist ein Tripel (q, w1 ...wm , z) mit
• q ∈ Q... augenblicklicher Zustand,
• w1 ...wn ∈ Σ∗ ... noch nicht gelesener Teil des Eingabewortes und
• z ∈ Γ∗ ... Inhalt des Stapels (Spitze ist links.)
Beispiel:
(a) ⊢ (q1 , ε, ε)
(q0 , 01#10, Z0 ) ⊢ (q0 , 1#10, 0Z0 ) ⊢ (q0 , #10, 10Z0 ) ⊢ (q1 , 10, 10Z0 ) ⊢ (q1 , 0, 0Z0 ) ⊢ (q1 , ε, Z0 )
(b) ⊢ (q2 , ε, Z0 )
Nachfolgerelation ⊢ für Konfiguration
(q, w1 w2 ...wn , z1 ...zk ) ⊢ (q ′ , w2 ...wn , zz2 ...zk ) falls (q ′ , z) ∈ δ(q, w1 , z1 ), w1 ∈ Σ
(q, w1 w2 ...wn , z1 ...zk ) ⊢ (q ′ , w1 ...wn , zz2 ...zk ) falls (q ′ , z) ∈ δ(q, ε, z1 )

∗
⊢ ... transitive reflexive Hülle von ⊢
45
Die vom PDA M akzeptierte Sprache ist:

∗
a) L(M ) = {x ∈ Σ∗ : (q0 , x, Z0 ) ⊢ (q ′ , ε, ε), q ′ ∈ Q}
∗
b) L(M ) = {x ∈ Σ∗ : (q0 , x, Z0 ) ⊢ (q ′ , ε, z), q ′ ∈ F, z ∈ Γ∗ }
Definition: Ein PDA ist ein deterministischer Kellerautomat (DPDA) wenn:
∀q ∈ Q, γ ∈ Γ, a ∈ Σ: |δ(q, a, γ)| + |δ(q, ε, γ)| ≤ 1
(Dann gibt es zu jeder Konfiguration höchstens eine Nachfolgekonfiguration.)
D. h. unser obiges Beispiel ist eigentlich ein DPDA
Beispiel: L2 = {wwR | w ∈ {0, 1}∗}
Σ = {0, 1} Γ = {0, 1, Z0}
δ(q0 , w, γ) wie oben (w ∈ {0, 1})
δ(q0 , ε, γ) = {(q1 , γ)} für γ ∈ {0, 1, Z0}
δ(q1 , ...) wie oben.
(q0 , 0110, Z0) ⊢ (q0 , 110, 0Z0) ⊢ (q0 , 10, 10Z0) ⊢ (q1 , 10, 10Z0) ⊢ ...weiter wie bisher ⊢ (q0 , 0110, Z0)
⊢ (q0 , 110, 0Z0) ⊢ (q1 , 110, 0Z0 ) STOP.
Satz: Die PDAs, die nach (a) und nach (b) akzeptieren, akzeptieren dieselbe Klasse von Sprachen.
Beweis: ⇒“ Seien M = (Q, Σ, Γ, q0 , Z0 , δ) ein PDA, der mit leerm Keller akzeptiert, und
” ′
M = (Q ∪ {qF , q0′ }, Σ, Γ ∪ {Z0′ }, q0′ , Z0′ , δ ′ , F = {qF }) ein PDA, der nach b) akzeptiert
δ ′ (q0′ , ε, Z0′ ) = {(q0 , Z0 Z0′ )} δ ′ (q, ε, Z0′ ) = {(qF , ε)}
• Alle Übergänge von δ werden übernommen.

• M ′ fügt ein zusätzliches Kellersymbol Z0′ als unterstes ein.
⇐“ M = (Q, Σ, Γ, q0 , Z0 , δ, F ) sei ein Automat, der nach b) akzeptiert
”
neuer Automat M ′ :
• fügt ein zusätzliches unterestes Kellersymbol ein. Wenn M in einem akzeptierenden Zustand
übergehen, wo der Keller geleert wird, ohne die Eingabe gelesen wird.
• Das zusätzliche Kellersymbol stellt sicher, dass M ′ nicht nur deshalb akzeptiert, weil M den
Keller leert.
Satz: Die kontextfreien Sprachen sind genau die Sprachen, die von Kellerautomaten akzeptiert werden.
Beweis: ⇒“ Wir nehmen an, die Grammatik ist in CNF.
”
• Σ, Γ = V, Z0 = S, {q0 }, Automat akzeptiert mit leerem Keller.
• Für jede Regel A → B1 B2 ...Bk füge (q0 , B1 ...Bk ) ∈ δ(q0 , ǫ, A) ein.
• Für jede Regel A → u ∈ Σ füge (q0 , ε) ∈ δ(q0 , u, A) ein.
δ(q0 , ε, A) := {(q0 , B1 ...Bk ) | (A → B1 ...Bk ∈ V ∗ ) ∈ P }
δ(q0 , u, A) := {(q0 , ε) | (A → u) ∈ P }, u ∈ Σ
Der Kellerautomat kann nun genau die Linksableitung der Grammatik nachbilden.
S → ABC → uBC → uAAC → uAC → uvC → uvBC → uvuC → uvuv
m
(q0 , uvuv, S) ⊢ (q0 , uvuv, ABC) ⊢ (q0 , vuv, BC) ⊢ (q0 , vuv, AAC) ⊢ ...
⇐“ Gegeben: Kellerautomat, akzeptiert durch F ⊆ Q von akzeptierenden Zuständen.
”
Gesucht: Grammatik G.
V = Q × Γ × Q ∪ {S} Variablen haben die Form (q, Z, q ′ )

Tripelkonstruktion“
”
46
4.11. KELLERAUTOMATEN
∗
Idee: S → w1 w2 ...wk (q1 , Z1 , q2 )(q2 , Z2 , q3 )(q3 , Z3 , q4 )...(ql , Zl , ql+1 )
| {z }
das soll folgende Rechnung widerspiegeln
∗
(q0 , w1 ...wn , Z0 ) ⊢ (q1 , wk+1 ...wn , Z1 Z2 ...Zl ) (die ersten k Symbole sind gelesen.)
• qi>1 ist der Zustand, der in der weiteren Rechnung angenommen wird, sobald Zi als oberstes
Startsymbol erscheint.
• q2 , q3 , ... werden geraten.
Regeln: Für alle (q ′ , z ′ ) ∈ δ(q, a, z) mit |z ′ | ≥ 1, Z ′ = z1 z2 ...zl
(q, z, q̄) → a(q ′ , z1 , q1 )(q1 , z2 , q2 )...(ql−1 , zl , q̄), ∀q1 , q2 , ..., ql−1 , q̄ (a ∈ Σ ∪ {ε})
Für alle (q ′ , ε) ∈ δ(q, a, z)
(q, z, q ′ ) → a
∗ ∗
Behauptung: (q, Z, q ′ ) → w ∈ Σ∗ ⇔ (q, w, Z) ⊢ (q ′ , ε, ε)
Der Automat hat w gelesen und sieht das erste Mal, was unter Z auf dem Stapel ist.
Beweis durch Induktion nach der Länge der Ableitung bzw. nach der Länge der Rechnung.
Beispiel: L = {wwT | w ∈ {0, 1}∗ } Q = {q0 , q1 }
δ(q0 , x, z) = {(q0 , xz)}, x ∈ {0, 1}, z ∈ {0, 1, z0} (1)

δ(q0 , ε, z) = {(q1 , z)} (2)
δ(q1 , x, x) = {(q1 , ε)}, x ∈ {x ∈ {0, 1}} (3)
δ(q1 , ε, z0 ) = {(q1 , ε)}
Also werden die folgenden Produktionen gebildet

(1) am Beispiel δ(q0 , 0, Z0 ) = {(q0 , 0Z0 )}
(q0 , Z0 , q0 ) → 0(q0 , 0, q0 )(q0 , Z0 , q0 )

(q0 , Z0 , q0 ) → 0(q0 , 0, q1 )(q1 , Z0 , q0 )
−→ (q0 , Z0 , q1 ) → 0(q0 , 0, q0 )(q0 , Z0 , q1 )
−→ (q0 , Z0 , q1 ) → 0(q0 , 0, q1 )(q1 , Z0 , q1 )
(2) am Beispiel δ(q0 , ε, 0) = {(q1 , 0)}
(q0 , 0, q0 ) → (q1 , 0, q0 )
(q0 , 0, q1 ) → (q1 , 0, q1 )
(3) am Beispiel δ(q0 , ε, 0) = {(q1 , 0)}
(q1 , 1, q1 ) → 1
(q0 , 0110, Z0) ⊢ (q0 , 110, 0Z0) ⊢ (q0 , 10, 10Z0) ⊢ (q1 , 10, 10Z0) ⊢ (q1 , 0, 0Z0) ⊢ (q1 , ε, Z0 )
⊢ (q1 , ε, ε)
S → (q0 , Z0 , q1 ) → 0(q0 , 0, q1 )(q1 , Z0 , q1 ) → 01(q0 , 1, q1 )(q1 , 0, q1 )(q1 , Z0 , q1 )

→ 01(q1 , 1, q1 )(q1 , 0, q1 )(q1 , Z0 , q1 ) → 011(q1 , 0, q1 )(q1 , Z0 , q1 )
→ 0110(q1 , Z0 , q1 ) → 0110
Annahme: Automat akzeptiert durch leeren Keller

Startregeln: S → (q0 , Z0 , q̄) für alle q̄ ∈ Q
Aus der Behauptung folgt: L(G) = L(M )
∗ ∗ Beh. ∗
w ∈ L(G) ⇔ S w⇔ ∃q̄: (q0 , Z0 , q̄) → w ⇐⇒ ∃q̄: (q0 , w, Z0 ) ⊢ (q̄, ε, ε) ⇔ w ∈ L(M )
47
4.12 Abschlusseigenschaften kontextfreier Sprachen gegenüber regulären

Sprachen
Satz: Die kontextfreien Sprachen sind abgeschlossen gegenüber dem Durchschnitt mit regulären Sprachen.
Bew.: M1 sei ein PDA für die kontextfreie Sprache L1 , der durch akzeptierende Zustände akzeptiert. A2 sei ein
DEA für L2 .
• PDA: M mit Q = Q1 × Q2
δ((q1 , q2 ), ε, Z) := {((q ′ , q2 ), z ′ ) : (q ′ , z ′ ) ∈ δ1 (q1 , ε, Z)}

δ((q1 , q2 ), a, Z) := {((q ′ , δ2 (q2 , a)), z ′ : (q ′ , z ′ ) ∈ δ1 (q1 , a, Z))} a∈Σ
q0 = (q01 , q02 )
F = F1 × F2
Produkt der Automaten: Der neue Kellerautomat M simuliert M1 und A2 gleichzeitig:

”
L(M )) = L(M1 ) ∩ L(A2 )
4.13 Deterministische kontextfreie Sprachen

Definition: Eine deterministische kontextfreie Sprache ist eine Sprache, die von einem deterministischen Keller-
automaten mit einer akzeptierenden Zustandsmenge akzeptriert werden.
Beispiele: • {0n #1n | n ∈ N} ist deterministisch kontextfrei

• {w#wR | w ∈ Σ∗ } ist deterministisch kontextfrei
• {wwR | w ∈ {0, 1}∗} ist kontextfrei, aber nicht deterministisch kontextfrei
Bemerkung: Deterministisch kontextfreie Sprachen sind abgeschlossen unter Komplement, aber nicht unter
Umkehrung.
4.14 Deterministische Zweiwege-Kellerautomaten
⇐⇒ K1 K2
K1 K2
Kellerautomaten mit zwei Kellern, sind genauso mächtig wie Turingmaschinen.
Deterministische Zweiwege-Kellerautomaten können auf dem Eingabeband beliebig nach links uder nach rechts
fahren.
δ(q, a, z) = (q ′ , Z1 Z2 ...Zk , b), a ∈ Σ ∪ {%, $}, b ∈ {0, +1, −1}: Bewegung des Kopfes
Die Eingabe ist durch % und $ auf dem Eingabeband begrenzt.
%w1 w2 ...wn $ Ausgangskonfiguration
Lesekopf
48
4.14. DETERMINISTISCHE ZWEIWEGE-KELLERAUTOMATEN
4.14.1 Teilwortproblem
Eingabe: x#y
Frage: Kommt das Muster x im Text y vor?
L = {x#uxv | x, u, v ∈ (Σ0 )∗ }
% x # $
..
.
• Kopiere y auf den Stapel, von rechts nach links
• Fahre zur ersten Position von x
• (A) Vergleiche die Symbole von x mit dem Sybol auf dem Stapel, die Symbole werden vom Stapel gelöscht.
• Wenn # gelesen wird → Teilwort vorhanden → akzeptiere
• Bei einem Konflikt fahre zurück zum Anfang und fülle den Stapel mit den Symbolen von x auf. Lösche
erstes Symbol des Stapels und gehe zu (A).
Satz: Jede Sprache, die von enem deterministischen Zweiwege-Kellerautomaten akzeptiert wird, kann in linearer
Zeit von einer Registermaschine (RAM) entschieden werden.
Folgerung: Teilwortproblem ist in linearer Zeit lösbar.
Beweis: Entladefunktion
Eingabe: %w1 ...wn $
↑ ↑ ... ↑
0 1 n+1
ent(q, Z, i) = (q ′ , j) q, q ′ ∈ Q, Z ∈ Γ, 0 ≤ i, j ≤ n + 1
Wenn der Automat im Zustand q an Position i ist, und das oberste Stapelsymbol Z ist, dann ist er zu
dem Zeitpunkt, wo das darunterliegende Stapelsymbol sichtbar wird, in Zustand q ′ und an Position j
e n t ( q, Z, i )
i f i n A r b e i t [ q, Z, i ] then STOP ; // Wort wir d n i c h t a k z e p t i e r t
i f ENT[ q, Z, i ] 6= 0 then
return ENT[ q, Z, i ]
i n A r b e i t [ q, Z, i ] := true
..
.
(q ′ , Z1 ...Zk , b) := δ(q, wi , Z)
j := i + b
for l := 1, 2, ..., k
(q ′ , j) := e n t ( q ′ , Zl , j )
ENT[ q, Z, i ] := (q, j)
i n A r b e i t [ q, Z, i ] := f a l s e
return ( q ’ , j )
Idee: Speichere die Werte der Entladefunktion in einem Feld ENT[q, Z, i] der Größe O(n) sobald sie berechnet
wurden (Initialisiere zu 0).
Die Technik heißt Tabellieren (engl. memorization)
Laufzeit: O(n) Jeder Eintrag von ENT wird höchstens einmal berechnet.
Problem: Bei rekursiven Aufrufen kann die Laufzeit ∞ sein. Während ent(q, z, i) aufgerufen ist, kann ein rekur-
siver Aufruf mit denselben Parametern (q, z, i) gestartet werden.
⇒ Algorithmus terminiert nicht.
⇒ Kellerautomat terminiert nicht, weil sich die Konfiguration (q, z, i) unendlich oft wiederholt. Der Stapel
wird dabei immer weiter wachsen oder konstant bleiben.
49
Durch ein Boolsches Feld inArbeit[q, z, i] (am Anfang false) wird endlose Rekursion vermieden.
Wir können annehmen, dass der Kellerautomat, wenn er ein Wort akzeptieren will, in einen akzeptierenden
Zustand geht und dann der Keller leert.
Wort wird akzeptiert ⇐⇒ ent(q0 , z0 , 1) = (q ′ , j) mit q ′ ∈ F
50

GTI Mitschrift

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

GTI Mitschrift

Uploaded by

Copyright:

Available Formats

Grundlagen der Theoretischen Informatik

mitgeschrieben von Martin Lenders

1 Turing-Maschine, Berechenbarkeit, Entscheidbarkeit 5

2 Reguläre Sprachen und endliche Automaten 17

4 Kontextfreie Sprachen (Typ-2-Sprachen) 35

4.12 Abschlusseigenschaften kontextfreier Sprachen gegenüber regulären Sprachen . . . . . . . . . . . 48

Zweiseitiges, unendliches Band

Eine Turingmaschine wird beschrieben durch:

01, 0011, 000111, ... (richtig)

1.2 Church’sche These

Beispiel: Addition zweier Binärzahlen

formal: Γ = Γ1 × Γ2 × Γ3 × . . . × Γk , Γi . . . Bandalphabet für die i-te Spur.

Simulation eines RAM-Speichers auf einer TM:

##x1 #y1 ##x2 #y2 ##...###[Programmcode]

xi ... Adresse, yi ... Inhalt auf Adresse xi

1.4 Formale Sprachen

Definition: Eine formale Sprache L ist eine Teilmenge von Σ∗

1.4.1 Multiplikation von Wörtern

1.4.2 Multiplikation von Sprachen

Rechenregeln: 1. L1 · (L2 · L3 ) = (L1 · L2 ) · L3

Beispiel: L1 = {a,ab} L2 = {a,ba}

1.4.3 Potenz von Wörtern und von Sprachen

1.5 Konfiguration (Momentaufnahme einer Turingmaschine)

1.6 Turingmaschine mit mehreren Bändern

Γ1 = Γ ∪ (Γ × {X, ’ ’})k ∪ {L}

1.7 Die universelle Turingmaschine

Konventionen: a) M hat das Eingabealphabet {0, 1}

δ(q1 , 0) = (q2 , B, −1), δ(q4 , γ5 ) = (q2 , γ5 , +1), ...

LU = {hM ix|M akzeptiert x} ⊆ {0, 1}∗

Satz: Es gibt eine universelle Turingmaschine MU mit L(MU ) = LU

Aufzählung aller Wörter aus {0, 1}∗ und aller Turingmaschinen:

Definition: Die Diagonalsprache D ist

w1 w2 w3 ··· wi ··· wk ···

D = L(Mk ) = {w|Mk akzeptiert w}

Betrachtet das Wort wk :

Satz: Das Komplement D der Diagonalsprache

D = {wi |wi ∈ L(Mi )}

ist rekursiv aufzählbar, aber nicht entscheidbar

Beweis: 1. MD überprüft, ob die Eingabe eine gültige Gödelnummer hM i ist,

akzeptiert genau dann, wenn wi ∈

Lasse M1 und M2 parallel“ laufen (abwechselnd) auf derselben Eingabe x ∈ Σ∗

1.8.2 Das Halteproblem

Formuliereung des Problems als formale Sprache:

H = {hM i|M hält bei Eingabe von x}

Satz: Das Halteproblem ist unentscheidbar

1.8.3 Reduzierbarkeit von Problemen

1.8.4 Das Post’sche Korrespondenzproblem (PKP)

Satz: PKP ist unentscheidbar

Beweis: U ≤ P KP Zwischenschritt: Modifiziertes PKP

#q0 v# u1 q 1 v1 #u2 q 2 v2 #u3 q 3 v3 #...

(qa, q ′ b), falls δ(q, a) = (q ′ , b, 0)

Frage für MPKP: Gibt es eine Folge

Sodass xi1 xi2 ...xik = yi1 ...yik

x′i = xi mit einem neuen Symbol # nach jedem Buchstaben

x′0 = #x′1 x′0 = #0#

1.8.5 Andere unentscheidbare Probleme

1.8.6 Satz von RICE (1953)

L(M ′ ) hat Eigenschaft S ⇔ M hält bei Eingabe ε

• M ′ bekommt die Eingabe x ∈ Σ∗

• eine endliche Zustandsmenge Q

• ein endliches Eingabealphabet Σ

• eine Menge von akzeptierenden Zuständen F ⊆ Q

L(A) = die von A akzeptierte Sprache

Wir erweitern δ : Q × Σ → Q auf δ : Q × Σ∗ → Q