Listen & Beweisstrategie Prolog Grundkurs WS 99/00 Christof Rumpf rumpf@uni-duesseldorf.de

  • View
    103

  • Download
    0

Embed Size (px)

Text of Listen & Beweisstrategie Prolog Grundkurs WS 99/00 Christof Rumpf rumpf@uni-duesseldorf.de

  • Folie 1
  • Listen & Beweisstrategie Prolog Grundkurs WS 99/00 Christof Rumpf rumpf@uni-duesseldorf.de
  • Folie 2
  • 15.11.99GK Prolog - Listen, Beweisstrategie2 Listen Listen sind zusammengesetzte Terme, die in eckigen Klammern eine beliebige Anzahl von Termen als Elemente haben knnen, die durch Kommata getrennt werden. Die Reihenfolge der Elemente ist im Gegensatz zu Mengen relevant: Listen sind Sequenzen, bzw. Folgen. [atom,1,X,2.0,p(Y),[],[x]]
  • Folie 3
  • 15.11.99GK Prolog - Listen, Beweisstrategie3 Rekursive Definition von Listen Listen sind Terme. Es gibt zwei Arten von Listen: leere und nichtleere. leere Liste: [] nichtleere Liste: [Head|Tail] wobei Head ein Term ist und Tail eine Liste.
  • Folie 4
  • 15.11.99GK Prolog - Listen, Beweisstrategie4 Listenzerlegung Nichtleere Listen knnen mit dem Listenkonstruktor in Kopf und Rest zerlegt werden. ?- [1,2,3] = [H|T]. H = 1 Kopf T = [2,3] Rest yes
  • Folie 5
  • 15.11.99GK Prolog - Listen, Beweisstrategie5 Leere Liste Die leere Liste ist nicht zerlegbar. Nichtleere Listen haben als Rest hinter dem letzten Listenelement die leere Liste. Das bedeutet nicht, da die leere Liste Element in jeder nichtleeren Liste ist. ?-[a]=[H|T]. H=a, T=[], yes
  • Folie 6
  • 15.11.99GK Prolog - Listen, Beweisstrategie6 Zerlegungen von [1,2,3,4] ?- [1,2,3,4]=[A|T]. A=1, T=[2,3,4], yes ?- [1,2,3,4]=[A,B|T]. A=1, B=2, T=[3,4], yes ?- [1,2,3,4]=[A,B,C|T]. A=1, B=2, C=3, T=[4], yes ?- [1,2,3,4]=[A,B,C,D|T]. A=1, B=2, C=3, D=4, T=[], yes
  • Folie 7
  • 15.11.99GK Prolog - Listen, Beweisstrategie7 Zerlegen von Zerlegungen ?-[1,2,3,4]=[H1|T1], T1=[H2|T2], T2=[H3|T3], T3=[H4|T4]. H1=1, T1=[2,3,4] H2=2, T2=[3,4] H3=3, T3=[4] H4=4, T4=[] yes
  • Folie 8
  • 15.11.99GK Prolog - Listen, Beweisstrategie8 Listen als Strukturen Listen sind eigentlich Strukturen, fr die eine besondere Schreibweise vereinbart wurde. ListennotationPrdikatsnotation [][] [H|T]`.`(H,T) [1,2,3,4] `.`(1, `.`(2, `.`(3, `.`(4,[]))))
  • Folie 9
  • 15.11.99GK Prolog - Listen, Beweisstrategie9 Listenunifikation Leere Liste: mit Variablen und der leeren Liste unifizierbar. Nichtleere Listen: mit Variablen und nichtleeren Listen unifizierbar, wobei die Anzahl der Elemente gleich sein und das i- te Element der einen mit dem i-ten Element der anderen Liste unifizierbar sein mu.
  • Folie 10
  • 15.11.99GK Prolog - Listen, Beweisstrategie10 Listenkonstruktor Der Listenkonstruktor | zerlegt nichtleere Listen in Kopf und Rest. Eine Liste [H1|T1] unifiziert mit einer Liste L, wenn L in [H2|T2] zerlegbar ist, die Terme H1 und H2 unifizierbar sind und die Listen T1 und T2 unifizierbar sind.
  • Folie 11
  • 15.11.99GK Prolog - Listen, Beweisstrategie11 Beispiele zur Listenunifikation ?- [X,Y,Z]=[paul,klaut,bananen]. ?- [katze]=[X|Y]. ?- [X,Y|Z]=[anna,liebt,wein]. ?- [[die,Y]|Z]=[[X,katze],[ist,weg]]. ?- [a|B]=[A|b]. !!! ?- [X,anna]=[Y|[maria]].
  • Folie 12
  • 15.11.99GK Prolog - Listen, Beweisstrategie12 Rekursive Listenverarbeitung Listen sind eine rekursiv definierte Datenstruktur. Deshalb sind Prdikate zur Listenverarbeitung meist rekursive Prdikate mit folgender Strategie: Zerlege die Liste in Kopf und Rest. Mach was mit dem Kopf und verarbeite den (verkrzten) Rest rekursiv weiter. Terminiere, wenn die Liste leer ist, oder der aktuelle Kopf bestimmte Merkmale aufweist.
  • Folie 13
  • 15.11.99GK Prolog - Listen, Beweisstrategie13 member/2 % member(Term,Liste) member(X,[X|_]). member(X,[_|T]):- member(X,T). Das Prdikat member/2 ist beweisbar, wenn Term ein Element von Liste ist.
  • Folie 14
  • 15.11.99GK Prolog - Listen, Beweisstrategie14 Anfragen an member/2 ?- member(2,[1,2,3]). yes ?- member(4,[1,2,3]). no ?- member([],[1,2,3]). no ?- member(2,[1,X,3]). X=2 yes ?- member(X,[1,2,3]). X=1 ->; X=2 ->; X=3 ->; no ?- member(X,Y). X=_1 Y=[_1|_2] ->; X=_1 Y=[_3,_1|_2] ->;...
  • Folie 15
  • 15.11.99GK Prolog - Listen, Beweisstrategie15 Beweisstrategie des Interpreters Anfrage gilt als zu beweisende Behauptung. Anfrage unifiziert mit Kopf einer Klausel. Unifikation liefert Variableninstanzen. Klauselrumpf wird bewiesen. Alternative Lsungen ber Backtracking. Reihenfolge der Suchraumtraversierung: top-down depth-first left-to-right.
  • Folie 16
  • 15.11.99GK Prolog - Listen, Beweisstrategie16 Anfragen Anfragen werden als zu beweisende Behauptungen interpretiert. Der Beweis kann nur ber entsprechende Klauseln in der Prolog-Datenbasis erbracht werden. ?- sterblich(X). Es gibt ein X mit der Eigenschaft sterblich.
  • Folie 17
  • 15.11.99GK Prolog - Listen, Beweisstrategie17 Head-Matching Ein Prdikat aus einer Anfrage mu mit dem Kopf einer Klausel unifizierbar sein. ?- sterblich(sokrates). sterblich(X):- mensch(X). = {X=sokrates}
  • Folie 18
  • 15.11.99GK Prolog - Listen, Beweisstrategie18 Top-Down-Verfahren Das Head-Matching wird im top-down- Verfahren durchgefhrt. Der Interpreter durchsucht die Datenbasis von oben nach unten, um passende Klauseln fr einen Beweis zu finden. vorfahr(X,Y):- et(X,Y). vorfahr(X,Y):- et(X,Z), vorfahr(Z,Y).
  • Folie 19
  • 15.11.99GK Prolog - Listen, Beweisstrategie19 Lokale Variablen Variablen sind in Prolog immer lokale Variablen, d.h. Variablenidentitt gleichnamiger Variablen existiert nur innerhalb einer Klausel. Unifikation ermglicht Variablenidentitt ber Klauselgrenzen hinweg.
  • Folie 20
  • 15.11.99GK Prolog - Listen, Beweisstrategie20 Beweis von Regeln: left-to-right Regelrmpfe werden von links nach rechts bewiesen (left-to-right). Erst wenn ein Beweis fr das i-te Prdikat im Rumpf gefunden ist, kann das i+1-te Prdikat bewiesen werden. P 0 :- P 1,..., P i, P i+1,..., P n
  • Folie 21
  • 15.11.99GK Prolog - Listen, Beweisstrategie21 Backtracking: depth-first Backtracking kann durch zwei Ursachen ausgelst werden: Eine alternative Lsung soll berechnet werden. Der aktuelle Beweis ist in einer Sackgasse. In jedem Fall geht der Interpreter zur letzten Verzweigung im Beweisbaum zurck, an der noch Alternativen offen waren (depth- first).
  • Folie 22
  • 15.11.99GK Prolog - Listen, Beweisstrategie22 Backtracking Beispiel oma(X,Y):- et(X,Z),%1. et(Z,Y).%2. et(anna,maria). et(maria,ilse). et(maria,petra). et(petra,ulla). ?- oma(X,Y). X = anna Y = ilse ->; X = anna Y = petra ->; X = maria Y = ulla ->; no Die Alternativen des zweiten et/2 im Rumpf von oma/2 werden vor den Alternativen des ersten et/2 berechnet.
  • Folie 23
  • 15.11.99GK Prolog - Listen, Beweisstrategie23 Suchraum-Traversierung oma(X,Y) 1 3 et(X,Z) et(Z,Y) 2 4 et(anna,maria) et(anna,maria) et(maria,ilse) et(maria,ilse) et(maria,petra) et(maria,petra) et(petra,ulla) et(petra,ulla)
  • Folie 24
  • 15.11.99GK Prolog - Listen, Beweisstrategie24 Alternative Verfahren top-down bottom-up, left-corner depth-first breadth-first, best-first left-to-right right-to-left, Zufallsauswahl
  • Folie 25
  • 15.11.99GK Prolog - Listen, Beweisstrategie25 Ablaufprotokoll (Trace) Der Prolog-Interpreter verwendet ein Ablaufprotokoll, das 4 Typen von Beweisschritten unterscheidet: CALL Anfrage, neuer Schritt REDO Backtracking, alternativer Schritt EXIT Beweisschritt gelungen FAIL Beweischritt gescheitert
  • Folie 26
  • 15.11.99GK Prolog - Listen, Beweisstrategie26 Trace von member/2 (0) CALL: member(1,[1,2,1,3]) (0) EXIT(N): member(1,[1,2,1,3]) Backtracking (0) REDO: member(1,[1,2,1,3]) (1) CALL: member(1,[2,1,3]) (2) CALL: member(1,[1,3]) (2) EXIT(N): member(1,[1,3]) (1) EXIT(N): member(1,[2,1,3]) (0) EXIT(N): member(1,[1,2,1,3]) Backtracking (0) REDO: member(1,[1,2,1,3]) (1) REDO: member(1,[2,1,3]) (2) REDO: member(1,[1,3]) (3) CALL: member(1,[3]) (4) CALL: member(1,[]) (4) FAIL: member(1,[]) (3) FAIL: member(1,[3]) (2) FAIL: member(1,[1,3]) (1) FAIL: member(1,[2,1,3]) (0) FAIL: member(1,[1,2,1,3]) No more solutions. EXIT(N) steht fr nondeterministic exit, d.h. es gibt noch nicht besuchte Verzweigungen im Suchraum.
  • Folie 27
  • 15.11.99GK Prolog - Listen, Beweisstrategie27 Debugger Das Ablaufprotokoll des Interpreters kann mit dem Debugger angesehen werden. ?- trace. Debugger einschalten. ?- notrace. Debugger ausschalten. Bei eingeschaltetem Debugger wird nach jeder Anfrage das Debugger-Fenster eingeblendet.
  • Folie 28
  • 15.11.99GK Prolog - Listen, Beweisstrategie28 Deklarativ? Die Beweisstrategie des Prolog-Interpreters liefert eine prozedurale Interpretation von Prolog-Programmen, da Beweise Schritt fr Schritt betrachtet werden. Trotzdem lohnt sich in der Regel eine deklarative Perspektive auf Prolog- Programme, bei der vom Beweisverfahren abstrahiert wird.
  • Folie 29
  • 15.11.99GK Prolog - Listen, Beweisstrategie29 member/2 deklarativ Logisch/deklarative Perspektive auf member/2. Wenn der Term X in der Liste ist, dann ist er entweder im Kopf der Liste, oder er ist im Rest der Liste. member(X,[X|_]). member(X,[_|T]):- member(X,T).
  • Folie 30
  • 15.11.99GK Prolog - Listen, Beweisstrategie30 Deklarativ ist besser. Die deklarative Logik von member/2 erfat ver- schiedene Flle, fr die in prozedurealen Sprachen separate Prozeduren geschrieben werden mten. ?- member(1,[1,2,3]). Ist 1 in Liste [1,2,3] ? ?- member(1,L). In welchen Listen ist 1 ? ?- member(X,[1,2,3]). Welche X sind in [1,2,3] ? ?- member(X,L).