3 Logikprogrammierung

Transcription

Logik für Informatiker
3
Wintersemester 2012/13
Logikprogrammierung
P ROLOG ermöglicht
• deklarative Programmierung
• kompakte Programme
• agile Softwareentwicklung, rapid Prototyping
Die Auswertungsstrategie der SLDNF–Resolution benutzt
• Tiefensuche
• Backtracking
• Unifikation
Prof. Dr. Dietmar Seipel
298
3.1
Grundlagen von P ROLOG
Datentypen und Datenstrukturen
• Die Beschränkung auf wenige Basisdatentypen und einen einzigen
komplexen Datentyp, nämlich die Strukturen (Terme), der generisch ist
und alle anderen Datentypen subsumiert, standardisiert die
Datenstrukturen ganz entscheident.
• Es gibt keine expliziten Typdeklarationen.
Man kann aber rein syntaktisch zwischen P ROLOG–Atomen (Strings),
Zahlen und Variablensymbolen unterscheiden; aus diesen kann man
komplexere Strukturen (Terme) bilden.
• Es gibt eine große Kollektion von generischen Operationen, die auf alle
Strukturen (Terme) anwendbar sind – und somit auf alle Datentypen.
299
Methoden und Kontrollstrukturen
• Prädikate realisieren Methoden. Alle Parameter – auch die
Rückgabewerte – werden als Argumente eines Prädikats übergeben.
Kommentare helfen zu erkennen, welche Argumente die Eingabe bzw.
die Ausgabe bilden.
• Manche Prädikate kann man mit unterschiedlichen Bindungsmustern
aufrufen, und für dieselbe Eingabe kann es unterschiedliche Ausgaben
geben (relationales Programmieren).
Die meisten Prädikate sind aber funktional.
• Häufig werden Meta–Prädikate verwendet.
Auch Kontrollstrukturen basieren auf Meta–Prädikaten. Zusätzlich zu
den Standardkontrollstrukturen, wie Verzweigungen (if–then–else),
Schleifen (for, while), und Rekursion, können benutzerdefinierte
Kontrollstrukturen in Form von Meta–Prädikaten gebildet werden.
300
Strukturen in P ROLOG
P ROLOG–Atom: z.B. a, books, ’Books’, kt_321_xy
Konstante: P ROLOG–Atom | Number: z.B. books, 0, 123
Variable: beginnend mit Großbuchstaben oder mit “_”
z.B. X, Y, Books, _, _A, _a
Funktor (Funktions– bzw. Prädikatensymbol):
Operator | P ROLOG–Atom: z.B. +, -, ≤, ancestor
Struktur: Konstante | Variable | Funktor(Struktur, . . . , Struktur)
z.B. +(1,7), ancestor(’William’,’Elizabeth’)
Listen sind spezielle Strukturen zum Funktor “.”:
[a,b,c,d] = .(a, [b,c,d])
+(1,7) ist äquivalent zu 1+7 (Infix–Notation).
301
P ROLOG–Klauseln
Eine P ROLOG–Klausel (Regel, Fakt) ist eine Infix–Struktur der Form
Kopf :– Rumpf.
“:-” spricht man dabei als “falls” aus. Falls der Rumpf leer ist (Fakt), so
kann man “:-” weglassen und kurz “Kopf” schreiben.
Der Regelrumpf kann folgende Junktoren enthalten:
• Konjunktion “,”,
• Disjunktion “;”, und
• Negation “\+”, “not”.
Eine negierte Formel kann man als “\+ F” oder als “not(F)” schreiben.
302
Prädikatensymbole: ancestor, parent
Regel:
ancestor(X, Z) :ancestor(X, Y), parent(Y, Z).
Eine Elternteil Z eines Vorfahren Y von X ist ebenfalls ein Vorfahre.
In der PL1 könnte man das wie folgt schreiben:
∀X∀Y ∀Z ( ancestor(X, Y ) ∧ parent(Y, Z) → ancestor(X, Z) )
Fakten:
parent(a, b).
parent(b, c).
parent(c, d).
Goal:
?- ancestor(a, Z).
303
Prädikatensymbole: likes, woman, nice, loves
Regeln:
likes(george, Y) :woman(Y),
likes(Y, books).
likes(mary, Y) :( nice(Y)
; loves(Y, cats) )
Fakten:
woman(mary).
likes(mary, books).
loves(george, cats).
Goal:
?- likes(george, Y).}
304
Das Prädikat likes besteht aus 2 Regeln und einem Fakt. Diese decken
unterschiedliche Fälle ab:
• Die erste Regel besagt, daß George alle Frauen mag, die Bücher mögen.
• Die zweite Regel besagt, daß Mary alles, was schön (nice) ist, und
alle Lebewesen, die Katzen lieben, mag.
Ein Fakt besagt außerdem, daß Mary Bücher mag.
In der prozeduralen Programmierung könnte man eine Fallunterscheidung
in einem case–Statement ausdrücken.
Die likes–Regel zu Mary mit dem disjunktiven Rumpf könnte man in
zwei separate Regeln zerlegen. Die Bündelung der Information zu Mary –
zu der man eventuell auch noch das Fakt hinzunehmen könnte – erscheint
aber softwaretechnisch auch sehr sinnvoll. Da uns momentan keine
Information zu nice vorliegt, ist der erste Teil der Regel inaktiv.
305
Die Bündelung liefert folgende Regel mit einem disjunktiven Regelrumpf:
likes(mary, Y) :( nice(Y)
; loves(Y, cats)
; Y = books ).
Diese ist äquivalent zu drei einzelnen Regeln:
likes(mary,
nice(Y).
likes(mary,
loves(Y,
likes(mary,
Y) :Y) :cats).
books).
Die Reihenfolge der Regeln und Fakten zum selben Prädikatensymbol ist –
wie in klassischen Programmiersprachen auch – wichtig.
306
Notation
Wenn man geeignete Operatoren (Infix, Präfix, Postfix) definiert, dann kann
man die P ROLOG–Klauseln etwas natürlicher notieren:
X has_ancestor Z :X has_ancestor Y and
Y has_parent Z.
george likes Y :Y is_a_woman and Y likes books.
mary likes Y :Y is_nice or Y loves cats.
mary is_a_woman.
mary likes books.
george loves cats.
Man könnte H :- B sogar als B implies H schreiben.
307
Anfragen in P ROLOG
Ein P ROLOG–Interpreter versucht ein Goal durch Inferenz zu beweisen.
Dies erfolgt Top–Down vom Goal ausgehend durch DFS–Durchlauf
(Tiefensuche, Depth–First–Search) des SLD–Baumes.
Beispiel (Anfragen)
?- likes(george, Y).
Y = mary
?- likes(X,
X = george,
X = mary, Y
X = mary, Y
Y).
Y = mary ;
= george ;
= books
308
P ROLOG gibt eine Antwort auf eine Anfrage zurück:
• Falls die Anfrage erfolgreich beantwortet wurde, so gibt P ROLOG die
erzeugte Variablenbelegung als Antwort zurück; falls keine Variablen
belegt wurden, so ist die Antwort true.
• Falls die Anfrage erfolglos beantwortet wurde, so ist die Antwort
false.
Bei erfolgreicher Beantwortung der Anfrage kann man hinter der Antwort
einen Strichpunkt gefolgt von Return eingeben. Dieser stößt Backtracking
an, so daß P ROLOG versucht eine weitere Antwort zu finden.
Wenn man nur Return eingibt, so ist die Anfrageauswertung beendet.
Ebenso ist die Anfrageauswertung nach der Antwort false automatisch
sofort beendet.
309
Auswertung von Anfragen in P ROLOG
• Die Auswertung von P ROLOG–Regeln erfolgt Top–Down mittels der
Methode der SLDNF–Resolution: aus einer Anfrage an das Kopfatom
einer Regel werden Unteranfragen an die Rumpfatome erzeugt.
• Dies entspricht dem Vorgehen bei der Abarbeitung von prozeduralen
Programmiersprachen.
• Falls ein Rumpfatom mehrere Antworten liefert, so wird zuerst mit
einer solchen Antwort weitergerechnet (Tiefensuche); falls die
Berechnung später fehlschlägt, so kann mit der nächsten Antwort
fortgefahren werden (Backtracking).
• In der Praxis sind viele P ROLOG–Prädikate aber funktional: aus einer
Eingabe wird genau eine Ausgabe erzeugt.
310
Aus der Anfrage
← likes(X, Y )
wird mittels der Ersetzung X 7→ george und der Regel
r1 = likes(george, Y ) ← woman(Y ) ∧ likes(Y , books)
eine Folge von Unteranfragen erzeugt:
← woman(Y ) ∧ likes(Y , books)
Aufgrund des Fakts f1 wird die erste Unteranfrage mit Y 7→ mary
beantwortet. Der neue Wert für Y wird in der zweiten Unteranfrage sofort
berücksichtigt, so daß wir also
← likes(mary, books)
zu beantworten haben. Aufgrund des Fakts f2 ist die Antwort dafür ja.
311
SLD–Baum
← likes(X, Y )
r1
9
← woman(Y ) ∧ likes(Y, books)
f1
?
← likes(mary, books)
r2
← nice(books)
∨ loves(books, cats)
failure
r2
?
f2
q
← nice(Y ) ∨ loves(Y, cats)
2
{X 7→ mary, Y 7→ books}
f3
success
?
2
{X →
7 mary, Y 7→ george}
f2
j
success
2
{X 7→ george, Y 7→ mary}
success
Der SLD–Baum faßt alle SLD–Ableitungen zusammen. Jeder success–Ast
gibt eine Antwort.
312
Kontrollprimitive, welche über die PL1 hinausgehen:
• assert und retract verändern die interne Datenbank von
P ROLOG; clause sucht in dieser.
• call und apply rufen Goals auf, die vorher zusammengebaut
werden können.
• Der Cut “!” friert die bisherige Variablenbelegung in der aktuellen
Regel ein.
• fail ist ein Goal, das immer fehl schlägt.
• Meta–Prädikate wir findall und maplist realisieren komplexe
Kontrollstrukturen.
• ...
313
Anfrage mit einem Meta–Prädikat
Mit dem Meta–Prädikat findall/3 kann man alle Antworten auf eine
Anfrage bestimmen:
?- findall( [X, Y],
likes(X, Y),
Pairs ).
Pairs = [[george,mary], [mary,george], [mary,books]].
Das D DK erlaubt sogar folgende äquivalente Mengenschreibweise:
?- Pairs <= { [X, Y] | likes(X, Y) }.
Pairs wird als die Liste aller Paare [X, Y] bestimmt, für die
likes(X, Y) gilt.
314
Listen sind spezielle P ROLOG–Strukturen mit dem binären Funktor “.”.
Liste: [a,b,c,d] = .(a,.(b,.(c,.(d,[]))))
Listenkonstruktion:
Falls X und Xs bereits gebunden (mit Werten belegt) sind,
so ist [X|Xs] die Liste, die man erhält, wenn man
das Element X an die Liste Xs vorne anhängt.
Für X = a und Xs = [b,c,d] ist [X|Xs] = [a,b,c,d].
Listenzerlegung:
Falls X und Xs ungebunden sind, so liefert der Aufruf [X|Xs] =
[a,b,c,d] die Belegungen X = a und Xs = [b,c,d]; man
kann eine Liste also in ihren Kopf X und den Rest Xs zerlegen.
leere Liste: []
315
Listenkonstruktion und Listenzerlegung erfolgen also mittels desselben
Aufrufs Xs = [Head|Tail].
Die folgenden beiden Prädikate bestimmen das erste Listenelement Head
und den Rest Tail der Liste.
list_to_head(Xs, Head) :Xs = [Head|_].
list_to_tail(Xs, Tail) :Xs = [_|Tail].
Um eine “singleton variable warning” zu vermeiden, wird der
jeweils nicht benötigte Listenteil mittels einer anonymen Variable “_”
(Wildcard) bezeichnet.
316
Die Listenschreibweise
[X1 , . . . ,Xn ]
nennt man Syntactic Sugar. Eine Liste ist eigentlich eine stark
verschachtelte binäre Struktur:
.( X1 , .(X2 , . . . ,.(Xn ,[]))).
{z
}
|{z}
|
Tail
Head
Somit ist Xs = [Head|Tail] = .(Head, Tail).
Für Xs = [a,b,c,d] = .(a,.(b,.(c,.(d,[])))) bestimmt
der Aufruf Xs = [Head|Tail], oder
.(a,.(b,.(c,.(d,[])))) = .(Head, Tail),
mittels Unifikation Head = a und Tail = .(b,.(c,.(d,[]))).
317
Die Listenkonstruktion aus einem gegebenen Kopf und einem Rest erfolgt –
wie bereits gezeigt – auch mittels des Aufrufs Xs = [Head|Tail]:
head_and_tail_to_list(Head, Tail, Xs) :Xs = [Head|Tail].
Dasselbe Prädikat kann man auch benutzen, um eine gegebene Liste in
Kopf und Rest zu zerlegen:
?- head_and_tail_to_list([a], [b,c,d], Xs).
Xs = [a,b,c,d].
?- head_and_tail_to_list(Head, Tail, [a,b,c,d]).
Head = [a], Tail = [b,c,d].
318
Arbeiten mit Termen
• Aufbau und Zerlegung: =../2
• functor/3
• arg/3
?- likes(mary, books) =.. Xs.
Xs = [likes, mary, books].
?- functor([a,b,c,d], F, N).
F = ’.’, N = 2.
?- arg(N, [a,b,c,d], A).
N = 1, A = a ;
N = 2, A = [b,c,d].
319
Eingabe und Ausgabe
• Einlesen einer P ROLOG–Datei: consult/1, [...]
• Eingabe von Termen: read/1,2
• Ausgabe von Termen: write/1,2
?- [’sources/projects/teaching/likes.pl’].
% sources/.../likes.pl compiled 0.00 sec, 0 bytes
?- read(X).
|: likes(mary, cats).
X = likes(mary, cats).
?- write(likes(mary, cats)).
likes(mary, cats)
Die zweistelligen Prädikate read/2 und write/2 greifen auf Dateien zu.
320
Man kann mittels assert/1 auch dynamisch die Datenbasis von P ROLOG
erweitern:
?- read(X), assert(X).
|: likes(mary, cats).
X = likes(mary, cats).
Nachfolgende Aufrufe können die erweiterte Datenbasis benutzen:
?- likes(mary, cats).
true.
Mittels retract/1 kann man in der Datenbasis von P ROLOG löschen.
321
Aufruf dynamischer Goals
Man kann zur Laufzeit mittels =../2 Goals zusammenbauen und mittels
call/1 aufrufen:
?- read(P), Goal =.. [P, X, Y], call(Goal).
|: likes.
P = likes, Goal = likes(X, Y),
X = george, Y = mary.
Dies geht noch eleganter, wenn man stattdessen apply/2 verwendet, denn
Goal =.. [P,X1,...,Xn], call(Goal) ist äquivalent zu
apply(P, [X1,...,Xn]).
Der Aufruf read(P), P(X,Y) ist in P ROLOG nicht erlaubt, da eine
Variable – hier P – nicht an der Stelle eines Prädikatensymbols stehen kann.
322
Rekursion: das Prädikat member
/* member(?X, +Xs) <X is a member of the list Xs. */
member(X, [X|_]).
member(X, [_|Xs]) :member(X, Xs).
?- member(b, [a,b,c]).
true.
Ein Element liegt in einer Liste, falls es das erste Listenelement
(Listenkopf) ist, oder falls es in der Restliste liegt (rekursiver Aufruf).
Genauer gesagt wird eine Substitution gesucht, die X mit einem Element der
Liste Xs unifiziert.
323
In dieser kompakten Notation wird die Eingabeliste bereits im Regelkopf in
den Listenkopf und die Restliste zerlegt.
1. Der Kopf der ersten Regel testet auch gleich, ob der Listenkopf mit
dem gesuchten Element unifizierbar ist.
2. Die zweite Regel sucht in der Restliste rekursiv weiter.
Zur Verdeutlichung geben wir im folgenden die entsprechende Langfassung
an:
member(X, Xs) :list_to_head(Xs, Head),
X = Head.
member(X, Xs) :list_to_tail(Xs, Tail),
member(X, Tail).
324
Relationales Programmieren
member: Element × List 7→ Boolean
?- member(b, [a,b,c]).
true.
?- member(X, [a,b,c]).
X = a ;
X = b ;
X = c
Beim Aufruf member(X, Xs) sind X und Xs nicht funktional
voneinander abhängig. Stattdessen realisiert member/2 eine
n : m–Beziehung (Relation) zwischen Listen und ihren Elementen.
325
Das Prädikat member/2 definiert eine virtuelle Relation:
member
Element
List
a
[a,b,c]
b
[a,b,c]
c
[a,b,c]
a
[a,b]
...
...
Diese Relation ist unendlich, sie wird aber nie berechnet.
Es werden meist nur die Elemente einer gegebenen Liste bestimmt.
326
Tracing
Man kann die Anfrageauswertung in P ROLOG mittels trace schrittweise
verfolgen:
?- trace.
true.
[trace] ?- member(X, [a,b]).
Call: (6) member(X, [a, b]) ? creep
Exit: (6) member(a, [a, b]) ? creep
X = a ;
Der initiale Aufruf member(X, [a,b]) wird zuerst mit dem Fakt
member(X, [X|_]) unifiziert. Dabei wird X auf a gesetzt und die
anonyme Variable (Wildcard) _ auf [b].
Somit ergibt sich die erste Antwort X = a.
327
Die Eingabe des Strichpunkts hinter der Antwort X = a stößt
Backtracking an:
Redo:
Call:
Exit:
Exit:
X = b ;
(6)
(7)
(7)
(6)
member(X,
member(X,
member(b,
member(b,
[a, b]) ? creep
[b]) ? creep
[b]) ? creep
[a, b]) ? creep
Nun wird der Aufruf member(X, [a,b]) mit dem Kopf
member(X, [_|Xs]) der Regel unifiziert.
Dabei wird X belassen, und es wird _ auf a und Xs auf [b] gesetzt.
Der neue Aufruf member(X, [b]) ergibt sich aus dem Rumpf der
Regel. Er wird mittels des Fakts mit X = b beantwortet (zweite Antwort).
328
Die Eingabe des Strichpunkts hinter der Antwort X = b stößt noch einmal
Backtracking an:
Redo:
Call:
Fail:
Fail:
Fail:
Fail:
false.
(8)
(9)
(9)
(8)
(7)
(6)
member(X,
member(X,
member(X,
member(X,
member(X,
member(X,
[b]) ? creep
[]) ? creep
[]) ? creep
[b]) ? creep
[b]) ? creep
[a, b]) ? creep
Nun wird der Aufruf member(X, [b]) mit dem Kopf
member(X, [_|Xs]) der Regel unifiziert.
Dabei wird X belassen, und es wird _ auf b und Xs auf [] gesetzt.
Der neue Aufruf member(X, []) ergibt sich aus dem Rumpf der Regel.
Er kann nicht beantwortet werden. Also ergibt sich die Antwort false.
329
Bindungsmuster
Einige Prädikate, wie z.B. das boolean_and/3, können mit
unterschiedlichen Bindungsmustern für die Argumente aufgerufen werden:
/* boolean_and(U, V, W) <W is derived as the boolean conjunction
of the truth values U and V. */
boolean_and(0,
boolean_and(0,
boolean_and(1,
boolean_and(1,
0,
1,
0,
1,
0).
0).
0).
1).
Hier kann man beliebig viele (auch 0) Argumente mit Werten versehen und
die restlichen Werte berechnen.
330
Wenn die ersten beiden Argumente gebunden sind, dann realisiert das
Prädikat eine Funktion:
?- boolean_and(1, 0, W).
W = 0 .
Man kann die Berechnung umkehren, und nach allen Paaren von
Wahrheitswerten U und V fragen, deren Konjunktion 0 ist; dann realisiert
das Prädikat eine n : m–Beziehung (Relation):
?- boolean_and(U, V, 0).
U = 0, V = 0 ;
U = 0, V = 1 ;
U = 1, V = 0
Dabei wird durch die Eingabe von ; hinter einer Lösung die Berechnung
der nächsten Lösung angestoßen.
331
Arithmetik
Im Gegensatz zum Unifikationsprädikat =/2 wertet das Prädikat is/2 den
arithmetischen Ausdruck zu seiner rechten aus und unifiziert das Ergebnis
mit dem Ausdruck zu seiner linken:
?- X = 3, Y is e^X + sin(X).
X = 3, Y = 20.2267.
Der entsprechende Aufruf mit =/2 würde Y dagegen lediglich mit dem
Term e^3 + sin(3) unifizieren:
?- X = 3, Y = e^X + sin(X).
X = 3, Y = e^3 + sin(3).
332
Symbolisches Differenzieren
Das Prädikat diff/3 differenziert beim Aufruf diff(F, X, DF) einen
Funktionsterm F symbolisch nach der Variablen X – die beim Aufruf durch
eine Konstante instanziiert sein muß – und liefert DF als Ergebnis:
?- diff(e^x + sin(x), x, F).
F = e^x + cos(x).
?- diff(x^7 + 3 * x^6, x, F).
F = 7 * x^6 + 3 * 6 * x^5.
Dasselbe Prädikat diff/3 kann bei einem anderen Bindungsmuster zum
symbolischen Integrieren benutzt werden, wenn stattdessen X und DF
gebunden sind.
Bei den Aufrufen des folgenden Prädikats diff/3 muß die Unbekannte,
nach der differenziert wird, durch ein P ROLOG–Atom repräsentiert sein.
333
Die ersten beiden Regeln behandeln die Spezialfälle, daß F identisch ist
mit X, oder daß F ein anderes P ROLOG–Atom ist:
% diff(+F, +X, ?DF) <% diff(?F, +X, +DF) <diff(X, X, 1) :!.
diff(C, X, 0) :atomic(C).
Der Cut, “!”, weist P ROLOG an, keine weiteren Regeln zu versuchen, falls
die aktuelle Regel anwendbar ist. Ohne den Cut würde der Aufruf
diff(x,x,DF) sowohl das Resultat DF=1 (die richtige Antwort aus
Regel 1) als auch DF=0 (die falsche Antwort aus Regel 2) liefern.
334
diff(X^N, X, N*X^M) :N > 0,
M is N - 1.
diff(sin(X), X, cos(X)).
diff(e^X, X, e^X).
diff(F+G, X, DF+DG) :diff(F, X, DF),
diff(G, X, DG).
diff(C*F, X, C*DF) :atomic(C),
!,
diff(F, X, DF).
Der Cut in der letzten Regel ist hier eigentlich nicht erforderlich. Er wird
erst dann wichtig, wenn man das Regelsystem noch erweitert.
335
3.2
SLD– und SLDNF–Resolution
Definites Logikprogramm, Anfrage
1. Ein definites Logikprogramm besteht aus Horn–Klauseln in
Implikations–Notation mit jeweils genau einem Kopfatom:
Fakt:
A
Regel:
A ← B1 ∧ . . . ∧ Bm , m ≥ 0.
Fakten stellen Wissen ohne Vorbedingung dar, Regeln mit m ≥ 1
konditionales Wissen mit Vorbedingung β = B1 ∧ . . . ∧ Bm .
2. Horn–Klauseln in Implikations–Notation ohne Kopfatom
repräsentieren Anfragen:
Goal:
← B1 ∧ . . . ∧ Bm , m ≥ 0.
Dabei sind A und die Bi prädikatenlogische Atome.
336
Die SLD–Resolution (Linear Resolution with Selection Function for
Definite Clauses) wurde ursprünglich zum automatischen Theorembeweisen
für allgemeine Klauseln verwendet, vgl. J.A. Robinson (1965).
• Sei s eine Selektionsfunktion, die aus jedem Goal ein Atom auswählt.
• Sei G ein Goal und r = A ← β eine definite Regel:
G = ← β1 ∧ B ∧ β2 .
Dabei seien β1 und β2 Konjunktionen von Atomen und s(G) = B das
von s selektierte Atom. Falls M GU (A, B) = θ existiert, dann heißt
G′ = ← ( β1 ∧ β ∧ β2 ) θ
eine Resolvente von G und r bezüglich s.
Falls r ein Fakt ist (d.h. β ist leer), dann ist G′ um ein Atom kürzer als G.
337
Die SLD–Resolution ergibt sich aus der binären Resolution der PL1.
Bekanntlich ist ein Goal G = ← β1 ∧ B ∧ β2 äquivalent zu einer
Disjunktion
α1 = ¬β1 ∨ ¬B ∨ ¬β2 ,
und eine Regel r = A ← β ist äquivalent zu einer Disjunktion
α2 = A ∨ ¬β.
Durch die bekannte binäre Resolution der PL1 erhält man mittels eines
allgemeinsten Unifikators θ von A und B eine neue Disjunktion
α = (¬β1 ∨ ¬β ∨ ¬β2 )θ,
die wieder einem Goal G′ = ← ( β1 ∧ β ∧ β2 ) θ entspricht.
338
SLD–Widerlegung
• Sei P ein definites Logikprogramm und Q eine Anfrage.
Eine SLD–Widerlegung von h P, Q i ist eine endliche Folge
h Gi i0≤i≤n , wobei G0 = Q und Gn = 2,
von Goals zusammen mit einer Folge h ri i1≤i≤n von Regeln und einer
Folge h θi i1≤i≤n von Substitutionen, wobei für alle 1 ≤ i ≤ n gilt:
– ri ist eine Variante einer Regel aus P ,
– Gi ist eine Resolvente aus Gi−1 und ri bezüglich s, und
– θi ist der benutzte allgemeinste Unifikator.
Die Substitution θ = θ1 · θ2 · . . . · θn heißt Antwortsubstitution.
• Die SLD–Widerlegung einer atomaren Anfrage Q = ← A ist
äquivalent zu dem Beweis, daß die Instanz Aθ, welche man Antwort
nennt, aus P abgeleitet werden kann.
339
• Ein SLD–Widerlegungsbaum veranschaulicht eine SLD–Widerlegung:
G0
?
G1
?
G2
?
r1
r2
r3
G3
..
.
..
.
rn
?
Gn = 2
Man kann eine SLD–Widerlegung natürlich auch einfach als eine
r1
r2
r3
rn
lineare Kette G0 −→
G1 −→
G2 −→
. . . −→
Gn = 2 repräsentieren,
wenn man die Kanten mit den verwendeten Regeln markiert.
340
Beispiel (SLD–Resolution)
Für das DATALOG–Programm P = { r, f1 , f2 }, mit
r = p ← a ∧ b,
f1 = a,
f2 = b,
erhalten wir mit der Selektionsfunktion sl eine SLD–Widerlegung zum
Goal Q = ← p.
←p
?
←a∧b
?
←b
?
2
r
f1
f2
341
In Klauselschreibweise
r = p ∨ ¬a ∨ ¬b,
f1 = a,
f2 = b,
erhalten wir folgende Folge von binären Resolutionen zum Goal Q = ¬p :
¬p
r
?
¬a ∨ ¬b
f1
?
¬b
f2
?
2
342
Nicht–Lineare Resolution
Für die inkonsistente Klauselmenge
F = { p ∨ q, p ∨ ¬q, ¬p ∨ q, ¬p ∨ ¬q }
gibt es keine lineare Widerlegung, aber folgende Resolutionsableitung:
p∨q
p ∨ ¬q ¬p ∨ q
Rp
¬p ∨ ¬q
R¬p
s
2
+
Diese Klauselmenge ist keine Hornklauselmenge.
Für eine inkonsistente Hornklauselmenge gibt es immer eine lineare
Ableitung der leeren Klausel, die mit einer Integritätsbedingung startet.
343
Substitutionen
Wir schreiben eine Substitution [X1 |t1 , . . . Xn |tn ], bei der alle Ersetzungen
parallel angewendet werden, als Menge θ = { X1 7→ t1 , . . . , Xn 7→ tn }.
θ definiert eine Abbildung von einer Struktur t auf eine neue Struktur tθ:
• Für eine Konstante c gilt cθ = t.
• Für eine Variable X erhalten wir Xθ = t, falls es eine Ersetzung
X 7→ t ∈ θ gibt, und ansonsten Xθ = X.
• Für eine komplexe Struktur gilt f (t1 , . . . , tn )θ = f (t1 θ, . . . , tn θ).
Dann entspricht die Substitution θ1 = [X|Z][Z|Y ] der Substitution
[X|Y, Z|Y ], da X zuerst durch Y und dieses dann durch Z ersetzt wird.
Sie ist damit verschieden von θ2 = [X|Z, Z|Y ].
Für t = f (X, Y, Z) gilt z.B. tθ1 = f (Y, Y, Y ) und tθ2 = f (Z, Y, Y ).
344
Wir betrachten das nicht–rekursive, definite Logikprogramm
P = { r, f1 , f2 , f3 , f4 } und die Anfrage Q = ← grandparent(X, Z):
r = grandparent(X, Z) ← parent(X, Y ) ∧ parent(Y, Z),
f1 = parent(’Elizabeth’, ’Queen Mum’),
f2 = parent(’Elizabeth’, ’George’),
f3 = parent(’Charles’, ’Elizabeth’),
f4 = parent(’William’, ’Charles’).
Aus G0 = Q erhält man mittels r und θ1 = ∅ die Resolvente
G1 = ← parent(X, Y ) ∧ parent(Y, Z).
’Queen Mum’
’George’
f1
f2
’Elizabeth’
f3
’Charles’
f4
’William’
Daraus kann man mit der Selektionsfunktion sl , welche stets das linkeste
Literal eines Goals auswählt, z.B. folgende SLD–Widerlegungen erhalten:
345
• Mittels f3 und θ2 = { X 7→ ’Charles’, Y 7→ ’Elizabeth’ } erhalten wir
G2 = ← parent(’Elizabeth’, Z).
– Mittels f1 und θ3 = { Z 7→ ’Queen Mum’ } erhalten wir G3 = 2
und die Antwortsubstitution
θ = { X 7→ ’Charles’, Y 7→ ’Elizabeth’, Z 7→ ’Queen Mum’ }.
– Mittels f2 und θ3 = { Z 7→ ’George’ } erhalten wir ebenfalls
G3 = 2; nun ist die Antwortsubstitution
θ ′ = { X 7→ ’Charles’, Y 7→ ’Elizabeth’, Z 7→ ’George’ }.
• Mittels f4 und f3 erhalten wir aus G1 die Antwortsubstitution
θ ′′ = { X 7→ ’William’, Y 7→ ’Charles’, Z 7→ ’Elizabeth’ }.
Später werden wir alle SLD–Widerlegungen in einem SLD–Baum
zusammenfassen.
346
Betrachten wir das rekursive, definite Logikprogramm P = { r, e, f } mit
den folgenden Regeln (bzw. Fakten):
r = anc(X, Y ) ← par (X, Z) ∧ anc(Z, Y ),
e = anc(X, X),
f = par (a, b).
Zur Vereinfachung benutzen wir anstelle der üblichen bereichsbeschränkten
Regel
e′ = anc(X, Y ) ← par (X, Y )
das Fakt e = anc(X, X) mit Variablen zusammen mit der rekursiven
Regel r. Dadurch wird hier anc als die reflexive, transitive Hülle von par
berechnet.
347
Dann kann das Goal G0 = ← anc(X, b) von allen Selektionsfunktionen
mittels der Regel r zu
G1 = ← A1 ∧ A2 ,
mit A1 = par (X, Z ′ ) und A2 = anc(Z ′ , b), resolviert werden.
Sei sl (sr ) die Selektionsfunktion, welche stets das linkeste (rechteste)
Literal eines Goals auswählt.
1. sl wählt das erste (linkeste) Atom A1 = par (X, Z ′ ) in G1 .
Dieses kann nur mit dem Fakt f = A = par (a, b) resolviert werden.
Mit M GU (A1 , A) = { X 7→ a, Z ′ 7→ b } erhält man das verkürzte Goal
G2 = ← anc(b, b).
Eine weitere Resolution mit dem Fakt e würde die leere Klausel
G3 = ← 2 liefern, und somit die Antwort anc(a, b).
348
2. sr wählt das zweite (rechteste) Atom A2 = anc(Z ′ , b) in G1 .
Dieses kann mit Varianten
r ′′ = anc(X ′′ , Y ′′ ) ← par (X ′′ , Z ′′ ) ∧ anc(Z ′′ , Y ′′ ),
e′′ = anc(X ′′ , X ′′ ),
der Regeln r bzw. e resolviert werden. Sei A′′ jeweils deren Regelkopf.
• Mit r ′′ , A′′ = anc(X ′′ , Y ′′ ) und
M GU (A2 , A′′ ) = { X ′′ 7→ Z ′ , Y ′′ 7→ b }
erhält man das verlängerte Goal
G′2 = ← par (X, Z ′ ) ∧ par (Z ′ , Z ′′ ) ∧ anc(Z ′′ , b).
• Mit e′′ , A′′ = anc(X ′′ , X ′′ ) und
M GU (A2 , A′′ ) = { X ′′ 7→ b, Z ′ 7→ b }
erhält man das verkürzte Goal
G′′2 = ← par (X, b).
349
Eine weitere Resolution mit dem Fakt f würde
M GU (par (X, b), f ) = { X 7→ a }
und die leere Klausel G′′3 = ← 2 liefern, und somit die Antwort
anc(a, b).
Mittels des Faktes e kann das Goal G0 = ← anc(X, Y ) von allen
Selektionsfunktionen zur leeren Klausel G′1 = ← 2 resolviert werden.
Dabei wird
M GU (anc(X, Y ), anc(X, X)) = { Y 7→ X }
berechnet, und somit die Antwort anc(X, X).
Diese Antwort enthält noch das Variablensymbol X.
350
Beispiel (SLD–Widerlegungsbäume)
Wir betrachten weiterhin das definite Logikprogramm P = { r, e, f },
jetzt aber mit den Anfragen
Q1 = ← anc(X, b),
Q2 = ← anc(X, Y ).
Die Regeln (bzw. Fakten) sind folgende:
r
=
anc(X, Y ) ← par (X, Z) ∧ anc(Z, Y ),
e
=
anc(X, X),
f
=
par (a, b).
Anders als in Q1 , ist in Q2 auch die zweite Argumentposition mit einem
Variablensysmbol – hier Y – belegt. Deswegen kann eine Antwort
berechnet werden, die noch Variablensymbole enthält.
351
Im folgenden werden ein SLD–Widerlegungsbaum T1 für Q1 und die
zugehörige Grundversion T1 θ angegeben:
T1 :
← anc(X, b)
?9
← par (X, Z ′ ) ∧ anc(Z ′ , b)
?9
← anc(b, b)
r ′ = anc(X ′ , Y ′ ) ← par (X ′ , Z ′ ) ∧ anc(Z ′ , Y ′ )
θ1 = { X ′ 7→ X, Y ′ 7→ b }
f ′ = par (a, b)
θ2 = { X 7→ a, Z ′ 7→ b }
e′ = anc(X ′′ , X ′′ )
?9
2
θ3 = { X ′′ 7→ b }
Die berechnete Antwort ist anc(a, b).
352
Die Grundinstanz für die berechnete Antwort anc(a, b) ist folgende:
T1 θ:
← anc(a, b)
?9
← par (a, b) ∧ anc(b, b)
?9
← anc(b, b)
?9
2
r ′ θ = anc(a, b) ← par (a, b) ∧ anc(b, b)
f ′ θ = par (a, b)
e′ θ = anc(b, b)
θ = θ1 · θ2 · θ3 = { X 7→ a, X ′ 7→ a,
X ′′ 7→ b, Y ′ 7→ b, Z ′ 7→ b }
353
Die Top–Down–Auswertung kann auch nicht–bereichsbeschränkte definite
Logikprogramme behandeln.
Sie hat keine Probleme mit Fakten, die Variablen enthalten, wie etwa
e = anc(X, X).
T2 :
← anc(X, Y )
?)
2
e = anc(X, X)
θ = { Y 7→ X }
Allerdings ist die erzeugte Antwortsubstitution θ dann unter Umständen
keine Grundsubstitution. Im obigem Beispiel für Q2 = ← anc(X, Y ) ist
die berechnete Antwort anc(X, X) dann ein Fakt mit Variablen, das zeigt,
daß die beiden Grundinstanzen anc(a, a) und anc(b, b) aus P ableitbar sind.
354
Vollständigkeit und Korrektheit der SLD–Resolution
Sei P ein definites Logikprogramm und Q = ← A eine atomare Anfrage.
1. Es gibt genau dann eine SLD–Widerlegung mit der Antwort Aθ,
wenn Aθ im minimalen Modell MP von P liegt.
2. Dieses Resultat ist unabhängig von der verwendeten
Selektionsfunktion s.
P ROLOG verwendet immer die Selektionsfunktion sl , welche stets das
linkeste (erste) Literal eines Goals auswählt.
Durch Umstellung der Atome in den Regelrümpfen kann der
Programmierer de facto eine andere Selektionsfunktion simulieren.
355
SLD–Bäume
Sei P ein definites Logikprogramm, Q eine Anfrage und s eine
Selektionsfunktion.
s
Der SLD–Baum TP,Q
faßt alle möglichen SLD–Ableitungen zusammen:
s
1. Die Knoten von TP,Q
sind mit Goals markiert,
s
und die Kanten von TP,Q
sind mit Regeln r ∈ P markiert.
s
2. Die Wurzel von TP,Q
ist mit Q markiert.
3. Ein Knoten v, der mit einem Goal G markiert ist, hat für jede
SLD–Resolvente G′ , die man aus G und einer Regel r ∈ P bezüglich s
bilden kann, einen Nachfolgerknoten v ′ .
4. Dieser ist mit G′ markiert, und die Kante h v, v ′ i ist mit r markiert.
356
Jeder mit dem Goal G = 2 endende Ast eines SLD–Baumes entspricht
einer SLD–Widerlegung bzw. einem SLD–Widerlegungsbaum:
• Die Blätter dieser Äste werden als erfolgreich (success) markiert.
• Alle anderen Blätter werden als erfolglos (failure) markiert.
• Daneben kann es noch unendliche Äste im Baum geben.
s1
s2
Zwei SLD–Bäume TP,Q
und TP,Q
zu unterschiedlichen
Selektionsfunktionen s1 , s2 haben immer dieselben Antworten
(success–Äste).
Sie unterscheiden sich aber in der Regel hinsichtlich ihrer failure–Äste bzw.
ihrer unendlichen Äste.
357
Beispiel (SLD–Bäume)
Wir betrachten das nicht–rekursive, definite Logikprogramm
P = { r, f1 , f2 , f3 , f4 } und die Anfrage Q = ← grandparent(X, Z):
r = grandparent(X, Z) ← parent(X, Y ) ∧ parent(Y, Z),
f1 = parent(’Elizabeth’, ’Queen Mum’),
f2 = parent(’Elizabeth’, ’George’),
f3 = parent(’Charles’, ’Elizabeth’),
f4 = parent(’William’, ’Charles’).
In diesem Falle sind alle SLD–Bäume – unabhängig von der
Selektionsfunktion – endlich.
sl
Wir zeigen unten den SLD–Baum TP,Q
zur Selektionsfunktion sl .
358
← grandparent(X, Z)
r
?
← parent(X, Y ) ∧ parent(Y, Z)
f1
9
f2
← parent(’Queen Mum’, Z )
← parent(’George’, Z )
failure
failure
)
2
{ X 7→ ’Charles’,
Y 7→ ’Elizabeth’,
Z 7→ ’Queen Mum’ }
success
f3
f4
j
z
← parent(’Elizabeth’, Z )
f1
f2
?
2
{X →
7 ’Charles’,
Y 7→ ’Elizabeth’,
Z →
7 ’George’ }
success
← parent(’Charles’, Z )
f3
?
2
{X →
7 ’William’,
Y →
7 ’Charles’,
Z 7→ ’Elizabeth’ }
success
359
Beispiel (SLD–Bäume)
Wir betrachten wieder das rekursive, definite Logikprogramm
P = { r, e, f } und die Anfrage Q = ← anc(X, b):
e = anc(X, X),
f = par (a, b).
Die SLD–Bäume zu den Selektionsfunktionen sl bzw. sr haben dieselben
Antworten (success–Äste).
• Allerdings ist in diesem Falle Tl endlich,
• wohingegen Tr unendliche Äste hat.
Für sr könnte man in obigem Beispiel die unendlichen Äste vermeiden,
indem man die Reihenfolge der Rumpfatome invertiert.
360
Der SLD–Baum Tl zur Selektionsfunktion sl ist endlich:
← anc(X, b)
Tl :
r
← par (X, Z ′ ) ∧ anc(Z ′ , b)
f
?
← anc(b, b)
r
← par (b, Z ′′ ) ∧ anc(Z ′′ , b)
failure
e
R
2
{ X 7→ b }
success
e
R
2
{ X 7→ a }
success
361
Der SLD–Baum Tr zur Selektionsfunktion sr ist unendlich, hat aber die
gleichen Antwortsubstitutionen in den success–Blättern wie Tl :
← anc(X, b)
Tr :
r
e
R
← par (X, Z ′ ) ∧ anc(Z ′ , b)
r
e
←
par (X, Z ′ )
∧
par (Z ′ , Z ′′ )
r
)
← par (X, Z ′ ) ∧ par (Z ′ , Z ′′ )
∧ par(Z ′′ , Z ′′′ ) ∧ anc(Z ′′′ , b)
r
e
R
∧
R
anc(Z ′′ , b)
2
{ X 7→ b }
success
← par (X, b)
e
f
s
R
← par (X, Z ′ ) ∧ par (Z ′ , b)
f
?
2
{ X 7→ a }
success
← par (X, a)
failure
(unendlicher Ast)
362
Steuerung der SLD–Resolution
Der Logikprogrammierer kann bei gegebener Selektionsfunktion durch
• die Reihenfolge der Regeln und
• die Reihenfolge der Rumpfatome in den Regeln
die Abarbeitung steuern:
• Wenn wir in unserem letzten Beispiel die Regel e vor die Regel r
stellen, dann wandern im neuen SLD–Baum Tr′ zur Selektionsfunktion
sr die mit e markierten Kanten vor die mit r markierten.
• Bei Backtracking findet der LWR–Durchlauf von Tr′ nun die beiden
Antworten, bevor der unendliche Ast zu einer Dauerschleife führt.
• Wenn wir dagegen die Reihenfolge der Rumpfatome von r vertauschen,
dann hat der neue SLD–Baum Tr′′ zu sr dieselbe Struktur wie der alte
SLD–Baum Tl zu sl : r ′′ = anc(X, Y ) ← anc(Z, Y ) ∧ par (X, Z).
363
• Generell ist es am besten die nicht–rekursive Regel e vor die rekursive
Regel r zu stellen:
e = anc(X, X),
r = anc(X, Y ) ← par (X, Z) ∧ anc(Z, Y ).
• Für die Standard–Selektionsfunktion sl sollte in der rekursiven Regel r
der nicht–rekursive Aufruf par (X, Z) vor dem rekursiven Aufruf
anc(Z, Y ) stehen. Dies garantiert die Terminierung für azyklische
par –Relationen.
• Bei zyklischer par –Relation enthält der SLD–Baum Tl aber leider
trotzdem unendliche Äste. Für die Fakten
f1 = par (a, b),
f2 = par (b, a),
und die Anfrage Q = ← anc(a, Y ) generiert die alternierende
Verwendung von f1 und f2 abwechselnd die Antworten Y 7→ a und Y 7→ b.
364
← anc(a, Y )
Tl :
e
r
R
2
← par (a, Z ′ ) ∧ anc(Z ′ , Y )
{Y →
7 a}
success
f1
?
← anc(b, Y )
e
r
R
2
← par (b, Z ′′ ) ∧ anc(Z ′′ , Y )
{ Y 7→ b }
f2
success
?
← anc(a, Y )
(unendlicher Ast)
365
Beispiel (Redundanz in SLD–Bäumen)
Wir betrachten nun das etwas erweiterte rekursive, definite Logikprogramm
P = { r, e, f1 , f2 } und die Anfrage Q = ← anc(X, Y ):
e = anc(X, X),
f1 = par (a, b), f2 = par (b, c).
Der SLD–Baum Tl zur Selektionsfunktion sl ist endlich.
Die success–Äste leiten der Reihe nach die folgenden Grundinstanzen ab:
• success–Äste 1 bis 3: tc(a, c), tc(a, b), tc(b, c);
• success–Ast 4: tc(a, a), tc(b, b), tc(c, c).
Die Unteranfrage ← anc(c, Y ) wurde redundant in zwei success–Ästen
(1 und 3) mit Y 7→ c beantwortet. Derartige Redundanz tritt bei Graphen
mit längeren Ketten (hier: a → b → c) noch verstärkt auf.
366
← anc(X, Y )
Tl :
r
e
R
2
← par (X, Z ′ ) ∧ anc(Z ′ , Y )
{ X 7→ Y }
success
f1
f2
R
← anc(b, Y )
r
e
←
par (b, Z ′′ )
f2
∧
← anc(c, Y )
r
R
anc(Z ′′ , Y
par (c, Z ′′ )
2
)
←
{ X 7→ a, Y 7→ b }
success
?
e
R
∧
z
anc(Z ′′ , Y
failure
2
)
{ X 7→ b, Y 7→ c }
success
← anc(c, Y )
r
e
R
← par (c, Z ′′′ ) ∧ anc(Z ′′′ , Y ) 2
{ X 7→ a, Y 7→ c }
failure
success
367
Normale Logikprogramme
Syntax:
1. Ein normales Logikprogramm besteht aus Regeln in
Implikations–Notation mit jeweils genau einem Kopfatom:
Fakt:
A
Regel:
A ← B1 ∧ . . . ∧ Bm ∧ not C1 ∧ . . . ∧ not Cn .
Fakten stellen Wissen ohne Vorbedingung dar,
Regeln mit m ≥ 1 oder n ≥ 1 konditionales Wissen mit Vorbedingung.
2. Regeln mit n = 0 und ohne Kopfatom repräsentieren Anfragen:
Goal:
← B1 ∧ . . . ∧ Bm .
Dabei sind A, die Bi und die Ci Atome. not nennt man Default–Negation.
In P ROLOG schreibt man diese als “not(C)” oder “\+ C”.
368
SLDNF–Resolution
Die SLDNF–Resolution erweitert die SLD–Resolution auf normale
Logikprogramme durch ein Konzept namens Negation–as–Finite–Failure
zur Behandlung negativer Literale not A:
• Wenn im Rahmen einer SLDNF–Resolution ein negatives Literal not A
abgeleitet werden soll, so wird eine neue SLDNF–Resolution für das
Goal G0 = ← A gestartet.
• Falls diese erfolglos abbricht, so ist not A abgeleitet; sonst war der
Ableitungsversuch für not A erfolglos.
not A bedeutet, daß A nicht ableitbar ist, und nicht etwa, daß ¬A ableitbar
ist. Damit sind die beiden wesentlich verschieden.
Zur Illustration der SLDNF–Resolution wollen wir damit im folgenden
Zwei–Personen–Gewinnspiele mit azyklischen Übergangsgraphen behandeln.
369
Beispiel (Zwei–Personen–Gewinnspiele)
• Bei Tic–Tac–Toe markieren die Spieler abwechselnd Felder auf einem
3 × 3–Brett. Ein Spieler gewinnt, wenn er als erster eine Reihe, Spalte
oder Diagonale zu besetzt.
• Wenn beide Spieler allerdings optimal spielen, so gehen die Spiele
Unentschieden aus:
370
• Für Tic–Tac–Toe ist der Übergangsgraph azyklisch:
Es gibt 765 wesentlich verschiedene Positionen. Achsenspiegelungen
erzeugen strukturell gleiche Positionen.
• Für Schach ist der Übergangsgraph zyklisch.
371
Beispiel (Zwei–Personen–Gewinnspiele mit SLDNF)
Wir betrachten das normale Logikprogramm P = { r, f1 , f2 } und die
Anfrage Q = ← win(X) :
r = win(X) ← move(X, Y ) ∧ not win(Y ),
f1 = move(b, c), f2 = move(a, b).
a
-
b
-
c
Ein Spieler kann in Position X gewinnen, wenn es einen Zug von X nach Y
gibt, so daß man in Position Y nicht gewinnen kann.
• Offenbar kann man in Position b gewinnen, da man nach c ziehen kann,
und da es keinen Zug von c aus gibt; c ist eine Verlustposition.
• In Position a kann man nicht gewinnen, da man nach b ziehen muß,
und da b ja dann eine Gewinnposition für den Gegner ist.
372
Sei G0 = Q:
• Wir starten eine SLDNF–Resolution für G0 = ← win(X) :
– h G0 , r i 7→ G1 = ← move(X, Y ) ∧ not win(Y )
– h G1 , f1 i 7→ G2 = ← not win(c)
• Wir starten eine SLDNF–Resolution für H0 = ← win(c) :
– h H0 , r i 7→ H1 = ← move(c, Y ) ∧ not win(Y )
– H1 kann bezüglich sl nicht weiter resolviert werden,
und es gibt keine Möglichkeit zum Backtracking.
– Deshalb schlägt die SLDNF–Resolution für H0 fehl.
• Damit ist die SLDNF–Resolution für G0 erfolgreich mit der
Substitution { X 7→ b, Y 7→ c }, und somit ist win(b) abgeleitet.
373
• Backtracking innerhalb der SLDNF–Resolution für G0 liefert:
– h G1 , f2 i 7→ G′2 = ← not win(b)
• Wir starten eine SLDNF–Resolution für H0′ = ← win(b) :
– h H0′ , r i 7→ H1′ = ← move(b, Y ) ∧ not win(Y )
– h H1′ , f1 i 7→ H2′ = ← not win(c)
– Da die SLDNF–Resolution für ← win(c) bekanntermaßen
fehlschlägt, ist die SLDNF–Resolution für H0′ = ← win(b)
erfolgreich.
• Damit bricht die aktuelle Berechnungslinie erfolglos ab.
• Jetzt gibt es keine weiteren Alternativen zum Backtracking innerhalb
der SLDNF–Resolution für G0 .
374
?- trace.
[trace]
Call:
Call:
Exit:
Call:
Call:
Call:
Fail:
Fail:
Exit:
Exit:
X = b ;
?- win(X).
(6) win(X)
(7) move(X, Y)
(7) move(b, c)
(7) not(win(c))
(8) win(c)
(9) move(c, Y’)
(9) move(c, Y’)
(8) win(c)
(7) not(win(c))
(6) win(b)
Fail:
Redo:
Exit:
Call:
Call:
Call:
Exit:
Call:
(7)
(7)
(7)
(7)
(8)
(9)
(9)
(9)
not(win(c))
move(X, Y)
move(a, b)
not(win(b))
win(b)
move(b, Y’)
move(b, c)
not(win(c))
Call:
Call:
Fail:
Fail:
Exit:
Exit:
Fail:
Fail:
Fail:
(10) win(c)
(11) move(c, Y’’)
(11) move(c, Y’’)
(10) win(c)
(9) not(win(c))
(8) win(b)
(7) not(win(b))
(7) move(X, Y)
(6) win(X)
false.
375
Zyklisches, nicht–terminierendes Verhalten
Wir betrachten nun das normale Logikprogramm P = { r, f3 } und die
Anfrage Q = ← win(X) :
r = win(X) ← move(X, Y ) ∧ not win(Y ),
f3 = move(c, c).
Die Relation move/2 ist hier zyklisch.
• In diesem Fall führt die SLDNF–Resolution für G0 = Q zu einer
Dauerschleife, da immer wieder das Goal ← win(c) auftritt.
• Deswegen kann weder win(c) noch ¬win(c) abgeleitet werden.
Das P ROLOG–System X SB kann solche Dauerschleifen durch eine
modifizierte Auswertung mit Zyklentest vermeiden.
376
führt zur Dauerschleife:
zyklische Relation move/2:
win(X) :move(X, Y),
not(win(Y)).
move(c, c).
[trace]
Call:
Call:
Exit:
^ Call:
Call:
Call:
Exit:
^ Call:
Call:
...
?- win(X).
(6) win(X)
(7) move(X, Y)
(7) move(c, c)
(7) not(win(c))
(8) win(c)
(9) move(c, Y’)
(9) move(c, c)
(9) not(win(c))
(10) win(c)
377
Abhängigkeitsgraph
Es gibt ein DDK–Tool zur Veranschaulichung der Abhängigkeitsgraphen
von P ROLOG–Programmen. Da hier die Regeln keine Namen haben,
werden die Regel–Knoten mit den entsprechenden File–Namen markiert.
378
3.3
Suche in Graphen
Labyrinth:
379
Berechnung einfacher Pfade mittels Backtracking
Das Prädikat graph_search/2 berechnet einen einfachen Pfad von
einem gegebenen Knoten zu einer Senke des Graphen:
% graph_search(+Node, ?Path) <graph_search(X, Path) :graph_search(X, [X], Path).
Es wird ein weiteres Prädikat graph_search/3 mit demselben
Prädikatensymbol aber einer anderen Stelligkeit aufgerufen.
Der Graph ist in Form von Fakten für die Prädikate graph_arc/2 und
graph_sink/1 gegeben.
Notation für die Argumente in der Kommentarzeile:
+: gebunden, -: frei, ?: gebunden oder frei
380
Path =
Visited [Y1 =Y, . . . ,Yn =Z]
-X -Y
-Z
• Beim Aufruf graph_search(X, Visited, Nodes) mit
einem gebundenen Argument X, das keine Senke ist, und einer Liste
Visited von bereits besuchten Knoten, wird
– eine Kante von X zu einem bisher nicht besuchten
Nachfolgerknoten Y benutzt, und dann
– ein Weg Path von Y zu einer Senke Z berechnet, der Y und die
Knoten in Visited nicht benutzt.
Falls kein Weg von Y zu einer Senke gefunden werden kann, so muß
ein anderer Nachfolgerknoten von X benutzt werden (Backtracking).
• Das Ergebnis Nodes = [X|Path] ist ein einfacher Pfad von X zu
einer Senke des Graphen.
381
Das Prädikat graph_search/3 ist aufgrund seiner zweiten Regel
rekursiv:
% graph_search(+Node, +Visited, ?Path) <graph_search(X, _, [X]) :graph_sink(X).
graph_search(X, Visited, [X|Path]) :Path =
graph_edge(X, Y),
[Y1 =Y,
Visited
-X-Y
not(member(Y, Visited)),
write(user, ’->’), write(user, Y),
graph_search(Y, [Y|Visited], Path).
. . . ,Yn =Z]
-Z
Die Terminierung wird dadurch gewährleistet, daß Knoten nicht mehrfach
besucht werden dürfen.
382
• Der initiale Aufruf graph_search(X, [X], Path) berechnet
einen einfachen Pfad von X zu einer Senke des Graphen.
– Falls X bereits eine Senke ist, so bestimmt die erste Regel für
graph_search/3 den Pfad Path als die leere Liste.
– Ansonsten wählt die rekursive zweite Regel mittels graph_edge
(X, Y) einen Nachfolgerknoten Y und sucht von dort aus weiter.
• Bei Backtracking können weitere einfache Pfade berechnet werden.
– Dazu können in der zweiten Regel alternative Nachfolgerknoten Y
betrachtet werden.
– In der obigen Implementierung kann über eine Senke hinaus zu
anderen Senken weitergesucht werden, indem man die zweite Regel
anstelle der ersten verwendet.
383
Implizites und explizites Backtracking
In P ROLOG wird automatisch (implizit) Backtracking verwendet.
In einer prozeduralen Sprache muß man das Backtracking explizit
implementieren.
Falls man obigen Code eins–zu–eins in einer prozeduralen Umgebung
umsetzen würde, so könnte ein Aufruf graph_edge(X, Y) nur einen
einzigen Nachfolgerknoten Y von X produzieren – falls es dann keinen Pfad
von Y zu einer Senke gibt, so würde die Berechnung fehlschlagen.
Außerdem könnte nur maximal eine Lösung ermittelt werden.
Wenn man die Graph–Suche prozedural mit explizitem Backtracking
realisiert, so ergibt sich mehr Code als bei der P ROLOG–Implementierung.
384
Repräsentation des Graphen mit P ROLOG–Fakten
Labyrinth:
a
b
c
d
e
f
g
h
i
6
-
graph_arc(i,
graph_arc(i,
graph_arc(h,
graph_arc(g,
graph_arc(d,
graph_arc(d,
graph_arc(a,
graph_arc(b,
f).
h).
g).
d).
e).
a).
b).
c).
graph_sink(c).
385
Die folgende Regel symmetrisiert das Prädikat graph_arc/2:
graph_edge(X, Y) :( graph_arc(X, Y)
; graph_arc(Y, X) ).
Dadurch ist es nicht nötig, für die Kanten die Rückrichtung explizit
anzugeben:
graph_edge(i,
graph_edge(f,
graph_edge(i,
graph_edge(h,
...
f).
i).
h).
i).
386
Berechnung
• Das Prädikat graph_search/2 benutzt Tiefensuche, und es
berechnet einfache Pfade (ohne doppelte Knoten).
• Beim Aufruf graph_search(+Node, ?Path) können alle
einfachen Pfade von Node zu einer Senke (graph_sink) über
Backtracking berechnet werden:
?- graph_search(i, Path).
->f->h->g->d->e->a->b->c
Path = [i, h, g, d, a, b, c]
?- graph_search(e, Path).
->d->a->b->c
Path = [e, d, a, b, c] ;
->g->h->i->f
false.
387
• Würde man eine weitere Kante graph_arc(e, b) in den Graphen
einfügen (die Wand zwischen e und b einreisen), so gäbe es einen
weiteren einfachen Pfad [e, b, c] von e zur Senke c.
• Man kann alle Antworten mittels Backtracking und findall/3
bestimmen:
graph_arc(e, b).
?- findall( Path,
graph_search(e, Path),
Paths ).
...
Paths = [ [e, d, a, b, c], [e, b, c] ]
388
Das Meta–Prädikat findall/3
Finden aller Lösungen für ein Goal:
findall( X,
goal(X),
Xs )
Das D DK erlaubt sogar folgende äquivalente Mengenschreibweise:
Xs <= { X | goal(X) }
Weitere wichtige Meta–Prädikate sind checklist/2 und maplist/3
für Listen sowie die Prädikate für Schleifen (Kontrollstrukturen) aus der
Loops–Bibliothek (z.B. foreach-do).
389
3.4
Sortieren und Suchbäume
Im folgenden werden einige wohlbekannte Algorithmen zum Sortieren und
Suchen in P ROLOG formuliert.
Vorzüge von P ROLOG liegen hierbei
• im einfachen Umgang mit Datenstruktuen (Listen, Bäume, X ML) und
• in der kompakten Realisierbarkeit von Fallunterscheidungen durch
verschiedene Regeln.
Die Algorithmen sind typischerweise rekursiv. Die Rekursion wird durch
die kompakten Listenzugriffe gut formulierbar.
Auch Meta–Prädikate tragen zur eleganten Implementierung bei.
390
Quicksort in P ROLOG
% quicksort(+List, ?Sorted_List) <quicksort([], []) :!.
quicksort([X|Xs], Ys) :quicksort_divide(X, Xs, Xs1, Xs2),
quicksort(Xs1, Ys1),
quicksort(Xs2, Ys2),
append(Ys1, [X|Ys2], Ys).
Der eigentliche Aufwand steckt in der Listenaufteilung (Divide); der
Merge–Schritt ist einfach (append).
391
[X|Xs] = [4,3,7,2,5,1,6]
quicksort_divide
R
Xs1 = [3,2,1]
Xs2 = [7,5,6]
quicksort
?
?
Ys1 = [1,2,3]
Ys2 = [5,6,7]
append
R
Ys = [ 1,2,3, 4, 5,6,7 ]
392
quicksort_divide(X, Xs, Xs1, Xs2) :findall( X1,
( member(X1, Xs),
X1 < X ),
Xs1 ),
findall( X2,
( member(X2, Xs),
X2 > X ),
Xs2 ).
append([], Ys, Ys).
append([X|Xs], Ys, [X|Zs]) :append(Xs, Ys, Zs).
393
Mittels des Meta–Prädikats sublist/3 kann man die Listenaufteilung
noch etwas kompakter formulieren:
quicksort_divide(X, Xs, Xs1, Xs2) :sublist(>(X), Xs, Xs1),
sublist(<(X), Xs, Xs2).
Ein Element X1 von Xs kommt nach Xs1, falls >(X, X1) gilt; in
Infix–Notation bedeutet dies X > X1. Analog kommen die Elemente X2 von
Xs mit <(X, X2) nach Xs2; in Infix–Notation bedeutet dies X < X2.
Falls ein Element mehrfach in der zu sortierenden Liste vorkommt, so ist es
trotzdem nur einmal in der Resultatsliste enthalten, denn das Pivot–Element
X wird nicht in Xs1 oder Xs2 aufgenommen.
Dies könnte man ändern, indem man > durch >= ersetzt, oder < durch =<.
394
Mergesort in P ROLOG
% mergesort(+List, ?Sorted_List) <mergesort(Xs, Xs) :length(Xs, N),
N =< 1,
!.
mergesort(Xs, Ys) :middle_split(Xs, Xs1, Xs2),
mergesort(Xs1, Ys1),
mergesort(Xs2, Ys2),
mergesort_merge(Ys1, Ys2, Ys).
Die Aufteilung (Divide mittels middle_split) ist einfach; der
eigentliche Aufwand steckt im Merge–Schritt.
395
mergesort_merge([], Xs, Xs) :!.
mergesort_merge(Xs, [], Xs) :!.
mergesort_merge([X1|Xs1], [X2|Xs2], [X|Xs]) :( X1 < X2 ->
X = X1,
mergesort_merge(Xs1, [X2|Xs2], Xs)
; X = X2,
mergesort_merge([X1|Xs1], Xs2, Xs) ).
middle_split(Xs,Xs1,Xs2) splittet eine Liste Xs in zwei etwa
gleich große Teile Xs1 und Xs2.
Hier wird die Kontrollstruktur If -> Then ; Else verwendet.
396
Binäre Suchbäume in P ROLOG
% search_in_binary_tree(+Key, +Tree) <search_in_binary_tree(Key, Tree) :binary_tree_parse(Tree, Root, Lson, Rson),
( Key = Root
; Key < Root ->
search_in_binary_tree(Key, Lson)
; Key > Root ->
search_in_binary_tree(Key, Rson) ).
Die Suchbäume können dabei in einer X ML–artigen Termnotation in
P ROLOG vorliegen (binary_tree_mode=xml) oder in einer
einfachen – aber schwerer zu lesenden – Listennotation.
397
Suchbaum in X ML–Darstellung
<node key="8">
<node key="4">
<node key="2">
<node key="1"/>
<node key="3"/>
</node>
<node key="6">
<node key="5"/>
<node key="7"/>
</node>
</node>
<node key="12">
<node key="10">
<node key="9"/>
<node key="11"/>
</node>
<node key="13"/>
</node>
</node>
Visualisierung in P ROLOG mittels
binary_tree_to_picture(Picture, Tree)
398
Suchbaum – verschiedene Darstellungen
X ML–Darstellung:
<node key="2">
<node key="1"/>
<node key="3"/>
</node>
P ROLOG–Darstellung:
node:[key:2]:[
node:[key:1]:[],
node:[key:3]:[] ]
alternative, einfache P ROLOG–Darstellung:
[ 2,
[1],
[3] ]
2
1
U
3
399
Der leere Baum wird in X ML als leerer Knoten
<node/>
dargestellt. Falls ein Knoten eines Suchbaumes nur genau einen Sohn hat,
so wird als anderer Sohn der leere Baum eingetragen:
<node key="2">
<node key="1"/>
<node/>
</node>
2
1
Dies gilt auch für die alternative P ROLOG–Darstellung
[ 2, [1], [] ]
Eine entsprechende JAVA–Klasse wäre folgende:
Class node { int key ; node lson, rson; ... }
400
Kapselung des Zugriffs:
% binary_tree_empty(?Tree) <binary_tree_empty(node:[]:[]).
binary_tree_empty([]).
Dabei ist “:” ein binärer, assoziativer Operator, und X:Y:Z wird wie
X:(Y:Z) geklammert.
Man braucht natürlich jeweils nur eines der beiden Fakten.
Das erste ist für die X ML–Repräsentation, das zweite für die alternative
P ROLOG–Repräsentation.
401
% binary_tree_parse(+Tree, ?Key, ?Lson, ?Rson) <% binary_tree_parse(?Tree, +Key, +Lson, +Rson) <binary_tree_parse(Tree, Key, Empty, Empty) :binary_tree_empty(Empty),
Tree = node:[key:Key]:[].
binary_tree_parse(Tree, Key, Lson, Rson) :Tree = node:[key:Key]:[Lson, Rson].
binary_tree_parse(Tree, Key, Empty, Empty) :binary_tree_empty(Empty),
Tree = [Key].
binary_tree_parse(Tree, Key, Lson, Rson) :Tree = [Key, Lson, Rson].
Diese Methode schlägt für den leeren Baum bewußt fehl.
Man braucht auch hier jeweils nur eines der beiden Regelpaare.
402
Einzelne Einfügeoperation
% insert_into_binary_tree(+Key, +Tree, ?New_Tree) <insert_into_binary_tree(Key, Tree, New_Tree) :binary_tree_parse(Tree, Root, Lson, Rson),
( Key = Root ->
New_Tree = Tree
; Key < Root ->
insert_into_binary_tree(Key, Lson, L),
binary_tree_parse(New_Tree, Root, L, Rson)
; Key > Root,
insert_into_binary_tree(Key, Rson, R),
binary_tree_parse(New_Tree, Root, Lson, R) ).
insert_into_binary_tree(Key, Empty, New_Tree) :binary_tree_empty(Empty),
binary_tree_parse(New_Tree, Key, Empty, Empty).
403
Aufbau eines Suchbaums
% keys_to_binary_tree(+Keys, ?Tree) <keys_to_binary_tree(Keys, Tree) :binary_tree_empty(Empty),
insert_into_binary_tree_(Keys, Empty, Tree).
% insert_into_binary_tree_(+Keys, +Tree, ?New_Tree) <insert_into_binary_tree_([], Tree, Tree).
insert_into_binary_tree_([Key|Keys], Tree, New_Tree) :insert_into_binary_tree(Key, Tree, Tree_2),
insert_into_binary_tree_(Keys, Tree_2, New_Tree).
404
Berechnung der Höhe eines Suchbaums
% binary_tree_to_height(+Tree, ?H) <-
binary_tree_to_height(Tree, -1) :binary_tree_empty(Tree),
L
!.
binary_tree_to_height(Tree, H) :binary_tree_parse(Tree, Root, Lson, Rson),
binary_tree_to_height(Lson, L),
binary_tree_to_height(Rson, R),
max(L, R, M),
H is M + 1.
j
R
1
max(L,R)
Funktional könnte man in P ROLOG auch H is max(L,R) + 1
schreiben.
405
Man kann in P ROLOG (im Gegensatz zur “reinen” Logikprogrammierung)
auch
• prozedural
• mit Seiteneffekten und
• mit globalen Variablen (realisiert mit Hilfe von assert und
retract)
programmieren.
Es gibt umfangreiche Programmbibliotheken und Erweiterungen:
• Datenstrukturen und Algorithmen, Kombinatorik,
• Datenbank– und Web–Programmierung,
• GUI–Programmierung, etc.
406
Anwendungsbereiche:
• regelbasierte Diagnosesysteme (Medizin, Technik)
• symbolische Informationsverarbeitung, Parsing
• Datenbanken mit komplexen Strukturen (Hierarchien, X ML)
• Datenintegration
• Semantic Web
• Default Reasoning
• kombinatorische Suchprobleme
(Graphenprobleme, Spiele wie Sudoku oder Minesweeper, etc.)
407

3 Logikprogrammierung

Transcription

Similar documents

Formale Methoden zur Verifikation regelbasierter

Kapitel 4

4. Kapitel - user.phil.uni

Skript zum ersten Teil der Vorlesung (Prolog / Scala)

EPA Mathematik - Kultusministerkonferenz

Wiederholung zur SLD

Deduktion mit Resolution

PROLOG Einführung

Prädikatenlogik

Aufgaben und Lösungen (AWT) Nachtermin

Klausur - AG Programmiersprachen und Übersetzerkonstruktion