Programmieren mit Prädikatenlogik

1. Programmieren mit Prädikatenlogik Klaus Becker 2004

2. Programmieren mit Logik Alle Menschen sind sterblich.Sokrates ist ein Mensch. Sokrates ist sterblich. sterblich(X) :- mensch(X).mensch(sokrates). sterblich(sokrates). sterblich(X) :- mensch(X).mensch(sokrates). ?- sterblich(X).X = sokrates;No.

3. Teil 1 Fakten und Regeln

4. Die Welt der griechischen Götter (Heaven) Uranus = Gaea (Earth) | --------------------------------------- | | | | | Cronus = Rhea Coeus = Phoebe Oceanus = Tethys | | | ---------------------- Leto = Zeus Iapetus | | | | | | | Hestia | Poseidon | Demeter=Zeus | ---------------- Hades Zeus = Hera | | | | | | | Persephone | | Prometheus | Athena | --------- | | | | | Atlas Epimetheus --------------- Apollo Artemis | | | | | | | Ares Hebe Hephaestus Zeus=Maia Zeus=Dione | | From Edith Hamiltion's Mythology Hermes Aphrodite

5. Modellierungsansatz Eine (Mini)Welt besteht aus Objekten (Personen, Gegenstände, ...), die Eigenschaften haben und in Beziehung zueinander stehen. Hera(weiblich) Zeus(männlich) ist verheiratet mit

6. Modellierungsansatz Objekte werden mit Konstanten (Termen) beschrieben,Eigenschaften und Beziehungen mit Hilfe von Prädikaten. Fakten: weiblich(hera). maennlich(zeus). verheiratet(zeus, hera). Prädikat Konstante Konstante Hera(weiblich) Zeus(männlich) ist verheiratet mit

7. Modellierungsansatz Sachverhalte der Miniwelt können direkt mit Hilfe von Fakten beschrieben werden. Fakten: weiblich(hera). maennlich(zeus). verheiratet(zeus, hera). Hera(weiblich) Zeus(männlich) ist verheiratet mit Miniwelt

8. Modellierungsansatz Sachverhalte der Miniwelt können auch indirekt mit Hilfe von Regeln beschrieben werden. Fakten: weiblich(maia).maennlich(zeus). kind(hermes, zeus).kind(hermes, maia). Zeus=Maia Zeus=Dione | | Hermes Aphrodite Miniwelt Regeln: vater(X, Y) :- kind(Y, X), maennlich(X). mutter(X, Y) :- kind(Y, X), weiblich(X).

9. Regeln Regeln sind Wenn-Dann-Aussagen. Implikation Und Variable Regeln: vater(X, Y) :- kind(Y, X), maennlich(X). mutter(X, Y) :- kind(Y, X), weiblich(X). Regelkopf(Folgerung) Regelrumpf (Bedingung) informelle Beschreibung: X ist Vater von Y, wenn Y Kind von X ist und X männlich ist. X ist Mutter von Y, wenn Y Kind von X ist und X weiblich ist.

10. Rekursive Regeln Das Prädikat im Regelkopf kann im Regelrumpf vorkommen. Regeln: vorfahr(X, Y) :- kind(Y, X). vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). Regelkopf(Folgerung) Regelrumpf (Bedingung) informelle Beschreibung: X ist Vorfahr von Y, wenn Y Kind von X ist. X ist Vorfahr von Y, wenn Y Kind von Z und X Vorfahr von Z ist.

11. Von der Miniwelt zur Modellwelt Uranus|Rhea|Zeus|Hebe... Miniwelt Modellwelt vorfahr(zeus, hebe). vorfahr(rhea, hebe). vorfahr(uranus, hebe). ... Fakten und Regeln: kind(hebe, zeus).kind(hebe, hera).kind(zeus, rhea).kind(zeus, cronus).kind(rhea, uranus).... vorfahr(X, Y) :- kind(Y, X). vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). Beschreibung der Miniwelt

12. Logische Herleitung der Modellwelt kind(hebe, zeus).kind(hebe, hera).kind(zeus, rhea).kind(zeus, cronus).kind(rhea, uranus).... vorfahr(X, Y) :- kind(Y, X). vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). Beschreibung der Miniwelt Logische Herleitung kind(hebe, zeus). vorfahr(X, Y) :- kind(Y, X). vorfahr(zeus, hebe). kind(zeus, rhea). vorfahr(zeus, hebe). vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). vorfahr(rhea, hebe). vorfahr(zeus, hebe). vorfahr(rhea, hebe). ... Modellwelt

13. Modus Ponens Zur Festlegung der Modellwelt wird die logische Schlussregel „modus ponens“ benutzt. Regeln werden dabei als Wenn-Dann-Aussagen interpretiert. Die in der Regel vorkommenden Variablen sind Platzhalter für alle Objekte der Modellwelt. Alle Menschen sind sterblich.Sokrates ist ein Mensch. Sokrates ist sterblich. Für alle X: mensch(X)  sterblich(X).mensch(sokrates). sterblich(sokrates). sterblich(X) :- mensch(X).mensch(sokrates). sterblich(sokrates).

14. Modellierungskonzept Das gesamte Wissen über die Welt wird mit Fakten und Regeln modelliert. In der Modellwelt gelten nur die „Sachverhalte“, die mit Hilfe der gegebenen Fakten und Regeln logisch abgeleitet werden können. Dies sind die direkt genannten Fakten und die mit Hilfe der logischen Schlussregel abgeleiteten Fakten (closed-world-assumption).

15. Anfragen maennlich(zeus). weiblich(hera).weiblich(maia).kind(apollo, zeus).kind(hermes, maia).kind(hermes, zeus). vater(X, Y) :- kind(Y, X), maennlich(X). ?- maennlich(zeus). % Ist Zeus männlich?Yes. ?- maennlich(hera). % Ist Hera männlich?No. Ja-Nein-Anfrage

16. Anfragen maennlich(zeus). weiblich(hera).weiblich(maia).kind(apollo, zeus).kind(hermes, maia).kind(hermes, zeus). vater(X, Y) :- kind(Y, X), maennlich(X). ?- vater(W, hermes). % Wer ist Vater von Hermes?W = zeus;No. ?- weiblich(Frau). % Wer ist weiblich?Frau = hera;Frau = maia;No. Ergänzungsanfrage

17. Anfragen mit anonymen Variablen maennlich(zeus). weiblich(hera).weiblich(maia).kind(apollo, zeus).kind(hermes, maia).kind(hermes, zeus). vater(X, Y) :- kind(Y, X), maennlich(X). mutter(X) :- weiblich(X), kind(_, X). ?- vater(V, _Kind) % Wer ist Vater? ?- mutter(M) % Wer ist Mutter? Anonyme Variable Anonyme Variablen werden nicht instanziert.

18. Datenflussrichtung maennlich(zeus). weiblich(hera).weiblich(maia).kind(apollo, zeus).kind(hermes, maia).kind(hermes, zeus). vater(X, Y) :- kind(Y, X), maennlich(X). ?- vater(maia, hermes). % Ist Maia der Vater von Hermes? ?- vater(V, hermes). % Wer ist der Vater von Hermes? ?- vater(zeus, K). % Von wem ist Zeus der Vater? ?- vater(V, K). % Wer ist Vater von wem?

19. Datenflussrichtung maennlich(zeus). weiblich(hera).weiblich(maia).kind(apollo, zeus).kind(hermes, maia).kind(hermes, zeus). vater(X, Y) :- % vater(?Vater, ?Kind) kind(Y, X), maennlich(X). Kann in beiden Rollen (+ / -) verwendet werden ?- vater(maia, hermes). % vater(+Vater, +Kind) instanziert ?- vater(V, hermes). % vater(-Vater, +Kind) ?- vater(zeus, K). % vater(+Vater, -Kind) offen ?- vater(V, K). % vater(-Vater, -Kind) Die Datenflussrichtung kann flexibel gestaltet werden.

20. Logik-Programm maennlich(zeus). weiblich(hera).weiblich(maia).kind(apollo, zeus).kind(hermes, maia).kind(hermes, zeus). vater(X, Y) :- kind(Y, X), maennlich(X). Wissensbasis ?- weiblich(Frau). Anfrage Ein Logik-Programm besteht aus einer Wissensbasis und einer Anfrage.

21. Hinweise zur Syntax maennlich(zeus). weiblich(hera).weiblich(maia).kind(apollo, zeus).kind(hermes, maia).kind(hermes, zeus). vater(X, Y) :- kind(Y, X), maennlich(X). ?- weiblich(Frau). Jede Deklaration der Wissensbasis und jede Anfrage schließt mit einem Punkt ab. Variablenbezeichner beginnen mit einem Großbuchstaben (oder anonym mit _), Konstanten- und Prädikatenbezeichner mit Kleinbuchstaben.

22. PROLOG PROLOG („Programming in Logic“): Die Programmiersprache PROLOG wurde Anfang der siebziger Jahre (des 20. Jahrhunderts) von Alain Colmerauer und Robert Kowalski konzipiert. SWI-PROLOG ist ein freies und professionelles PROLOG-System, das seit 1987 an der Universität Amsterdam entwickelt und gepflegt wird. Der SWI-Prolog-Editor ist eine (unterrichtsgeeignete) Entwicklungsumgebung zur Erstellung von PROLOG-Programmen(Autor: G. Röhner).

23. SWI-Prolog-Editor Wissensbasis Anfrage

24. SWI-Prolog-Editor Consultieren Mit consult(<Datei>) werden aus der angegebenen Datei die Fakten und Regeln in die Wissensbasis eingelesen.

25. Übungen Aufgabe 1: Familie Entwickeln Sie eine Wissensbasis zu einer Familien-Welt. Folgende Prädikate können festgelegt werden: maennlich, weiblich, kind, vater, mutter, vorfahr, sohn, tochter, grossvater, grossmutter, enkel, geschwister, bruder, schwester, onkel, tante, ... Testen Sie ihre Wissensbasis mit Hilfe geeigneter Anfragen.

26. Übungen Aufgabe 2: Wir betrachten die unten abgebildete Blockwelt. Wie könnte man die Strukrur dieser Blockwelt mit Hilfe von Fakten und Regeln beschreiben? d g c f a e b p1 p2 p3

27. Teil 2 Das Berechnungskonzept

28. Berechnungsproblem Gegeben: Logik-Programm (Wissensbasis + Anfrage) maennlich(zeus). weiblich(hera).weiblich(maia).kind(apollo, zeus).kind(hermes, maia).kind(hermes, zeus). vater(X, Y) :- kind(Y, X), maennlich(X). maennlich(zeus). weiblich(hera).weiblich(maia).kind(apollo, zeus).kind(hermes, maia).kind(hermes, zeus).vater(zeus, apollo).vater(zeus, hermes). ... ?- vater(V, hermes). Gesucht: Instanzen der Anfrage, die zur Modellwelt gehören V = zeus. Problem: Wie erzeugt man systematisch Anfrageergebnisse?

29. Berechnungsproblem Wissensbasis maennlich(zeus). weiblich(hera).weiblich(maia).kind(apollo, zeus).kind(hermes, maia).kind(hermes, zeus). vater(X, Y) :- kind(Y, X), maennlich(X). ... Herleitung (Beweis) kind(hermes, zeus). maennlich(zeus). vater(X, Y) :- kind(Y, X), maennlich(X). ------------------------------------ vater(zeus, hermes). Anfrage ?- vater(V, hermes). Ergebnis V = zeus. /* Substitution */ Problem: Wie erzeugt man systematisch logische Herleitungen?

30. Auswertung von Anfragen /*1*/ maennlich(zeus). /*2*/ weiblich(hera). /*3*/ weiblich(maia)./*4*/ kind(apollo, zeus). /*5*/ kind(hermes, maia). /*6*/ kind(hermes, zeus). /*7*/ vater(X, Y) :- kind(Y, X), maennlich(X). Regel 7 Substitution X = V, Y = hermes. Ziel ?- vater(V, hermes). ?- kind(hermes, V), maennlich(V). Unifikation:Suche einen Fakt / Regelkopf, der mit dem ersten Term des Ziels unifiziert (d. h. durch eine Substitution gleichgemacht werden kann). Resolution (bei Regel):Ersetze den ersten Term des Ziels durch den Regelrumpf und wende auf alle Terme des Ziels die Substitution an.

31. Auswertung von Anfragen /*1*/ maennlich(zeus). /*2*/ weiblich(hera). /*3*/ weiblich(maia)./*4*/ kind(apollo, zeus). /*5*/ kind(hermes, maia). /*6*/ kind(hermes, zeus). /*7*/ vater(X, Y) :- kind(Y, X), maennlich(X). Regel 7 5 Substitution X = V, Y = hermes. V = maia. Ziel ?- vater(V, hermes). ?- kind(hermes, V), maennlich(V). ?- maennlich(maia). Unifikation:Suche einen Fakt / Regelkopf, der mit dem ersten Term des Ziels unifiziert (d. h. durch eine Substitution gleichgemacht werden kann). Resolution (bei Regel):Ersetze den ersten Term des Ziels durch den Regelrumpf und wende auf alle Terme des Ziels die Substitution an.

32. Auswertung von Anfragen /*1*/ maennlich(zeus). /*2*/ weiblich(hera). /*3*/ weiblich(maia)./*4*/ kind(apollo, zeus). /*5*/ kind(hermes, maia). /*6*/ kind(hermes, zeus). /*7*/ vater(X, Y) :- kind(Y, X), maennlich(X). Regel 7 5 No Substitution V = maia. Ziel ?- vater(V, hermes). ?- kind(hermes, V), maennlich(V). ?- maennlich(maia). ?- kind(hermes, V), maennlich(V). Backtracking:Wenn der erste Term des Ziels mit keinem Fakt / Regelkopf unifiziert, dann geh zurück zu dem Ziel, bei dem als letztes eine Auswahlmöglichkeit bestand und treffe eine neue Auswahl.

33. Auswertung von Anfragen /*1*/ maennlich(zeus). /*2*/ weiblich(hera). /*3*/ weiblich(maia)./*4*/ kind(apollo, zeus). /*5*/ kind(hermes, maia). /*6*/ kind(hermes, zeus). /*7*/ vater(X, Y) :- kind(Y, X), maennlich(X). Regel 7 5 No 6 Substitution V = maia. V = zeus. Ziel ?- vater(V, hermes). ?- kind(hermes, V), maennlich(V). ?- maennlich(maia). ?- kind(hermes, V), maennlich(V). ?- maennlich(zeus).

34. Auswertung von Anfragen /*1*/ maennlich(zeus). /*2*/ weiblich(hera). /*3*/ weiblich(maia)./*4*/ kind(apollo, zeus). /*5*/ kind(hermes, maia). /*6*/ kind(hermes, zeus). /*7*/ vater(X, Y) :- kind(Y, X), maennlich(X). Regel 7 5 No 6 1 Substitution V = maia. V = zeus. V = zeus. Ziel ?- vater(V, hermes). ?- kind(hermes, V), maennlich(V). ?- maennlich(maia). ?- kind(hermes, V), maennlich(V). ?- maennlich(zeus). Ergebnis: Ist keine Zielklausel mehr vorhanden, so liefert die Substitution das gesuchte Ergebnis.

35. Beweisbaum /*1*/ maennlich(zeus). /*2*/ weiblich(hera). /*3*/ weiblich(maia)./*4*/ kind(apollo, zeus). /*5*/ kind(hermes, maia). /*6*/ kind(hermes, zeus). /*7*/ vater(X, Y) :- kind(Y, X), maennlich(X). vater(V, hermes) kind(hermes, V) maennlich(V) kind(hermes, maia) kind(hermes, zeus) maennlich(zeus) UND-Knoten X = V, Y = hermes. ODER-Knoten V = maia. V = zeus. V = zeus. Veranschaulichung: Die Herleitung eines Berechnungsergebnisses kann mit Hilfe eines Beweisbaumes verdeutlicht werden.

36. Trace einer Beweissuche vater(V, hermes) kind(hermes, V) maennlich(V) kind(hermes, maia) kind(hermes, zeus) maennlich(zeus) UND-Knoten ODER-Knoten CALL: Teilziel aufrufen EXIT: Zeilziel erfolgr. b. REDO: Teilziel nochmal b. FAIL: Teilziel erfolglos b. ?- vater(V, hermes). CALL: vater(V, hermes) CALL: kind(hermes, V) CALL: kind(hermes, maia) EXIT: kind(hermes, maia) CALL: maennlich(maia) FAIL: maennlich(maia) REDO: kind(hermes, V) CALL: kind(hermes, zeus) EXIT: kind(hermes, zeus) CALL: maennlich(zeus) EXIT: maennlich(zeus) EXIT: vater(V, hermes) V = zeus.

37. Das Berechnungskonzept Das Berechnungskonzept bei der logischen Programmierung beruht auf „maschinellem“ logischen Schließen. Hierzu werden die folgenden Algorithmen von einer sog. Inferenzmaschine geeignet kombiniert: Unifikationsalgorithmus (erzeugt Variablenbindung) Inferenzalgorithmus (führt Resolution durch) Suchalgorithmus (benutzt Backtracking)

38. Das Berechnungskonzept Die Inferenzmaschine versucht, logische Ableitungen zur Anfrage aus der Wissensbasis zu erstellen. Anfrage ?- vorfahr(A, B). kind(hermes, maia).vorfahr(X, Y) :- kind(Y, X).vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). Inferenz-maschine Wissensbasis Ergebnis X = maia, Y = hermes.

39. Deklarative Semantik Logisches Programm (Wissensbasis + Anfrage) maennlich(zeus). weiblich(hera).weiblich(maia).kind(apollo, zeus).kind(hermes, maia).kind(hermes, zeus). vater(X, Y) :- kind(Y, X), maennlich(X). ?- vater(V, hermes). Deklarative Semantik eines Logik-Programms Menge der Instanzen der Anfrageklausel, die zur Modellwelt gehören bzw. die aus der Wissensbasis mit Hilfe der Schlussregel „modus ponens“ hergeleitet werden können.

40. Prozedurale Semantik Logisches Programm (Wissensbasis + Anfrage) maennlich(zeus). weiblich(hera).weiblich(maia).kind(apollo, zeus).kind(hermes, maia).kind(hermes, zeus). vater(X, Y) :- kind(Y, X), maennlich(X). ?- vater(V, hermes). Prozedurale Semantik des Programms Menge der Instanzen der Anfrageklausel, die die Inferenzmaschine mittels Unifikations-, Inferenz- und Suchalgorithmus erzeugt.

41. Übungen Aufgabe 3: Berechnungskonzept Wir betrachten das folgende Logik-Programm zur Blockwelt: auf(a, p1). auf(c, a). auf(e, p2). auf(b, p3). auf(f, b). auf(g, f). auf(d, g). ueber(X, Y) :- auf(X, Y). ueber(X, Y) :- auf(X, Z), ueber(Z, Y). d g c f a e b p1 p2 p3 ?- ueber(X, g). Schalten Sie den Trace-Modus ein und verfolgen Sie die Erzeugung der Berechnungsergebnisse. Erstellen Sie auch einen Beweisbaum.

42. Übungen Aufgabe 4: Berechnungskonzept Wir betrachten die beiden folgenden Logik-Programme: Wissensbasis - Version 1: kind(hermes, maia).vorfahr(X, Y) :- kind(Y, X).vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). Wissensbasis - Version 2: kind(hermes, maia).vorfahr(X, Y) :- vorfahr(X, Z), kind(Y, Z). vorfahr(X, Y) :- kind(Y, X). ?- vorfahr(A, B). Welche Berechnungsergebnisse erwarten Sie? Bestimmen Sie die Ergebnisse mit Hilfe von PROLOG. Verfolgen Sie die Berechnung der Ergebnisse mit Hilfe einer Trace. Wie lässt sich das Verhalten von PROLOG erklären?

43. Grenzen der Logik Logisches Programm (Wissensbasis + Anfrage) Wissensbasis - Version 1: kind(hermes, maia).vorfahr(X, Y) :- kind(Y, X).vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). Wissensbasis - Version 2: kind(hermes, maia).vorfahr(X, Y) :- vorfahr(X, Z), kind(Y, Z). vorfahr(X, Y) :- kind(Y, X). ?- vorfahr(A, B). kind(hermes, maia). vorfahr(X, Y) :- kind(Y, X). vorfahr(maia, hermes). Die Modellierungen sind logisch äquivalent – die Logik-Programme haben dieselbe deklarative Semantik.

44. Grenzen der Logik Logisches Programm (Wissensbasis + Anfrage) Wissensbasis - Version 1: /*1*/ kind(hermes, maia)./*2*/ vorfahr(X, Y) :- kind(Y, X). /*3*/ vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). Regel 2 1 Substitution X = A, Y = B B = hermes, A = maia. Ziel ?- vorfahr(A, B). ?- kind(B, A).

45. Grenzen der Logik Logisches Programm (Wissensbasis + Anfrage) Wissensbasis - Version 2: /*1*/ kind(hermes, maia)./*2*/ vorfahr(X, Y) :- vorfahr(X, Z), kind(Y, Z). /*3*/ vorfahr(X, Y) :- kind(Y, X). Regel 2 2 2 Substitution X = A, Y = B X = A, Y = Z. ... Ziel ?- vorfahr(A, B). ?- vorfahr(A, Z), kind(B, Z). ?- vorfahr(A, U), kind(Z, U), kind... ... Die Inferenzmaschine liefert unterschiedliche Berechnungsergebnisse – die Logik-Programme haben eine unterschiedliche prozedurale Semantik.

46. Grenzen der Logik Logisches Programm (Wissensbasis + Anfrage) Wissensbasis - Version 1: kind(hermes, maia).vorfahr(X, Y) :- kind(Y, X).vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). Wissensbasis - Version 2: kind(hermes, maia).vorfahr(X, Y) :- vorfahr(X, Z), kind(Y, Z). vorfahr(X, Y) :- kind(Y, X). ?- vorfahr(A, B). Beachte: Die prozedurale Semantik wird durch die Algorithmen der Inferenzmaschine festgelegt. Die Reihenfolge der Programmklauseln und Zielklauseln können hierbei eine entscheidende Rolle spielen.

47. Deklarative Programmierung Beschreiben, was in der Modellwelt gelten soll Anfrage ?- vorfahr(A, B). kind(hermes, maia).vorfahr(X, Y) :- kind(Y, X).vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). Inferenz-maschine Wissensbasis Ergebnis X = maia, Y = hermes. Deklarative Programmierung besteht darin, den Problemkontext (Miniwelt) mit gegebenen Mitteln (hier: Fakten und Regeln) zu beschreiben.

48. Imperative Programmierung Beschreiben, wie die Ergebnisse berechnet werden sollen A.-Zustand {x: 3; y: 5} z := x; x := y; y := z; Register-maschine Anweisungen E.-Zustand {x: 5; y: 3; z: ...} Imperative Programmierung besteht darin, eine (mehr oder weniger abstrakte) Maschine mit Hilfe von Anweisungen zu steuern.

49. Teil 3 Anwendung: Datenbanken

50. Eine einfache Bibliothekswelt