Kellerautomaten und Turingmaschinen Klaus Becker 2010

Kellerautomat und Turingmaschine

Erkennen von Klammersprachen Teil 1 Erkennen von Klammersprachen

Klammersprachen Der Hund, der die Katze, die eine Maus, die gerade ein Stück Käse, das gestern, als das Fußballspiel, das im Fernsehen gezeigt wurde, gerade zu Ende war, weggeworfen wurde, anbeißt, jagt, anbellt, heißt Bello. 12+5 23*(57+18) 3+5*(7+4) ((2+6)+5)*(7+4) ... <?xml version="1.0" encoding="iso-8859-1"?> <Buch> <Autor> <Name>Borik</Name> <Vorname>Otto</Vorname> <Hrsg/> </Autor> <Titel>Meyers Schachlexikon</Titel> <Verlag>Meyers Lexikonverlag</Verlag> <Erscheinungsort>Mannheim</Erscheinungsort> <Erscheinungsjahr>1993</Erscheinungsjahr> <ISBN>3-411-08811-7</ISBN> </Buch> MarkeSetzen Schritt SOLANGE NichtIstMarke TUE SOLANGE NichtIstWand TUE Schritt *SOLANGE LinksDrehen *SOLANGE

Beispiel: Rechenausdrücke Rechenausdrücke sind Ausdrücke, in denen Zahlen, Rechenzeichen und Klammern vokommen können. Sie begegnen uns überall, wo kompliziertere Rechnungen dargestellt werden müssen. 12+5 23*(57+18) 3+5*(7+4) ((2+6)+5)*(7+4) ... z+z z*(z+z) z+z*(z+z) ((z+z)+z)*(z+z) ... Im folgenden wollen wir uns auf die Klammer- und Rechenstruktur solcher Rechenausdrücke konzentrieren. Die Zahlen soll nur eine untergeordnete Rolle spielen. Wir ersetzen daher jede Zahl durch das Symbol "z". Zusätzlich betrachten wir der Einfachheit halber nur Rechenausdrücke mit den Rechenzeichen + und *. Entscheidend für die so vereinfachten Rechenausdrücke ist die korrekte Klammerung: Zu jeder öffnenden Klammer muss es - an passender Stelle - eine schließende Klammer geben.

Beispiel: Rechenausdrücke Die Sprache LRA der vereinfachten Rechenausdrücke soll genau solche Klammer- und Rechenstrukturen beschreiben. Sie basiert auf dem Alphabet Σ = {z, +, *, (, )}. Präzise beschreiben kann man sie mit der folgenden Grammatik: A -> A + S A -> S S -> S * F S -> F F -> ( A ) F -> z Aufgabe: Zeige mit Hilfe einer Ableitung, dass das Wort z*(z+z) (einfach) bzw. das Wort z+z*(z+z) (schwieriger) mit Hilfe der Grammatik erzeugt werden kann.

Beispiel: Programmiersprachen Als Beispiel für eine sehr einfache Programmiersprache betrachten wir die Sprache, mit der man den Roboter Karol steuern kann. Auch hier kommen Klammerstrukturen vor. Bei einer Solange-Anweisung werden Beginn und Ende mit den Schlüsselwörtern SOLANGE und *SOLANGE gekennzeichnet.

Beispiel: Programmiersprachen Wir wollen Karol-Programme vereinfacht darstellen. Mit dem Symbol e soll eine elementare Anweisung beschrieben werden, mit dem Symbol b eine Bedingung. Mit den Symbolen s und * sollen Beginn und Ende einer SOLANGE-Anweisung gekennzeichnet werden. MarkeSetzen Schritt SOLANGE NichtIstMarke TUE SOLANGE NichtIstWand TUE Schritt *SOLANGE LinksDrehen *SOLANGE e e s b s b e * e * eesbsbe*e* Aufgabe: Entwickle eine Grammatik für die Sprache LRP der vereinfachten Roboterprogramme. Du kannst sie auch selbstständig um Symbole zur Kennzeichnung von Fallunterscheidungen erweitern.

Beispiel: XML XML benutzt sogenannte Tags zur Informationsbeschreibung. Anfangs- und Endtags bilden dabei jeweils Klammerpaare. <?xml version="1.0" encoding="iso-8859-1"?> <Buch> <Autor> <Name>Borik</Name> <Vorname>Otto</Vorname> <Hrsg/> </Autor> <Titel>Meyers Schachlexikon</Titel> <Verlag>Meyers Lexikonverlag</Verlag> <Erscheinungsort>Mannheim</Erscheinungsort> <Erscheinungsjahr>1993</Erscheinungsjahr> <ISBN>3-411-08811-7</ISBN> </Buch> XML erlaubt es dem Benutzer, solche Klammerpaare selbst festzulegen und somit flexibel komplexe Klammerstrukturen zu entwickeln.

Beispiel: XML Die Sprache LMyXML soll vereinfachte XML-artige Ausdrücke beschreiben. Jedes zu dieser Sprache gehörende Wort soll aus einem Anfangstag, einem Text und einem Endtag bestehen. Anfangs- und Endtag sollen im Wesentlichen identisch sein. Die Tag-Bezeichner sind beliebige nicht-leere Zeichenketten, die nur aus den Buchstaben a und b bestehen. Der Text zwischen den Anfangs- und End-Tag soll nur aus den Buchstaben a, b und c bestehen. Zur Sprache LMyXML gehört beispielsweise das Wort <ab>acaa</ab>. S -> <aAT> S -> <bBT> T -> aAT T -> bBT T -> M Aa -> aA Ab -> bA AM -> Ma Ba -> aB Bb -> bB BM -> Mb M -> >N N -> aN N -> bN N -> cN N -> </ Aufgabe: Die Sprache LMyXML kann mit der gezeigten Grammatik beschrieben werden. Erstelle eine Ableitung des Worts <ab>acaa</ab>.

Grenzen von endlichen Automaten Problem: Kann man Klammersprachen mit endlichen Automaten erkennen? (((()))) aaaabbbb ok A ((()) aaabb Fehler Wir betrachten hier korrekte Klammerausdrücke der Gestalt (((...))), die nach einer Anzahl öffnender Klammern genauso viele schließende Klammern haben. So ist (()) ein korrekter Klammerausdruck, während die Ausdrücke (() und (()))) keine korrekten Klammerausdrücke in unserem Sinne sind. Versuche, einen endlichen Automaten A zur Erkennung solcher Klammerausdrücke zu konstruieren, scheitern an der Schwierigkeit, die Anzahl der öffnenden Klammern im Automaten mitzuzählen. Es scheint, dass diese Schwierigkeit bei endlichen Automaten - die ja eine feste Anzahl von Zuständen haben - unüberwindbar ist. Die folgenden Argumentationen zeigen, dass das tatsächlich der Fall ist.

Grenzen von endlichen Automaten Gibt es einen endlichen Automaten, der L = {anbn | n = 1, 2, 3, ...} erkennt? (((()))) aaaabbbb ok DFA ((()) aaabb Fehler Angenommen, es gibt einen endlichen Automaten A mit L(A) = L. Dieser Automat A hat eine feste Anzahl Zustände, etwa m = 15 (die Zahl 15 ist hier willkürlich gewählt, sie spielt für die Argumentation keine Rolle). Wie wählen nun ein Wort w = akbk aus L = {anbn | n = 1, 2, 3, ...} aus mit k > m, etwa k = 16. Bei der Abarbeitung des Wortes w = akbk muss bereits bei der Verarbeitung der 16 a's mindestens ein Zustand z mindestens zweimal durchlaufen werden, denn es gibt mehr a's als Zustände. Wir nehmen einmal an, dass der Zustand z mit dem dritten a und mit dem siebten a erreicht wird. Für die folgende Argumentation ist nicht entscheidend, mit welchen a's man z erreicht, sondern nur, dass z zweimal durchlaufen wird. Es entsteht eine Schleife, die erst mit dem ersten b wieder verlassen wird. Wie die 16 b's den Automaten in einen Endzustand bringen, ist für die Argumentation ohne Belang.

Grenzen von endlichen Automaten Die folgende Grafik soll die Situation verdeutlichen: - A hat m Zustände (hier m = 15). - A akzeptiert w = akbk mit k > m (hier w = a16b16). - Bei der Verarbeitung des a-Anfangsteils von w wird ein Zustand mindestens zweimal durchlaufen werden (hier wird q3 insgesamt 4 mal durchlaufen). Weitere spezielle Eigenschaften von A, die in der Grafik zu erkennen sind, sind für den Beweisgang nicht von Bedeutung. Grafik entnommen aus: http://hsg.region-kaiserslautern.de/faecher/inf/material/automaten/anbn/index.php

Grenzen von endlichen Automaten Dem Bild kann man direkt entnehmen, dass neben w = a16b16 auch andere Wörter wie a4b16 (Schleife wurde nicht durchlaufen) oder auch a8b16 (Schleife wurde einmal durchlaufen) akzeptiert werden. Der Automat akzeptiert folglich auch Wörter, die nicht zu L = {anbn | n = 1, 2, 3, ...} gehören. Das steht aber im Widerspruch zur Annahme, dass der Automat A die Sprache L = {anbn | n = 1, 2, 3, ...} erkennt. Da die Annahme, dass es einen endlichen Automaten gibt, der die Sprache L = {anbn | n = 1, 2, 3, ...} erkennt, zu einem Widerspruch führt, muss die Annahme falsch sein. Satz (über die Grenzen von endlichen Automaten): Die Sprache L = {anbn | n = 1, 2, 3, ...} kann nicht von einem endlichen Automaten erkannt werden. Sie ist also nicht regulär.

Erweitertes Automatenmodell Wir betrachten hier korrekte Klammerausdrücke der Gestalt (((...))), die nach einer Anzahl öffnender Klammern genauso viele schließende Klammern haben. So ist (()) ein korrekter Klammerausdruck, während die Ausdrücke (() und (()))) keine korrekten Klammerausdrücke in unserem Sinne sind. Kellerautomat / Stapelautomat

Erweitertes Automatenmodell Aufgabe Erstelle mit JFlap den abgebildeten erweiterten Automaten (mit [File][New][Pushdown Automaton]). Teste mit [Input][Step by State] die Arbeitsweise des erweiterten Automaten.

Kellerautomat Der Kellerautomat hat eine nichtleere endliche Menge Z von Zuständen. Im vorliegenden Fall ist das die Menge Z = {q0, q1, q2}. Der Zustand q0 ist hier als Anfangszustand ausgezeichnet, der Zustand q2 als ein Endzustand. Eine Verarbeitung wird durch einen Zustandsübergang (von einem Zustand in einen anderen, gegebenenfalls denselben Zustand) beschrieben. Ein Zustandsübergang erfolgt nur in Abhängigkeit von einem Eingabesymbol und den obersten Kellersymbolen. Ein Zustandsübergang aktualisiert zudem den Keller, indem Symbole vom Keller entfernt und neue Symbole im Keller abgelegt werden. zu entfernende oberste Kellersymbole hinzuzufügende oberste Kellersymbole Eingabe

Fachkonzept - Kellerautomat Ein (deterministischer) Kellerautomat ist eine Verarbeitungseinheit, die durch folgende Bestandteile festgelegt wird: e. nichtleere, endl. Menge von Zuständen eine nichtleere, endliche Menge von Eingabesymbolen eine nichtleere, endliche Menge von Kellersymbolen, eine Überführungsfunktion, die dem aktuellem Zustand in Abhängigkeit von einer vorgegebener Eingabe und einer Folge von Kellersymbolen die Folgezustände zuordnet und zudem die jeweils neu im Keller aufzunehmenden Symbole festlegt, ein ausgezeichneter Zustand - dem Anfangszustand -, eine Menge von Endzuständen ein ausgezeichnetes Kellersymbol, das die untere Kellerbegrenzung beschreibt. Bei einem nichtdeterministischen Kellerautomaten müssen die Zustandsübergänge nicht eindeutig sein. Zudem sind λ-Übergänge möglich.

Fachkonzept - Kellerautomat Die Menge der Eingabesymbole eines Kellerautomaten kann als Alphabet einer Sprache aufgefasst werden. Unter der Sprache eines Kellerautomaten versteht man die Menge aller Wörter aus Eingabesymbolen, die den Kellerautomaten vom Anfangszustand in einen Endzustand überführen. Wenn K ein gegebener Kellerautomat ist, dann schreiben wir L(K) für die Sprache des Kellerautomaten K.  = {(, )} L(A) = {(), (()), ((())), ...}

Fachkonzept - Kellerautomat Ein Kellerautomat ist also eine Verarbeitungseinheit, die Symbole eines Eingabeworts verarbeitet, sich dabei stets in einem bestimmten Zustand befindet und die zum Zwischenspeichern von Symbolen einen Stapel / Keller benutzt.

Übungen Im Folgenden sollen etwas verallgemeinerte Klammerausdrücke betrachtet werden: ()(), (()(())), ()(())(()()), ... bzw. in abstrahierter Form: abab, aabaabbb, abaabbaababb, ... (a) Beschreibe diese verallgemeinerten Klammerausdrücke mit einer Grammatik. (b) Entwickle einen Kellerautomaten, der die Sprache der verallgemeinerten Klammerausdrücke erkennt.

Übungen Entwickle einen Kellerautomaten, der die Sprache der vereinfachten Rechenausdrücke / vereinfachten Karol-Programme erkennt. z+z z*(z+z) z+z*(z+z) ((z+z)+z)*(z+z) ... eesbsbe*e*

Kellerautomaten und kontextfreie Sprachen Teil 2 Kellerautomaten und kontextfreie Sprachen

JFlap: Grammatik -> Kellerautomat Wir betrachten eine Grammatik für die Sprache Lab = {anbn | n = 1, 2, 3, ...} der Klammerausdrücke. Aufgabe: Analysiere den Zusammenhang zwischen der vorgegebenen Grammatik und dem erzeugten Kellerautomaten. Analysiere auch, was sich im Keller des Kellerautomaten abspielt, wenn ein Eingabewort verarbeitet wird. Der aus der Grammatik erzeugte Kellerautomat ist nichtdeterministisch. Woran erkennt man das?

JFlap: Kellerautomat -> Grammatik Wir betrachten einen Kellerautomaten zur Erkennung der Sprache Lab = {anbn | n = 1, 2, 3, ...} der Klammerausdrücke.

JFlap: Kellerautomat -> Grammatik Wir ändern den Kellerautomaten geringfügig ab, so dass die Fehlermeldung "Transitions must pop 1 and push 0 or 2" nicht mehr auftritt.

JFlap: Kellerautomat -> Grammatik JFlap erzeugt aus dem Kellerautomaten eine komplizierte Grammatik.

JFlap: Kellerautomat -> Grammatik JFlap vereinfacht die erzeugte Grammatik.

Kontextfreie Grammatiken Zum Kellerautomaten K lässt sich die Grammatik GK erzeugen. Es fällt auf, dass alle Produktionen dieser Grammatik GK eine bestimmte Struktur haben. Nichtterminalsymbol S -> LD A -> a B -> b L -> FB D -> λ F -> AL F -> λ Wort bestehend aus Terminal- und Nichtterminalsymbolen

Fachkonzept - kontextfreie Sprache Eine Produktion u -> v heißt kontextfrei genau dann, wenn gilt: Die linke Seite u der Produktion ist ein Nichtterminalsymbol. Die rechte Seite v der Produktion ist ein beliebiges Wort (also auch das leere Wort) bestehend aus Terminal- und Nichtterminalsymbolen. A -> A+S A -> S S -> S*F S -> F F -> (A) F -> z kontextfreie Grammatik für LRA S -> <aAT> S -> <bBT> T -> aAT T -> bBT T -> M Aa -> aA Ab -> bA AM -> Ma Ba -> aB Bb -> bB BM -> Mb M -> >N N -> aN N -> bN N -> cN N -> </ Eine Grammatik heißt kontextfrei genau dann, wenn alle Produktionen der Grammatik regulär sind. Eine Sprache heißt kontextfrei genau dann, wenn es eine reguläre Grammatik gibt, die diese Sprache erzeugt. Um nachzuweisen, dass eine Sprache kontextfrei ist, reicht es aus, eine reguläre Grammatik zur Sprache zu konstruieren. Auch wenn man noch keine kontextfreie Grammatik zu einer Sprache gefunden hat, so heißt das noch nicht, dass die Sprache nicht-kontextfrei ist. nicht-kontextfreie Grammatik für LMyXML

Theorie - kontextfreie Sprachen Satz (Zusammenhang zwischen kontextfreien Sprachen und Kellerautomaten): Zu jeder kontextfreien Sprache gibt es einen nichtdeterministischen Kellerautomaten, der diese Sprache erkennt. Der Kellerautomat kann automatisiert aus einer kontextfreien Grammatik zur kontextfreien Sprache erzeugt werden. S -> aSb S -> λ

Theorie - kontextfreie Sprachen S -> aSb S -> λ Ableitung mit der Grammatik S -> aSb -> aaSbb -> aabb Zustand; Kellerinhalt Eingabewort ------------------------------------------------ q0; Z aabb | λ,Z;SZ q1; SZ aabb | λ,S;aSb q1; aSbZ aabb | a,λ;a q1; SbZ abb q1; aSbbZ abb q1; SbbZ bb | λ,S;λ q1; bbZ bb | b,λ;b q1; bZ b q1; Z | λ,Z;λ q2 Zustandsübergänge beim Kellerautomaten Beachte, dass alle Produktionen der Grammatik in den Zustandsübergängen des Kellerautomaten kodiert sind. Der Kellerauromat ist so konstruiert, dass jede Ableitung mit Produktionen der Grammatik G mit Hilfe von Zustansübergängen des Kellerautomaten simuliert werden kann.

Theorie: kontextfreie Sprachen Satz (Zusammenhang zwischen Kellerautomaten und kontextfreien Sprachen): Die Sprache eines nichtdeterministischen Kellerautomaten ist kontextfrei: Zum nichtdeterministischen Kellerautomaten gibt es eine kontextfreie Grammatik, die dieselbe Sprache erzeugt, die vom Kellerautomaten erkannt wird. Man kann diese kontextfreie Grammatik automatisiert erzeugen. S -> LD A -> a B -> b L -> FB D -> λ F -> AL L -> λ

nicht-/deterministische Kellerautomaten Nichtdeterministische Kellerautomaten sind mächtiger als deterministische Kellerautomaten. Es gibt kontextfreie Sprachen, die zwar von nichtdeterministischen, nicht jedoch von deterministischen Kellerautomaten erkannt werden. S -> 0S0 S -> 1S1 S -> λ

Exkurs: Shift-Reduce-Parser Teil 3 Exkurs: Shift-Reduce-Parser

Kellerautomat für eine Rechtsableitung Wir betrachten die Sprache LRA der vereinfachten Rechenausdrücke mit der Grammatik G .

Rechtsableitung eines Wortes A reduce by A -> A+S -> A+S reduce by S -> S*F -> A+S*F reduce by F -> (A) -> A+S*(A) reduce by A -> A+S -> A+S*(A+S) reduce by S -> F -> A+S*(A+F) reduce by F -> z -> A+S*(A+z) reduce by A -> S -> A+S*(S+z) reduce by S -> F -> A+S*(F+z) reduce by F -> z -> A+S*(z+z) reduce by S -> F -> A+F*(z+z) reduce by F -> z -> A+z*(z+z) reduce by A -> S -> S+z*(z+z) reduce by S -> F -> F+z*(z+z) reduce by F -> z -> z+z*(z+z) A -> A+S A -> S S -> S*F S -> F F -> (A) F -> z Die gezeigte Ableitung ist eine sogenannte Rechtsableitung. In jedem Ableitungsschritt wird das am weitesten rechts stehende Nichtterminalsymbol mit einer Regel aus G ersetzt.

Simulation mit einem Kellerautomaten A reduce by A -> A+S -> A+S reduce by S -> S*F -> A+S*F reduce by F -> (A) -> A+S*(A) reduce by A -> A+S -> A+S*(A+S) reduce by S -> F -> A+S*(A+F) reduce by F -> z -> A+S*(A+z) reduce by A -> S -> A+S*(S+z) reduce by S -> F -> A+S*(F+z) reduce by F -> z -> A+S*(z+z) reduce by S -> F -> A+F*(z+z) reduce by F -> z -> A+z*(z+z) reduce by A -> S -> S+z*(z+z) reduce by S -> F -> F+z*(z+z) reduce by F -> z -> z+z*(z+z) Kellerinhalt Eingabewort Aktion --------------------------------------------------------------------------- Z z+z*(z+z)$ shift z zZ +z*(z+z)$ reduce by F -> z FZ +z*(z+z)$ reduce by S -> F SZ +z*(z+z)$ reduce by A -> S AZ +z*(z+z)$ shift + +AZ z*(z+z)$ shift z z+AZ *(z+z)$ reduce by F -> z F+AZ *(z+z)$ reduce by S -> F S+AZ *(z+z)$ shift * *S+AZ (z+z)$ shift ( (*S+AZ z+z)$ shift z z(*S+AZ +z)$ reduce by F -> z F(*S+AZ +z)$ reduce by S -> F S(*S+AZ +z)$ reduce by A -> S A(*S+AZ +z)$ shift + +A(*S+AZ z)$ shift z z+A(*S+AZ )$ reduce by F -> z F+A(*S+AZ )$ reduce by S -> F S+A(*S+AZ )$ reduce by A -> A+S A(*S+AZ )$ shift ) )A(*S+AZ $ reduce by F -> (A) F*S+AZ $ reduce by S -> S*F S+AZ $ reduce by A -> A+S AZ $

Simulation mit einem Kellerautomaten Kellerinhalt Eingabewort Aktion --------------------------------------------------------------------------- Z z+z*(z+z)$ shift z zZ +z*(z+z)$ reduce by F -> z FZ +z*(z+z)$ reduce by S -> F SZ +z*(z+z)$ reduce by A -> S AZ +z*(z+z)$ shift + +AZ z*(z+z)$ shift z z+AZ *(z+z)$ reduce by F -> z F+AZ *(z+z)$ reduce by S -> F S+AZ *(z+z)$ shift * *S+AZ (z+z)$ shift ( (*S+AZ z+z)$ shift z z(*S+AZ +z)$ reduce by F -> z F(*S+AZ +z)$ reduce by S -> F S(*S+AZ +z)$ reduce by A -> S A(*S+AZ +z)$ shift + +A(*S+AZ z)$ shift z z+A(*S+AZ )$ reduce by F -> z F+A(*S+AZ )$ reduce by S -> F S+A(*S+AZ )$ reduce by A -> A+S A(*S+AZ )$ shift ) )A(*S+AZ $ reduce by F -> (A) F*S+AZ $ reduce by S -> S*F S+AZ $ reduce by A -> A+S AZ $ reduce-Aktionen shift-Aktionen A -> A+S A -> S S -> S*F S -> F F -> (A) F -> z Der Keller ist zu Beginn leer. Nach und nach werden mit sogenannten shift-Aktionen Symbole des Eingabeworts im Keller abgelegt. Wenn möglich, wird dann mit einer sogenannten reduce-Aktion eine Produktion rückwärts angewandt.

Praxistauglichkeit des Kellerautomaten Als nachteilig erweisen sich beim gezeigten Kellerautomaten die vielen nichtdeterministischen Zustandsübergänge. Wenn man mit [Input][Step by State] ein Eingabewort wie z.B. z+z*(z+z) schrittweise analysiert, dann ergibt sich schnell eine Vielzahl von möglichen Ableitungen.

Steuerung mit einer Parsingtabelle Kellerinhalt; Eingabewort Aktion ----------------------------------------------------------------------- 0; z+z*(z+z)$ | s5 shift z 5z0; +z*(z+z)$ | r6 reduce by F->z 3F0; +z*(z+z)$ | r4 reduce by S->F 4S0; +z*(z+z)$ | r2 reduce by A->S 2A0; +z*(z+z)$ | s7 shift + 7+2A0 z*(z+z)$ 5z7+2A0 *(z+z)$ 3F7+2A0 *(z+z)$ 10S7+2A0 *(z+z)$ | s8 shift * 8*10S7+2A0 (z+z)$ | s1 shift ( 1(8*10S7+2A0 z+z)$ ... 8*10S7+2A0 $ | r3 reduce by S->S*F 10S7+2A0 $ | r1 reduce by A->A+S 2A0 $ | acc accept A0 $ Kellerinhalt Eingabewort Aktion --------------------------------------------------------------------------- Z z+z*(z+z)$ shift z zZ +z*(z+z)$ reduce by F -> z FZ +z*(z+z)$ reduce by S -> F SZ +z*(z+z)$ reduce by A -> S AZ +z*(z+z)$ shift + +AZ z*(z+z)$ shift z z+AZ *(z+z)$ reduce by F -> z F+AZ *(z+z)$ reduce by S -> F S+AZ *(z+z)$ shift * *S+AZ (z+z)$ shift ( (*S+AZ z+z)$ shift z z(*S+AZ +z)$ reduce by F -> z F(*S+AZ +z)$ reduce by S -> F S(*S+AZ +z)$ reduce by A -> S A(*S+AZ +z)$ shift + +A(*S+AZ z)$ shift z z+A(*S+AZ )$ reduce by F -> z F+A(*S+AZ )$ reduce by S -> F S+A(*S+AZ )$ reduce by A -> A+S A(*S+AZ )$ shift ) )A(*S+AZ $ reduce by F -> (A) F*S+AZ $ reduce by S -> S*F S+AZ $ reduce by A -> A+S AZ $ Die Aktionen des Kellerautomaten werden mit einer sog. Parsingtabelle gesteuert.

Steuerung mit einer Parsingtabelle Kellerinhalt; Eingabewort Aktion ----------------------------------------------------------------------- 0; z+z*(z+z)$ | s5 shift z 5z0; +z*(z+z)$ | r6 reduce by F->z 3F0; +z*(z+z)$ | r4 reduce by S->F 4S0; +z*(z+z)$ | r2 reduce by A->S 2A0; +z*(z+z)$ | s7 shift + 7+2A0 z*(z+z)$ 5z7+2A0 *(z+z)$ 3F7+2A0 *(z+z)$ 10S7+2A0 *(z+z)$ | s8 shift * 8*10S7+2A0 (z+z)$ | s1 shift ( 1(8*10S7+2A0 z+z)$ ... 8*10S7+2A0 $ | r3 reduce by S->S*F 10S7+2A0 $ | r1 reduce by A->A+S 2A0 $ | acc accept A0 $ ALGORITHMUS shift-reduce-Analyse: lege 0 im Stapel ab WIEDERHOLE zustand = oberstes Symbol im Stapel lookahead = erstes Zeichen im aktuellen Eingabewort aktion = Eintrag in der Parsingtabelle zum Paar (zustand, lookahead) FALLS aktion == shift i (kurz: si): entferne das erste Zeichen des Eingabeworts und ... ... lege es im Stapel ab lege i im Stapel ab FALLS aktion == reduce i (kurz: ri): entferne doppelt so viele Symbole vom Stapel, ... ... wie Symbole auf der rechten Seite von Produktion i stehen zustand = oberstes Symbol vom Stapel symbol = linke Seite von Produktion i zustand = Eintrag i. d. Parsingtabelle zum Paar (zustand, symbol) lege symbol im Stapel ab lege zustand im Stapel ab BIS aktion == acc oder aktion == rej (bzw. leerer Eintrag)

Erzeugung einer Parsingtabelle JFlap erzeugt zu (geeigneten) kontextfreien Grammatiken eine passende Parsingtabelle.

Erkennung kontextfreier Sprachen Viele Sprachen, die in der Praxis genutzt werden, können durch kontextfreie Grammatiken beschrieben werden. Automatisiert erzeugte Kellerautomaten zur Erkennung solcher Sprachen sind meist nichtdeterministisch und daher zum praktischen Einsatz wenig geeignet. Zum Erkennen kontextfreier Sprachen nutzt man in der Praxis Shift-Reduce-Parser mit geeigneten Parsingtabellen. Solche Shift-Reduce-Parser benutzen - genau wie Kellerautomaten - einen Keller / Stapel zum Zwischenspeichern von Symbolen. Anders als Kellerautomaten nutzen sie aber eine Art Vorschau auf das nächste zu verarbeitende Eingabesymbol. Shift-Reduce-Parser arbeiten deterministisch, d.h. sie können Wortprobleme direkt - ohne Ausprobieren mehrerer Möglichkeiten - lösen. Man kann jedoch nicht zu jeder kontextfreien Grammatik einen passenden Shift-Reduce-Parser automatisiert erzeugen. Nur wenn die Grammatik eine bestimmte Gestalt hat, ist eine automatisierte Erzeugung möglich. Verfahren zur Erzeugung von Shift-Reduce-Parsern sind komplex und werden daher hier nicht behandelt.

Teil 4 Turingmaschinen

Vereinfachte XML-Ausdrücke Die Sprache LMyXML soll vereinfachte XML-artige Ausdrücke beschreiben. Jedes zu dieser Sprache gehörende Wort soll aus einem Anfangstag, einem Text und einem Endtag bestehen. Anfangs- und Endtag sollen im Wesentlichen identisch sein. Die Tag-Bezeichner sind beliebige nicht-leere Zeichenketten, die nur aus den Buchstaben a und b bestehen. Der Text zwischen den Anfangs- und End-Tag soll nur aus den Buchstaben a, b und c bestehen. Zur Sprache LMyXML gehört beispielsweise das Wort <ab>acaa</ab>. S -> <aAT> S -> <bBT> T -> aAT T -> bBT T -> M Aa -> aA Ab -> bA AM -> Ma Ba -> aB Bb -> bB BM -> Mb M -> >N M -> aM M -> bM M -> cM M -> </

Grenzen von Kellerautomaten Problem: Kann man die Sprache LMyXML mit Kellerautomaten erkennen? <ab>acaa</ab> ok K <ab>acaa</ba> Fehler Man kann zeigen, dass die Sprache LMyXML nicht von einem (noch so komplizierten) Kellerautomaten erkannt werden kann.

Ein mächtigere Verarbeitungsmodell

Ein mächtigere Verarbeitungsmodell Aufgabe: Teste das Verhalten des gezeigten verallgemeinerten Automaten. Mit [Input][Step...] kannst du Eingabewörter wie z.B. <ab>acaa</ab> eingeben, mit [Step] den Automaten dann schrittweise das Eingabewort verarbeiten lassen. Vergleiche das neue Verarbeitungsmodell - man nennt es Turingmaschine - mit einem endlichen Automaten. Was ist bei einer Turingmaschine anders als bei einem endlichen Automaten? Versuche auch, die Idee der gezeigten Turingmaschine zur Erkennung von Wörtern der Sprache LMyXML herauszufinden. Teste hierzu verschiedene, zur Sprache gehörende und auch nicht gehörende Wörter über dem Alphabet {a, b, c, <, >}. Beschreibe die Verarbeitung in eigenen Worten.

Turingmaschine Die gezeigte Verarbeitungseinheit befindet sich stets in einem bestimmten Zustand. Sie verfügt über ein nach rechts und links unbegrenztes Band, auf dem sich zu Beginn das Eingabewort befindet. Die einzelnen Zellen des Bandes können mit einem Lese-/Schreibkopf angesteuert werden. Der Lese-Schreibkopf kann sich jeweils einen Schritt nach rechts und nach links bewegen (oder auch stehen bleiben). Er kann den Inhalt einer Zelle lesen und auch Symbole in Zellen schreiben. gelesene Bandsymbol geschriebene Bandsymbol Bewegung des Lese-/Schreib-Kopfes

Fachkonzept - Turingmaschine Eine (deterministische) Turingmaschineist eine Verarbeitungseinheit, die durch folgende Bestandteile festgelegt wird: eine nichtleere, endliche Menge von Zuständen eine nichtleere, endliche Menge von Eingabesymbolen, die das Symbol ∅ nicht enthält eine nichtleere, endliche Menge von Bandsymbolen, die alle Eingabesymbole und auch das Symbol ∅ für eine leere Zelle enthält eine Überführungsfunktion, die dem aktuellem Zustand in Abhängigkeit von einem gelesenen Symbol den Folgezustand zuordnet, zudem das zu schreibende Symbol und die Bewegung des Lese-Schreibkopfes einen ausgezeichneten Zustand - den Anfangszustand - eine Menge von Endzuständen Bei einer nichtdeterministischen Turingmaschine müssen die Zustandsübergänge nicht eindeutig sein.

Fachkonzept - Turingmaschine Die Menge der Eingabesymbole einer Turingmaschine kann als Alphabet einer Sprache aufgefasst werden. Unter der Sprache einer Turingmaschine versteht man die Menge aller Wörter aus Eingabesymbolen, die die Turingmaschine vom Anfangszustand in einen Endzustand überführen. Wenn T eine gegebene Turingmaschine ist, dann schreiben wir L(T) für die Sprache der Turingmaschine T.  = {(, )} L(T) = {(), (()), ((())), ...}

Fachkonzept - Turingmaschine Eine Turingmaschine ist also eine Verarbeitungseinheit, die Symbole verarbeitet, sich dabei stets in einem bestimmten Zustand befindet und die zum Zwischenspeichern von Symbolen ein unbegrenztes, beschreibbares und nach rechts und links begehbares Band benutzt.

Bedeutung der Turingmaschine Satz (Zusammenhang zwischen Turingmaschinen und formalen Sprachen): Zu jeder formalen Sprache, die mit einer Grammatik beschreibbar ist, gibt es eine (nicht-) deterministische Turingmaschine, der diese Sprache erkennt. Umgekehrt gibt es auch zu jeder (nicht-) deterministischen Turingmaschine eine Grammatik, die dieselbe Sprache erzeugt, die von der Turingmaschine erkannt wird. Trotz dieser Mächtigkeit wird das Verarbeitungsmodell Turingmaschine in der Praxis nicht genutzt. Wegen der doch sehr eingeschränkten Verarbeitungsmöglichkeiten einer Turingmaschine werden die Verfahren zur Erkennung von Sprachen schnell kompliziert und aufwendig. Das Verarbeitungsmodell Turingmaschine hat eine zentrale Bedeutung im Rahmen der Theoriebildung. Die Verwendung beschränkt sich dabei nicht auf den Kontext Spracherkennung, das Verarbeitungsmodell wird auch bei Fragen der Berechenbarkeit benutzt.

Übungen Man kann zeigen, dass die Sprache L = {anbncn | n = 1, 2, 3, ...} nicht mit einem Kellerautomaten erkannt werden kann. Diese Sprache besteht aus Wörtern, die wie folgt aufgebaut sind: abc, aabbcc, aaabbbccc, aaaabbbbcccc, ... Zeige, dass diese Sprache mit einer Turingmaschine erkannt werden kann. Erweitere hierzu die Turingmaschine zur Erkennung von L = {anbn | n = 1, 2, 3, ...}.

Sprachklassen und Automatenklassen Teil 5 Sprachklassen und Automatenklassen

Chomsky-Hierarchie Typ Grammatik äquivalenter Automat 0 allgemein (nicht)deterministische Turingmaschine 1 kontextsensitiv nichtdet. linear beschr. Turingmaschine 2 kontextfrei nichtdeterministischer Kellerautomat 3 regulär (nicht)deterministischer endl. Automat

Literaturhinweise F. Gasper, I. Leiß, M. Spengler, H. Stimm: Technische und theoretische Informatik. Bsv 1992. E. Modrow: Automaten, Schaltwerke, Sprachen. Dümmlers Verlag 1988. R. Baumann: Informatik für die Sekundarstufe II, Band 2. Klett-Verlag 1993. Informatik heute, Band 2. Schroedel-Verlag 1988. U. Schöning: Theoretische Informatik – kurzgefasst. Spektrum Akademischer Verlag 2001. J. E. Hopcroft / J. D. Ullman: Einführung in die Automatentheorie, Formale Sprachen und Komplexitätstheorie. Addison-Wesley 1988. S. H. Rodger, T. W. Finley: JFLAP. Jones and Bartlett Publishers 2006. ... Die Darstellung hier orientiert sich an den Materialien auf den Webseiten: http://www.inf-schule.de