Spracherkennung mit Kellerautomaten und Turingmaschinen

1. Spracherkennung mit Kellerautomaten und Turingmaschinen Klaus Becker 2013

2. Kellerautomat und Turingmaschine

3. Teil 1 Erkennen von Klammersprachen

4. 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> MarkeSetzenSchrittSOLANGE NichtIstMarke TUE SOLANGE NichtIstWand TUE Schritt *SOLANGE LinksDrehen*SOLANGE

5. 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.

6. 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.

7. 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.

8. 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. MarkeSetzenSchrittSOLANGE NichtIstMarke TUE SOLANGE NichtIstWand TUE Schritt *SOLANGE LinksDrehen*SOLANGE ees 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.

9. 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.

10. 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 -> aATT -> bBTT -> MAa -> aAAb -> bAAM -> MaBa -> aBBb -> bBBM -> MbM -> >NN -> aNN -> bNN -> cNN -> </ Aufgabe: Die Sprache LMyXML kann mit der gezeigten Grammatik beschrieben werden. Erstelle eine Ableitung des Worts <ab>acaa</ab>.

11. Grenzen von endlichen Automaten 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. Allen Klammersprachen ist gemeinsam, dass es zu jeder öffnenden Klammer eine korrespondierende schließende Klammer geben muss. Wir betrachten im Folgenden nur noch diese zentrale Eigenschaft von Klammersprachen. Wir erfassen diese Eigenschaft mit ganz einfachen Klammerausdrücken, die wie folgt aufgebaut sind: (), (()), ((())), ... ab, aabb, aaabbb, …

12. 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

13. 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.

14. 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

15. Fachkonzept - Kellerautomat Ein (nichtdeterministischer) 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 deterministischen Kellerautomaten müssen die Zustandsübergänge eindeutig sein. Es sind auch keine λ-Übergänge der Gestalt λ,λ;λ erlaubt.

16. 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) = {(), (()), ((())), ...}

17. 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.

18. Übungen Aufgabe: 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. Aufgabe: Entwickle einen Kellerautomaten, der die Sprache der vereinfachten Rechenausdrücke / vereinfachten Karol-Programme erkennt. eesbsbe*e* z+z z*(z+z) z+z*(z+z) ((z+z)+z)*(z+z) ...

19. Teil 2 Kellerautomaten und kontextfreie Sprachen

20. 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?

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

22. 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.

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

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

25. 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 -> LDA -> aB -> bL -> FB D -> λ F -> AL F -> λ Wort bestehend aus Terminal- und Nichtterminalsymbolen

26. 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

27. 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 -> λ

28. 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 | λ,S;aSb q1; aSbbZ abb | a,λ;a q1; SbbZ bb | λ,S;λ q1; bbZ bb | b,λ;b q1; bZ b | b,λ;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.

29. 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 -> λ

30. 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 -> λ

31. Teil 3 Exkurs: Shift-Reduce-Parser

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

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

34. 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 $ 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)

35. 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.

36. 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.

37. 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)$ | s5 shift z 5z7+2A0 *(z+z)$ | r6 reduce by F->z 3F7+2A0 *(z+z)$ | r4 reduce by S->F 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.

38. 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)$ | s5 shift z 5z7+2A0 *(z+z)$ | r6 reduce by F->z 3F7+2A0 *(z+z)$ | r4 reduce by S->F 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)

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

40. 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.

41. Teil 4 Turingmaschinen

42. 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 -> aATT -> bBTT -> MAa -> aAAb -> bAAM -> MaBa -> aBBb -> bBBM -> MbM -> >NM -> aMM -> bMM -> cMM -> </

43. Grenzen von Kellerautomaten Problem: Kann man die Sprache LMyXMLmit 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.

44. Ein mächtigere Verarbeitungsmodell

45. 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 LMyXMLherauszufinden. 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.

46. 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

47. 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.

48. 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) = {(), (()), ((())), ...}

49. 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.

50. 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.