Effizienz und Grammatiken
Effizienz
Differenzlisten Grammatiken
Effizienz
Differenzlisten Grammatiken
Effizienz im Allgemeinen
Ausführungszeit, Speichererfordernis
Die traditionelle Computerarchitektur ist nicht besonders passend für Prologs Programmausführung: beweisen einer Zielliste
Für praktische Applikationen ist die mangelnde Effizienz von Prolog dann bedeutsam,
(1) wenn die Grundlaufzeit des Programms hoch ist und das Programm öfter aufgerufen werden muss.
(2) wenn die Anwendung online ist und der Benutzer auf Terminierung warten muss
Vorteile von Prolog bezüglich Programmentwicklungszeiten:
symbolische, nicht-numerische Programmierung, strukturierte Datenobjekte und Relationen auf diesen.
→ aber heute auch viele Bibliotheken z.B. in Java Ausführungszeit, Speichererfordernis
Die traditionelle Computerarchitektur ist nicht besonders passend für Prologs Programmausführung: beweisen einer Zielliste
Für praktische Applikationen ist die mangelnde Effizienz von Prolog dann bedeutsam,
(1) wenn die Grundlaufzeit des Programms hoch ist und das Programm öfter aufgerufen werden muss.
(2) wenn die Anwendung online ist und der Benutzer auf Terminierung warten muss
Vorteile von Prolog bezüglich Programmentwicklungszeiten:
symbolische, nicht-numerische Programmierung, strukturierte Datenobjekte und Relationen auf diesen.
→ aber heute auch viele Bibliotheken z.B. in Java
Effizienz im Allgemeinen
Ausführungszeit: im Allgemeinen ist ein compiliertes Programm schneller als ein interpretiertes. Deshalb falls vorhanden für
zeitkritische Anwendungen compilierte Programme verwenden.
Daneben:
- Ordnung der Klauseln
- Prozedurale Steuerung durch den Cut Schließlich:
Oft kann der Algorithmus selbst entscheidend verbessert werden.
- Verbesserung der Sucheffizienz, indem unnötiges Backtracking vermieden wird, aussichtslose Alternativen so schnell wie möglich beenden
- Passendere Datenstrukturen verwenden um die Objekte des Programms zu repräsentieren, so dass Operationen möglichst effizient implementiert werden können.
- Caching mit assert
Ausführungszeit: im Allgemeinen ist ein compiliertes Programm schneller als ein interpretiertes. Deshalb falls vorhanden für
zeitkritische Anwendungen compilierte Programme verwenden.
Daneben:
- Ordnung der Klauseln
- Prozedurale Steuerung durch den Cut Schließlich:
Oft kann der Algorithmus selbst entscheidend verbessert werden.
- Verbesserung der Sucheffizienz, indem unnötiges Backtracking vermieden wird, aussichtslose Alternativen so schnell wie möglich beenden
- Passendere Datenstrukturen verwenden um die Objekte des Programms zu repräsentieren, so dass Operationen möglichst effizient implementiert werden können.
- Caching mit assert
Effizienz durch Anordnung
Beispiel 1: Verbesserung der Effizienz des 8-Damen Programms In der ersten Lösung wurden die Y-Koordinaten für jede Dame
festgelegt indem Integer zwischen eins und acht ausgewählt werden.
member(Y,[1,2,3,4,5,6,7,8]).
Also wird zunächst 1, dann 2 usw. ausprobiert.
Nachdem die Damen in aufeinanderfolgenden Spalten auf dem Brett angeordnet werden, muss gelten, dass zwei aufeinanderfolgende
Damen in vertikaler Richtung mindestens zwei Quadrate entfernt angeordnet werden müssen.
member(Y,[1,5,2,6,3,7,4,8]) verbessert die erste Lösung um Faktor 3-4
Beispiel 1: Verbesserung der Effizienz des 8-Damen Programms In der ersten Lösung wurden die Y-Koordinaten für jede Dame
festgelegt indem Integer zwischen eins und acht ausgewählt werden.
member(Y,[1,2,3,4,5,6,7,8]).
Also wird zunächst 1, dann 2 usw. ausprobiert.
Nachdem die Damen in aufeinanderfolgenden Spalten auf dem Brett angeordnet werden, muss gelten, dass zwei aufeinanderfolgende
Damen in vertikaler Richtung mindestens zwei Quadrate entfernt angeordnet werden müssen.
member(Y,[1,5,2,6,3,7,4,8]) verbessert die erste Lösung um Faktor 3-4
Effizienz durch Anordnung
Beispiel2: Map coloring Problem: markiere jedes Land einer
gegebenen Karte aus vier Farben, so dass keine benachbarten Länder in derselben Farbe markiert sind.
ngb(Land,Nachbarn).
ngb(albanien,[griechenland,mazedonien,serbien]
ngb(andora,[frankreich,spanien]).
…
Lösung: Liste von Paaren Land/Farbe [albanien/C1,andorra/C2,...]
Definiere ein Prädikat für colors(Länder_Farben_Liste)
Beispiel2: Map coloring Problem: markiere jedes Land einer
gegebenen Karte aus vier Farben, so dass keine benachbarten Länder in derselben Farbe markiert sind.
ngb(Land,Nachbarn).
ngb(albanien,[griechenland,mazedonien,serbien]
ngb(andora,[frankreich,spanien]).
…
Lösung: Liste von Paaren Land/Farbe [albanien/C1,andorra/C2,...]
Definiere ein Prädikat für colors(Länder_Farben_Liste)
Effizienz durch Anordnung
colors([]).
colors([Country/Color|Rest]):-
colors(Rest), member(Color,[gelb,blau,rot,grün]), not(member(Country1/Color,Rest), neighbor(Country,Country1)).
neighbor(Country,Country1):-
ngb(Country,Neighbours),
member(Country1,Neighbors).
colors([]).
colors([Country/Color|Rest]):-
colors(Rest), member(Color,[gelb,blau,rot,grün]), not(member(Country1/Color,Rest), neighbor(Country,Country1)).
neighbor(Country,Country1):-
ngb(Country,Neighbours),
member(Country1,Neighbors).
Effizienz durch Anordnung
Aufruf über Hilfsprädikat:
country(C) :- ngb(C,_).
?- setoff(Country/Color, country(Country),CountryColorList), colors(ContryColorList).
setoff kontruiert eine Liste für z.B. Europa nach den ngb-Fakten in der Datenbank mit Variablen für die Farben. colors-Ziel soll dann die Farben belegen.
Aufruf über Hilfsprädikat:
country(C) :- ngb(C,_).
?- setoff(Country/Color, country(Country),CountryColorList), colors(ContryColorList).
setoff kontruiert eine Liste für z.B. Europa nach den ngb-Fakten in der Datenbank mit Variablen für die Farben. colors-Ziel soll dann die Farben belegen.
Effizienz durch Anordnung
Ineffizienzproblem:
Staaten und die Country/Color-Liste sind alphabetisch arrangiert.
Kein Zusammenhang mit der geographischen Lage.
Zuweisungsprozess der Farben startet am Ende der Liste (Warum?).
Zuweisungsprozess ist unabhängig von der ngb-Relation (Warum?).
Die Farben werden also beginnend von einem Punkt auf der Karte weiter bei einem anderen usw zugewiesen.
Mehr oder weniger zufällig. Es kann sehr leicht passieren, dass für ein Land, das viele Nachbarn hat, alle 4 Farben schon verbraucht sind! Dann ist aufwändiges Backtracking notwendig.
Ineffizienzproblem:
Staaten und die Country/Color-Liste sind alphabetisch arrangiert.
Kein Zusammenhang mit der geographischen Lage.
Zuweisungsprozess der Farben startet am Ende der Liste (Warum?).
Zuweisungsprozess ist unabhängig von der ngb-Relation (Warum?).
Die Farben werden also beginnend von einem Punkt auf der Karte weiter bei einem anderen usw zugewiesen.
Mehr oder weniger zufällig. Es kann sehr leicht passieren, dass für ein Land, das viele Nachbarn hat, alle 4 Farben schon verbraucht sind! Dann ist aufwändiges Backtracking notwendig.
Effizienz durch Anordnung
Klar ist: die Effizienz hängt von der Ordnung ab, in der Ländern die Farbe zugewiesen wird. Intuitiv ist schon eine einfache Strategie besser als Random:
Starte mit einem Land mit vielen Nachbarn, dann dessen Nachbarn und der Nachbarn Nachbarn...
Klar ist: die Effizienz hängt von der Ordnung ab, in der Ländern die Farbe zugewiesen wird. Intuitiv ist schon eine einfache Strategie besser als Random:
Starte mit einem Land mit vielen Nachbarn, dann dessen Nachbarn und der Nachbarn Nachbarn...
Effizienz durch Anordnung
makelist Prädikat
ausgehend von einem Land, z.B. Deutschland, wird eine Liste mit allen Ländern erstellt, die Closed heisst. Jedes Land wird zunächst in eine andere Liste geschrieben, die Open heisst. Aus Open kommt das Land zu Closed, wenn seine Nachbarn aus nbg(Land, Nachbarn), auf Open geschrieben worden sind.
makelist Prädikat
ausgehend von einem Land, z.B. Deutschland, wird eine Liste mit allen Ländern erstellt, die Closed heisst. Jedes Land wird zunächst in eine andere Liste geschrieben, die Open heisst. Aus Open kommt das Land zu Closed, wenn seine Nachbarn aus nbg(Land, Nachbarn), auf Open geschrieben worden sind.
Effizienz durch Anordnung
makelist Prädikat
makelist(List) :- collect([germany],[],List).
collect([],Closed,Closed). %keine Kandidaten für Closed %rausschreiben auf List
collect([X|Open],Closed,List) :-
member(X,Closed), !, collect(Open,Closed,List).
%X schon gesammelt collect([X|Open],Closed,List) :-
ngb(X,Ngbs),
append(Ngbs,Open,Open1),
collect(Open1,[X|Closed],List).
makelist Prädikat
makelist(List) :- collect([germany],[],List).
collect([],Closed,Closed). %keine Kandidaten für Closed %rausschreiben auf List
collect([X|Open],Closed,List) :-
member(X,Closed), !, collect(Open,Closed,List).
%X schon gesammelt collect([X|Open],Closed,List) :-
ngb(X,Ngbs),
append(Ngbs,Open,Open1),
collect(Open1,[X|Closed],List).
Differenzlisten
Verbesserung der Effizienz der Listenkonkatenation mithilfe von Differenzlisten
Programm zur Konkatenation von Listen bislang war:
append([],L,L).
append([X|L1],L2,[X|L3]):- append(L1,L2,L3).
Ineffizient, wenn die erste Liste lang ist.
Verbesserung der Effizienz der Listenkonkatenation mithilfe von Differenzlisten
Programm zur Konkatenation von Listen bislang war:
append([],L,L).
append([X|L1],L2,[X|L3]):- append(L1,L2,L3).
Ineffizient, wenn die erste Liste lang ist.
Differenzlisten
Beispiel: ?- append([a,b,c], [d,e],L).
Zielsequenz
append([a,b,c], [d,e],L)
append([b,c], [d,e],L') mit L = [a|L']
append([c], [d,e],L'') mit L' = [b|L'']
append([], [d,e],L''') mit L'' = [c|L''']
true mit L''' = [d,e]
Das append prädikat arbeitet die gesamte erste Liste ab, bis endlich die Leere Liste erreicht ist, dann beginnt der rekursive
Zusammenbau.
Beispiel: ?- append([a,b,c], [d,e],L).
Zielsequenz
append([a,b,c], [d,e],L)
append([b,c], [d,e],L') mit L = [a|L']
append([c], [d,e],L'') mit L' = [b|L'']
append([], [d,e],L''') mit L'' = [c|L''']
true mit L''' = [d,e]
Das append prädikat arbeitet die gesamte erste Liste ab, bis endlich die Leere Liste erreicht ist, dann beginnt der rekursive
Zusammenbau.
Differenzlisten
Beispielimplementierung von append mit Akkumulator Beispiel: ?- append_acc([a,b,c], [d,e],L).
Zielsequenz
append_acc([],L,L).
append_acc([X|Rest],Acc,L):- append_acc(Rest,[X|Acc],L).
L=[c,b,a,d,e].
Schon effizienter aber die erste Liste wird in umgekehrter Reihenfolge angehängt.
Beispielimplementierung von append mit Akkumulator Beispiel: ?- append_acc([a,b,c], [d,e],L).
Zielsequenz
append_acc([],L,L).
append_acc([X|Rest],Acc,L):- append_acc(Rest,[X|Acc],L).
L=[c,b,a,d,e].
Schon effizienter aber die erste Liste wird in umgekehrter Reihenfolge angehängt.
Differenzlisten
Was wir uns wünschen würden:
Skip das Scannen der ersten Liste und hänge die zweite Liste an, ohne die gesammte erste Liste abzuarbeiten.
Wir müssen wissen, wo das Ende einer Liste ist → wir brauchen eine andere Repräsentation von Listen.
Die Lösung wird als Differenzlisten bezeichnet.
Eine Differenzliste wird als Listenpaar repräsentiert.
L = [a,b,c] kann mit L1=[a,b,c,d,e] und L2= [d,e] als L1-L2 repräsentiert werden.
Achtung: nur wenn L2 ein Suffix von L1 ist!!!
Was wir uns wünschen würden:
Skip das Scannen der ersten Liste und hänge die zweite Liste an, ohne die gesammte erste Liste abzuarbeiten.
Wir müssen wissen, wo das Ende einer Liste ist → wir brauchen eine andere Repräsentation von Listen.
Die Lösung wird als Differenzlisten bezeichnet.
Eine Differenzliste wird als Listenpaar repräsentiert.
L = [a,b,c] kann mit L1=[a,b,c,d,e] und L2= [d,e] als L1-L2 repräsentiert werden.
Achtung: nur wenn L2 ein Suffix von L1 ist!!!
Differenzlisten
Dieselbe Liste kann von verschiedenen Differenzpaaren repräsentiert werden.
[a,b,c] - [ ]
[a,b,c,d,e] - [d,e]
[a,b,c,d,e|T] - [d,e|T]
[a,b,c|T] – T
wobei T eine beliebige Liste ist.
Die leere Liste wird durch irgendein Paar der Form L-L als Differenzliste repräsentiert.
Dieselbe Liste kann von verschiedenen Differenzpaaren repräsentiert werden.
[a,b,c] - [ ]
[a,b,c,d,e] - [d,e]
[a,b,c,d,e|T] - [d,e|T]
[a,b,c|T] – T
wobei T eine beliebige Liste ist.
Die leere Liste wird durch irgendein Paar der Form L-L als Differenzliste repräsentiert.
Differenzlisten
Nachdem nun die zweite Liste im Paar das Ende der Liste
repräsentiert, ist das Ende direkt zugänglich. Dies kann für eine effiziente Implementation der Konkatenation ausgenutzt werden.
append_diff(As-Bs,Bs-Cs,As-Cs).
Anwendung: konkateniere [a,b,c] und [d,e].
Also [a,b,c|Bs] – Bs, [d,e|Cs] – Cs über den Aufruf
?- append_diff([a,b,c|Bs] – Bs,[d,e|Cs] – Cs,L - []) Cs = [ ]
Bs = [d,e|[]]
und damit L = [a,b,c,d,e|[]]
wichtig daran ist der Zusammenbau von As in L durch Unifikation indem Bs instantiert ist. Es wird Cs mit [] aufgerufen kann man
das Ergebnis weiter verarbeiten.
Nachdem nun die zweite Liste im Paar das Ende der Liste
repräsentiert, ist das Ende direkt zugänglich. Dies kann für eine effiziente Implementation der Konkatenation ausgenutzt werden.
append_diff(As-Bs,Bs-Cs,As-Cs).
Anwendung: konkateniere [a,b,c] und [d,e].
Also [a,b,c|Bs] – Bs, [d,e|Cs] – Cs über den Aufruf
?- append_diff([a,b,c|Bs] – Bs,[d,e|Cs] – Cs,L - []) Cs = [ ]
Bs = [d,e|[]]
und damit L = [a,b,c,d,e|[]]
wichtig daran ist der Zusammenbau von As in L durch Unifikation indem Bs instantiert ist. Es wird Cs mit [] aufgerufen kann man
das Ergebnis weiter verarbeiten.
Kontextfreie Grammatiken in Prolog
Kontextfreie Grammatik Pseudocode s → np vp
np → det n vp → v np | v det → der | das
n → Programmierer | Programm v → steht | schrieb
Kontextfreie Grammatik Pseudocode s → np vp
np → det n vp → v np | v det → der | das
n → Programmierer | Programm v → steht | schrieb
Übersetzung in Prolog
S(S) :- append(NP,VP,S), np(NP),
vp(VP).
wir zerteilen den Eingabesatz S eine Liste von Prolog-Atomen in zwei Teillisten und prüfen ob diese die Eigenschaft np und vp haben
S(S) :- append(NP,VP,S), np(NP),
vp(VP).
wir zerteilen den Eingabesatz S eine Liste von Prolog-Atomen in zwei Teillisten und prüfen ob diese die Eigenschaft np und vp haben
Übersetzung in Prolog
np(NP) :- append(D,N,NP), det(D),n(N).
vp(VP) :- append(V,NP,VP), v(V),np(NP).
vp(VP) :- v(VP).
det([der]).
det([das]).
n(['Programmierer']).
n(['Programm']).
v([steht]).
v([schrieb]).
np(NP) :- append(D,N,NP), det(D),n(N).
vp(VP) :- append(V,NP,VP), v(V),np(NP).
vp(VP) :- v(VP).
det([der]).
det([das]).
n(['Programmierer']).
n(['Programm']).
v([steht]).
v([schrieb]).
Übersetzung in Prolog
Aufruf des Programms:
[trace] ?- np([das,'Programm']).
Call: (6) np([das, 'Programm']) ? creep
Call: (7) append(_G1595, _G1596, [das, 'Programm']) ? creep Exit: (7) append([], [das, 'Programm'], [das, 'Programm']) ? creep Call: (7) det([]) ? creep
Fail: (7) det([]) ? creep
Exit: (7) append([das], ['Programm'], [das, 'Programm']) ? creep Call: (7) det([das]) ? creep
Exit: (7) det([das]) ? creep
Call: (7) n(['Programm']) ? creep Exit: (7) n(['Programm']) ? creep
Exit: (6) np([das, 'Programm']) ? creep true .
Problem zu viele append Aufrufe.
Aufruf des Programms:
[trace] ?- np([das,'Programm']).
Call: (6) np([das, 'Programm']) ? creep
Call: (7) append(_G1595, _G1596, [das, 'Programm']) ? creep Exit: (7) append([], [das, 'Programm'], [das, 'Programm']) ? creep Call: (7) det([]) ? creep
Fail: (7) det([]) ? creep
Exit: (7) append([das], ['Programm'], [das, 'Programm']) ? creep Call: (7) det([das]) ? creep
Exit: (7) det([das]) ? creep
Call: (7) n(['Programm']) ? creep Exit: (7) n(['Programm']) ? creep
Exit: (6) np([das, 'Programm']) ? creep true .
Problem zu viele append Aufrufe.
Übersetzung in Prolog
Lösung: Differenzlisten. Wir parsen den Satz entlang von links nach rechts. Wir können also sagen, Eingabe ist eine Liste von Atomen, von denen mit der ersten Regel np ein Teil NP abgearbeitet wird und dann bleibt noch ein Teil VP übrig. Wird mit vp der Teil VP
abgearbeitet, so bleibt nichts mehr übrig. Zugleich gilt: S = NP+VP wir erinnern uns an die Differenzlistenimplementierung.
appendl(As-Bs,Bs-Cs,As-Cs).
Damit wird NP: S – VP VP: VP - [ ]
Aufruf: S- [ ]
Lösung: Differenzlisten. Wir parsen den Satz entlang von links nach rechts. Wir können also sagen, Eingabe ist eine Liste von Atomen, von denen mit der ersten Regel np ein Teil NP abgearbeitet wird und dann bleibt noch ein Teil VP übrig. Wird mit vp der Teil VP
abgearbeitet, so bleibt nichts mehr übrig. Zugleich gilt: S = NP+VP wir erinnern uns an die Differenzlistenimplementierung.
appendl(As-Bs,Bs-Cs,As-Cs).
Damit wird NP: S – VP VP: VP - [ ]
Aufruf: S- [ ]
Übersetzung in Prolog
Neue Grammatikregeln:
s(S-[]) :-
appendl(S-VP,VP-[ ],S-[]), beginnt_mit_np(S-VP), beginnt_mit_vp(VP-[]).
Neue Grammatikregeln:
s(S-[]) :-
appendl(S-VP,VP-[ ],S-[]), beginnt_mit_np(S-VP), beginnt_mit_vp(VP-[]).
Übersetzung in Prolog
Vereinfacht ohne Append mit zwei Argumenten: Eingabeliste des Prädikats und Ausgaberestliste.
s(I,J) :- beginnt_mit_np(I,K),beginnt_mit_vp(K,J).
mit J = [ ] aufgerufen, dann wird der ganze Satz in der Liste
I=['Der','Programmierer',programmiert] abgearbeitet wenn J mit []
zurückkommt.
beginnt_mit_np(I,K) :- det(I,J), n(J,K).
beginnt_mit_vp(K,J) :- v(K,J).
Terminale:
det(I,J) :- I = [der|J].
det(I,J) :- I = ['Der'|J].
n(I,J) :- I = ['Programmierer'|J].
v(I,J) :- I = [programmiert|J].
Vereinfacht ohne Append mit zwei Argumenten: Eingabeliste des Prädikats und Ausgaberestliste.
s(I,J) :- beginnt_mit_np(I,K),beginnt_mit_vp(K,J).
mit J = [ ] aufgerufen, dann wird der ganze Satz in der Liste
I=['Der','Programmierer',programmiert] abgearbeitet wenn J mit []
zurückkommt.
beginnt_mit_np(I,K) :- det(I,J), n(J,K).
beginnt_mit_vp(K,J) :- v(K,J).
Terminale:
det(I,J) :- I = [der|J].
det(I,J) :- I = ['Der'|J].
n(I,J) :- I = ['Programmierer'|J].
v(I,J) :- I = [programmiert|J].
Übersetzung in Prolog
Startaufrufe und Abarbeitung Determinator
[trace] ?- s(['Der','Programmierer',programmiert],[]).
Call: (6) s(['Der', 'Programmierer', programmiert], []) ? creep
Call: (7) np(['Der', 'Programmierer', programmiert], _G138943) ? creep Call: (8) det(['Der', 'Programmierer', programmiert], _G138943) ? creep Call: (9) ['Der', 'Programmierer', programmiert]=[der|_G138939] ? creep Fail: (9) ['Der', 'Programmierer', programmiert]=[der|_G138939] ? creep Redo: (8) det(['Der', 'Programmierer', programmiert], _G138943) ? creep Call: (9) ['Der', 'Programmierer', programmiert]=['Der'|_G138939] ? creep
Exit: (9) ['Der', 'Programmierer', programmiert]=['Der', 'Programmierer', programmiert] ? creep
Exit: (8) det(['Der', 'Programmierer', programmiert], ['Programmierer', programmiert]) ? creep
Startaufrufe und Abarbeitung Determinator
[trace] ?- s(['Der','Programmierer',programmiert],[]).
Call: (6) s(['Der', 'Programmierer', programmiert], []) ? creep
Call: (7) np(['Der', 'Programmierer', programmiert], _G138943) ? creep Call: (8) det(['Der', 'Programmierer', programmiert], _G138943) ? creep Call: (9) ['Der', 'Programmierer', programmiert]=[der|_G138939] ? creep Fail: (9) ['Der', 'Programmierer', programmiert]=[der|_G138939] ? creep Redo: (8) det(['Der', 'Programmierer', programmiert], _G138943) ? creep Call: (9) ['Der', 'Programmierer', programmiert]=['Der'|_G138939] ? creep
Exit: (9) ['Der', 'Programmierer', programmiert]=['Der', 'Programmierer', programmiert] ? creep
Exit: (8) det(['Der', 'Programmierer', programmiert], ['Programmierer', programmiert]) ? creep
Übersetzung in Prolog
Abarbeitung Nomen schließen Nominalphrase np
[trace]
Call: (8) n(['Programmierer', programmiert], _G139255) ? creep
Call: (9) ['Programmierer', programmiert]=['Programmierer'|_G139251] ? creep Exit: (9) ['Programmierer', programmiert]=['Programmierer', programmiert] ? creep Exit: (8) n(['Programmierer', programmiert], [programmiert]) ? creep
Exit: (7) np(['Der', 'Programmierer', programmiert], [programmiert]) ? creep
Abarbeitung Nomen schließen Nominalphrase np
[trace]
Call: (8) n(['Programmierer', programmiert], _G139255) ? creep
Call: (9) ['Programmierer', programmiert]=['Programmierer'|_G139251] ? creep Exit: (9) ['Programmierer', programmiert]=['Programmierer', programmiert] ? creep Exit: (8) n(['Programmierer', programmiert], [programmiert]) ? creep
Exit: (7) np(['Der', 'Programmierer', programmiert], [programmiert]) ? creep
Übersetzung in Prolog
Abarbeitung verb/schließen Verbalphrase vp
[trace]
Call: (7) vp([programmiert], []) ? creep Call: (8) v([programmiert], []) ? creep
Call: (9) [programmiert]=[programmiert] ? creep Exit: (9) [programmiert]=[programmiert] ? creep Exit: (8) v([programmiert], []) ? creep
Exit: (7) vp([programmiert], []) ? creep
Exit: (6) s(['Der', 'Programmierer', programmiert], []) ? creep true
Abarbeitung verb/schließen Verbalphrase vp
[trace]
Call: (7) vp([programmiert], []) ? creep Call: (8) v([programmiert], []) ? creep
Call: (9) [programmiert]=[programmiert] ? creep Exit: (9) [programmiert]=[programmiert] ? creep Exit: (8) v([programmiert], []) ? creep
Exit: (7) vp([programmiert], []) ? creep
Exit: (6) s(['Der', 'Programmierer', programmiert], []) ? creep true
Übersetzung in Prolog
Tatsächlich erfolgt die Abarbeitung der Differenzlisten auf der Ebene der Terminale über den Restlistenoperator.
Alternative Schreibung der Terminale:
Eingabeliste mit dem Terminal in Atomform als Kopf Ausgabeliste ist der Rest.
det([der|J],J).
Dieser Rest ist dann wiederum Eingabeliste für das n Goal aus der np Regel
n([Programmierer|J],J).
Dieser Rest wird dann an die np als deren Ausgabeliste weitergegeben, der Rest vom Satz
np(I,J) :- det(I,K),n(K,J).
Tatsächlich erfolgt die Abarbeitung der Differenzlisten auf der Ebene der Terminale über den Restlistenoperator.
Alternative Schreibung der Terminale:
Eingabeliste mit dem Terminal in Atomform als Kopf Ausgabeliste ist der Rest.
det([der|J],J).
Dieser Rest ist dann wiederum Eingabeliste für das n Goal aus der np Regel
n([Programmierer|J],J).
Dieser Rest wird dann an die np als deren Ausgabeliste weitergegeben, der Rest vom Satz
np(I,J) :- det(I,K),n(K,J).
Übersetzung in Prolog
Format der Klauselgrammatiken in Prolog
In Prolog wird die Regelübersetzung von Grammatikklauseln in das notwendige Abarbeitungsformat durch das Prädikat
--> /2 erreicht.
Format der Klauselgrammatiken in Prolog
In Prolog wird die Regelübersetzung von Grammatikklauseln in das notwendige Abarbeitungsformat durch das Prädikat
--> /2 erreicht.
Übersetzung in Prolog
Unsere Beispielgrammatik als DCG:
s --> np,vp.
np --> det,n.
vp --> v, np.
vp --> v.
det --> [der].
det --> [das].
n --> ['Programmierer'].
n --> ['Programm'].
v --> [steht].
v --> [schrieb].
Diese Regeln werden dann intern in die Differenzlistenform übersetzt: np(I,J) :- det(I,K),n(K,J).
Unsere Beispielgrammatik als DCG:
s --> np,vp.
np --> det,n.
vp --> v, np.
vp --> v.
det --> [der].
det --> [das].
n --> ['Programmierer'].
n --> ['Programm'].
v --> [steht].
v --> [schrieb].
Diese Regeln werden dann intern in die Differenzlistenform übersetzt: np(I,J) :- det(I,K),n(K,J).
Hausaufgabe
Lesen Leiss-Skript zu Kapitel 6 DCG Lesen Bratko Kapitel 21
Lesen Leiss-Skript zu Kapitel 6 DCG Lesen Bratko Kapitel 21
