Datenstrukturen DCG Grammatiken Operationen auf Datenstrukturen I Sortieren von Listen DCGs teilweise Wiederholung Bratko Kapitel 21 DCGs und Semantik I Operationen auf Datenstrukturen I Sortieren von Listen DCGs teilweise Wiederholung Bratko Kapitel 21 DCGs und Semantik I

Datenstrukturen und Operationen Eine Fundamentale Frage der Programmierung: wie repräsentieren wir komplexe Datenobjekte etwa Mengen und wie implementieren wir -effizient- Operationen auf solchen Objekten. Im den folgenden Sitzungen nach Bratko Kapitel 9: Listen, Bäume und Graphen Sortieren, Datenmengen als Bäume repräsentieren, Daten in Bäume speichern, Daten aus Bäumen holen und Pfade in Graphen finden Eine Fundamentale Frage der Programmierung: wie repräsentieren wir komplexe Datenobjekte etwa Mengen und wie implementieren wir -effizient- Operationen auf solchen Objekten. Im den folgenden Sitzungen nach Bratko Kapitel 9: Listen, Bäume und Graphen Sortieren, Datenmengen als Bäume repräsentieren, Daten in Bäume speichern, Daten aus Bäumen holen und Pfade in Graphen finden

Sortieren von Listen Eine Liste kann sortiert werden, wenn es eine Ordnungsrelation zwischen den Listengliedern (Items) gibt. Nehmen wir an es gebe gt(X,Y). Für Zahlen implementiert als: gt(X,Y) :- X>Y. Für Atome: gt(X,Y) :- %ordnet Atome alphabetisch, komplexe Terme %nach Stelligkeit sort(List,Sorted) soll eine Relation bezeichnen, wo die Liste eine Liste von Objekten ist und sorted aufsteigend sortiert gemäß der gt Relation. Eine Liste kann sortiert werden, wenn es eine Ordnungsrelation zwischen den Listengliedern (Items) gibt. Nehmen wir an es gebe gt(X,Y). Für Zahlen implementiert als: gt(X,Y) :- X>Y. Für Atome: gt(X,Y) :- %ordnet Atome alphabetisch, komplexe Terme %nach Stelligkeit sort(List,Sorted) soll eine Relation bezeichnen, wo die Liste eine Liste von Objekten ist und sorted aufsteigend sortiert gemäß der gt Relation.

Sortieren von Listen Bubblesort Algorithmus: Eingabe ist eine Liste von Elementen z.B. [2,4,7,6,3,1,5] Idee: (1) Finde zwei benachbarte Elemente, X und Y in der Liste, so dass gt(X,Y), vertausche X und Y in der Liste und erhalte List1; sortiere nun List1 (2) Existieren keine zwei benachbarten Elemente mehr so dass gilt gt(X,Y) dann ist die Liste bereits sortiert. Hintergrund: swapping(vertauschen) bringt uns der sortierten Liste näher! Bubblesort Algorithmus: Eingabe ist eine Liste von Elementen z.B. [2,4,7,6,3,1,5] Idee: (1) Finde zwei benachbarte Elemente, X und Y in der Liste, so dass gt(X,Y), vertausche X und Y in der Liste und erhalte List1; sortiere nun List1 (2) Existieren keine zwei benachbarten Elemente mehr so dass gilt gt(X,Y) dann ist die Liste bereits sortiert. Hintergrund: swapping(vertauschen) bringt uns der sortierten Liste näher!

Sortieren von Listen BubbleSort Implementierung bubblesort(List,Sorted) :- %Sortiere ein Paar (1) swap(List,List1),!, bubblesort(List1,Sorted). bubblesort(Sorted,Sorted). %Abbruchklausel (2) swap([X,Y|Rest],[Y,X|Rest]):- %Tausche ein Paar gt(X,Y). swap([Z|Rest],[Z|Rest1]):- %Suche weiter nach swap(Rest,Rest1). %einem Paar BubbleSort Implementierung bubblesort(List,Sorted) :- %Sortiere ein Paar (1) swap(List,List1),!, bubblesort(List1,Sorted). bubblesort(Sorted,Sorted). %Abbruchklausel (2) swap([X,Y|Rest],[Y,X|Rest]):- %Tausche ein Paar gt(X,Y). swap([Z|Rest],[Z|Rest1]):- %Suche weiter nach swap(Rest,Rest1). %einem Paar

Sortieren von Listen InsertionSort Idee: um eine nicht-leere Liste L=[X|T] zu sortieren: (1) sortiere den Teil T (2) füge den Kopf X so in T ein, dass die resultierende Liste sortiert ist -> die ganze Liste ist sortiert. InsertionSort Idee: um eine nicht-leere Liste L=[X|T] zu sortieren: (1) sortiere den Teil T (2) füge den Kopf X so in T ein, dass die resultierende Liste sortiert ist -> die ganze Liste ist sortiert.

Sortieren von Listen InsertionSort Implementation: insertsort([],[]). insertsort([X|Tail],Sorted) :- insertsort(Tail,SortedTail), %rekursiv kleineren Teil insert(X,SortedTail,Sorted). %Einfügen des Kopfes insert(X,[Y|RestSortedTail],[Y|RestSorted]):- gt(X,Y),insert(X,RestSortedTail,RestSorted). %X grösser Kopf insert(X,SortedTail,[X|SortedTail]). %X wird als Kopf %eingefügt InsertionSort Implementation: insertsort([],[]). insertsort([X|Tail],Sorted) :- insertsort(Tail,SortedTail), %rekursiv kleineren Teil insert(X,SortedTail,Sorted). %Einfügen des Kopfes insert(X,[Y|RestSortedTail],[Y|RestSorted]):- gt(X,Y),insert(X,RestSortedTail,RestSorted). %X grösser Kopf insert(X,SortedTail,[X|SortedTail]). %X wird als Kopf %eingefügt

Sortieren von Listen Beide Sortieralgorithmen sind relativ ineffizient und haben durchschnittlich quadratische Zeitkomplexität bezüglich der Listenlänge.

Sortieren von Listen Idee eines effizienteren Algorithmus v.a. für längere Listen Idee eines effizienteren Algorithmus v.a. für längere Listen [5,3,7,8,1,4,7,6] [3,1,4][7,8,7,6] [1,3,4][6,7,7,8] [1,3,4,5,6,7,7,8] split all ≤ 5 split all > 5 sort add X concatenate köpfe Pivot

Sortieren von Listen Quicksort Idee: (1) Lösche ein Element X aus der Liste (Pivot-Element) in Prolog nimm den Kopf der Liste (2) Splitte den Rest der Liste L in Small und Big Small: {Y|Y L ʌ Y ≤ X} Big: {Y|Y L ʌ Y > X} (3) Sortiere Small → SortedSmall Sortiere Big → SortedBig (4) Konkateniere SortedSmall mit [X|SortedBig] Falls die Liste die zu sortieren ist leer ist, ist das Resultat auch leer Quicksort Idee: (1) Lösche ein Element X aus der Liste (Pivot-Element) in Prolog nimm den Kopf der Liste (2) Splitte den Rest der Liste L in Small und Big Small: {Y|Y L ʌ Y ≤ X} Big: {Y|Y L ʌ Y > X} (3) Sortiere Small → SortedSmall Sortiere Big → SortedBig (4) Konkateniere SortedSmall mit [X|SortedBig] Falls die Liste die zu sortieren ist leer ist, ist das Resultat auch leer

Sortieren von Listen Quicksort Implementierung: quicksort([],[]). quicksort([X|Tail],Sorted):- split(X,Tail,Small,Big), quicksort(Small,SortedSmall), quicksort(Big,SortedBig), append(SortedSmall,[X|SortedBig],Sorted). Quicksort Implementierung: quicksort([],[]). quicksort([X|Tail],Sorted):- split(X,Tail,Small,Big), quicksort(Small,SortedSmall), quicksort(Big,SortedBig), append(SortedSmall,[X|SortedBig],Sorted).

Sortieren von Listen quicksort([],[]). quicksort([X|Tail],Sorted):- split(X,Tail,Small,Big), quicksort(Small,SortedSmall), quicksort(Big,SortedBig), append(SortedSmall,[X|SortedBig],Sorted). Beispiel: [5,3,7,8,1,4,7,6] Pivot 5 splittet: [3,1,4] [7,8,7,6] Reihenfolge bleibt unverändert Rekursiver Aufruf1: [3,1,4] Wird zunächst komplett abgearbeitet Pivot 3 splittet [1] [4] Rekursiver Aufruf1: [1] Pivot 1 splittet [] [] Rekursiver Aufruf []: Abbruchbedingung gibt [] sortiert zurück Rekursiver Aufruf quicksort(Big,SortedBig) ebenso [] Damit Konkatenation mit append zu append([],[1],[1]) Als nächstes [4] genauso also append([1],[3|4]) Genauso die andere Liste der ersten Teilung [7,8,7,6] Schliesslich append([1,3,4],[5|6,7,7,8]). quicksort([],[]). quicksort([X|Tail],Sorted):- split(X,Tail,Small,Big), quicksort(Small,SortedSmall), quicksort(Big,SortedBig), append(SortedSmall,[X|SortedBig],Sorted). Beispiel: [5,3,7,8,1,4,7,6] Pivot 5 splittet: [3,1,4] [7,8,7,6] Reihenfolge bleibt unverändert Rekursiver Aufruf1: [3,1,4] Wird zunächst komplett abgearbeitet Pivot 3 splittet [1] [4] Rekursiver Aufruf1: [1] Pivot 1 splittet [] [] Rekursiver Aufruf []: Abbruchbedingung gibt [] sortiert zurück Rekursiver Aufruf quicksort(Big,SortedBig) ebenso [] Damit Konkatenation mit append zu append([],[1],[1]) Als nächstes [4] genauso also append([1],[3|4]) Genauso die andere Liste der ersten Teilung [7,8,7,6] Schliesslich append([1,3,4],[5|6,7,7,8]).

Sortieren von Listen Hilfsprädikat von Quicksort: split split(X,[],[],[]). %leere Liste wird zu zwei leeren Listen split(X,[Y|Tail],[Y|Small],Big) :- gt(X,Y),!,split(X,Tail,Small,Big). %Pivot ist grösser als der Kopf schreibe den %Kopf auf small und splitte den Rest split(X,[Y|Tail],Small,[Y|Big]) :- split(X,Tail,Small,Big). %Pivot ist kleiner, schreibe den Kopf auf Big %splitte den Rest Hilfsprädikat von Quicksort: split split(X,[],[],[]). %leere Liste wird zu zwei leeren Listen split(X,[Y|Tail],[Y|Small],Big) :- gt(X,Y),!,split(X,Tail,Small,Big). %Pivot ist grösser als der Kopf schreibe den %Kopf auf small und splitte den Rest split(X,[Y|Tail],Small,[Y|Big]) :- split(X,Tail,Small,Big). %Pivot ist kleiner, schreibe den Kopf auf Big %splitte den Rest

Sortieren von Listen Zeitkomplexität von Quicksort: hängt davon ab wieviel Glück wir haben. Wenn die Split-Listen ungefähr gleich groß sind, ist sie n log n mit n als der Länge der zu sortierenden Liste. Wenn eine Liste viel grösser ist als die andere ist die Komplexität quadratisch. Eine noch effizientere Implementation entweder mit Akkumulator siehe Leiss-Skript oder über Differenzlisten siehe Bratko S Zeitkomplexität von Quicksort: hängt davon ab wieviel Glück wir haben. Wenn die Split-Listen ungefähr gleich groß sind, ist sie n log n mit n als der Länge der zu sortierenden Liste. Wenn eine Liste viel grösser ist als die andere ist die Komplexität quadratisch. Eine noch effizientere Implementation entweder mit Akkumulator siehe Leiss-Skript oder über Differenzlisten siehe Bratko S. 201.

DCG nach Bratko Kap 21 Grammatikregeln in Prolog Wiederholung: viele Prologimplementationen stellen eine Notationsergänzung zur Verfügung. Diese erlaubt es leicht, formale Grammatiken mit Prolog zu implementieren. Eine Grammatik, die in DCG Format implementiert ist, kann direkt zur Syntaxanalyse verwandt werden. Ausserdem kann mithilfe von Prolog die Bedeutung (Semantik) implementiert werden -- zumindest für ein begrenztes Sprachsegment und als eine spezielle Interpretation von sprachlicher Bedeutung.

Grammatik Definition nach Bratko: Eine Grammatik ist ein formaler Mechanismus, um eine Menge von Symbolsequenzen zu definieren. So eine Sequenz kann abstrakt sein, ohne spezielle Bedeutung, oder eine Programmiersprache oder ein Segment einer natürlichen Sprache beschreiben. Ein populäres Grammatikformat zur Definition von Programmiersprachen ist die kontextfreie BNF. Definition nach Bratko: Eine Grammatik ist ein formaler Mechanismus, um eine Menge von Symbolsequenzen zu definieren. So eine Sequenz kann abstrakt sein, ohne spezielle Bedeutung, oder eine Programmiersprache oder ein Segment einer natürlichen Sprache beschreiben. Ein populäres Grammatikformat zur Definition von Programmiersprachen ist die kontextfreie BNF.

DCG Beispiel I Erstes Beispiel: Schreibe eine Grammatik, welche Strings der Form a n b n mit n = 1,2,3,... akzeptiert. Produktionsregeln: s --> [a],[b]. % s kann zuTerminalen ab werden s --> [a],s,[b]. % Terminal a, Produktionsregel,Terminal b Die Menge der "Sätze" die durch eine Grammatik akzeptiert (generiert) wird, heisst Sprache welche durch die Grammatik definiert ist. Überlegen Sie wie durch Backtracking die Menge der Strings aufgebaut wird. Schreiben Sie eine Mengendefinition der Sprache. Erstes Beispiel: Schreibe eine Grammatik, welche Strings der Form a n b n mit n = 1,2,3,... akzeptiert. Produktionsregeln: s --> [a],[b]. % s kann zuTerminalen ab werden s --> [a],s,[b]. % Terminal a, Produktionsregel,Terminal b Die Menge der "Sätze" die durch eine Grammatik akzeptiert (generiert) wird, heisst Sprache welche durch die Grammatik definiert ist. Überlegen Sie wie durch Backtracking die Menge der Strings aufgebaut wird. Schreiben Sie eine Mengendefinition der Sprache.

DCG Beispiel 2 Zweites Beispiel: Man stelle sich einen Roboter mit folgenden Bewegungsmöglichkeiten vor. up: ein Schritt aufwärts down: ein Schritt abwärts Akzeptierte Kommandosequenzen sollen sein: up up up down up down D.h. Sequenzen von Schritten (step) die durch den Roboter ausgeführt werden sollen. Implementiert werden diese durch einen move, der entweder ein step sein kann oder ein step gefolgt von einem neuen move. Zweites Beispiel: Man stelle sich einen Roboter mit folgenden Bewegungsmöglichkeiten vor. up: ein Schritt aufwärts down: ein Schritt abwärts Akzeptierte Kommandosequenzen sollen sein: up up up down up down D.h. Sequenzen von Schritten (step) die durch den Roboter ausgeführt werden sollen. Implementiert werden diese durch einen move, der entweder ein step sein kann oder ein step gefolgt von einem neuen move.

DCG Beispiel 2 Roboterarmprogramm: %Produktionsregeln move --> step. move --> step, move. %Terminalregeln step --> [up]. step --> [down]. Überlegen Sie wiederum wie die Sprache aussieht, die durch Backtracking ausgegeben wird. Falls Sie Probleme haben probieren Sie das Programm aus. Roboterarmprogramm: %Produktionsregeln move --> step. move --> step, move. %Terminalregeln step --> [up]. step --> [down]. Überlegen Sie wiederum wie die Sprache aussieht, die durch Backtracking ausgegeben wird. Falls Sie Probleme haben probieren Sie das Programm aus.

Grammatiken Charakteristik Zwischenergebnis: Eine Grammatik generiert Sätze. In der Gegenrichtung kann eine Grammatik dazu benutzt werden, um einen gegebenen Satz zu erkennen. Ein Erkenner entscheidet, ob ein gegebener Satz zu einer bestimmten Sprache gehört. Erkennung ist somit die Inverse von Generierung. Die Erkennung ist Erfolgreich, wenn die gesamte Eingabe zu einerm Nicht-Terminalsymbol der Grammatik reduziert ist. Zwischenergebnis: Eine Grammatik generiert Sätze. In der Gegenrichtung kann eine Grammatik dazu benutzt werden, um einen gegebenen Satz zu erkennen. Ein Erkenner entscheidet, ob ein gegebener Satz zu einer bestimmten Sprache gehört. Erkennung ist somit die Inverse von Generierung. Die Erkennung ist Erfolgreich, wenn die gesamte Eingabe zu einerm Nicht-Terminalsymbol der Grammatik reduziert ist.

DCG Eingabesatz Der Erkenner von Prolog erwartet, dass Eingaben als Differenzlisten von Terminalsymbolen repräsentiert werden. Prolog erwartet folglich zwei Listen in der Eingabe: z.B. [a,a,b,b] und [ ] um die Sequenz aabb zu repräsentieren. %erkenne aabb mit der Grammatik aus dem ersten Beispiel ?- s([a,a,b,b],[]). yes %erkenne up,up,down mit der Robotergrammatik ?- move([up,up,down],[]). yes. Der Erkenner von Prolog erwartet, dass Eingaben als Differenzlisten von Terminalsymbolen repräsentiert werden. Prolog erwartet folglich zwei Listen in der Eingabe: z.B. [a,a,b,b] und [ ] um die Sequenz aabb zu repräsentieren. %erkenne aabb mit der Grammatik aus dem ersten Beispiel ?- s([a,a,b,b],[]). yes %erkenne up,up,down mit der Robotergrammatik ?- move([up,up,down],[]). yes.

DCG Interne Repräsentation Interne Repräsentation der DCG Regeln: move(List,Rest) :- step(List,Rest). move(List,Rest) :- step(List,ListRest), move(ListRest,Rest). step([up|Rest],Rest). step([down|Rest],Rest). move wird mit zwei Argumentlisten versehen der Eingabeliste List und der Restliste, das was übrig bleiben soll Rest. move(List,Rest) wird dann wahr, wenn die Differenz von List und Rest ein akzeptabler move ist, eine Sequenz von up and down. Interne Repräsentation der DCG Regeln: move(List,Rest) :- step(List,Rest). move(List,Rest) :- step(List,ListRest), move(ListRest,Rest). step([up|Rest],Rest). step([down|Rest],Rest). move wird mit zwei Argumentlisten versehen der Eingabeliste List und der Restliste, das was übrig bleiben soll Rest. move(List,Rest) wird dann wahr, wenn die Differenz von List und Rest ein akzeptabler move ist, eine Sequenz von up and down.

DCG Beispiel 3 Interessantere Grammatiken: Programmiersprachen, natürliche Sprachen sentence --> noun_phrase, verb_phrase. noun_phrase --> determiner, noun. verb_phrase --> verb, noun_phrase. determiner --> [eine]. determiner --> [die]. noun --> [katze]. noun --> [maus]. verb --> [erschreckt]. verb --> [hasst]. sentence([die,katze,erschreckt,eine,maus), [ ] ). yes. Interessantere Grammatiken: Programmiersprachen, natürliche Sprachen sentence --> noun_phrase, verb_phrase. noun_phrase --> determiner, noun. verb_phrase --> verb, noun_phrase. determiner --> [eine]. determiner --> [die]. noun --> [katze]. noun --> [maus]. verb --> [erschreckt]. verb --> [hasst]. sentence([die,katze,erschreckt,eine,maus), [ ] ). yes.

DCG Beispiel 3 Jetzt einen mit zusätzlichen Terminalen Kater einführen: determiner --> [der]. noun --> [kater]. Was ist das Problem? Die erweiterte Grammatik erzeugt zwar den gewünschten Satz [der, kater, erschreckt, eine, maus] aber auch nicht-grammatische Sätze wie [die, kater, erschreckt, eine, maus]. Im Deutschen Kasus,Genus,Numerus Kongruenz: Das bedeutet die Regel sentence --> noun_phrase, verb_phrase. kann so nicht stehenbleiben da hier unabhängig vom Kontext jede np mit jeder vp kombinierbar ist! Jetzt einen mit zusätzlichen Terminalen Kater einführen: determiner --> [der]. noun --> [kater]. Was ist das Problem? Die erweiterte Grammatik erzeugt zwar den gewünschten Satz [der, kater, erschreckt, eine, maus] aber auch nicht-grammatische Sätze wie [die, kater, erschreckt, eine, maus]. Im Deutschen Kasus,Genus,Numerus Kongruenz: Das bedeutet die Regel sentence --> noun_phrase, verb_phrase. kann so nicht stehenbleiben da hier unabhängig vom Kontext jede np mit jeder vp kombinierbar ist!

DCG Kontextmodellierung Kontextabhängigkeit übersteigt die unmittelbare Ausdruckskraft von BNF Grammatiken, sie ist aber leicht mit DCG Grammatiken auszudrücken. DCG kann im Unterschied zu BNF Argumente transportieren. Argumente werden den nicht-terminalen mitgegeben. noun_phrase(Genus) sentence --> noun_phrase(Genus), verb_phrase. noun_phrase(Genus) --> det(Genus),noun(Genus). noun(male) --> [Kater]. det(male) --> [der]. Überlegen Sie, wo der ungrammatische Satz: der Katze erschreckt die Maus scheitert. Kontextabhängigkeit übersteigt die unmittelbare Ausdruckskraft von BNF Grammatiken, sie ist aber leicht mit DCG Grammatiken auszudrücken. DCG kann im Unterschied zu BNF Argumente transportieren. Argumente werden den nicht-terminalen mitgegeben. noun_phrase(Genus) sentence --> noun_phrase(Genus), verb_phrase. noun_phrase(Genus) --> det(Genus),noun(Genus). noun(male) --> [Kater]. det(male) --> [der]. Überlegen Sie, wo der ungrammatische Satz: der Katze erschreckt die Maus scheitert.

DCG Kontextmodellierung Konversion in Standard Prolog: sentence(Genus, SentenceList, RestList) :- nounphrase(Genus, SentenceList, RestNP), verbphrase(RestNP,RestList). noun_phrase(Genus,InNP,OutNP) :- determiner(Genus,InNP,OutDet), noun(Genus,OutDet,OutNP). noun(male,[kater|OutNoun],OutNoun). %Terminal schneidet ab Konversion in Standard Prolog: sentence(Genus, SentenceList, RestList) :- nounphrase(Genus, SentenceList, RestNP), verbphrase(RestNP,RestList). noun_phrase(Genus,InNP,OutNP) :- determiner(Genus,InNP,OutDet), noun(Genus,OutDet,OutNP). noun(male,[kater|OutNoun],OutNoun). %Terminal schneidet ab

DCG Parsebaum Wiederholung: Konstruktion von Parsebäumen (1) alle Blätter sind mit Terminalsymbolen der Grammatik gelabelt (2) alle internen Symbole sind mit Nicht-Terminalen gelabelt Wurzel(Root) ist mit einem Nicht-Terminal gelabelt, das mit der Phrase korrespondiert (3) Eltern-Kind Relation im Baum wird durch die Regeln der Grammatik festgelegt Wiederholung: Konstruktion von Parsebäumen (1) alle Blätter sind mit Terminalsymbolen der Grammatik gelabelt (2) alle internen Symbole sind mit Nicht-Terminalen gelabelt Wurzel(Root) ist mit einem Nicht-Terminal gelabelt, das mit der Phrase korrespondiert (3) Eltern-Kind Relation im Baum wird durch die Regeln der Grammatik festgelegt

DCG Parsebaum Beispiel zur Parsebaumkonstruktion: s --> p,q,r. Manchmal ist es notwendig den Parsebaum explizit zu repräsentieren etwa um die Bedeutung eines Satzes aus seiner Struktur zu extrahieren. Ein Parsebaum wird wie folgt repräsentiert: Functor ist Root des jeweiligen Baumes, die Argumente sind seine Teilbäume. Beispiel zur Parsebaumkonstruktion: s --> p,q,r. Manchmal ist es notwendig den Parsebaum explizit zu repräsentieren etwa um die Bedeutung eines Satzes aus seiner Struktur zu extrahieren. Ein Parsebaum wird wie folgt repräsentiert: Functor ist Root des jeweiligen Baumes, die Argumente sind seine Teilbäume. s p q r

DCG Parsebaum Parsebaum für np [die, Katze] np ist der Funktor, Argumente sind die Teilbäume, die unter np liegen np(det(die),n(Katze)). In der Grammatik wird ein zusätzliches argument mitgegeben: np(Genus, np(Det,N)) --> det(Genus, Det), n(Genus,N). det(female, det(die)) --> [die]. n(female, n(katze)) --> [katze]. Parsebaum für np [die, Katze] np ist der Funktor, Argumente sind die Teilbäume, die unter np liegen np(det(die),n(Katze)). In der Grammatik wird ein zusätzliches argument mitgegeben: np(Genus, np(Det,N)) --> det(Genus, Det), n(Genus,N). det(female, det(die)) --> [die]. n(female, n(katze)) --> [katze].

Syntax und Semantik Vom Parse zur Bedeutung Prolog Grammatiken sind auch dazu geeignet, die "Bedeutung" von Sätzen wiederzugeben. Die Bedeutung einer Struktur kann über Nicht-Terminale im Baum weitergegeben bzw. zusammengebaut werden. (I) Erste Möglichkeit ist ein zweistufiges Vorgehen (1) generiere den Parsebaum (2) verarbeite den Parsebaum, um die Bedeutung zu generieren Vom Parse zur Bedeutung Prolog Grammatiken sind auch dazu geeignet, die "Bedeutung" von Sätzen wiederzugeben. Die Bedeutung einer Struktur kann über Nicht-Terminale im Baum weitergegeben bzw. zusammengebaut werden. (I) Erste Möglichkeit ist ein zweistufiges Vorgehen (1) generiere den Parsebaum (2) verarbeite den Parsebaum, um die Bedeutung zu generieren

Syntax und Semantik Roboterarmprogramm: move(move(Step)) --> step(Step). move(move(Step,Move)) --> step(Step),move(Move). step(step(up)) --> [up]. step(setp(down)) --> [down]. Bedeutung: die Bedeutung soll die Distanz zwischen der Roboterposition vor dem move und danach sein. Sei ein jeder Schritt (step) 1mm in positiver(up) bzw. negativer(down) Richtung. [up, up, down, up] würde also 2 bedeuten Roboterarmprogramm: move(move(Step)) --> step(Step). move(move(Step,Move)) --> step(Step),move(Move). step(step(up)) --> [up]. step(setp(down)) --> [down]. Bedeutung: die Bedeutung soll die Distanz zwischen der Roboterposition vor dem move und danach sein. Sei ein jeder Schritt (step) 1mm in positiver(up) bzw. negativer(down) Richtung. [up, up, down, up] würde also 2 bedeuten

Syntax und Semantik Parsebaum des move Parsebaum des move move step up down up

Syntax und Semantik Bedeutung des Parsebaums %meaning(ParseTree,Value). meaning(move(Step,Move),Dist) :- meaning(Step,D1), meaning(Move,D2), Dist is D1 + D2. meaning(move(Step),Dist) :- meaning(Step,Dist). meaning(step(up),1). meaning(step(down),-1). Bedeutung des Parsebaums %meaning(ParseTree,Value). meaning(move(Step,Move),Dist) :- meaning(Step,D1), meaning(Move,D2), Dist is D1 + D2. meaning(move(Step),Dist) :- meaning(Step,Dist). meaning(step(up),1). meaning(step(down),-1).

Syntax und Semantik ?- move(Tree, [up,up,down,up],[]), meaning(Tree,Dist). Dist = 2. Tree = move(step(up), move(step(up), move(step(down), move(step(up))))). ?- move(Tree, [up,up,down,up],[]), meaning(Tree,Dist). Dist = 2. Tree = move(step(up), move(step(up), move(step(down), move(step(up))))).

Syntax und Semantik (II) Syntax und Semantik zusammen. Semantik direkt in der Grammatik implementieren. Wir erinnern uns: Einbringen von Standardprolog in DCG Regeln durch geschweifte Klammern. move(D) --> step(D). move(D) --> step(D1),move(D2), {D is D1 + D2}. step(1) --> [up]. step(-1) --> [down]. Also deutlich einfacher! (II) Syntax und Semantik zusammen. Semantik direkt in der Grammatik implementieren. Wir erinnern uns: Einbringen von Standardprolog in DCG Regeln durch geschweifte Klammern. move(D) --> step(D). move(D) --> step(D1),move(D2), {D is D1 + D2}. step(1) --> [up]. step(-1) --> [down]. Also deutlich einfacher!

Syntax und Semantik move(D) --> step(D1),move(D2), {D is D1 + D2}. Ein move, dessen Bedeutung D ist besteht aus: einem Step mit Bedeutung D1 und einem move mit Bedeutung D2, wobei die Relation D is D1+D2 gilt. Aber Achtung, solche kollabierten Programme sind oft weniger transparent und schwieriger modifizierbar. move(D) --> step(D1),move(D2), {D is D1 + D2}. Ein move, dessen Bedeutung D ist besteht aus: einem Step mit Bedeutung D1 und einem move mit Bedeutung D2, wobei die Relation D is D1+D2 gilt. Aber Achtung, solche kollabierten Programme sind oft weniger transparent und schwieriger modifizierbar.

Hausaufgabe + Nächstes Mal Musterklausur unter realen Bedingungen, Arbeitszeit 90 Minuten lösen und per mail Bereiche nennen, die wir nochmals durchsprechen sollen Nächstes Mal: Bäume + Graphen Prolog + Semantik natürlicher Sprache Musterklausur unter realen Bedingungen, Arbeitszeit 90 Minuten lösen und per mail Bereiche nennen, die wir nochmals durchsprechen sollen Nächstes Mal: Bäume + Graphen Prolog + Semantik natürlicher Sprache