Formale Sprachen und Automaten

Präsentation zum Thema: "Formale Sprachen und Automaten"—  Präsentation transkript:

1 Formale Sprachen und Automaten
Klaus Becker 2004

2 Formale Sprachen ! Terminalsymbole
ATagZustand = '<' z '>' ETagZustand = '<' '/' z '>' ATagZustandsmenge = '<' z m '>' ETagZustandsmenge = '<' '/' z m '>' Bezeichner = {Alphanumeric}+ ! Produktionen "Start Symbol" = <Zustandsmenge> <Zustand> ::= ATagZustand Bezeichner ETagZustand <Zustaende> ::= <Zustand> <Zustaende> ::= <Zustand> <Zustaende> <Zustandsmenge> ::= ATagZustandsmenge <Zustaende> ETagZustandsmenge

3 Sprachbeschreibung und Spracherkennung
Teil 1 Sprachbeschreibung und Spracherkennung

4 Exkurs: XML <?xml version="1.0"?> <automat name="Klimaanlage"> <zustandsmenge> <zustand>off</zustand> <zustand>low</zustand> <zustand>high</zustand> </zustandsmenge> <anfangszustand> <zustand>off</zustand> </anfangszustand> <ueberfuehrungsfunktion> <delta>off,Schalter,low</delta> <delta>low,Schalter,high</delta> <delta>high,Schalter,off</delta> </ueberfuehrungsfunktion> <ausgabefunktion> <lambda>off,Schalter,AnAus</lambda> <lambda>low,Schalter,AnAn</lambda> <lambda>high,Schalter,AusAus</lambda> </ausgabefunktion> </automat>

5 Was ist XML? <?xml version="1.0"?> <automat name="Klimaanlage"> <zustandsmenge> <zustand>off</zustand> <zustand>low</zustand> <zustand>high</zustand> </zustandsmenge> </automat> „XML (Abk. für extended markup language) ist eine Metasprache zur Beschreibung von Auszeichnungssprachen für allgemeine Dokumente.“ (Duden Informatik) Mit Hilfe von XML kann man Informationen strukturiert darstellen. Des weiteren kann man die Struktur (und die Formatierung) von Dokumenten festlegen, d. h. man kann die Sprache festlegen, in der die Dokumente verfasst werden müssen.

6 Darstellung von XML-Dokumenten
<?xml version="1.0"?> <automat name="Klimaanlage"> <zustandsmenge> <zustand>off</zustand> <zustand>low</zustand> <zustand>high</zustand> </zustandsmenge> <anfangszustand> <zustand>off</zustand> </anfangszustand> <ueberfuehrungsfunktion> <delta>off,Schalter,low</delta> <delta>low,Schalter,high</delta> <delta>high,Schalter,off</delta> </ueberfuehrungsfunktion> <ausgabefunktion> <lambda>off,Schalter,AnAus</lambda> <lambda>low,Schalter,AnAn</lambda> <lambda>high,Schalter,AusAus</lambda> </ausgabefunktion> </automat> XML-Dokument Browser-Ansicht

7 Ein fehlerhaftes Dokument
<?xml version="1.0"?> <automat name="Klimaanlage"> <zustandsmenge> <zustand>off</zustand> <zustand>low</zustand> <zustand>high<zustand> </zustandsmenge> <anfangszustand> <zustand>off</zustand> </anfangszustand> </automat> Der Browser erkennt, wenn ein allgemeiner Syntaxfehler vorliegt (hier: kein passendes Ende-Tag gefunden).

8 Noch ein fehlerhaftes Dokument
<?xml version="1.0"?> <automat name="Klimaanlage"> <zustandsmenge> <zustand>off</zustand> <zustand>low</zustand> <zustand>high</zustand> </zustandsmenge> <!-- kein Anfangszustand --> <ueberfuehrungsfunktion> <delta>off,Schalter,low</delta> <delta>low,Schalter,high</delta> <delta>high,Schalter,off</delta> </ueberfuehrungsfunktion> </automat> Der Browser erkennt aber nicht, wenn ein spezieller Syntaxfehler vorliegt (hier: betrifft die vom Benutzer vorgesehene Struktur des Dokuments).

9 Festlegung der Dokumentenstruktur
<?xml version="1.0"?> <!DOCTYPE automat [ <!ELEMENT automat (zustandsmenge?, anfangszustand, eingabemenge?, ausgabemenge?, ueberfuehrungsfunktion, ausgabefunktion)> <!ATTLIST automat name CDATA #REQUIRED> <!ELEMENT zustandsmenge (zustand)+> <!ELEMENT anfangszustand (zustand)> <!ELEMENT zustand (#PCDATA)> <!ELEMENT eingabemenge (eingabe)+> <!ELEMENT eingabe (#PCDATA)> <!ELEMENT ausgabemenge (ausgabe)+> <!ELEMENT ausgabe (#PCDATA)> <!ELEMENT ueberfuehrungsfunktion (delta)*> <!ELEMENT delta (#PCDATA)> <!ELEMENT ausgabefunktion (lambda)*> <!ELEMENT lambda (#PCDATA)> ] > <automat name="Klimaanlage2">...</automat>

10 Dokument mit festgelegtem Typ
<?xml version="1.0"?> <!DOCTYPE automat [ <!ELEMENT automat (zustandsmenge?, anfangszustand, eingabemenge?, ausgabemenge?, ueberfuehrungsfunktion, ausgabefunktion)> <!ATTLIST automat name CDATA #REQUIRED> <!ELEMENT zustandsmenge (zustand)+> <!ELEMENT anfangszustand (zustand)> <!ELEMENT zustand (#PCDATA)> <!ELEMENT eingabemenge (eingabe)+> <!ELEMENT eingabe (#PCDATA)> <!ELEMENT ausgabemenge (ausgabe)+> <!ELEMENT ausgabe (#PCDATA)> <!ELEMENT ueberfuehrungsfunktion (delta)*> <!ELEMENT delta (#PCDATA)> <!ELEMENT ausgabefunktion (lambda)*> <!ELEMENT lambda (#PCDATA)> ] > <automat name="Klimaanlage2">...</automat>

11 Aktivierung des Parser
<HTML> <HEAD> <TITLE>Automatenbeschreibungstest</TITLE> <SCRIPT LANGUAGE="JavaScript" FOR="window" EVENT="ONLOAD"> Document = Test.XMLDocument; message = "parseError.errorCode: „ + Document.parseError.errorCode + "\nl„ "parseError.filepos: „ + Document.parseError.filepos + "\nl„ "parseError.line: „ + Document.parseError.line + "\nl„ "parseError.linepos: „ + Document.parseError.linepos + "\nl„ "parseError.reason: „ + Document.parseError.reason + "\nl„ "parseError.srcText: „ + Document.parseError.srcText; alert (message); </SCRIPT> </HEAD> <BODY> <XML ID="Test" SRC="Klimaanlage2.XML"></XML> <H2>DTD Automatentest</H2> </BODY> </HTML> nach J. Müller: XML, Teil 4. In: LOG IN 122/123 (2003)

12 Korrekte Automatenbeschreibung
<?xml version="1.0"?> <!DOCTYPE automat [ ] > <automat name="Klimaanlage"> <zustandsmenge> <zustand>off</zustand> <zustand>low</zustand> <zustand>high</zustand> </zustandsmenge> <anfangszustand> <zustand>off</zustand> </anfangszustand> </automat> <HTML> <HEAD> <TITLE>Automatenbeschreibungstest</TITLE> <SCRIPT LANGUAGE="JavaScript" FOR="window" EVENT="ONLOAD"> Document = Test.XMLDocument; message = "parseError.errorCode: „ + Document.parseError.errorCode + "\nl„ "parseError.filepos: „ + Document.parseError.filepos + "\nl„ "parseError.line: „ + Document.parseError.line + "\nl„ "parseError.linepos: „ + Document.parseError.linepos + "\nl„ "parseError.reason: „ + Document.parseError.reason + "\nl„ "parseError.srcText: „ + Document.parseError.srcText; alert (message); </SCRIPT> </HEAD> <BODY> <XML ID="Test" SRC="Klimaanlage2.XML"></XML> <H2>DTD Automatentest</H2> </BODY> </HTML> Der Parser überprüft die Dokumentenstruktur.

13 Fehlerhafte Automatenbeschreibung
<?xml version="1.0"?> <!DOCTYPE automat [ ] > <automat name="Klimaanlage"> <zustandsmenge> <zustand>off</zustand> <zustand>low</zustand> <zustand>high</zustand> </zustandsmenge> <!-- kein Anfangszustand --> </automat> <HTML> <HEAD> <TITLE>Automatenbeschreibungstest</TITLE> <SCRIPT LANGUAGE="JavaScript" FOR="window" EVENT="ONLOAD"> Document = Test.XMLDocument; message = "parseError.errorCode: „ + Document.parseError.errorCode + "\nl„ "parseError.filepos: „ + Document.parseError.filepos + "\nl„ "parseError.line: „ + Document.parseError.line + "\nl„ "parseError.linepos: „ + Document.parseError.linepos + "\nl„ "parseError.reason: „ + Document.parseError.reason + "\nl„ "parseError.srcText: „ + Document.parseError.srcText; alert (message); </SCRIPT> </HEAD> <BODY> <XML ID="Test" SRC="Klimaanlage4.XML"></XML> <H2>DTD Automatentest</H2> </BODY> </HTML> Der Parser erkennt einen Syntaxfehler.

14 Übersicht Aus: M. Näf: Einführung in XML, DTD und XSL.

15 Zielsetzung Ziel ist es, Verfahren zur präzisen Festlegung von Sprachen (wie der Automatenbeschreibungssprache) zu entwickeln. <?xml version="1.0"?> <!DOCTYPE automat [ <!ELEMENT automat (zustandsmenge?, anfangszustand, eingabemenge?, ausgabemenge?, ueberfuehrungsfunktion, ausgabefunktion)> <!ATTLIST automat name CDATA #REQUIRED> <!ELEMENT zustandsmenge (zustand)+> <!ELEMENT anfangszustand (zustand)> <!ELEMENT zustand (#PCDATA)> <!ELEMENT eingabemenge (eingabe)+> ] > <automat name="Klimaanlage2">...</automat>

16 Zielsetzung Ziel ist es, Systeme zu entwickeln, mit deren Hilfe man entscheiden kann, ob eine „sprachliche Beschreibung“ (wie eine Automatenbeschreibung) korrekt oder fehlerhaft ist. <?xml version="1.0"?> <!DOCTYPE automat [ ] > <automat name="Klimaanlage"> <zustandsmenge> <zustand>off</zustand> <zustand>low</zustand> <zustand>high</zustand> </zustandsmenge> <!-- kein Anfangszustand --> </automat>

17 Sprachbeschreibung mit Grammatiken
Teil 2 Sprachbeschreibung mit Grammatiken

18 Die Sprache der Zustandsmengen
Das präzise Festlegen einer Sprache soll zunächst anhand einer übersichtlichen, vereinfachten Teilsprache der XML-Automatenbeschreibungssprache entwickelt werden. Wir betrachten hierzu die Beschreibung von Zustandsmengen, die in verkürzter Form dargestellt werden. <zm> <z>z0</z> <z>z1</z> <z>z2</z> <z>z21</z> <z>z3</z> </zm>

19 Informelle Beschreibung
<zm> <z>z0</z> <z>z1</z> <z>z2</z> <z>z21</z> <z>z3</z> </zm> Regeln: /1/ Eine Zustandsmengenbeschreibung wird durch die Tags <zm> und </zm> eingeschlossen. /2/ Sie enthält beliebig viele, aber mindestens einen Zustand. /3/ Jeder Zustand wird durch die Tags <z> und </z> eingeschlossen. ...

20 Das Alphabet einer Sprache
Jede Sprache benutzt bestimmte Zeichen, um Wörter bzw. Sätze zu bilden. Die Menge  der zulässigen Zeichen wird Alphabet genannt. Ein Alphabet ist somit eine endliche (geordnete) Menge von Zeichen. Zustandsmengenbeschreibung: <zm><z>z0</z><z>z1</z><z>z2</z><z>z21</z><z>z3</z></zm> Das Alphabet der Zustandsmengen-Sprache:  = {<, >, /, a, ..., z, A, ..., Z, 0, ..., 9}

21 Wörter über einem Alphabet
Durch Hintereinanderreihung endlich vieler Zeichen aus dem vorgegebenen Alphabet  erhält man Wörter (über dem Alphabet). Die Menge aller möglichen Wörter über einem Alphabet  wird mit * bezeichnet. Zu dieser Menge gehört auch das sogenannte leere Wort , das keine Zeichen enthält. Das Alphabet der Zustandsmengen-Sprache:  = {<, >, /, a, ..., z, A, ..., Z, 0, ..., 9} Wörter über diesem Alphabet: <zm><z>z0</z><z>z1</z><z>z2</z><z>z21</z><z>z3</z></zm> <zm><z>rotgelb</z></zm> <a><z3

22 Formale Sprachen Eine (formale) Sprache über einem Alphabet  ist eine Teilmenge von *. Wörter, die zur Zustandsmengen-Sprache gehören: <zm><z>z0</z><z>z1</z><z>z2</z><z>z21</z><z>z3</z></zm> <zm><z>rotgelb</z></zm> Wörter, die nicht zur Zustandsmengen-Sprache gehören: <a><z3 <zm><z>rotgelb<z><zm> Problem: Festlegung aller Wörter, die zur Sprache gehören

23 Syntaxdiagramme ATagZustand ETagZustand ATagZustandsmenge
< z > ETagZustand < / z > ATagZustandsmenge < z m > ETagZustandsmenge < / z m >

24 AlphanumerischesZeichen
Syntaxdiagramme AlphanumerischesZeichen a b ... A B ... 1 ... Bezeichner AlphanumerischesZeichen Zustand ATagZustand Bezeichner ETagZustand

25 Bestandteile von Syntaxdiagramme
AlphanumerischesZeichen a b ... A B ... 1 ... Terminalsymbol Bezeichner AlphanumerischesZeichen Nichtterminalsymbol Terminalsymbole gehören zum Alphabet der Sprache. Nichtterminalsymbole sind Variablen, die als Platzhalter für syntaktische Einheiten fungieren.

26 Übung Ergänzen Sie die Sprachbeschreibung um Syntaxdiagramme für Zustandsmengen. Beachten Sie, dass eine Zustandsmenge beliebig viele, aber mindestens einen Zustand hat.

27 Lösung Zustandsmenge ATagZustandsmenge Zustand ETagZustandsmenge

28 Übersetzung in Produktionsregeln
ATagZustand < z > <ATagZustand>  '<' 'z' '>'

29 Übersetzung in Produktionsregeln
AlphanumerischesZeichen a b ... A B ... 1 ... <AlphanumerischesZeichen>  'a' <AlphanumerischesZeichen>  'b' ...

30 Übersetzung in Produktionsregeln
Bezeichner AlphanumerischesZeichen <Bezeichner>  <AlphanumerischesZeichen> <Bezeichner>  <AlphanumerischesZeichen> <Bezeichner>

31 Übung Ergänzen Sie die fehlenden Produktionsregeln.

32 Lösung <Zustand>  <ATagZustand> <Bezeichner> <ETagZustand> <Zustaende>  <Zustand> <Zustaende>  <Zustand> <Zustaende> <Zustandsmenge>  <ATagZustandsmenge> <Zustaende> <ETagZustandsmenge>

33 Grammatik Eine Grammatik ist ein Tupel G = (T, N, P, S) bestehend aus - einer endlichen nichtleeren Menge T von Terminalzeichen, - einer endlichen nichtleeren Menge N von Nichtterminalzeichen, - einer endlichen Menge P von Produktionen (Regeln) und - einem Startsymbol S  N. Eine Produktion (Regel) hat die Gestalt u  v. Die linke Seite u und die rechte Seite v sind dabei Wörter über dem Alphabet V = T  N.

34 Backus-Naur-Form Die Backus-Naur-Form ist eine Kurzschreibweise für Produktionen. <AlphanumerischesZeichen>  'a' <AlphanumerischesZeichen>  'b' ... <AlphanumerischesZeichen> ::= 'a' | 'b' | .. | 'A' | 'B' | .. | '0' | .. <Bezeichner>  <AlphanumerischesZeichen> <Bezeichner>  <AlphanumerischesZeichen> <Bezeichner> <Bezeichner> ::= <AlphanumerischesZeichen> | <AlphanumerischesZeichen> <Bezeichner>

35 Übung Beschreiben Sie die gesamte Grammatik der Zustandsmengen-sprache in Backus-Naur-Form.

36 Wortproblem Gegeben: Wort über dem Alphabet T
Beispiel: <zm><z>z0</z></zm> Gesucht: Ableitung des Wortes mit Hilfe der Produktionen der Grammatik ausgehend vom Startzustand Ableitung durch Wortersetzung: Eine Produktion u  v wird so interpretiert, dass u überall, wo es als Teil eines Wortes auftritt, durch v ersetzt werden darf.

37 Wort aus Terminalsymbolen
Worterzeugung Gegeben: <zm><z>z0</z></zm> Gesucht: Ableitung des Wortes mit Hilfe der Produktionen Startsymbol <Zustandsmenge>  <ATagZustandsmenge> <Zustaende> <ETagZustandsmenge>  '<' 'zm' '>' <Zustaende> <ETagZustandsmenge>  '<' 'zm' '>' <Zustaende> '<' '/' 'zm' '>'  '<' 'zm' '>' <Zustand> '<' '/' 'zm' '>'  '<' 'zm' '>' <ATagZustand> <Bezeichner> <ETagZustand> '<' '/' 'zm' '>'  '<' 'zm' '>' '<' 'z' '>' <Bezeichner> <ETagZustand> '<' '/' 'zm' '>'  '<' 'zm' '>' '<' 'z' '>' <Bezeichner> '<' '/' 'z' '>' '<' '/' 'zm' '>'  '<' 'zm' '>' '<' 'z' '>' <Alphan.Zeichen> <Bezeichner> '<' '/' 'z' '>' '<' '/' 'zm' '>'  '<' 'zm' '>' '<' 'z' '>' 'z' <Bezeichner> '<' '/' 'z' '>' '<' '/' 'zm' '>'  '<' 'zm' '>' '<' 'z' '>' 'z' <AlphanumerischesZeichen> '<' '/' 'z' '>' '<' '/' 'zm' '>'  '<' 'zm' '>' '<' 'z' '>' 'z' '0' '<' '/' 'z' '>' '<' '/' 'zm' '>' Wort aus Terminalsymbolen

38 Übung Kommentieren Sie die Ableitung, indem Sie für jeden Ersetzungs-schritt die benutzte Grammatikregel (Produktion) angeben. <Zustandsmenge>  <ATagZustandsmenge> <Zustaende> <ETagZustandsmenge>  '<' 'zm' '>' <Zustaende> <ETagZustandsmenge>  '<' 'zm' '>' <Zustaende> '<' '/' 'zm' '>'  '<' 'zm' '>' <Zustand> '<' '/' 'zm' '>'  '<' 'zm' '>' <ATagZustand> <Bezeichner> <ETagZustand> '<' '/' 'zm' '>'  '<' 'zm' '>' '<' 'z' '>' <Bezeichner> <ETagZustand> '<' '/' 'zm' '>'  '<' 'zm' '>' '<' 'z' '>' <Bezeichner> '<' '/' 'z' '>' '<' '/' 'zm' '>'  '<' 'zm' '>' '<' 'z' '>' <Alphan.Zeichen> <Bezeichner> '<' '/' 'z' '>' '<' '/' 'zm' '>'  '<' 'zm' '>' '<' 'z' '>' 'z' <Bezeichner> '<' '/' 'z' '>' '<' '/' 'zm' '>'  '<' 'zm' '>' '<' 'z' '>' 'z' <AlphanumerischesZeichen> '<' '/' 'z' '>' '<' '/' 'zm' '>'  '<' 'zm' '>' '<' 'z' '>' 'z' '0' '<' '/' 'z' '>' '<' '/' 'zm' '>'

39 Ein Werkzeug zur Sprachbeschreibung
Teil 3 Ein Werkzeug zur Sprachbeschreibung

40 Spracherkennung mit Werkzeugen
Siehe:

41 Zwei-Stufen-Beschreibung
Oft ist eine zweistufige Beschreibung der Sprache zweckmäßig: Zeichen: <, >, /, a, ..., z, A, ..., Z, 0, ..., 9 Festlegung der korrekten Token (Wörter) Wörter / Token: <zm>, <z>, rotgelb, gruen, ... Festlegung der korrekten Tokenfolgen (Sätze) Sätze / Tokenfolgen: <zm><z>rotgelb</z></zm>, <zm></z>, ...

42 Sprache der Token Alphabet: Grammatik:
 = {<, >, /, a, ..., z, A, ..., Z, 0, ..., 9} Grammatik: <ATagZustand> ::= '<' 'z' '>' <ETagZustand> ::= '<' '/' 'z' '>' <ATagZustandsmenge> ::= '<' 'z' 'm' '>' <ETagZustandsmenge> ::= '<' '/' 'z' 'm' '>' <AlphanumerischesZeichen> ::= 'a' | 'b' | .. | 'A' | 'B' | .. | '0' | .. <Bezeichner> ::= <AlphanumerischesZeichen> | <AlphanumerischesZeichen> <Bezeichner>

43 Sprache der Tokenfolgen
Alphabet:  = {<z>, </z>, <zm>, </zm>, ..., rotgelb, ..., gruen, ...} Grammatik: <Bezeichner> ::= ... | rotgelb | ... | gruen | ... <Zustand> ::= '<z>' <Bezeichner> '</z>' <Zustaende> ::= <Zustand> | <Zustand> <Zustaende> <Zustandsmenge> ::= '<zm>' <Zustaende> '</zm>'

44 Darstellung einer Grammatik
Zwei-stufige Darstellung beim Werkzeug „GOLD Parser Builder“ ! Terminalsymbole ATagZustand = '<' z '>' ETagZustand = '<' '/' z '>' ATagZustandsmenge = '<' z m '>' ETagZustandsmenge = '<' '/' z m '>' Bezeichner = {Alphanumeric}+ ! Produktionen "Start Symbol" = <Zustandsmenge> <Zustand> ::= ATagZustand Bezeichner ETagZustand <Zustaende> ::= <Zustand> <Zustaende> ::= <Zustand> <Zustaende> <Zustandsmenge> ::= ATagZustandsmenge <Zustaende> ETagZustandsmenge Reguläre Ausdrücke Produktionen in BNF

45 Ableitungsbaum

46 Zustandsautomat Zur Analyse der Terminalsymbole benutzt das Werkzeug „GOLD Parser Builder“ einen Automaten.

47 Übung Aufgabe 1 Testen Sie das Werkzeug am Beispiel der Zustandsmengensprache. Aufgabe 2 Erstellen Sie eine vollständige Grammatik zur Automaten-beschreibungssprache mit Hilfe des Werkzeugs.

48 Exkurs: Verknüpfung von Sprachen
X und Y seien Sprachen über dem Alphabet . XY = {xy | xX, yY} ist die Menge aller Worte, die sich ergeben, wenn man an ein beliebiges Wort aus X ein beliebiges Wort aus Y hängt. X0 = {}; X1 = X; X2 = XX; X3 = X2X = XXX; ... X* = X0  X1  X2  X3 … ist die Menge aller Worte, die sich ergeben, wenn man beliebig viele (auch keine) Worte aus X aneinanderhängt. X+ = X1  X2  X3  X4 … ist die Menge aller Worte, die sich ergeben, wenn man beliebig viele Worte, aber mindestens ein Wort, aus X aneinanderhängt. Beispiele: Sei X = {a, b}; Y = {c}. XY = {ac, bc} X0 = {}; X1 = X = {a, b}; X2 = XX = {aa, ab, ba, bb} X* = X0  X1  X2  X3 … = {, a, b, aa, ab, ba, bb, ...} X+ = X1  X2  X3  X4 … = {a, b, aa, ab, ba, bb, ...}

49 Exkurs: Reguläre Ausdrücke
Gebeben sei das Alphabet .  ist ein regulärer Ausdruck, der die leere Menge {} bezeichnet.  ist ein regulärer Ausdruck, der die Menge {} mit dem leeren Wort bezeichnet. Für jedes a   ist a ein regulärer Ausdruck, der die Menge {a} bezeichnet. Sind x und y reguläre Ausdrücke, die die Mengen X und Y bezeichnen, so ist auch - (x+y) ein regulärer Ausdruck, der die Menge XY bezeichnet, - xy ein regulärer Ausdruck, der die Menge XY bezeichnet, - (x)* ein regulärer Ausdruck, der die Menge X* bezeichnet, - (x)+ ein regulärer Ausdruck, der die Menge X+ bezeichnet, Beispiele: Sei  = {a, b, c}. (a+b)* = ({a}{b})0  ({a}{b})1  ({a}{b})2  … = {, a, b, aa, ab, ba, ...} a+b*c = ({a}1  {a}2  {a}3 …) ({b}0  {b}1  {b}2 …)({c}) = {ac, aac, aaac, …, abc, aabc, aaabc, …, abbc, aabbc, aaabbc, …} = {aibjc | i >0; j  0}

50 Darstellung und Test regulärer Ausdrücke
Beispiel 1: ! Regulärer Ausdruck L = a[a|b]*c "Start Symbol" = <S> <S> ::= L a(a+b)*c Beispiel 2: ! Regulärer Ausdruck L = b[a]*|[b]+ "Start Symbol" = <S> <S> ::= L ba*+b+ Beispiel 3: ! Regulärer Ausdruck L = A{Letter}*n "Start Symbol" = <S> <S> ::= L A(a+b+...+Z)*n

51 Übung Erstellen Sie reguläre Ausdrücke zur Beschreibung folgender Mengen: (a) Die Menge aller Zeichenketten über dem Alphabet {0, 1}, die mit 00 enden. (b) Die Menge aller Zeichenketten über dem Alphabet {a, b}, die mit a beginnen oder mit b enden. (c) Die Menge aller Zeichenketten über dem Alphabet {a, b}, die nach jedem a genau zwei b´s haben. (d) Alle Namen über dem Standardalphabet, die mit A anfangen. (e) Die Menge folgender Klassen: {5a, 5b, 5c, ..., 10a, 10b, 10c}. (f) Die Menge zulässiger Zeitangaben; z. B. 12:00.

52 Übung Wir betrachten Adressen nach dem http-Protokoll mit folgendem Aufbau: Beispiel: Der Einfachheit halber sollen alle Domainnamen nur aus Buchstaben bestehen. Entwickeln Sie eine Grammatik zur Beschreibung solcher Adressen. Testen Sie die Grammatik.

53 Übung Im Internet-Standarddokument (Request for Comment) RCF1945 für das HTTP-Protokoll findet man die folgende Grammatik für erlaubte Datum-Uhrzeit-Formate. HTTP-date = rfc1123-date | rfc850-date | asctime-date rfc1123-date = wkday "," SP date1 SP time SP "GMT" rfc850-date = weekday "," SP date2 SP time SP "GMT" asctime-date = wkday SP date3 SP time SP 4DIGIT date = 2DIGIT SP month SP 4DIGIT date = 2DIGIT "-" month "-" 2DIGIT date = month SP ( 2DIGIT | ( SP 1DIGIT )) time = 2DIGIT ":" 2DIGIT ":" 2DIGIT wkday = "Mon" | "Tue" | "Wed" | "Thu" | "Fri" | "Sat" | "Sun" weekday = "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday" month = "Jan" | "Feb" | "Mar" | "Apr" | "May" | "Jun" | "Jul" | "Aug" | "Sep" | "Oct" | "Nov" | "Dec" Ergänzen Sie geeignete Grammatikregeln für SP, 1DIGIT, 2DIGIT, 4DIGIT. Erzeugen Sie verschiedene korrekte Datum-Uhrzeit-Angaben.

54 Spracherkennung mit Automaten
Teil 4 Spracherkennung mit Automaten

55 Zielsetzung Ziel ist es, Spracherkennungssysteme zu entwickeln.
Ein Spracherkennungssystem soll bei Eingabe eines beliebigen Wortes entscheiden, ob dieses Wort zur vorgegebenen Sprache gehört oder nicht. Wort ja / nein

56 Vereinfachte Bezeichner
Beispiel: Das System soll vereinfachte Bezeichner erkennen: Regeln zur Bildung vereinfachter Bezeichner /1/ Der Bezeichner beginnt mit einem z. /2/ Danach kommt beliebig oft, aber mindestens einmal eine der Ziffern 0 oder 1. Beispiele für korrekte vereinfachte Bezeichner: z0, z10, z01101, z000000 Beispiele für nicht-korrekte vereinfachte Bezeichner: 0z, z10z, z01a, z

57 Erzeugende Systeme Spracherkennungsansatz: Erzeugung von Ableitungen
Alphabet: Erzeugung von Ableitungen:  = {z, 0, 1, a} B  zN  z1 # z1N  z10 # z10N ... Grammatik: B  zN N  0 N  1 N  0N N  1N Erzeuge systematisch Ableitungen mit Hilfe von Grammatikregeln und überprüfe, ob das gegebene Wort auf diese Weise erzeugt werden kann. Wort: z1001

58 Analysierende Systeme
Spracherkennungsansatz: Zustandsbasierte Wortanalyse Verarbeite das Wort mit Hilfe eines erkennenden Automaten: Überprüfe, ob das gegebene Wort den Automaten vom Anfangszustand in einen Endzustand überführt. Endzustand Anfangszustand

59 Erkennende Automaten Ein erkennender Automat / Akzeptor ist ein Tupel A = (Z, za, Ze, E, ) bestehend aus - einer endlichen Menge Z von Zuständen, - einem Anfangszustand za  Z, - einer Menge Ze  Z von Endzuständen, - einer endlichen Menge E von Eingabezeichen und - einer Überführungsfunktion : Z x E  Z. Zustandsmenge: Z = {Z0, Z1, Z2, Z3} Anfangszustand: za = Z0 Endzustände: Ze = {Z2} Eingabemenge: E = {z, a, 0, 1} Überführungsfunktion: : (Z0, z)  Z1; (Z0, a)  Z3; ...

60 Die Sprache eines Akzeptors
Sei A = (Z, za, Ze, E, A, ) ein Akzeptor. Unter der Sprache L(A) dieses Akzeptors versteht man die Menge aller Wörter über dem Alphabet E, die den Automaten vom Anfangszustand za in einen Endzustand aus Ze überführen. L(A) = {z0, z1, z00, z01, z10, z11, ...}

61 Übung Ein Akzeptor soll Zustandsbeschreibungen der folgenden Form akzeptieren: <z> <z>AAA <z>AA</z> BB<z> BB<z>BBBAAA B<z>BBABB</z> Bem.: A steht für ein beliebiges alphanumerisches Zeichen; B steht für ein Leerzeichen (blank). Werkzeuge: Automaton Simulator, Charon

62 Übung Ein Akzeptor soll Zahlen mit folgendem Format akzeptieren:
... Präzisieren Sie zunächst die Grammatik dieser Zahldarstellung. Entwickeln Sie anschließend einen geeigneten Akzeptor. Werkzeuge: GOLD Parser Builder, Automaton Simulator, Charon

63 Teil 5 Scanner und Parser

64 Automatenbeschreibungsübersetzer
<?xml version="1.0"?> <automat name="Klimaanlage"> <zustandsmenge> <zustand>off</zustand> <zustand>low</zustand> <zustand>high</zustand> </zustandsmenge> </automat> <?xml version="1.0"?> <automat name="Klimaanlage"> <zustandsmenge> <zustand>off</zustand> <zustand>low</zustand> <zustand>high<zustand> </zustandsmenge> </automat> Übersetzer <?xml version="1.0"?> <automat name="Klimaanlage"> <zustandsmenge> <zustand>off</zustand> <zustand>low</zustand> <zustand>high</zustand> </zustandsmenge> ... </automat> Fehler

65 Vereinfachung: Zustandsmengenübersetzer
<zm> <z> off </z> <z>low </z> <z> high</z> </zm> <zm> <z> off </z> < z>low </z> <z> high</z> <zm> Übersetzer <zm> <z>off</z> <z>low</z> <z>high</z> </zm> Fehler

66 Scanner Scanner Erzeugt lexikal. Einheiten (Token)
<zm> <z> off </z> <z>low </z> <z> high</z> </zm> <zm> <z> off <z> < z>low </z> <z> high</z> </zm> Erzeugt lexikal. Einheiten (Token) Führt die lexikalische Analyse durch Scanner <zm> <z> off </z> <z> low </z> <z> high </z> </zm> <zm> <z> off <z> !

67 Parser Parser Erzeugt „Verarbeitungs-programm“ in Normalform
<zm> <z> off </z> <z> low </z> <z> high </z> </zm> <zm> <z> off </z> <z> low <z> <z> high </z> </zm> Erzeugt „Verarbeitungs-programm“ in Normalform Führt eine syntaktische Analyse durch Parser <zm> <z>off</z> <z>low</z> <z>high</z> </zm> <zm> <z>off</z> !

68 Scanner als Akzeptor <zm> <z> off </z> <z>low </z> <z> high</z> </zm> <zm> <z> off </z> <z> low </z> <z> high </z> </zm> Verarbeite jedes Zeichen des Quelltextes. Wenn ein Endzustand verlassen wird, dann mache aus den verarbeiteten Zeichen ein neues Token.

69 Parser als Akzeptor <zm> <z> off </z> <z> low </z> <z> high </z> </zm> Verarbeite jedes Token der Tokenfolge. Wenn ein Endzustand verlassen wird, dann mache aus den verarbeiteten Token eine neue Verarbeitungseinheit. <zm> <z>off</z> <z>low</z> <z>high</z> </zm>

70 Auftrag Es sollen Programme entwickelt werden, mit deren Hilfe man Automatenbeschreibungen (vereinfachte Zustandsmengen) scannen bzw. parsen kann.

71 Scanner-Prototyp Scan-Automat Tokenfolge Quelltext

72 Klassendiagramm

73 Scan-Algorithmus begin automat.anfangszustand; Token := ''; for i := 0 to Quelltext.Count-1 do begin zeile := Quelltext[i]; for j := 1 to length(zeile) do begin e := zeile[j]; aZ := automat.getZustand; if automat.endzustand then eZ := true else eZ := false; automat.neuerZustand(e); nZ := automat.getZustand; if (eZ and (nZ <> aZ)) then begin Tokenfolge.Add(Token); Token := ''; end; if e <> ' ' then Token := Token + e; end; end; if automat.endzustand then Tokenfolge.Add(Token); end;

74 Übung Testen Sie den Scanner. Geben Sie hierzu zunächst den entwickelten Scan-Automaten für Zustandsmengen ein. Testen Sie dann verschiedene korrekte und fehlerhafte Zustandsmengenbeschreibungen.

75 Parser-Prototyp Parse-Automat Generierter Code Tokenfolge

76 Klassendiagramm

77 Parse-Algorithmus begin automat.anfangszustand; Code := ''; for i := 0 to Quelltext.Count-1 do begin Token := Quelltext[i]; aZ := automat.getZustand; if automat.endzustand then eZ := true else eZ := false; automat.neuerZustand(Token); nZ := automat.getZustand; if (eZ and (nZ <> aZ)) then begin Tokenfolge.Add(Code); Code := ''; end; Code := Code + Token; end; if automat.endzustand then Tokenfolge.Add(Token); end;

78 Übung Testen Sie den Parser. Geben Sie hierzu zunächst den entwickelten Parse-Automaten für Zustandsmengen ein. Testen Sie dann verschiedene korrekte und fehlerhafte Zustandsmengenbeschreibungen.

79 Literaturhinweise Gasper / Leiß / Spengler / Stimm: Technische und theoretische Informatik. Bsv 1992. Jürgen Müller: XML. Teil LOG IN 5-6 (2001), Nr. 120 (2002), Nr. 121 (2002), Nr. 122/123 (2002). Selfhtml von Stefan Münz: Linksammlung von Klaus Merkert: