Logische Programmierung Einführende Beispiele

Logische Programmierung Einführende Beispiele Verwandschaftsbeziehungen in Prolog vater(peter,maria). mutter(susanne,maria). vater(peter,monika). mutter(susanne,monika). vater(karl, peter). mutter(elisabeth, peter). vater(karl, pia). mutter(elisabeth, pia). vater(karl, paul). mutter(elisabeth, paul). KI, SS 07, F ol7, Seite 1, 26. Juni2007

frau(maria). frau(elisabeth). frau(susanne). frau(monika). frau(pia). mann(peter). mann(karl). mann(paul). Logische Programmierung Einführende Beispiele KI, SS 07, F ol7, Seite 2, 26. Juni2007

Prolog: einführendes Beispiel eltern(x,y) :- eltern(x,y) :- vater(x,y). mutter(x,y). %%%%% einfach aber nicht terminierend vorfahrtrans(x,y) :- eltern(x,y). vorfahrtrans(x,z) :- vorfahrtrans(x,y),vorfahrtrans(y,z). %%%%% einfach und terminierend vorfahr(x,y) :- eltern(x,y). vorfahr(x,z) :- eltern(x,y),vorfahr(y,z). bruder(x,y) :- mann(x),vater(z,x),vater(z,y), not(x == Y), mutter(m,x),mutter(m,y). schwester(x,y) :- frau(x),vater(z,x),vater(z,y), not(x == Y),mutter(M,X),mutter(M,Y). geschwister(x,y) :- vater(z,x),vater(z,y), not(x == Y),mutter(M,X),mutter(M,Y). KI, SS 07, F ol7, Seite 3, 26. Juni2007

Prolog: Graph-Beispiel ungerichteter Graph. a b e f c d g kante(a,b). kante(a,c). kante(c,d). kante(d,b). kante(b,e). kante(f,g). KI, SS 07, F ol7, Seite 4, 26. Juni2007

Prolog: Graph-Beispiel verbunden(x,y) :- kante(x,y). verbunden(x,y) :- kante(y,x). verbunden(x,z) :- kante(x,y),verbunden(y,z). verbunden(x,z) :- kante(y,x),verbunden(y,z). %%% verbunden2 terminiert verbunden2(x,y) :- verb(x,y,[]). ungkante(x,y) :- kante(x,y). ungkante(x,y) :- kante(y,x). verb(x,y,_) :- ungkante(x,y). verb(x,z,l) :- ungkante(x,y), not(member(y,l)), verb(y,z,[y L]). member(x,[x _]). member(x,[_ L]) :- member(x,l). KI, SS 07, F ol7, Seite 5, 26. Juni2007

Prolog: Listen und Mengen member(x,[x _]). member(x,[_ Y]) :- member(x,y). append([],x,x). append([x R],Y,[X Z]) :- append(r,y,z). listtoset([],[]). listtoset([x R],[X S]) :- remove(x,r,s1),listtoset(s1,s). remove(e,[],[]). remove(e,[e R],S):- remove(e,r,s). remove(e,[x R],[X S]):- not(e == X), remove(e,r,s). KI, SS 07, F ol7, Seite 6, 26. Juni2007

Prolog: Listen und Mengen union(x,y,z) :- append(x,y,xy), listtoset(xy,z). intersect([],x,[]). intersect([x R],S,[X T]) :- member(x,s),intersect(r,s,t1), listtoset(t1,t). intersect([x R],S,T) :- not(member(x,s)),intersect(r,s,t1), listtoset(t1,t). reverse([],[]). reverse([x R],Y) :- reverse(r,rr), append(rr,[x],y). reversea(x,y) :- reverseah(x,[],y). reverseah([x Xs],Acc,Y):- reverseah(xs,[x Acc],Y). reverseah([],y,y). KI, SS 07, F ol7, Seite 7, 26. Juni2007

Grundlagen der logischen Programmierung: deklarative Programmierung Theoretische Basis von Prolog: Prädikatenlogik erster Stufe Ausführung der Programme: Spezialisierung der Resolution. logischen Programme sind spezielle Klauseln: Horn-Klauseln KI, SS 07, F ol7, Seite 8, 26. Juni2007

Grundlagen der logischen Programmierung Eine Hornklausel ist eine Klausel mit maximal einem positiven Literal Eine definite Klausel ist eine Klausel mit genau einem positiven Literal. D.h. A B 1... B m oder in Notation der logischen Programmierung: A B 1,..., B m bzw. A :- B 1,..., B m Man nennt A den Kopf, {B 1,..., B m } den Rumpf der Klausel. KI, SS 07, F ol7, Seite 9, 26. Juni2007

Grundlagen der logischen Programmierung Eine Klausel ohne positive Literale nennt man definites Ziel (Anfrage,Query,goal). Notation: B 1,..., B n Die B i werden Unterziele (Subgoals) genannt. Eine Unit-Klausel (oder Fakt) ist eine definite Klausel mit leerem Rumpf. Notation: A. KI, SS 07, F ol7, Seite 10, 26. Juni2007

Grundlagen der logischen Programmierung Ein definites Programm ist eine Menge von definiten Klauseln. Die Menge aller Klauseln, deren Kopfliteral das Prädikat Q hat, nennen wir Definition von Q. KI, SS 07, F ol7, Seite 11, 26. Juni2007

Beispiele und Negationen Folgende Literale der Beispiele passen nicht zur Definition eines definiten Programms: not(x == Y) not(member(y,l)) not(e == X) not(member(x,s)) (wird noch besprochen) KI, SS 07, F ol7, Seite 12, 26. Juni2007

Modell-Eigenschaft der Definiten Programme Es gilt: Zu jedem definiten Programm P gibt es ein eindeutiges kleinstes Modell M P. M P besteht aus allen mit Resolution und Instanziierung herleitbaren Grund-Fakten. M P entspricht allen Atomen, die das Programm mit JA beantwortet. KI, SS 07, F ol7, Seite 13, 26. Juni2007

Anfragen an Prolog-Programme Das definite Ziel x 1,..., x n : B 1... B n ist äquivalent zu: x 1,..., x n : B 1... B n Die Anfrage ist: x 1,..., x n : B 1... B n KI, SS 07, F ol7, Seite 14, 26. Juni2007

Anfragen an Prolog-Programme Es gilt: für die Resolution auf Hornklausel-Mengen: im Falle der Herleitung der leeren Klausel werden die existierenden Objekte ausgerechnet D.h. Resolution berechnet Substitutionen, die Antworten auf die Anfrage sind. KI, SS 07, F ol7, Seite 15, 26. Juni2007

Anfragen an Prolog-Programme: Beispiel Für nicht-hornklauselmengen berechnet Resolution nicht immer eine (eindeutige) Antwort: Formel: Q(a) Q(b). Anfrage: x.q(x). Die Klauselmenge dazu ist : {{Q(a) Q(b)}, { Q(x)}} Resolution ergibt die leere Klausel. {x a}, {x b} werden beide verwendet! Q(a) Q(b) hat kein eindeutiges kleinstes Modell! KI, SS 07, F ol7, Seite 16, 26. Juni2007

SLD-Resolution SLD-Resolution ist eine spezielle Resolutionsstrategie ist die (operationale) prozedurale Semantik von definiten Programmen. definiert die Ausführung von logischen Programmen: S: Selektions-Funktion L: Lineare Resolution D: Definite Klauseln KI, SS 07, F ol7, Seite 17, 26. Juni2007

SLD-Resolution Definition G = A 1,..., A m,..., A k sei definites Ziel C = A B 1,..., B q eine definite Klausel. Resolutions-Herleitung eines neuen definiten Ziels G : A m ist das selektierte Atom des definiten Ziels G. θ ist ein allgemeinster Unifikator von A m und A, dem Kopf von C. G ist das neue Ziel: θ(a 1,..., A m 1, B 1,..., B q, A m+1,..., A k ). G ist eine Resolvente von G und C. Ableitungsrelation G P,C,m G KI, SS 07, F ol7, Seite 18, 26. Juni2007

Beispiel Definites Ziel: eltern(x, Y ). Klausel dazu: eltern(x, Y ) Programmklausel eltern(x, Y ) : mutter(x, Y ) Klauselschreibweise eltern(x 1, Y 1 ) mutter(x 1, Y 1 ) allg., Unifikator: X = X 1, Y = Y 1 Resolvente (neues Ziel) mutter(x, Y ) KI, SS 07, F ol7, Seite 19, 26. Juni2007

SLD-Resolution und SLD-Ableitung Definition Sei P ein definites Programm und G ein definites Ziel. Eine SLD-Ableitung von P {G} ist eine Folge G C1,m 1 G 1 C2,m 2 G 2... von SLD-Schritten wobei C i jeweils eine umbenannte Klausel aus P ist Die SLD-Ableitung ist eine SLD-Widerlegung, wenn sie mit einer leeren Klausel endet. C i nennt man auch die Eingabe-Klauseln. KI, SS 07, F ol7, Seite 20, 26. Juni2007

SLD-Resolution und SLD-Ableitung erfolgreiche SLD-Ableitung: Wenn es eine SLD-Widerlegung ist. fehlgeschlagene SLD-Ableitung: Wenn diese nicht fortsetzbar ist. unendliche SLD-Ableitung KI, SS 07, F ol7, Seite 21, 26. Juni2007

SLD-Ableitung Sei P ein definites Programm und G ein definites Ziel. Eine korrekte Antwort ist eine Substitution θ, so dass P = θ( G) gilt. Eine berechnete Antwort θ für P {G} ist eine Substitution: Einschränkung von θ n... θ 1 auf die Variablen von G, wobei θ 1... θ n die allgemeinsten Unifikatoren (in dieser Reihenfolge) zu einer SLD-Widerlegung von G sind. KI, SS 07, F ol7, Seite 22, 26. Juni2007

Beispiel Definites Ziel: eltern(x, Y ). Klausel dazu: eltern(x, Y ) Programmklausel eltern(x, Y ) : mutter(x, Y ) Klauselschreibweise eltern(x 1, Y 1 ) mutter(x 1, Y 1 ) allg., Unifikator θ 1 X = X 1, Y = Y 1 Resolvente (neues Ziel) mutter(x 1, Y 1 ) Programmklausel mutter(susanne, maria). allg., Unifikator θ 2 X 1 = susanne, Y 1 = maria Antwort: θ 2 θ 1 : X = susanne, Y = maria KI, SS 07, F ol7, Seite 23, 26. Juni2007

SLD-Ableitung: Korrektheit Es gilt: Korrektheit (Soundness) der SLD-Resolution Sei P ein definites Programm und G ein definites Ziel. Dann ist jede berechnete Antwort θ auch korrekt. D.h. P = θ( G) KI, SS 07, F ol7, Seite 24, 26. Juni2007

Vollständigkeit der SLD-Resolution Wir betrachten verschiedene Vollständigkeitsaussagen für die SLD- Resolution. Satz (Widerlegungsvollständigkeit) Sei P ein definites Programm und G ein definites Ziel. Wenn P {G} unerfüllbar ist, dann gibt es eine SLD-Widerlegung von P {G}. KI, SS 07, F ol7, Seite 25, 26. Juni2007

Vollständigkeit der SLD-Resolution Es gilt ein stärkerer Satz über die Vollständigkeit der berechneten Antworten: zu jeder Antwortsubstitution gibt es eine allgemeinere berechnete Antwort Satz (Vollständigkeit der SLD-Resolution) Sei P ein definites Programm und G ein definites Ziel. Zu jeder korrekten Antwort θ gibt es eine berechnete Antwort σ für P {G} und eine Substitution γ so dass x F V (G): γσ(x) = θ(x). KI, SS 07, F ol7, Seite 26, 26. Juni2007

Strategien zur Berechnung der Antworten Breitensuche: 1. Gegeben Programm P und ein Ziel A 1,..., A n : (a) Probiere alle Möglichkeiten aus, ein Unterziel A aus A 1,..., A n auszuwählen (b) Probiere alle Möglichkeiten aus, eine Resolution von A mit einem Kopf einer Programmklausel durchzuführen. 2. Erzeuge neues Ziel B: Löschen von A, Instanziieren des restlichen Ziels, Hinzufügen des Rumpfs der Klausel. 3. Wenn B =, dann gebe die Antwort aus. Sonst: mache weiter mit 1. mit dem Ziel B. KI, SS 07, F ol7, Seite 27, 26. Juni2007

Strategien zur Berechnung der Antworten Breitensuche hat zwei Verzweigungspunkte pro Resolutionsschritt: Die Auswahl eines Atoms aus der Anfrage Die Auswahl einer Klausel zum Resolvieren Es gilt: die Auswahl des Atoms ist don t care Die Suche bleibt vollständig, wenn man die Alternativen weglässt. Z.B. leicht zu lösende Atome kann man zuerst auswählen Umstellung kann aber unendlich tiefe Suchpfade einführen KI, SS 07, F ol7, Seite 28, 26. Juni2007

Strategien Eine vollständige Suchstrategie: Breitensuche über die Resolutionsmöglichkeiten Anfrage als Stack von Atomen Reihenfolge der Atome wie in definiten Klauseln KI, SS 07, F ol7, Seite 29, 26. Juni2007

Strategien in Prolog-Implementierung Tiefensuche, d.h. noch deterministischer: Anfrage als Stack Die Programmklauseln werden in der Reihenfolge abgesucht, in der sie im Programm stehen. Prolog benutzt die Tiefensuche Rechts-Links-Ordnung ist definiert durch die Reihenfolge der Klauseln im Programm und die Reihenfolge der Literale in den Rümpfen KI, SS 07, F ol7, Seite 30, 26. Juni2007

Prolog-Implementierung Weitere Veränderungen gegenüber der theoretischen Fundierung sind: Der occurs-check wird i.a. nicht durchgeführt. CUT- Operatoren zum Beeinflussen des Backtracking zb nur erste Sub-Antwort statt aller Lösungen Assert/Retract: Damit können Programmklauseln zum Programm hinzugefügt bzw. gelöscht werden. I.a, betrifft dies nur Fakten. Negation: Negation wird definiert als Fehlschlagen der Suche. Typinformation zu Programmen hinzugefügt. moded Argumente von Prädikaten haben Markierung I bzw. O : Input, Output Prädikat als Funktionen, wenn deterministisch. KI, SS 07, F ol7, Seite 31, 26. Juni2007

Prolog-Implementierung Vergleich der theoretischen Eigenschaften mit der Implementierung. Pures Prolog nichtpures Prolog nichtpur, Definite Programme Cut, Negation, ohne occurs-check Klauselreihenfolge fest SLD: korrekt SLD: korrekt SLD: i.a. nicht korrekt vollständig unvollständig unvollständig KI, SS 07, F ol7, Seite 32, 26. Juni2007

Implementierung: Beispiele für Unvollständigkeit bei festgelegten Reihenfolge der Klauseln: P(a,b). P(c,b). P(X,Y) :- P(Y,X). P(X,Z) :- P(X,Y), P(Y,Z). Die symmetrisch-transitive Hülle kann nicht berechnet werden, da das Programm in eine Schleifen gerät. Aber eine SLD-Widerlegung existiert, da diese nicht-deterministisch vorgehen darf, und insbesondere sich eine Programmklausel aussuchen darf. KI, SS 07, F ol7, Seite 33, 26. Juni2007

Beispielprogramme und Prolog-Ausführung likes (maria, essen). likes(maria,wein). likes(peter, maria). likes(peter,wein). Einfache Anfragen: >?- likes(peter,maria) yes Konjunktive Anfragen (mit logischem und verknüpfte) >?- likes(peter,maria), likes(maria,peter) no KI, SS 07, F ol7, Seite 34, 26. Juni2007

Zuerst wird das erste Unterziel bearbeitet: Antwort:. ja, Dann zweite: nein. Konjunktive Anfragen mit Instanziierung. >?- likes(peter, X), likes(maria,x) Abarbeitung: 1. X = maria, likes(maria,maria): no 2. X = wein: likes(maria,wein). yes X = wein Backtracking ist notwendig (Zurücksetzen) zum Finden weiterer Lösungen.

Beispielprogramm und Prolog-Ausführung vater(peter,maria). mutter(susanne,maria). vater(karl, peter). mutter(elisabeth, peter).... vorfahr(x,y) :- vater(x,y). vorfahr(x,y) :- mutter(x,y). vorfahr(x,z) :- vorfahr(x,y),vorfahr(y,z). KI, SS 07, F ol7, Seite 36, 26. Juni2007

Prolog-Abarbeitung: Anfragen:?- vorfahr(elisabeth,maria) Abarbeitung : 1. vorfahr(elisabeth,maria) 1.1 vater(elisabeth,maria). nein 1.2 mutter(elisabeth,maria): nein 1.3 vorfahr(elisabeth, X0), vorfahr(x0,maria) 1.3.1 vater(elisabeth, X0), vorfahr(x0,maria): nein 1.3.2 mutter(elisabeth, X0), vorfahr(x0,maria): X0 = peter 1.3.2 vorfahr(peter,maria): 1.3.2.1 vater(peter,maria): ja usw. KI, SS 07, F ol7, Seite 37, 26. Juni2007

Syntaxkonventionen von Prolog Namen Aus Großbuchstaben, Kleinbuchstaben, Ziffern und (Unterstrich) oder nur aus Sonderzeichen Konstanten: Variablen: erstes Zeichen ist Kleinbuchstabe erstes Zeichen ist Großbuchstabe oder oder nur: (wildcard, joker, Leerstelle) Terme Funktor(component 1,...,component n ) Stelligkeit von Prädikaten/ Funktionen ist nicht variabel. gleicher Funktorname mit verschiedener Stelligkeit ergibt anderen Funktor z.b. Schreibweise: vater/2 KI, SS 07, F ol7, Seite 38, 26. Juni2007

arithmetische Ausdrücke: Die Operatoren +,,, / und die Vergleichsoperatoren <=,... sind erlaubt. Infix usw. ist teilweise möglich: z.b. a b + c steht für den Term +( (a, b), c). Zahlen sind abhängig von der Implementierung. KI, SS 07, F ol7, Seite 39, 26. Juni2007

Gleichheit Spezialprädikat = (Gleichheit) kann definiert werden durch X = X. Z.B.?- besitzt(peter, X) = besitzt(peter,buch(lloyd,prolog)) yes; X = buch(lloyd,prolog) Gleichheitsabarbeitung benutzt Unifikation KI, SS 07, F ol7, Seite 40, 26. Juni2007

Arithmetische Vergleiche erlaubte Operatoren: =, \=, <, >, =<, >=, =\=, =:= Beachte: die Operanden müssen als Zahl ausgewertet sein vor Auswertung des Ausdrucks. 3 + 4 = 7 ergibt: no 3 + 4 =:= 7 ergibt yes D.h., es gibt einen Unterschied zwischen Term und Wert. KI, SS 07, F ol7, Seite 41, 26. Juni2007

Zuweisung und Auswertung Zuweisung mit gleichzeitiger Auswertung kann man mit is durchführen: X is 3 + 5 danach: X 8 X = 3 + 5 danach X 3 + 5 KI, SS 07, F ol7, Seite 42, 26. Juni2007

Datenstrukturen und Unifikation in Prolog Term-Gleichungen werden durch Instanziierung der Variablen gelöst: d.h. durch Unifikation k(x, a) = k(b, Y ) ergibt X = b, Y = a Auch Unterstrukturen können Wert von Variablen sein: k(x, h(a, Z)) = k(b, Y ) ergibt X = b, Y = h(a, Z) KI, SS 07, F ol7, Seite 43, 26. Juni2007

Datenstrukturen und Unifikation in Prolog: Beispiel k(x, h(a, Z), X) = k(h(y, b), U, U) ergibt zunächst: X = h(y, b), U = h(a, Z), X = U Endergebnis: X = h(a, b), U = h(a, b), Y = a, Z = b KI, SS 07, F ol7, Seite 44, 26. Juni2007

Beispiel Unifikation Dieses Ergebnis kann man z.b. im Prolog Interpreter direkt verifizieren. k(x,h(a,z),x) = k(h(y,b),u,u). X = h(a,b) Z = b Y = a U = h(a,b) yes KI, SS 07, F ol7, Seite 45, 26. Juni2007

Behandlung des occurs-check k(x, X) = k(y, h(y )) erfordert Unifikation von X = h(x). Es gibt eine Lösung in unendlichen Bäume: X = h(h(h(...))). h Prolog-Implementierungen vermeiden den occurs-check. Oft abgeschaltet: ist nicht korrekt bzgl. P L 1 -Semantik Teilweise Elimination durch statische Analyse eliminiert. KI, SS 07, F ol7, Seite 46, 26. Juni2007

Listen in Prolog Prolog benutzt eine abkürzende Syntax: [1, 2, 3] entspricht cons(1,cons(2,cons(3,nil))) [] entspricht nil KI, SS 07, F ol7, Seite 47, 26. Juni2007

Listen in Prolog: member Element-Test mittels member member(x,[x _]). member(x,[_ Y]) :- member(x,y). Terminiert member in allen möglichen Situationen? member(s,t): wenn t keine Variablen enthält. dann wird t nächsten mal kleiner. beim KI, SS 07, F ol7, Seite 48, 26. Juni2007

member. Terminierung? member(y,y): Die erste Klausel unifiziert nicht (aber unifiziert, wenn occurs-check aus ist: Antwort: ja) Die zweite Klausel ergibt: member(x_1,[_ Y_1]) :- X_1 = Y = [_ Y_1] member(x_1,y_1). Die neue Anfrage ist: member([_ Y_1],Y_1) Nächste Unifikation ebenfalls mit zweiter Klausel member(x_2,[_ Y_2]) :- member(x_2,y_2) X_2 = [_ Y_1], Y_1 = [_ Y_2] usw. Man sieht: das terminiert nicht. KI, SS 07, F ol7, Seite 49, 26. Juni2007

Listen in Prolog: islist islist([_ X]) :- islist(x). islist([]). Diese Funktion terminiert ebenfalls für Listen ohne Variablen aber nicht für islist(x). Eine Umstellung der Klauseln ergibt: islist([]). islist([_ X]) :- islist(x). Dieses Programm terminiert für die Anfrage islist(x). Antwort: X = [], falls die Eingabe eine Liste ist. Antwort ist dann ja. KI, SS 07, F ol7, Seite 50, 26. Juni2007

Listen in Prolog: length laenge([],0). laenge([_ X],N) :- laenge(x,n_1), N is N_1 + 1. Damit kann man folgende Beispiele rechnen:?- laenge([1,2,3], N). N = 3.?- laenge(x,2). Antwort X = [ 1, 2]. Aber: terminiert in manchen Implementierungen nicht KI, SS 07, F ol7, Seite 51, 26. Juni2007

Sortiere Listen von Zahlen: sortiert([]). sortiert([x]). sortiert([x [Y Z]]) :- X <= Y, sortiert([y Z]). sortiert_einfuegen(x,[],[x]). sortiert_einfuegen(x,[y Z], [X [Y Z]]) :- X =< Y. sortiert_einfuegen (X,[Y Z], [Y U]) :- Y < X, sortiert_einfuegen(x,z,u). ins_sortiere(x,x) :- sortiert(x). ins_sortiere([x Y], Z) :- ins_sortiere(y,u), sortiert_einfuegen(x,u,z). KI, SS 07, F ol7, Seite 52, 26. Juni2007

Programmierung von append: in Prolog: append([],x,x). append([x Y],U,[X Z]) :- append(y,u,z). KI, SS 07, F ol7, Seite 53, 26. Juni2007